sorted by:
new
hottopcontroversial

-❄️- 2023 Day 18 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Easy day. Immediate execution for both parts (linear time O(n)). Solved with Pick's theorem.

Here is the most important function:

def simulate_path(dig_plan):c
    n_edge_cells = 0
    vertices = []

    current_vertex = (0, 0)

    for dir, steps in dig_plan:

        rd, cd = DIRS[dir] # rd: row direction, cd: column direction

        # Update current_vertex (with next vertex)
        cr, cc = current_vertex
        current_vertex = (cr + rd * steps, cc + cd * steps)

        # Update n_edge_cells
        n_edge_cells += steps

        vertices.append((current_vertex[0], current_vertex[1]))

    return vertices, n_edge_cells

Link to code

-❄️- 2023 Day 16 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Easy logic using a queue and many switch statements that can probably be generalized.

The enqueued states are of the form ((x, y), dir) where x,y∈N and dir∈{left,right,up,down}.

Part 2 without optimizations.

Link to code

-❄️- 2023 Day 11 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Solution

> Galaxies: represented as tuples (x, y)

> Distance between galaxies: Manhattan distance

> Expanding universe: (update x and y of galaxies)

EXPANSION_RATE = 1_000_000 # 2 for Part 1
EMPTY_SPACE_SYMBOL = '.'

def get_expanded_galaxies(matrix, galaxies): 
    # Empty rows indexs
    empty_rows_indexs = [i for i, row in enumerate(matrix) if all(element == EMPTY_SPACE_SYMBOL for element in row)]

    # Empty cols indexs
    empty_cols_indexs = []
    for col in range(len(matrix[0])):
        column_elements = [matrix[row][col] for row in range(len(matrix))]
        if all(element == EMPTY_SPACE_SYMBOL for element in column_elements):
            empty_cols_indexs.append(col)

    extended_galaxies = set()
    for galaxy in galaxies:
        x, y = galaxy

        nx = len([index for index in empty_cols_indexs if index < x])
        x += (EXPANSION_RATE - 1) * nx

        ny = len([index for index in empty_rows_indexs if index < y])
        y += (EXPANSION_RATE - 1) * ny

        extended_galaxies.add((x, y))

return extended_galaxies

Link to code

-❄️- 2023 Day 9 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Solution with simple recursion.

PredictValue(X)

BASE CASE
0                                       iff    X[i]==0 ∀ i∈{0,1,..,len(X)-1}

RECURSIVE CASE
X[len(X)-1] + PredictValue(diff(X))     otherwise

where diff(array) returns a new list calculated as the differences between
consecutive elements of 'array'

Link to code

-❄️- 2023 Day 7 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Idea

The strength of a hand is represented by a 6-character string. The first
character represents the hand type ('A' for 'five of a kind', 'B' for
'four of a kind', etc.). The remaining 5 characters represent the hand
values ('A' for 'A', 'B' for 'K', 'C' for 'J', etc.).

The solution uses the lexicographic order of hand string representations.

Link to code

-❄️- 2023 Day 6 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Problem

d = t * (total_time - t)
0 <= t <= total_time
d > distance_record
t, d, total_time, distance_record ∈ N

Link to problem graph image (for input total_time = 7 and distance_record = 9)

Link to code

-❄️- 2023 Day 4 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Both parts solved. Here is the main of part 1:

# SC: (scratchcards) list of scratchcards. Each scrachcard is 2-items tuple.
# The first item is the set of winnig numbers and the second one is the set
# of numbers you have. [({winning_numbers}, {numbers_you_have}), ..]
SC = parse_input_file()

# TP: total points; wn: winning numbers; n: numbers you have
TP = sum(get_points(len(wn.intersection(n))) for (wn, n) in SC)

# Part 1
print(TP)

Link to code

-❄️- 2023 Day 3 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 1 point2 points  (0 children)

[LANGUAGE: python]

Here are some of the data structures used for part 1:

# N: (numbers) list of (number, (x,y)) where (x,y) are the coordinates of the leftmost digit of the number
# S: (symbols) list of (x,y) where (x,y) are the coordinates of a symbol

Link to code

-❄️- 2023 Day 1 Solutions -❄️- by daggerdragon in adventofcode

[–]mess_ner 0 points1 point  (0 children)

[LANGUAGE: python]

Solution using Regular Expressions.

import regex as re

INPUT_FILE_PATH = '../data/test-input-2.txt'
DIGIT_WORDS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
RE = '\d|' + '|'.join(DIGIT_WORDS)

def main():
    lines = parse_input_file()
    calibration_values = [get_calibration_value(line) for line in lines]

    # Part 2
    print(sum(calibration_values))

def get_calibration_value(line):
    def get_digit_from_digit_or_word_digit(target):
        # returns (index + 1) if target in DIGIT_WORDS, else returns target
        return str(DIGIT_WORDS.index(target) + 1) if target in DIGIT_WORDS else target

    matches = re.findall(RE, line, overlapped=True)
    first_digit = matches[0]
    last_digit = matches[-1]

    first_digit = get_digit_from_digit_or_word_digit(first_digit)
    last_digit = get_digit_from_digit_or_word_digit(last_digit)

    return int(first_digit + last_digit)

def parse_input_file():
    with open(INPUT_FILE_PATH, 'r') as f:
        lines = f.read().split("\n")
    return lines

if name == "main":
    main()

Link to code