Add solution files

day01/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,46 @@
+def read_lists(filename):
+    left = []
+    right = []
+    with open(filename, 'r') as f:
+        for line in f:
+            l, r = line.strip().split()
+            left.append(int(l))
+            right.append(int(r))
+    return left, right
+
+def calculate_distance(left, right):
+    # Sort both lists
+    sorted_left = sorted(left)
+    sorted_right = sorted(right)
+    
+    # Calculate total distance
+    total_distance = 0
+    for l, r in zip(sorted_left, sorted_right):
+        total_distance += abs(l - r)
+    
+    return total_distance
+
+def calculate_similarity(left, right):
+    # Count occurrences in right list
+    right_counts = {}
+    for num in right:
+        right_counts[num] = right_counts.get(num, 0) + 1
+    
+    # Calculate similarity score
+    total_similarity = 0
+    for num in left:
+        # Multiply number by its occurrences in right list
+        total_similarity += num * right_counts.get(num, 0)
+    
+    return total_similarity
+
+# Read input
+left_list, right_list = read_lists("./input.txt")
+
+# Part 1
+distance = calculate_distance(left_list, right_list)
+print(str(distance))
+
+# Part 2
+similarity = calculate_similarity(left_list, right_list)
+print(str(similarity))

day01/solution_gemini-1.5-pro.py

@@ -0,0 +1,27 @@
+def solve():
+    file = "./input.txt"
+    left_list = []
+    right_list = []
+
+    with open(file, 'r') as f:
+        for line in f:
+            left, right = map(int, line.strip().split())
+            left_list.append(left)
+            right_list.append(right)
+    
+    # Part 1
+    left_list_sorted = sorted(left_list)
+    right_list_sorted = sorted(right_list)
+    total_distance = 0
+    for i in range(len(left_list)):
+        total_distance += abs(left_list_sorted[i] - right_list_sorted[i])
+    print(total_distance)
+
+    # Part 2
+    similarity_score = 0
+    for left_num in left_list:
+        count = right_list.count(left_num)
+        similarity_score += left_num * count
+    print(similarity_score)
+
+solve()

day01/solution_gpt-4o.py

@@ -0,0 +1,35 @@
+file = "input.txt"
+
+def calculate_total_distance(left_list, right_list):
+    left_list.sort()
+    right_list.sort()
+    total_distance = sum(abs(l - r) for l, r in zip(left_list, right_list))
+    return total_distance
+
+def calculate_similarity_score(left_list, right_list):
+    from collections import Counter
+    right_count = Counter(right_list)
+    similarity_score = sum(l * right_count[l] for l in left_list)
+    return similarity_score
+
+def main():
+    with open(file, 'r') as f:
+        lines = f.readlines()
+    
+    left_list = []
+    right_list = []
+    
+    for line in lines:
+        left, right = map(int, line.split())
+        left_list.append(left)
+        right_list.append(right)
+    
+    # Part 1: Calculate the total distance
+    total_distance = calculate_total_distance(left_list, right_list)
+    print(total_distance)
+    
+    # Part 2: Calculate the similarity score
+    similarity_score = calculate_similarity_score(left_list, right_list)
+    print(similarity_score)
+
+main()

day01/solution_jerpint.py

@@ -0,0 +1,36 @@
+with open("input.txt") as f:
+    data = f.read()
+
+#  with open("test.txt") as f:
+#      data = f.read()
+
+l1 = []
+l2 = []
+for line in data.split("\n"):
+    if len(line.split("   ")) > 1:
+        v1, v2 = line.split("   ")
+        l1.append(int(v1))
+        l2.append(int(v2))
+
+total = 0
+for n1, n2 in zip(sorted(l1), sorted(l2)):
+    total += abs(n2 - n1)
+
+print(total)
+
+# Problem 2
+def get_counts(l):
+    counts = {}
+    for num in l:
+        counts[num] = counts.get(num, 0) + 1
+    return counts
+
+
+c2 = get_counts(l2)
+
+total = 0
+for n in l1:
+    total += n * c2.get(n, 0)
+
+print(total)
+

day02/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,52 @@
+def is_safe_sequence(nums):
+    if len(nums) <= 1:
+        return True
+    
+    # Check first difference to determine if we're expecting increasing or decreasing
+    diff = nums[1] - nums[0]
+    increasing = diff > 0
+    
+    for i in range(len(nums)-1):
+        curr_diff = nums[i+1] - nums[i]
+        
+        # Check if difference is between 1 and 3
+        if abs(curr_diff) < 1 or abs(curr_diff) > 3:
+            return False
+        
+        # Check if direction matches
+        if increasing and curr_diff <= 0:
+            return False
+        if not increasing and curr_diff >= 0:
+            return False
+    
+    return True
+
+def can_be_safe_with_removal(nums):
+    if is_safe_sequence(nums):
+        return True
+    
+    # Try removing each number
+    for i in range(len(nums)):
+        new_nums = nums[:i] + nums[i+1:]
+        if is_safe_sequence(new_nums):
+            return True
+    
+    return False
+
+# Read input
+with open("input.txt", "r") as f:
+    lines = f.readlines()
+
+# Parse numbers
+sequences = []
+for line in lines:
+    nums = [int(x) for x in line.strip().split()]
+    sequences.append(nums)
+
+# Part 1: Count safe sequences
+safe_count = sum(1 for seq in sequences if is_safe_sequence(seq))
+print(str(safe_count))
+
+# Part 2: Count sequences that can be made safe with one removal
+safe_with_removal_count = sum(1 for seq in sequences if can_be_safe_with_removal(seq))
+print(str(safe_with_removal_count))

day02/solution_gemini-1.5-pro.py

@@ -0,0 +1,45 @@
+def is_safe(report):
+    increasing = all(report[i] <= report[i+1] for i in range(len(report)-1))
+    decreasing = all(report[i] >= report[i+1] for i in range(len(report)-1))
+    
+    if not (increasing or decreasing):
+        return False
+
+    for i in range(len(report) - 1):
+        diff = abs(report[i] - report[i+1])
+        if not (1 <= diff <= 3):
+            return False
+    return True
+
+def solve_part1(reports):
+    safe_count = 0
+    for report in reports:
+        if is_safe(report):
+            safe_count += 1
+    return safe_count
+
+def solve_part2(reports):
+    safe_count = 0
+    for report in reports:
+        if is_safe(report):
+            safe_count += 1
+            continue
+
+        for i in range(len(report)):
+            temp_report = report[:i] + report[i+1:]
+            if is_safe(temp_report):
+                safe_count += 1
+                break
+    return safe_count
+
+
+with open("./input.txt", "r") as f:
+    reports = []
+    for line in f:
+        reports.append(list(map(int, line.strip().split())))
+
+result1 = solve_part1(reports)
+print(result1)
+
+result2 = solve_part2(reports)
+print(result2)

day02/solution_gpt-4o.py

@@ -0,0 +1,45 @@
+def is_safe(report):
+    increasing = True
+    decreasing = True
+    for i in range(len(report) - 1):
+        diff = report[i+1] - report[i]
+        if not (1 <= abs(diff) <= 3):
+            return False
+        if diff > 0:
+            decreasing = False
+        if diff < 0:
+            increasing = False
+    return increasing or decreasing
+
+def is_safe_with_removal(report):
+    if is_safe(report):
+        return True
+    for i in range(len(report)):
+        modified_report = report[:i] + report[i+1:]
+        if is_safe(modified_report):
+            return True
+    return False
+
+def count_safe_reports(file_path, part_two=False):
+    with open(file_path, 'r') as file:
+        reports = [list(map(int, line.split())) for line in file]
+    
+    safe_count = 0
+    for report in reports:
+        if part_two:
+            if is_safe_with_removal(report):
+                safe_count += 1
+        else:
+            if is_safe(report):
+                safe_count += 1
+    return safe_count
+
+file = "input.txt"
+
+# Part One
+result1 = count_safe_reports(file, part_two=False)
+print(result1)
+
+# Part Two
+result2 = count_safe_reports(file, part_two=True)
+print(result2)

day02/solution_jerpint.py

@@ -0,0 +1,51 @@
+#  with open("test.txt") as f:
+#      inputs = f.readlines()
+
+with open("input.txt") as f:
+    inputs = f.readlines()
+
+def is_increasing_or_decreasing(data):
+    sorted_data = sorted(data)
+    if data[0] > data[-1]:
+        return data == sorted_data[::-1]
+    else:
+        return data == sorted_data
+
+def adjacency_check(data):
+    for i in range(len(data)-1):
+        abs_diff = abs(data[i] - data[i+1])
+        if not (0 < abs_diff < 4):
+            return False
+    return True
+
+
+def is_safe(data: list[str]) -> bool:
+    return is_increasing_or_decreasing(data) and adjacency_check(data)
+
+total = 0
+for line in inputs:
+    data = [int(i) for i in line.split(" ")]
+    if is_safe(data):
+        total += 1
+
+print(total)
+
+
+## Part 2
+# ... just brute force it?
+
+total = 0
+for line in inputs:
+    data = [int(i) for i in line.split(" ")]
+    if is_safe(data):
+        total += 1
+    else:
+        for i in range(len(data)):
+            new_data = data.copy()
+            new_data.pop(i)
+
+            if is_safe(new_data):
+                total += 1
+                break
+
+print(total)

day03/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,53 @@
+import re
+
+def parse_multiplications(text):
+    # Find all valid mul(X,Y) patterns where X and Y are 1-3 digit numbers
+    pattern = r'mul\((\d{1,3}),(\d{1,3})\)'
+    matches = re.finditer(pattern, text)
+    total = 0
+    
+    for match in matches:
+        x, y = int(match.group(1)), int(match.group(2))
+        total += x * y
+    
+    return total
+
+def parse_with_conditionals(text):
+    # Find all instructions in order
+    mul_pattern = r'mul\((\d{1,3}),(\d{1,3})\)'
+    do_pattern = r'do\(\)'
+    dont_pattern = r'don\'t\(\)'
+    
+    # Combine all patterns
+    all_patterns = f'({mul_pattern}|{do_pattern}|{dont_pattern})'
+    matches = re.finditer(all_patterns, text)
+    
+    enabled = True
+    total = 0
+    
+    for match in matches:
+        full_match = match.group(0)
+        if full_match == 'do()':
+            enabled = True
+        elif full_match == "don't()":
+            enabled = False
+        else:
+            # It's a multiplication
+            if enabled:
+                x = int(match.group(2))
+                y = int(match.group(3))
+                total += x * y
+    
+    return total
+
+# Read input file
+with open('./input.txt', 'r') as file:
+    content = file.read()
+
+# Part 1
+result1 = parse_multiplications(content)
+print(str(result1))
+
+# Part 2
+result2 = parse_with_conditionals(content)
+print(str(result2))

day03/solution_gemini-1.5-pro.py

@@ -0,0 +1,36 @@
+import re
+
+file = "./input.txt"
+
+def solve_part1(input_string):
+    pattern = r"mul\((\d{1,3}),(\d{1,3})\)"
+    matches = re.findall(pattern, input_string)
+    total = 0
+    for match in matches:
+        total += int(match[0]) * int(match[1])
+    return str(total)
+
+def solve_part2(input_string):
+    pattern = r"mul\((\d{1,3}),(\d{1,3})\)|do\(\)|don't\(\)"
+    matches = re.findall(pattern, input_string)
+    total = 0
+    enabled = True
+    for match in matches:
+        if match[0] and match[1]:
+            if enabled:
+                total += int(match[0]) * int(match[1])
+        elif match[0:2] == "do":
+            enabled = True
+        elif match[0:5] == "don't":
+            enabled = False
+    return str(total)
+
+
+with open(file, 'r') as f:
+    input_string = f.read()
+
+result1 = solve_part1(input_string)
+print(result1)
+
+result2 = solve_part2(input_string)
+print(result2)

day03/solution_gpt-4o.py

@@ -0,0 +1,56 @@
+import re
+
+def parse_instructions(memory):
+    # Regular expression to find valid mul(X,Y) instructions
+    mul_pattern = re.compile(r'mul\((\d{1,3}),(\d{1,3})\)')
+    # Regular expression to find do() and don't() instructions
+    do_pattern = re.compile(r'do\(\)')
+    dont_pattern = re.compile(r"don't\(\)")
+
+    # Find all mul instructions
+    mul_matches = mul_pattern.finditer(memory)
+    
+    # Find all do() and don't() instructions
+    do_matches = list(do_pattern.finditer(memory))
+    dont_matches = list(dont_pattern.finditer(memory))
+    
+    # Sort do and don't matches by their start position
+    control_matches = sorted(do_matches + dont_matches, key=lambda m: m.start())
+    
+    # Part 1: Sum of all valid mul instructions
+    part1_sum = 0
+    for match in mul_matches:
+        x, y = int(match.group(1)), int(match.group(2))
+        part1_sum += x * y
+    
+    # Part 2: Sum of enabled mul instructions
+    part2_sum = 0
+    mul_matches = mul_pattern.finditer(memory)  # Re-iterate over mul matches
+    enabled = True  # Initially, mul instructions are enabled
+    control_index = 0
+    
+    for match in mul_matches:
+        # Check if there are any control instructions before this mul
+        while control_index < len(control_matches) and control_matches[control_index].start() < match.start():
+            if control_matches[control_index].group() == 'do()':
+                enabled = True
+            elif control_matches[control_index].group() == "don't()":
+                enabled = False
+            control_index += 1
+        
+        if enabled:
+            x, y = int(match.group(1)), int(match.group(2))
+            part2_sum += x * y
+    
+    return part1_sum, part2_sum
+
+# Read the input file
+with open('input.txt', 'r') as file:
+    memory = file.read()
+
+# Get the results for both parts
+result1, result2 = parse_instructions(memory)
+
+# Print the results
+print(result1)
+print(result2)

day03/solution_jerpint.py

@@ -0,0 +1,37 @@
+import re
+with open("input.txt") as f:
+    data = f.read()
+
+#  with open("test2.txt") as f:
+#      data = f.read()
+
+pattern = r"mul\([0-9]*,[0-9]*\)"
+matches = re.findall(pattern, data)
+
+total = 0
+for match in matches:
+    d1, d2 = match[4:-1].split(",")  # Drop 'mul(' and ')'
+    d1, d2 = int(d1), int(d2)
+    total += d1*d2
+print(total)
+
+
+## Part 2
+
+pattern = r"don't\(\)|do\(\)|mul\([0-9]*,[0-9]*\)"
+match_iters = re.finditer(pattern, data)
+
+is_on = True
+total = 0
+for i in match_iters:
+    if i.group() == "don't()":
+        is_on = False
+    elif i.group() == "do()":
+        is_on = True
+    elif is_on:
+        d1, d2 = i.group()[4:-1].split(",")  # Drop 'mul(' and ')'
+        d1, d2 = int(d1), int(d2)
+        total += d1*d2
+
+
+print(total)

day04/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,66 @@
+def read_grid(filename):
+    with open(filename, 'r') as f:
+        return [line.strip() for line in f.readlines()]
+
+def get_word_at(grid, x, y, dx, dy, length):
+    if not (0 <= x + (length-1)*dx < len(grid[0]) and 0 <= y + (length-1)*dy < len(grid)):
+        return ""
+    return ''.join(grid[y + i*dy][x + i*dx] for i in range(length))
+
+def count_xmas(grid):
+    directions = [
+        (1,0), (0,1), (1,1), (-1,1),  # right, down, diagonal-right, diagonal-left
+        (-1,0), (0,-1), (-1,-1), (1,-1)  # left, up, diagonal-left-up, diagonal-right-up
+    ]
+    
+    count = 0
+    for y in range(len(grid)):
+        for x in range(len(grid[0])):
+            for dx, dy in directions:
+                if get_word_at(grid, x, y, dx, dy, 4) == "XMAS":
+                    count += 1
+    return count
+
+def check_xmas_pattern(grid, x, y):
+    # Check both diagonals for MAS or SAM
+    patterns = 0
+    diagonals = [
+        [(x-1, y-1), (x, y), (x+1, y+1)],  # top-left to bottom-right
+        [(x+1, y-1), (x, y), (x-1, y+1)]   # top-right to bottom-left
+    ]
+    
+    def is_valid_pos(pos):
+        return 0 <= pos[0] < len(grid[0]) and 0 <= pos[1] < len(grid)
+    
+    def get_string(positions):
+        if not all(is_valid_pos(pos) for pos in positions):
+            return ""
+        return ''.join(grid[y][x] for x, y in positions)
+    
+    for d1 in diagonals:
+        for d2 in diagonals:
+            if d1 == d2:
+                continue
+            s1 = get_string(d1)
+            s2 = get_string(d2)
+            if ((s1 == "MAS" or s1 == "SAM") and 
+                (s2 == "MAS" or s2 == "SAM")):
+                patterns += 1
+    
+    return patterns // 2  # Each valid pattern is counted twice due to diagonal combinations
+
+def count_xmas_patterns(grid):
+    total = 0
+    for y in range(len(grid)):
+        for x in range(len(grid[0])):
+            total += check_xmas_pattern(grid, x, y)
+    return total
+
+# Read input and solve both parts
+grid = read_grid("input.txt")
+
+# Part 1
+print(str(count_xmas(grid)))
+
+# Part 2
+print(str(count_xmas_patterns(grid)))

day04/solution_gemini-1.5-pro.py

@@ -0,0 +1,52 @@
+def solve():
+    with open("./input.txt", "r") as f:
+        grid = [line.strip() for line in f]
+
+    rows = len(grid)
+    cols = len(grid[0])
+
+    def check_pattern(r, c, pattern):
+        for dr in [-1, 0, 1]:
+            for dc in [-1, 0, 1]:
+                if dr == 0 and dc == 0:
+                    continue
+                found = True
+                for i in range(len(pattern)):
+                    nr, nc = r + dr * i, c + dc * i
+                    if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == pattern[i]:
+                        continue
+                    else:
+                        found = False
+                        break
+                if found:
+                    return True
+        return False
+
+    # Part 1
+    count1 = 0
+    for r in range(rows):
+        for c in range(cols):
+            if check_pattern(r, c, "XMAS") or check_pattern(r, c, "SAMX"):
+                count1 += 1
+    print(count1)
+
+    # Part 2
+    count2 = 0
+    for r in range(rows):
+        for c in range(cols):
+            if (
+                1 <= r < rows - 1 and 1 <= c < cols - 1 and
+                (grid[r-1][c-1] == 'M' or grid[r-1][c-1] == 'S') and
+                (grid[r-1][c+1] == 'M' or grid[r-1][c+1] == 'S') and
+                (grid[r+1][c-1] == 'M' or grid[r+1][c-1] == 'S') and
+                (grid[r+1][c+1] == 'M' or grid[r+1][c+1] == 'S') and
+                (grid[r-1][c] == 'A' or grid[r-1][c] == 'A') and
+                (grid[r][c-1] == 'A' or grid[r][c-1] == 'A') and
+                (grid[r][c+1] == 'A' or grid[r][c+1] == 'A') and
+                (grid[r+1][c] == 'A' or grid[r+1][c] == 'A') and
+                (grid[r][c] == 'S' or grid[r][c] == 'M')
+            ):
+                count2 += 1
+    print(count2)
+
+solve()

day04/solution_gpt-4o.py

@@ -0,0 +1,45 @@
+def read_input(file):
+    with open(file, 'r') as f:
+        return [line.strip() for line in f.readlines()]
+
+def count_xmas(grid):
+    directions = [
+        (0, 1), (0, -1), (1, 0), (-1, 0),  # right, left, down, up
+        (1, 1), (1, -1), (-1, 1), (-1, -1) # diagonals: down-right, down-left, up-right, up-left
+    ]
+    word = "XMAS"
+    count = 0
+    rows, cols = len(grid), len(grid[0])
+    
+    for r in range(rows):
+        for c in range(cols):
+            for dr, dc in directions:
+                if all(0 <= r + i * dr < rows and 0 <= c + i * dc < cols and grid[r + i * dr][c + i * dc] == word[i] for i in range(len(word))):
+                    count += 1
+    return count
+
+def count_x_mas(grid):
+    count = 0
+    rows, cols = len(grid), len(grid[0])
+    
+    for r in range(1, rows - 1):
+        for c in range(1, cols - 1):
+            # Check for X-MAS pattern
+            if (grid[r-1][c-1] == 'M' and grid[r][c-1] == 'A' and grid[r+1][c-1] == 'S' and
+                grid[r-1][c+1] == 'M' and grid[r][c+1] == 'A' and grid[r+1][c+1] == 'S'):
+                count += 1
+            if (grid[r-1][c+1] == 'M' and grid[r][c+1] == 'A' and grid[r+1][c+1] == 'S' and
+                grid[r-1][c-1] == 'M' and grid[r][c-1] == 'A' and grid[r+1][c-1] == 'S'):
+                count += 1
+    return count
+
+file = "input.txt"
+grid = read_input(file)
+
+# Part 1
+result1 = count_xmas(grid)
+print(result1)
+
+# Part 2
+result2 = count_x_mas(grid)
+print(result2)

day04/solution_jerpint.py

@@ -0,0 +1,75 @@
+with open("input.txt") as f:
+    raw_data = f.readlines()
+
+data = []
+
+for line in raw_data:
+    data.append(list(line.strip("\n")))
+
+M = len(data)
+N = len(data[0])
+
+targets = ["XMAS", "SAMX"]
+
+## Part 1
+total = 0
+for i in range(M):
+    for j in range(N):
+
+        if j < N - 3:
+            # Check horizontally
+            line = data[i]
+            if "".join(line[j:j+4]) in targets:
+                total += 1
+
+        if i < M - 3:
+            # Check vertically
+            to_check = [data[i+a][j] for a in range(4)]
+            if "".join(to_check) in targets:
+                total += 1
+
+        # Check diagonally
+        directions = [(0,0), (1,1),(2,2),(3,3)]
+        to_check = ""
+        for dx, dy in directions:
+            if (i+dx) in range(M) and (j+dy) in range(N):
+                to_check += data[i+dx][j+dy]
+
+        if to_check in targets:
+            total += 1
+
+        # Check other diagonal
+        directions = [(0,0), (-1,1),(-2, 2),(-3, 3)]
+        to_check = ""
+        for dx, dy in directions:
+            if (i+dx) in range(M) and (j+dy) in range(N):
+                to_check += data[i+dx][j+dy]
+
+        if to_check in targets:
+            total += 1
+
+
+print(total)
+
+
+## Part 2
+targets = ["SAM", "MAS"]
+total = 0
+for i in range(M):
+    for j in range(N):
+        if data[i][j] == "A":
+            dir1 = [(-1,-1), (0,0), (1,1)]
+            to_check1 = ""
+            for dx, dy in dir1:
+                if (i+dx) in range(M) and (j+dy) in range(N):
+                    to_check1 += data[i+dx][j+dy]
+
+            dir2 = [(1,-1), (0,0), (-1,1)]
+            to_check2 = ""
+            for dx, dy in dir2:
+                if (i+dx) in range(M) and (j+dy) in range(N):
+                    to_check2 += data[i+dx][j+dy]
+
+            if to_check1 in targets and to_check2 in targets:
+                total += 1
+print(total)

day05/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,102 @@
+from collections import defaultdict
+import copy
+
+def parse_input(filename):
+    rules = []
+    updates = []
+    with open(filename) as f:
+        lines = f.read().strip().split('\n')
+        
+    # Find the empty line that separates rules and updates
+    separator = lines.index('')
+    
+    # Parse rules
+    for line in lines[:separator]:
+        x, y = map(int, line.split('|'))
+        rules.append((x, y))
+    
+    # Parse updates
+    for line in lines[separator+1:]:
+        update = list(map(int, line.split(',')))
+        updates.append(update)
+    
+    return rules, updates
+
+def build_graph(rules):
+    # Build adjacency list representation
+    graph = defaultdict(list)
+    for x, y in rules:
+        graph[x].append(y)
+    return graph
+
+def is_valid_order(nums, graph):
+    # Check if current order satisfies all rules
+    num_set = set(nums)
+    for i, num in enumerate(nums):
+        for next_num in graph[num]:
+            if next_num in num_set:
+                # If there's a rule num->next_num, check if next_num appears after num
+                next_pos = nums.index(next_num)
+                if next_pos < i:
+                    return False
+    return True
+
+def topological_sort(nums, graph):
+    # Create a graph only with the numbers in the update
+    num_set = set(nums)
+    local_graph = defaultdict(list)
+    in_degree = defaultdict(int)
+    
+    # Initialize in-degree for all numbers
+    for num in nums:
+        in_degree[num] = 0
+    
+    # Build local graph and calculate in-degrees
+    for num in nums:
+        for next_num in graph[num]:
+            if next_num in num_set:
+                local_graph[num].append(next_num)
+                in_degree[next_num] += 1
+    
+    # Find all nodes with in-degree 0
+    queue = [num for num in nums if in_degree[num] == 0]
+    result = []
+    
+    while queue:
+        current = queue.pop(0)
+        result.append(current)
+        
+        for next_num in local_graph[current]:
+            in_degree[next_num] -= 1
+            if in_degree[next_num] == 0:
+                queue.append(next_num)
+    
+    return result
+
+def get_middle_number(nums):
+    return nums[len(nums)//2]
+
+# Read and parse input
+rules, updates = parse_input("input.txt")
+graph = build_graph(rules)
+
+# Part 1: Sum middle numbers of correctly ordered updates
+valid_sum = 0
+invalid_updates = []
+
+for update in updates:
+    if is_valid_order(update, graph):
+        valid_sum += get_middle_number(update)
+    else:
+        invalid_updates.append(update)
+
+print(str(valid_sum))
+
+# Part 2: Sum middle numbers of corrected invalid updates
+invalid_sum = 0
+
+for update in invalid_updates:
+    sorted_update = topological_sort(update, graph)
+    invalid_sum += get_middle_number(sorted_update)
+
+print(str(invalid_sum))

day05/solution_gemini-1.5-pro.py

@@ -0,0 +1,61 @@
+from collections import defaultdict
+
+def parse_input(file):
+    with open(file, 'r') as f:
+        lines = f.read().splitlines()
+    rules_raw, updates_raw = lines[:lines.index('')], lines[lines.index('') + 1:]
+    rules = {}
+    for rule in rules_raw:
+        a, b = map(int, rule.split('|'))
+        rules[(a, b)] = True
+    updates = []
+    for update in updates_raw:
+        updates.append(list(map(int, update.split(','))))
+    return rules, updates
+
+def is_correct_order(update, rules):
+    for i in range(len(update)):
+        for j in range(i + 1, len(update)):
+            if (update[j], update[i]) in rules:
+                return False
+    return True
+
+def get_middle_page(update):
+    return update[len(update) // 2]
+
+def topological_sort(update, rules):
+    graph = defaultdict(list)
+    in_degree = defaultdict(int)
+    nodes = set(update)
+    for i in nodes:
+        for j in nodes:
+            if (i, j) in rules:
+                graph[i].append(j)
+                in_degree[j] += 1
+
+    queue = [node for node in nodes if in_degree[node] == 0]
+    result = []
+    while queue:
+        u = queue.pop(0)
+        result.append(u)
+        for v in graph[u]:
+            in_degree[v] -= 1
+            if in_degree[v] == 0:
+                queue.append(v)
+    return result
+
+file = "./input.txt"
+rules, updates = parse_input(file)
+
+correct_sum = 0
+incorrect_sum = 0
+
+for update in updates:
+    if is_correct_order(update, rules):
+        correct_sum += get_middle_page(update)
+    else:
+        correct_update = topological_sort(update, rules)
+        incorrect_sum += get_middle_page(correct_update)
+
+print(correct_sum)
+print(incorrect_sum)

day05/solution_gpt-4o.py

@@ -0,0 +1,77 @@
+from collections import defaultdict, deque
+
+def parse_input(file):
+    with open(file, 'r') as f:
+        lines = f.read().strip().split('\n')
+    
+    # Separate rules and updates
+    rules = []
+    updates = []
+    is_update_section = False
+    
+    for line in lines:
+        if '|' in line:
+            rules.append(tuple(map(int, line.split('|'))))
+        else:
+            updates.append(list(map(int, line.split(','))))
+    
+    return rules, updates
+
+def is_correct_order(update, rules):
+    # Create a map of page to its index in the update
+    index_map = {page: i for i, page in enumerate(update)}
+    
+    for x, y in rules:
+        if x in index_map and y in index_map:
+            if index_map[x] > index_map[y]:
+                return False
+    return True
+
+def find_middle_page(update):
+    n = len(update)
+    return update[n // 2]
+
+def reorder_update(update, rules):
+    # Create a graph and in-degree count for topological sorting
+    graph = defaultdict(list)
+    in_degree = defaultdict(int)
+    
+    # Only consider rules that involve pages in the current update
+    update_set = set(update)
+    for x, y in rules:
+        if x in update_set and y in update_set:
+            graph[x].append(y)
+            in_degree[y] += 1
+    
+    # Initialize queue with nodes having zero in-degree
+    queue = deque([page for page in update if in_degree[page] == 0])
+    sorted_update = []
+    
+    while queue:
+        node = queue.popleft()
+        sorted_update.append(node)
+        for neighbor in graph[node]:
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+    
+    return sorted_update
+
+def main():
+    file = "input.txt"
+    rules, updates = parse_input(file)
+    
+    correct_order_sum = 0
+    incorrect_order_sum = 0
+    
+    for update in updates:
+        if is_correct_order(update, rules):
+            correct_order_sum += find_middle_page(update)
+        else:
+            reordered_update = reorder_update(update, rules)
+            incorrect_order_sum += find_middle_page(reordered_update)
+    
+    print(correct_order_sum)
+    print(incorrect_order_sum)
+
+main()

day05/solution_jerpint.py

@@ -0,0 +1,92 @@
+with open("input.txt") as f:
+    data = f.readlines()
+
+
+def check_rule(pages: list[str], rule):
+    page2idx = {p: idx for idx, p in enumerate(pages)}
+    r0, r1 = rule
+    idx0 = page2idx.get(r0)
+    idx1 = page2idx.get(r1)
+
+    if idx0 is None or idx1 is None:
+        return True # "pass"
+
+    return idx0 < idx1
+
+
+def check_rules(pages, rules):
+    for rule in rules:
+        passes = check_rule(pages, rule)
+
+        if not passes:
+            return False
+
+    return True
+
+
+rules = []
+page_numbers = []
+for line in data:
+    line = line.strip("\n")
+    if "|" in line:
+        r1, r2 = [int(r) for r in line.split("|")]
+        rules.append((r1, r2))
+
+    elif len(line) > 0:
+        page_numbers.append([int(r) for r in line.split(",")])
+
+
+total = 0
+for pages in page_numbers:
+    passes = check_rules(pages, rules)
+
+    if passes:
+        mid_idx = len(pages) // 2
+        total += pages[mid_idx]
+
+print(total)
+
+## Part 2
+
+def return_failing_rule(pages, rules):
+    for rule in rules:
+        passes = check_rule(pages, rule)
+
+        if not passes:
+            return rule
+
+    return None
+
+
+def update_pages(pages, failed_rule):
+    "Swap the pages given the failed rule"
+    page2idx = {p: idx for idx, p in enumerate(pages)}
+    r0, r1 = failed_rule
+    idx0 = page2idx.get(r0)
+    idx1 = page2idx.get(r1)
+    new_pages = pages.copy()
+    new_pages[idx0] = r1
+    new_pages[idx1] = r0
+    return new_pages
+
+
+def fix_pages(pages, rules):
+    failed_rule = return_failing_rule(pages, rules)
+    while failed_rule:
+        pages = update_pages(pages, failed_rule)
+        failed_rule = return_failing_rule(pages, rules)
+
+    return pages
+
+
+
+total = 0
+for pages in page_numbers:
+    passes = check_rules(pages, rules)
+
+    if not passes:
+        new_pages = fix_pages(pages, rules)
+        mid_idx = len(pages) // 2
+        total += new_pages[mid_idx]
+
+print(total)

day06/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,76 @@
+def parse_input(file):
+    with open(file, 'r') as f:
+        return [list(line.strip()) for line in f.readlines()]
+
+def get_start_position(grid):
+    for y in range(len(grid)):
+        for x in range(len(grid[0])):
+            if grid[y][x] == '^':
+                return (x, y, 0)  # x, y, direction (0=up, 1=right, 2=down, 3=left)
+    return None
+
+def is_valid_position(x, y, grid):
+    return 0 <= y < len(grid) and 0 <= x < len(grid[0])
+
+def get_next_position(x, y, direction):
+    if direction == 0:  # up
+        return (x, y-1)
+    elif direction == 1:  # right
+        return (x+1, y)
+    elif direction == 2:  # down
+        return (x, y+1)
+    else:  # left
+        return (x-1, y)
+
+def simulate_path(grid, start_pos=None, added_obstacle=None):
+    if start_pos is None:
+        start_pos = get_start_position(grid)
+    x, y, direction = start_pos
+    visited = set([(x, y)])
+    
+    while True:
+        next_x, next_y = get_next_position(x, y, direction)
+        
+        # Check if out of bounds
+        if not is_valid_position(next_x, next_y, grid):
+            return visited, False
+            
+        # Check if obstacle ahead (including added obstacle)
+        if (grid[next_y][next_x] == '#' or (next_x, next_y) == added_obstacle):
+            direction = (direction + 1) % 4
+        else:
+            x, y = next_x, next_y
+            visited.add((x, y))
+            
+            # Check for loop
+            if len(visited) > len(grid) * len(grid[0]) * 4:
+                return visited, True
+
+def solve_part1(grid):
+    visited, _ = simulate_path(grid)
+    return len(visited)
+
+def solve_part2(grid):
+    start_pos = get_start_position(grid)
+    loop_positions = 0
+    
+    for y in range(len(grid)):
+        for x in range(len(grid[0])):
+            # Skip if not empty space or start position
+            if grid[y][x] != '.' or (x, y) == (start_pos[0], start_pos[1]):
+                continue
+                
+            # Try adding obstacle here
+            _, creates_loop = simulate_path(grid, start_pos, (x, y))
+            if creates_loop:
+                loop_positions += 1
+                
+    return loop_positions
+
+def main():
+    grid = parse_input("input.txt")
+    print(str(solve_part1(grid)))
+    print(str(solve_part2(grid)))
+
+if __name__ == "__main__":
+    main()

day06/solution_gemini-1.5-pro.py

@@ -0,0 +1,67 @@
+def solve():
+    file = "input.txt"
+    grid = []
+    with open(file, 'r') as f:
+        for line in f:
+            grid.append(list(line.strip()))
+
+    rows = len(grid)
+    cols = len(grid[0])
+
+    def find_guard():
+        for r in range(rows):
+            for c in range(cols):
+                if grid[r][c] == '^':
+                    return r, c, 0  # row, col, direction (0: up, 1: right, 2: down, 3: left)
+
+    def is_valid(r, c):
+        return 0 <= r < rows and 0 <= c < cols
+
+    def move_guard(r, c, direction):
+        dr = [-1, 0, 1, 0]
+        dc = [0, 1, 0, -1]
+
+        nr, nc = r + dr[direction], c + dc[direction]
+        if is_valid(nr, nc) and grid[nr][nc] != '#':
+            return nr, nc, direction
+        else:
+            return r, c, (direction + 1) % 4
+
+    # Part 1
+    visited = set()
+    r, c, direction = find_guard()
+    while is_valid(r, c):
+        visited.add((r, c))
+        r, c, direction = move_guard(r, c, direction)
+    print(len(visited))
+
+
+    # Part 2
+    def simulate_with_obstacle(obstacle_r, obstacle_c):
+        temp_grid = [row[:] for row in grid]
+        temp_grid[obstacle_r][obstacle_c] = '#'
+        visited = set()
+        r, c, direction = find_guard()
+        while (r,c) not in visited and is_valid(r,c):
+            visited.add((r,c))
+            
+            dr = [-1, 0, 1, 0]
+            dc = [0, 1, 0, -1]
+
+            nr, nc = r + dr[direction], c + dc[direction]
+            if is_valid(nr, nc) and temp_grid[nr][nc] != '#':
+                r,c = nr,nc
+            else:
+                direction = (direction + 1) % 4
+        return (r,c) in visited
+
+    loop_count = 0
+    start_r, start_c, _ = find_guard()
+    for r in range(rows):
+        for c in range(cols):
+            if grid[r][c] == '.' and (r, c) != (start_r, start_c):
+                if simulate_with_obstacle(r, c):
+                    loop_count += 1
+    print(loop_count)
+
+solve()

day06/solution_gpt-4o.py

@@ -0,0 +1,78 @@
+def parse_input(file):
+    with open(file, 'r') as f:
+        grid = [list(line.strip()) for line in f.readlines()]
+    return grid
+
+def find_guard_start(grid):
+    directions = {'^': (0, -1), '>': (1, 0), 'v': (0, 1), '<': (-1, 0)}
+    for y, row in enumerate(grid):
+        for x, cell in enumerate(row):
+            if cell in directions:
+                return (x, y), directions[cell]
+    return None, None
+
+def turn_right(direction):
+    right_turns = {(0, -1): (1, 0), (1, 0): (0, 1), (0, 1): (-1, 0), (-1, 0): (0, -1)}
+    return right_turns[direction]
+
+def move(position, direction):
+    return position[0] + direction[0], position[1] + direction[1]
+
+def is_within_bounds(position, grid):
+    x, y = position
+    return 0 <= x < len(grid[0]) and 0 <= y < len(grid)
+
+def simulate_guard(grid):
+    start_pos, direction = find_guard_start(grid)
+    visited = set()
+    position = start_pos
+
+    while is_within_bounds(position, grid):
+        visited.add(position)
+        next_position = move(position, direction)
+        if is_within_bounds(next_position, grid) and grid[next_position[1]][next_position[0]] == '#':
+            direction = turn_right(direction)
+        else:
+            position = next_position
+
+    return visited
+
+def simulate_with_obstruction(grid, obstruction_pos):
+    start_pos, direction = find_guard_start(grid)
+    visited = set()
+    position = start_pos
+    direction_map = {(-1, 0): '<', (0, -1): '^', (1, 0): '>', (0, 1): 'v'}
+
+    while is_within_bounds(position, grid):
+        if position == obstruction_pos:
+            return False  # Obstruction is here, can't move
+        if (position, direction) in visited:
+            return True  # Loop detected
+        visited.add((position, direction))
+        next_position = move(position, direction)
+        if is_within_bounds(next_position, grid) and (grid[next_position[1]][next_position[0]] == '#' or next_position == obstruction_pos):
+            direction = turn_right(direction)
+        else:
+            position = next_position
+
+    return False
+
+def find_loop_positions(grid):
+    loop_positions = 0
+    for y, row in enumerate(grid):
+        for x, cell in enumerate(row):
+            if cell == '.' and (x, y) != find_guard_start(grid)[0]:
+                if simulate_with_obstruction(grid, (x, y)):
+                    loop_positions += 1
+    return loop_positions
+
+file = "input.txt"
+grid = parse_input(file)
+
+# Part 1
+visited_positions = simulate_guard(grid)
+print(len(visited_positions))
+
+# Part 2
+loop_positions = find_loop_positions(grid)
+print(loop_positions)

day06/solution_jerpint.py

@@ -0,0 +1,205 @@
+from dataclasses import dataclass
+
+file = "input.txt"
+with open(file) as f:
+    data = f.readlines()
+
+grid = []
+for line in data:
+    line = line.strip("\n")
+    grid.append(list(line))
+
+M = len(grid)
+N = len(grid[0])
+
+@dataclass
+class Position:
+    i: int
+    j: int
+    direction: str
+
+    def rotate_90(self):
+        directions = ["^", ">", "v", "<"]
+        new_idx = (directions.index(self.direction) + 1) % len(directions)
+        self.direction = directions[new_idx]
+
+
+    def is_in_bounds(self, grid):
+        M = len(grid)
+        N = len(grid[0])
+        return self.i in range(M) and self.j in range(N)
+
+
+def get_next_pos(position: Position):
+    i, j, direction = position.i, position.j, position.direction
+    if direction == "^":
+        # Up
+        i -= 1
+
+    elif direction == "v":
+        # Down
+        i += 1
+
+    elif direction == "<":
+        # Left
+        j -= 1
+
+    elif direction == ">":
+        # Right
+        j += 1
+
+    return Position(i, j, direction)
+
+def get_start_pos(grid):
+
+    M = len(grid)
+    N = len(grid[0])
+
+    for i in range(M):
+        for j in range(N):
+            if grid[i][j] == "^":
+                return Position(i, j, "^")
+
+
+def count_Xs(grid):
+    total = 0
+    for i in range(M):
+        for j in range(N):
+            if grid[i][j] == "X":
+                total += 1
+    return total
+
+
+def pprint(grid, pos = None):
+
+    grid_copy = grid.copy()
+
+    if pos:
+        # Print the current position
+        grid_copy[pos.i][pos.j] = pos.direction
+
+    grid_str = ""
+
+    for line in grid_copy:
+        grid_str += "".join(line)
+        grid_str += "\n"
+
+    print("*"*20)
+    print()
+    print(grid_str)
+    print()
+    print("*"*20)
+
+
+
+pos = get_start_pos(grid)
+
+grid[pos.i][pos.j] = "X"  # Mark starting point as visited
+in_bounds = True
+while in_bounds:
+    #  pprint(grid, pos)
+    next_pos = get_next_pos(pos)
+    if next_pos.is_in_bounds(grid):
+
+        if grid[next_pos.i][next_pos.j] in [".", "X"]:
+            # Valid next mode, mark as visited and move
+            grid[pos.i][pos.j] = "X"
+            pos = next_pos
+        else:
+            # Otherwise, rotate
+            pos.rotate_90()
+    else:
+        # Out of bounds, game over
+        in_bounds = False
+        grid[pos.i][pos.j] = "X"
+        pos = None
+
+#  pprint(grid, pos)
+print(count_Xs(grid))
+
+
+### Part 2
+
+prev_grid = grid.copy()
+
+def load_grid(file):
+    with open(file) as f:
+        data = f.readlines()
+
+    grid = []
+    for line in data:
+        line = line.strip("\n")
+        grid.append(list(line))
+
+    return grid
+
+
+def check_is_infinite(grid):
+
+    pos = get_start_pos(grid)
+    grid[pos.i][pos.j] = "X"  # Mark starting point as visited
+
+    visited = set()  # Keep track of positions and orientations
+    in_bounds = True
+    infinite_loop = False
+    while in_bounds and not infinite_loop:
+        #  pprint(grid, pos)
+        next_pos = get_next_pos(pos)
+        if next_pos.is_in_bounds(grid):
+
+            if grid[next_pos.i][next_pos.j] in [".", "X"]:
+                # Valid next mode, mark as visited and move
+                grid[pos.i][pos.j] = "X"
+                pos = next_pos
+            else:
+                # Otherwise, rotate
+                pos.rotate_90()
+
+
+            set_pos = (pos.i, pos.j, pos.direction)
+            if set_pos in visited:
+                infinite_loop = True
+            else:
+                visited.add(set_pos)
+        else:
+            # Out of bounds, game over
+            in_bounds = False
+            grid[pos.i][pos.j] = "X"
+            pos = None
+
+    return infinite_loop
+
+file = "input.txt"
+
+# Load first to get stats
+#  grid = load_grid(file)
+M = len(grid)
+N = len(grid[0])
+
+# This is a very brute-force solution, takes long to run...
+# For every point, place an obstacle, run the game, check if it gets stuck in infinite loop or not
+# Surely, there must be a quicker way, but it works
+
+total = 0
+for i in range(M):
+    for j in range(N):
+
+        # Reset grid
+        grid = load_grid(file)
+        start_pos = get_start_pos(grid)
+
+
+        if start_pos.i == i and start_pos.j == j:
+            # Can't set obstacle on starting point, ignore
+            continue
+
+        if prev_grid[i][j] != "X":
+            # It never passed by there, so we can ignore
+            continue
+
+        #  print(i, j)
+
+        grid[i][j] = "O"  # Set Obstacle
+        if check_is_infinite(grid):
+            total += 1
+print(total)

day07/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,57 @@
+def parse_input(filename):
+    equations = []
+    with open(filename, 'r') as f:
+        for line in f:
+            test_value, numbers = line.strip().split(': ')
+            test_value = int(test_value)
+            numbers = [int(x) for x in numbers.split()]
+            equations.append((test_value, numbers))
+    return equations
+
+def evaluate(numbers, operators):
+    result = numbers[0]
+    for i, op in enumerate(operators):
+        if op == '+':
+            result += numbers[i + 1]
+        elif op == '*':
+            result *= numbers[i + 1]
+        elif op == '||':
+            result = int(str(result) + str(numbers[i + 1]))
+    return result
+
+def try_all_combinations(test_value, numbers, operators_set):
+    if len(numbers) == 1:
+        return test_value == numbers[0]
+    
+    n = len(numbers) - 1  # number of operators needed
+    for ops in itertools.product(operators_set, repeat=n):
+        if evaluate(numbers, ops) == test_value:
+            return True
+    return False
+
+import itertools
+
+def solve_part1(equations):
+    total = 0
+    operators = ['+', '*']
+    
+    for test_value, numbers in equations:
+        if try_all_combinations(test_value, numbers, operators):
+            total += test_value
+    
+    return str(total)
+
+def solve_part2(equations):
+    total = 0
+    operators = ['+', '*', '||']
+    
+    for test_value, numbers in equations:
+        if try_all_combinations(test_value, numbers, operators):
+            total += test_value
+    
+    return str(total)
+
+# Read input and solve both parts
+equations = parse_input("./input.txt")
+print(solve_part1(equations))
+print(solve_part2(equations))

day07/solution_gemini-1.5-pro.py

@@ -0,0 +1,56 @@
+def solve_part1(equation):
+    test_value, numbers_str = equation.split(":")
+    test_value = int(test_value)
+    numbers = [int(x) for x in numbers_str.split()]
+
+    def evaluate(index, current_value):
+        if index == len(numbers):
+            return current_value == test_value
+
+        if evaluate(index + 1, current_value + numbers[index]):
+            return True
+        if evaluate(index + 1, current_value * numbers[index]):
+            return True
+        return False
+
+    return evaluate(1, numbers[0])
+
+def solve_part2(equation):
+    test_value, numbers_str = equation.split(":")
+    test_value = int(test_value)
+    numbers = [int(x) for x in numbers_str.split()]
+
+    def evaluate(index, current_value):
+        if index == len(numbers):
+            return current_value == test_value
+
+        if evaluate(index + 1, current_value + numbers[index]):
+            return True
+        if evaluate(index + 1, current_value * numbers[index]):
+            return True
+        if evaluate(index + 1, int(str(current_value) + str(numbers[index]))):
+            return True
+
+        return False
+    return evaluate(1, numbers[0])
+
+
+with open("./input.txt") as f:
+    equations = f.readlines()
+
+part1_sum = 0
+for equation in equations:
+    if solve_part1(equation.strip()):
+        test_value, _ = equation.split(":")
+        part1_sum += int(test_value)
+
+print(part1_sum)
+
+
+part2_sum = 0
+for equation in equations:
+    if solve_part2(equation.strip()):
+        test_value, _ = equation.split(":")
+        part2_sum += int(test_value)
+
+print(part2_sum)

day07/solution_gpt-4o.py

@@ -0,0 +1,34 @@
+from itertools import product
+
+def evaluate_expression(numbers, operators):
+    result = numbers[0]
+    for i, op in enumerate(operators):
+        if op == '+':
+            result += numbers[i + 1]
+        elif op == '*':
+            result *= numbers[i + 1]
+        elif op == '||':
+            result = int(str(result) + str(numbers[i + 1]))
+    return result
+
+def is_valid_equation(test_value, numbers):
+    num_operators = len(numbers) - 1
+    for ops in product(['+', '*', '||'], repeat=num_operators):
+        if evaluate_expression(numbers, ops) == test_value:
+            return True
+    return False
+
+def main():
+    total_calibration_result = 0
+    with open("input.txt", "r") as file:
+        for line in file:
+            test_value_str, numbers_str = line.split(':')
+            test_value = int(test_value_str.strip())
+            numbers = list(map(int, numbers_str.split()))
+            
+            if is_valid_equation(test_value, numbers):
+                total_calibration_result += test_value
+
+    print(total_calibration_result)
+
+main()

day07/solution_jerpint.py

@@ -0,0 +1,115 @@
+def parse_data(file):
+    with open(file) as f:
+        raw_data = f.readlines()
+
+    # Read and parse the data
+    data = []
+    for line in raw_data:
+        line = line.strip("\n")
+        target, nums = line.split(":")
+        target = int(target)
+        nums = [int(num) for num in nums.split()]
+        data.append((target, nums))
+    return data
+
+
+def compute(a, b, op):
+    """Compute given the op"""
+    if op == "+":
+        return a + b
+    if op == "*":
+        return a * b
+
+
+def check_seq(nums, target, seq):
+    total = nums[0]
+    for i in range(len(seq)):
+        b = nums[i+1]
+        op = seq[i]
+
+        total = compute(total, b, op)
+
+        if total > target:
+            # Dead-end
+            return -1
+
+    # Check that we equal target and use all nums
+    return total == target and len(seq) == len(nums) - 1
+
+
+def bfs(target, nums, ops):
+    q = ops.copy()
+    dead_ends = set()
+
+    while len(q) > 0:
+        #  print(q)
+        #  print(dead_ends)
+        seq = q.pop(0)
+
+        if seq in dead_ends:
+            break
+
+        check = check_seq(nums, target, seq)
+
+        #  print(nums, target, seq, check)
+
+        if check == -1:
+            dead_ends.add(seq)
+            continue
+
+        elif check == True:
+            return True
+
+        else:
+            if len(seq) < len(nums)-1:
+                for op in ops:
+                    q.append(seq+op)
+
+    return False
+
+data = parse_data(file="input.txt")
+ops = ["+", "*"]
+total = 0
+for target, nums in data:
+
+    result = bfs(target, nums, ops)
+    #  print("*"*20)
+    #  print(target, nums)
+    #  print("Result:", result)
+    #  print("*"*20)
+
+    if result:
+        total += target
+
+print(total)
+
+## Part 2
+
+def compute(a, b, op):
+    """Compute given the op"""
+    if op == "+":
+        return a + b
+    elif op == "*":
+        return a * b
+    elif op == "|":
+        return int(str(a) + str(b))
+    else:
+        raise ValueError(f"Op {op} Unknown")
+
+
+
+ops = ["+", "*", "|"]
+data = parse_data(file="input.txt")
+total = 0
+for target, nums in data:
+
+    result = bfs(target, nums, ops)
+    #  print("*"*20)
+    #  print(target, nums)
+    #  print("Result:", result)
+    #  print("*"*20)
+
+    if result:
+        total += target
+
+print(total)

day08/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,86 @@
+def read_input(file_path):
+    with open(file_path, 'r') as f:
+        return [line.strip() for line in f.readlines()]
+
+def find_antennas(grid):
+    antennas = {}
+    for y in range(len(grid)):
+        for x in range(len(grid[y])):
+            if grid[y][x] not in '.':
+                freq = grid[y][x]
+                if freq not in antennas:
+                    antennas[freq] = []
+                antennas[freq].append((x, y))
+    return antennas
+
+def is_collinear(p1, p2, p3):
+    x1, y1 = p1
+    x2, y2 = p2
+    x3, y3 = p3
+    return (y2-y1)*(x3-x1) == (y3-y1)*(x2-x1)
+
+def distance_squared(p1, p2):
+    return (p2[0]-p1[0])**2 + (p2[1]-p1[1])**2
+
+def find_antinodes_part1(grid, antennas):
+    antinodes = set()
+    height, width = len(grid), len(grid[0])
+    
+    for freq, positions in antennas.items():
+        if len(positions) < 2:
+            continue
+            
+        for i in range(len(positions)):
+            for j in range(i+1, len(positions)):
+                a1, a2 = positions[i], positions[j]
+                
+                # Check all points in the grid
+                for y in range(height):
+                    for x in range(width):
+                        point = (x, y)
+                        if point == a1 or point == a2:
+                            continue
+                            
+                        if is_collinear(a1, a2, point):
+                            d1 = distance_squared(point, a1)
+                            d2 = distance_squared(point, a2)
+                            if d1 == 2*d2 or d2 == 2*d1:
+                                antinodes.add(point)
+    
+    return len(antinodes)
+
+def find_antinodes_part2(grid, antennas):
+    antinodes = set()
+    height, width = len(grid), len(grid[0])
+    
+    for freq, positions in antennas.items():
+        if len(positions) < 2:
+            continue
+            
+        # Add antenna positions as antinodes if there are multiple antennas of same frequency
+        antinodes.update(positions)
+        
+        # Check all points in the grid
+        for y in range(height):
+            for x in range(width):
+                point = (x, y)
+                
+                # Count how many pairs of antennas this point is collinear with
+                for i in range(len(positions)):
+                    for j in range(i+1, len(positions)):
+                        if is_collinear(positions[i], positions[j], point):
+                            antinodes.add(point)
+    
+    return len(antinodes)
+
+def solve(file_path):
+    grid = read_input(file_path)
+    antennas = find_antennas(grid)
+    
+    part1 = find_antinodes_part1(grid, antennas)
+    part2 = find_antinodes_part2(grid, antennas)
+    
+    print(str(part1))
+    print(str(part2))
+
+solve("./input.txt")

day08/solution_gemini-1.5-pro.py

@@ -0,0 +1,48 @@
+def solve():
+    with open("./input.txt", "r") as f:
+        grid = [list(line.strip()) for line in f]
+
+    rows = len(grid)
+    cols = len(grid[0])
+
+    def part1():
+        antinodes = set()
+        for r1 in range(rows):
+            for c1 in range(cols):
+                freq = grid[r1][c1]
+                for r2 in range(rows):
+                    for c2 in range(cols):
+                        if grid[r2][c2] == freq and (r1, c1) != (r2, c2):
+                            dr = r2 - r1
+                            dc = c2 - c1
+                            
+                            r3 = r2 + dr
+                            c3 = c2 + dc
+                            if 0 <= r3 < rows and 0 <= c3 < cols:
+                                antinodes.add((r3, c3))
+
+                            r3 = r1 - dr
+                            c3 = c1 - dc
+                            if 0 <= r3 < rows and 0 <= c3 < cols:
+                                antinodes.add((r3, c3))
+        return len(antinodes)
+
+    def part2():
+        antinodes = set()
+        for r1 in range(rows):
+            for c1 in range(cols):
+                freq = grid[r1][c1]
+                for r2 in range(rows):
+                    for c2 in range(cols):
+                        if grid[r2][c2] == freq and (r1, c1) != (r2, c2):
+                            for r3 in range(rows):
+                                for c3 in range(cols):
+                                    if (r3*(c2-c1) - c3*(r2-r1)) == (r1*(c2-c1) - c1*(r2-r1)):
+                                        antinodes.add((r3,c3))
+        return len(antinodes)
+
+
+    print(part1())
+    print(part2())
+
+solve()

day08/solution_gpt-4o.py

@@ -0,0 +1,80 @@
+def parse_input(file):
+    with open(file, 'r') as f:
+        grid = [line.strip() for line in f.readlines()]
+    return grid
+
+def find_antennas(grid):
+    antennas = {}
+    for y, row in enumerate(grid):
+        for x, char in enumerate(row):
+            if char != '.':
+                if char not in antennas:
+                    antennas[char] = []
+                antennas[char].append((x, y))
+    return antennas
+
+def calculate_antinodes_part_one(antennas):
+    antinodes = set()
+    for freq, positions in antennas.items():
+        n = len(positions)
+        for i in range(n):
+            for j in range(i + 1, n):
+                x1, y1 = positions[i]
+                x2, y2 = positions[j]
+                # Check for antinodes on the line between (x1, y1) and (x2, y2)
+                if x1 == x2:  # Vertical line
+                    for y in range(min(y1, y2) - abs(y2 - y1), max(y1, y2) + abs(y2 - y1) + 1):
+                        if y != y1 and y != y2:
+                            antinodes.add((x1, y))
+                elif y1 == y2:  # Horizontal line
+                    for x in range(min(x1, x2) - abs(x2 - x1), max(x1, x2) + abs(x2 - x1) + 1):
+                        if x != x1 and x != x2:
+                            antinodes.add((x, y1))
+                else:  # Diagonal line
+                    dx = x2 - x1
+                    dy = y2 - y1
+                    for k in range(-max(abs(dx), abs(dy)), max(abs(dx), abs(dy)) + 1):
+                        x = x1 + k * dx
+                        y = y1 + k * dy
+                        if (x, y) != (x1, y1) and (x, y) != (x2, y2):
+                            antinodes.add((x, y))
+    return antinodes
+
+def calculate_antinodes_part_two(antennas):
+    antinodes = set()
+    for freq, positions in antennas.items():
+        n = len(positions)
+        for i in range(n):
+            for j in range(i + 1, n):
+                x1, y1 = positions[i]
+                x2, y2 = positions[j]
+                # Mark all points in line with at least two antennas
+                if x1 == x2:  # Vertical line
+                    for y in range(min(y1, y2), max(y1, y2) + 1):
+                        antinodes.add((x1, y))
+                elif y1 == y2:  # Horizontal line
+                    for x in range(min(x1, x2), max(x1, x2) + 1):
+                        antinodes.add((x, y1))
+                else:  # Diagonal line
+                    dx = x2 - x1
+                    dy = y2 - y1
+                    for k in range(max(abs(dx), abs(dy)) + 1):
+                        x = x1 + k * (dx // abs(dx))
+                        y = y1 + k * (dy // abs(dy))
+                        antinodes.add((x, y))
+    return antinodes
+
+def main():
+    file = "input.txt"
+    grid = parse_input(file)
+    antennas = find_antennas(grid)
+    
+    # Part One
+    antinodes_part_one = calculate_antinodes_part_one(antennas)
+    print(len(antinodes_part_one))
+    
+    # Part Two
+    antinodes_part_two = calculate_antinodes_part_two(antennas)
+    print(len(antinodes_part_two))
+
+main()

day08/solution_jerpint.py

@@ -0,0 +1,142 @@
+def load_data(file):
+    with open(file) as f:
+        raw_data = f.readlines()
+
+    grid = []
+    for line in raw_data:
+        line = line.strip("\n")
+        grid.append(list(line))
+    return grid
+
+
+def get_antennas(grid):
+
+    M = len(grid)
+    N = len(grid[0])
+
+    antennas = {}
+    for i in range(M):
+        for j in range(N):
+            if grid[i][j] != ".":
+                a = grid[i][j]
+                if antennas.get(a):
+                    antennas[a].append((i,j))
+                else:
+                    antennas[a] = [(i,j)]
+    return antennas
+
+
+def get_next_nodes(a, b):
+
+    # Get direction vector
+    dx = b[0] - a[0]
+    dy = b[1] - a[1]
+
+    node_a = (a[0] - dx, a[1] - dy)  # Subtract from first node
+    node_b = (b[0] + dx, b[1] + dy)  # Add to second node
+
+    return node_a, node_b
+
+
+def add_antinode(a, grid):
+    M = len(grid)
+    N = len(grid[0])
+    i,j = a
+    if i in range(M) and j in range(N):
+        grid[i][j] = '#'
+
+
+def count_antinodes(grid):
+    M = len(grid)
+    N = len(grid[0])
+
+    total = 0
+    for i in range(M):
+        for j in range(N):
+            if grid[i][j] == '#':
+                total += 1
+    return total
+
+
+def add_antinodes(a, b, grid):
+    next_nodes = get_next_nodes(a,b)
+
+    for node in next_nodes:
+        add_antinode(node, grid)
+
+
+grid = load_data("input.txt")
+antennas = get_antennas(grid)
+
+for freq in antennas:
+
+    # Get all positions for a given freq.
+    positions = antennas[freq]
+    for i in range(len(positions)):
+        for j in range(i+1, len(positions)):
+            # For each pair of antennas, add the antinodes
+            a, b = positions[i], positions[j]
+            add_antinodes(a, b, grid)
+
+print(count_antinodes(grid))
+
+
+## Part 2
+def get_direction_vector(a, b):
+
+    # Get direction vector
+    dx = b[0] - a[0]
+    dy = b[1] - a[1]
+
+    return dx, dy
+
+
+def is_in_bounds(node, grid):
+    M = len(grid)
+    N = len(grid[0])
+
+    i, j = node
+
+    return i in range(M) and j in range(M)
+
+def add_antinodes(a, b, grid):
+    dx, dy = get_direction_vector(a,b)
+
+    next_node = (a[0] - dx, a[1] - dy)  # Subtract from first node
+    while is_in_bounds(next_node, grid):
+        add_antinode(next_node, grid)
+        next_node = (next_node[0] - dx, next_node[1] - dy)
+
+    next_node = (b[0] + dx, b[1] + dy)  # Add to second node
+    while is_in_bounds(next_node, grid):
+        add_antinode(next_node, grid)
+        next_node = (next_node[0] + dx, next_node[1] + dy)
+
+
+def count_antinodes(grid):
+    M = len(grid)
+    N = len(grid[0])
+
+    total = 0
+    for i in range(M):
+        for j in range(N):
+            if grid[i][j] != '.':
+                # Antennas count too
+                total += 1
+    return total
+
+grid = load_data("input.txt")
+antennas = get_antennas(grid)
+
+
+for freq in antennas:
+    positions = antennas[freq]
+    for i in range(len(positions)):
+        for j in range(i+1, len(positions)):
+            a, b = positions[i], positions[j]
+            add_antinodes(a, b, grid)
+print(count_antinodes(grid))
+
+def pprint(grid):
+    grid_str = "\n".join(["".join(l) for l in grid])
+    print(grid_str)

day09/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,99 @@
+def parse_input(s):
+    # Convert the input string into alternating lengths of files and spaces
+    lengths = [int(c) for c in s]
+    
+    # Convert to blocks representation
+    blocks = []
+    file_id = 0
+    pos = 0
+    for i, length in enumerate(lengths):
+        if i % 2 == 0:  # File
+            blocks.extend([file_id] * length)
+            file_id += 1
+        else:  # Space
+            blocks.extend([-1] * length)  # -1 represents free space
+    return blocks
+
+def calculate_checksum(blocks):
+    checksum = 0
+    for pos, block in enumerate(blocks):
+        if block != -1:  # Skip free space
+            checksum += pos * block
+    return checksum
+
+def compact_blocks_part1(blocks):
+    result = blocks.copy()
+    
+    while True:
+        # Find rightmost file block
+        right = len(result) - 1
+        while right >= 0 and result[right] == -1:
+            right -= 1
+        if right < 0:
+            break
+            
+        # Find leftmost free space
+        left = 0
+        while left < len(result) and result[left] != -1:
+            left += 1
+        if left >= right:
+            break
+            
+        # Move one block
+        result[left] = result[right]
+        result[right] = -1
+        
+    return result
+
+def compact_blocks_part2(blocks):
+    result = blocks.copy()
+    
+    # Get unique file IDs in descending order
+    file_ids = sorted(set(x for x in result if x != -1), reverse=True)
+    
+    for file_id in file_ids:
+        # Find all blocks of this file
+        file_blocks = []
+        start = None
+        for i, block in enumerate(result):
+            if block == file_id:
+                if start is None:
+                    start = i
+                file_blocks.append(block)
+            elif start is not None and block != file_id:
+                break
+                
+        if not file_blocks:
+            continue
+            
+        # Remove the file from its current position
+        for i in range(start, start + len(file_blocks)):
+            result[i] = -1
+            
+        # Find leftmost position where file can fit
+        pos = 0
+        while pos < len(result):
+            if all(result[i] == -1 for i in range(pos, pos + len(file_blocks)) if i < len(result)):
+                # Place file here
+                for i in range(len(file_blocks)):
+                    result[pos + i] = file_id
+                break
+            pos += 1
+            
+    return result
+
+# Read input
+with open("input.txt", "r") as f:
+    input_data = f.read().strip()
+
+# Part 1
+blocks = parse_input(input_data)
+compacted = compact_blocks_part1(blocks)
+checksum = calculate_checksum(compacted)
+print(str(checksum))
+
+# Part 2
+blocks = parse_input(input_data)
+compacted = compact_blocks_part2(blocks)
+checksum = calculate_checksum(compacted)
+print(str(checksum))

day09/solution_gemini-1.5-pro.py

@@ -0,0 +1,82 @@
+file = "input.txt"
+
+def solve_part1(disk_map):
+    disk_blocks = []
+    file_id = 0
+    is_file = True
+    for i in range(0, len(disk_map), 2):
+        file_size = int(disk_map[i])
+        free_size = int(disk_map[i+1])
+
+        disk_blocks.extend([file_id] * file_size)
+        disk_blocks.extend(["."] * free_size)
+        file_id += 1
+    
+    disk_str = "".join(map(str,disk_blocks))
+    
+    while "." in disk_str:
+        first_dot = disk_str.find(".")
+        last_file_block = disk_str.rfind(str(file_id - 1))
+        
+        disk_list = list(disk_str)
+        disk_list[first_dot] = disk_list[last_file_block]
+        disk_list[last_file_block] = "."
+        disk_str = "".join(disk_list)
+
+    checksum = 0
+    for i in range(len(disk_str)):
+        if disk_str[i] != ".":
+            checksum += i * int(disk_str[i])
+    return checksum
+
+def solve_part2(disk_map):
+    disk_blocks = []
+    file_sizes = {}
+    file_id = 0
+    is_file = True
+    for i in range(0, len(disk_map), 2):
+        file_size = int(disk_map[i])
+        free_size = int(disk_map[i+1])
+        file_sizes[file_id] = file_size
+        disk_blocks.extend([file_id] * file_size)
+        disk_blocks.extend(["."] * free_size)
+        file_id += 1
+
+    disk_str = "".join(map(str, disk_blocks))
+
+    for fid in range(file_id - 1, -1, -1):
+        file_size = file_sizes[fid]
+        first_occurrence = disk_str.find(str(fid))
+        free_space_size = 0
+        free_space_start = -1
+
+        for i in range(len(disk_str)):
+            if disk_str[i] == ".":
+                if free_space_start == -1:
+                    free_space_start = i
+                free_space_size += 1
+            else:
+                if free_space_size >= file_size and free_space_start < first_occurrence:
+                    disk_list = list(disk_str)
+                    for j in range(file_size):
+                        disk_list[free_space_start + j] = str(fid)
+                        disk_list[first_occurrence + j] = "."
+                    disk_str = "".join(disk_list)
+                    break
+                free_space_start = -1
+                free_space_size = 0
+        
+    checksum = 0
+    for i in range(len(disk_str)):
+        if disk_str[i] != ".":
+            checksum += i * int(disk_str[i])
+    return checksum
+
+with open(file) as f:
+    disk_map = f.readline().strip()
+
+result1 = solve_part1(disk_map)
+print(result1)
+
+result2 = solve_part2(disk_map)
+print(result2)

day09/solution_gpt-4o.py

@@ -0,0 +1,80 @@
+def parse_disk_map(disk_map):
+    disk = []
+    file_id = 0
+    for i in range(0, len(disk_map), 2):
+        file_length = int(disk_map[i])
+        free_space_length = int(disk_map[i+1])
+        disk.extend([str(file_id)] * file_length)
+        disk.extend(['.'] * free_space_length)
+        file_id += 1
+    return disk
+
+def compact_disk_individual_blocks(disk):
+    # Move individual blocks to the leftmost free space
+    for i in range(len(disk)):
+        if disk[i] == '.':
+            # Find the next file block to move
+            for j in range(i + 1, len(disk)):
+                if disk[j] != '.':
+                    # Move the block
+                    disk[i], disk[j] = disk[j], disk[i]
+                    break
+    return disk
+
+def compact_disk_whole_files(disk):
+    # Move whole files to the leftmost free space
+    file_positions = []
+    current_pos = 0
+    while current_pos < len(disk):
+        if disk[current_pos] != '.':
+            file_id = disk[current_pos]
+            file_start = current_pos
+            while current_pos < len(disk) and disk[current_pos] == file_id:
+                current_pos += 1
+            file_positions.append((file_id, file_start, current_pos - file_start))
+        else:
+            current_pos += 1
+
+    # Move files in reverse order of file ID
+    for file_id, file_start, file_length in sorted(file_positions, key=lambda x: -int(x[0])):
+        # Find the leftmost free space that can fit the file
+        free_start = 0
+        while free_start < len(disk):
+            if disk[free_start] == '.':
+                free_end = free_start
+                while free_end < len(disk) and disk[free_end] == '.':
+                    free_end += 1
+                if free_end - free_start >= file_length:
+                    # Move the file
+                    for i in range(file_length):
+                        disk[free_start + i] = file_id
+                    for i in range(file_length):
+                        disk[file_start + i] = '.'
+                    break
+            free_start = free_end + 1
+    return disk
+
+def calculate_checksum(disk):
+    checksum = 0
+    for position, block in enumerate(disk):
+        if block != '.':
+            checksum += position * int(block)
+    return checksum
+
+def main():
+    with open("input.txt", "r") as file:
+        disk_map = file.readline().strip()
+
+    # Part 1
+    disk = parse_disk_map(disk_map)
+    compacted_disk = compact_disk_individual_blocks(disk)
+    checksum_part1 = calculate_checksum(compacted_disk)
+    print(checksum_part1)
+
+    # Part 2
+    disk = parse_disk_map(disk_map)
+    compacted_disk = compact_disk_whole_files(disk)
+    checksum_part2 = calculate_checksum(compacted_disk)
+    print(checksum_part2)
+
+main()

day09/solution_jerpint.py

@@ -0,0 +1,159 @@
+def load_data(file):
+    with open(file) as f:
+        return f.read().strip("\n")
+
+
+def generate_blocks(disk_map):
+    blocks = []
+    for idx, i in enumerate(disk_map):
+
+        if idx % 2:
+            blocks.extend( ["."]*int(i))
+        else:
+            blocks.extend( [str(idx // 2)] *int(i))
+
+    return blocks
+
+
+def get_next_valid_block_from_end(end: int, blocks):
+    for j in range(end, -1, -1):
+        if blocks[j] != ".":
+            return j
+
+
+def compact_blocks(blocks):
+    #  blocks = list(blocks)
+    end = get_next_valid_block_from_end(len(blocks) - 1, blocks)
+    for idx, block in enumerate(blocks):
+
+        if end == idx:
+            break
+
+        if block == ".":
+            blocks[idx] = blocks[end]
+            blocks[end] = "."
+            end = get_next_valid_block_from_end(end, blocks)
+
+        #  print("".join(blocks))
+
+    return blocks
+
+def compute_checksum(blocks):
+    checksum = 0
+    for idx, num in enumerate(blocks):
+        if num == ".":
+            return checksum
+        checksum += idx*int(num)
+    return checksum
+
+
+disk_map = load_data("input.txt")
+blocks = generate_blocks(disk_map)
+compact_blocks = compact_blocks(blocks)
+print(compute_checksum(compact_blocks))
+
+
+## Part two
+
+def generate_blocks(disk_map):
+    blocks = []
+    for idx, i in enumerate(disk_map):
+
+        if idx % 2:
+            if int(i) > 0:
+                blocks.append( ["."]*int(i))
+        else:
+            blocks.append( [str(idx // 2)] *int(i))
+
+    return blocks
+
+
+def get_free_space_map(blocks):
+    free_space_map = []
+    pos = 0
+    for idx, block in enumerate(blocks):
+
+        if block[0] == ".":
+            free_space_map.append((idx, len(block)))
+
+        pos += len(block)
+
+    return free_space_map
+
+
+def get_next_valid_block_from_end(blocks):
+    for idx, block in enumerate(blocks[::-1]):
+        if block[0] != ".":
+            block_idx = len(blocks) - idx - 1
+            return block, block_idx
+
+
+def pprint(blocks):
+    print("".join(["".join(b) for b in blocks]))
+
+
+def move_block_at_fileid(blocks, file_id: int):
+
+    free_space_map = get_free_space_map(blocks)
+    #  block = blocks[block_idx]
+    for idx, block in enumerate(blocks):
+        if block[0] != "." and block[0] == str(file_id):
+            block_idx = idx
+            break
+
+    K = len(block)
+    for free_block_idx, free_len in free_space_map:
+
+        if free_len > K and free_block_idx < block_idx:
+            # First condition means we have more space than needed
+            # Second condition ensures we Only move forward in queue, not backwards
+            blocks[free_block_idx] = ["."] * (free_len - len(block))  # Remaining free memory after insert
+            blocks.insert(free_block_idx, block)  # Insert at index
+            blocks[block_idx + 1] = ["."] * K  # Overwrite at end (+1 because we added a new index)
+            return True
+
+        elif free_len == K and free_block_idx < block_idx:
+            # First condition means we have just enough space
+            # Second condition ensures we Only move forward in queue, not backwards
+            blocks[free_block_idx] = block
+            blocks[block_idx] = ["."] * K
+            return True
+
+    return False
+
+
+def compute_checksum(blocks):
+    blocks_ext = [b for block in blocks for b in block]
+    checksum = 0
+    for idx, num in enumerate(blocks_ext):
+        if num == ".":
+            continue
+
+        checksum += idx*int(num)
+    return checksum
+
+
+def get_max_file_id(blocks):
+    for block in blocks[::-1]:
+        if block[0] != ".":
+            max_file_id = int(block[0])
+            return max_file_id
+
+
+disk_map = load_data("input.txt")
+blocks = generate_blocks(disk_map)
+
+max_file_id = get_max_file_id(blocks)
+#  pprint(blocks)
+for file_id in range(max_file_id, -1, -1):
+
+    #  Progress-bar
+    #  if file_id % 1000 == 0:
+    #      print(file_id)
+
+    moved = move_block_at_fileid(blocks, file_id)
+
+    # if moved:
+    #    pprint(blocks)
+
+print(compute_checksum(blocks))

day10/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,70 @@
+from collections import defaultdict
+from typing import List, Set, Tuple, Dict
+
+def read_grid(filename: str) -> List[List[int]]:
+    with open(filename) as f:
+        return [[int(c) for c in line.strip()] for line in f]
+
+def get_neighbors(grid: List[List[int]], x: int, y: int) -> List[Tuple[int, int]]:
+    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+    height, width = len(grid), len(grid[0])
+    neighbors = []
+    for dx, dy in directions:
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < height and 0 <= ny < width:
+            neighbors.append((nx, ny))
+    return neighbors
+
+def find_trailheads(grid: List[List[int]]) -> List[Tuple[int, int]]:
+    return [(i, j) for i in range(len(grid)) for j in range(len(grid[0])) if grid[i][j] == 0]
+
+def count_reachable_nines(grid: List[List[int]], start: Tuple[int, int]) -> int:
+    def dfs(x: int, y: int, visited: Set[Tuple[int, int]]) -> Set[Tuple[int, int]]:
+        nines = set()
+        visited.add((x, y))
+        current_height = grid[x][y]
+        
+        if current_height == 9:
+            nines.add((x, y))
+            
+        for nx, ny in get_neighbors(grid, x, y):
+            if (nx, ny) not in visited and grid[nx][ny] == current_height + 1:
+                nines.update(dfs(nx, ny, visited))
+                
+        return nines
+    
+    return len(dfs(start[0], start[1], set()))
+
+def count_distinct_paths(grid: List[List[int]], start: Tuple[int, int]) -> int:
+    memo: Dict[Tuple[int, int], int] = {}
+    
+    def dfs(x: int, y: int) -> int:
+        if (x, y) in memo:
+            return memo[(x, y)]
+        
+        if grid[x][y] == 9:
+            return 1
+            
+        paths = 0
+        current_height = grid[x][y]
+        
+        for nx, ny in get_neighbors(grid, x, y):
+            if grid[nx][ny] == current_height + 1:
+                paths += dfs(nx, ny)
+                
+        memo[(x, y)] = paths
+        return paths
+    
+    return dfs(start[0], start[1])
+
+def solve_part1(grid: List[List[int]]) -> int:
+    trailheads = find_trailheads(grid)
+    return sum(count_reachable_nines(grid, start) for start in trailheads)
+
+def solve_part2(grid: List[List[int]]) -> int:
+    trailheads = find_trailheads(grid)
+    return sum(count_distinct_paths(grid, start) for start in trailheads)
+
+grid = read_grid("./input.txt")
+print(str(solve_part1(grid)))
+print(str(solve_part2(grid)))

day10/solution_gemini-1.5-pro.py

@@ -0,0 +1,72 @@
+from collections import deque
+
+def solve():
+    file = "input.txt"
+    grid = []
+    with open(file, 'r') as f:
+        for line in f:
+            grid.append([int(x) for x in line.strip()])
+
+    rows = len(grid)
+    cols = len(grid[0])
+
+    def get_neighbors(r, c):
+        neighbors = []
+        for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
+            nr, nc = r + dr, c + dc
+            if 0 <= nr < rows and 0 <= nc < cols:
+                neighbors.append((nr, nc))
+        return neighbors
+
+    def dfs_score(r, c):
+        score = 0
+        visited = set()
+        stack = [(r, c)]
+
+        while stack:
+            curr_r, curr_c = stack.pop()
+            if (curr_r, curr_c) in visited:
+                continue
+            visited.add((curr_r, curr_c))
+
+            if grid[curr_r][curr_c] == 9:
+                score += 1
+                continue
+
+            for nr, nc in get_neighbors(curr_r, curr_c):
+                if grid[nr][nc] == grid[curr_r][curr_c] + 1:
+                    stack.append((nr, nc))
+        return score
+
+    def dfs_rating(r, c):
+        rating = 0
+        stack = [([(r, c)], set())]
+
+        while stack:
+            path, visited = stack.pop()
+            curr_r, curr_c = path[-1]
+
+            if grid[curr_r][curr_c] == 9:
+                rating += 1
+                continue
+
+            for nr, nc in get_neighbors(curr_r, curr_c):
+                if grid[nr][nc] == grid[curr_r][curr_c] + 1 and (nr, nc) not in visited:
+                    new_path = path + [(nr, nc)]
+                    new_visited = set(visited)
+                    new_visited.add((nr,nc))
+                    stack.append((new_path, new_visited))
+        return rating
+
+    total_score = 0
+    total_rating = 0
+    for r in range(rows):
+        for c in range(cols):
+            if grid[r][c] == 0:
+                total_score += dfs_score(r, c)
+                total_rating += dfs_rating(r, c)
+
+    print(total_score)
+    print(total_rating)
+
+solve()

day10/solution_gpt-4o.py

@@ -0,0 +1,56 @@
+def read_map(file):
+    with open(file, 'r') as f:
+        return [list(map(int, line.strip())) for line in f]
+
+def find_trailheads(map_data):
+    trailheads = []
+    for r in range(len(map_data)):
+        for c in range(len(map_data[0])):
+            if map_data[r][c] == 0:
+                trailheads.append((r, c))
+    return trailheads
+
+def is_valid_move(map_data, r, c, current_height):
+    return 0 <= r < len(map_data) and 0 <= c < len(map_data[0]) and map_data[r][c] == current_height + 1
+
+def explore_trails(map_data, start):
+    stack = [(start, [start])]
+    reached_nines = set()
+    distinct_paths = set()
+
+    while stack:
+        (r, c), path = stack.pop()
+        current_height = map_data[r][c]
+
+        if current_height == 9:
+            reached_nines.add((r, c))
+            distinct_paths.add(tuple(path))
+            continue
+
+        for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+            nr, nc = r + dr, c + dc
+            if is_valid_move(map_data, nr, nc, current_height):
+                stack.append(((nr, nc), path + [(nr, nc)]))
+
+    return len(reached_nines), len(distinct_paths)
+
+def calculate_scores_and_ratings(map_data):
+    trailheads = find_trailheads(map_data)
+    total_score = 0
+    total_rating = 0
+
+    for trailhead in trailheads:
+        score, rating = explore_trails(map_data, trailhead)
+        total_score += score
+        total_rating += rating
+
+    return total_score, total_rating
+
+def main():
+    file = "input.txt"
+    map_data = read_map(file)
+    total_score, total_rating = calculate_scores_and_ratings(map_data)
+    print(total_score)
+    print(total_rating)
+
+main()

day10/solution_jerpint.py

@@ -0,0 +1,106 @@
+def load_data(file):
+    with open(file) as f:
+        data = f.readlines()
+    return [list(line.strip("\n")) for line in data]
+
+
+
+def find_zeros(grid):
+    M = len(grid)
+    N = len(grid[0])
+
+    positions = []
+    for i in range(M):
+        for j in range(N):
+            if grid[i][j] == "0":
+                positions.append((i,j))
+    return positions
+
+
+def get_neighbors(grid, pos):
+    M = len(grid)
+    N = len(grid[0])
+    directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]
+    ns = []
+    i, j = pos
+    for dx, dy in directions:
+        if (i+dx) in range(M) and (j+dy) in range(N):
+            ns.append((i+dx, j+dy))
+    return ns
+
+
+def val_at_pos(grid, pos):
+    i, j = pos
+    return int(grid[i][j]) if grid[i][j] != "." else -100
+
+def get_trailhead_score(grid, zero):
+    """bfs algorithm."""
+    score = 0
+
+    i,j = zero
+    q = [(i,j)]
+    visited = set((i,j))
+
+    while len(q) > 0:
+        pos = q.pop(0)
+        cur_val = val_at_pos(grid, pos)
+        neighbors = get_neighbors(grid, pos)
+        for n_pos in neighbors:
+            n_val = val_at_pos(grid, n_pos)
+
+
+            if (n_val - cur_val) == 1:
+                q.append(n_pos)
+
+                if n_val == 9 and n_pos not in visited:
+                    score += 1
+                    visited.add(n_pos)
+
+    return score
+
+
+grid = load_data("input.txt")
+zeros = find_zeros(grid)
+
+total = 0
+for zero in zeros:
+    total += get_trailhead_score(grid, zero)
+
+print(total)
+
+
+## Part 2
+
+def get_trailhead_rating(grid, zero):
+    """bfs algorithm."""
+    score = 0
+
+    i,j = zero
+    q = [(i,j)]
+    visited = set((i,j))
+
+    while len(q) > 0:
+        pos = q.pop(0)
+        cur_val = val_at_pos(grid, pos)
+        neighbors = get_neighbors(grid, pos)
+        for n_pos in neighbors:
+            n_val = val_at_pos(grid, n_pos)
+
+
+            if (n_val - cur_val) == 1:
+                q.append(n_pos)
+
+                if n_val == 9:
+                    score += 1
+
+    return score
+
+
+grid = load_data("input.txt")
+zeros = find_zeros(grid)
+
+total = 0
+for zero in zeros:
+    total += get_trailhead_rating(grid, zero)
+
+print(total)

day11/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,41 @@
+def read_input(filename):
+    with open(filename, 'r') as f:
+        return [int(x) for x in f.read().strip().split()]
+
+def has_even_digits(n):
+    return len(str(n)) % 2 == 0
+
+def split_number(n):
+    s = str(n)
+    mid = len(s) // 2
+    left = int(s[:mid])
+    right = int(s[mid:])
+    return [left, right]
+
+def transform_stones(stones):
+    new_stones = []
+    for stone in stones:
+        if stone == 0:
+            new_stones.append(1)
+        elif has_even_digits(stone):
+            new_stones.extend(split_number(stone))
+        else:
+            new_stones.append(stone * 2024)
+    return new_stones
+
+def simulate_blinks(stones, blinks):
+    current_stones = stones[:]
+    for _ in range(blinks):
+        current_stones = transform_stones(current_stones)
+    return len(current_stones)
+
+# Read input
+stones = read_input("./input.txt")
+
+# Part 1: 25 blinks
+result1 = simulate_blinks(stones, 25)
+print(str(result1))
+
+# Part 2: 75 blinks
+result2 = simulate_blinks(stones, 75)
+print(str(result2))

day11/solution_gemini-1.5-pro.py

@@ -0,0 +1,33 @@
+def solve():
+    with open("./input.txt", "r") as f:
+        initial_stones = [int(x) for x in f.readline().split()]
+
+    def blink(stones):
+        new_stones = []
+        for stone in stones:
+            if stone == 0:
+                new_stones.append(1)
+            elif len(str(stone)) % 2 == 0:
+                s = str(stone)
+                mid = len(s) // 2
+                left = int(s[:mid])
+                right = int(s[mid:])
+                new_stones.append(left)
+                new_stones.append(right)
+            else:
+                new_stones.append(stone * 2024)
+        return new_stones
+
+    # Part 1: 25 blinks
+    stones = initial_stones[:]  # Create a copy to avoid modifying the original
+    for _ in range(25):
+        stones = blink(stones)
+    print(len(stones))
+
+    # Part 2: 75 blinks
+    stones = initial_stones[:]  # Reset to the initial state
+    for _ in range(75):
+        stones = blink(stones)
+    print(len(stones))
+
+solve()

day11/solution_gpt-4o.py

@@ -0,0 +1,35 @@
+def transform_stones(stones):
+    new_stones = []
+    for stone in stones:
+        if stone == 0:
+            new_stones.append(1)
+        elif len(str(stone)) % 2 == 0:
+            # Split the stone
+            str_stone = str(stone)
+            mid = len(str_stone) // 2
+            left = int(str_stone[:mid])
+            right = int(str_stone[mid:])
+            new_stones.extend([left, right])
+        else:
+            # Multiply by 2024
+            new_stones.append(stone * 2024)
+    return new_stones
+
+def simulate_blinks(initial_stones, blinks):
+    stones = initial_stones
+    for _ in range(blinks):
+        stones = transform_stones(stones)
+    return stones
+
+# Read input from file
+file = "input.txt"
+with open(file, "r") as f:
+    initial_stones = list(map(int, f.read().strip().split()))
+
+# Part 1: After 25 blinks
+stones_after_25_blinks = simulate_blinks(initial_stones, 25)
+print(len(stones_after_25_blinks))
+
+# Part 2: After 75 blinks
+stones_after_75_blinks = simulate_blinks(initial_stones, 75)
+print(len(stones_after_75_blinks))

day11/solution_jerpint.py

@@ -0,0 +1,81 @@
+def load_data(file):
+    with open(file) as f:
+        data = f.read()
+    return list(data.split())
+
+
+
+def update_stone(stone):
+
+    if stone == "0":
+        return ["1"]
+
+    elif len(stone) % 2 == 0:
+        L = len(stone)
+        first_half = str(int(stone[:L//2]))
+        second_half = str(int(stone[L//2:]))
+
+
+
+        return [first_half, second_half]
+    else:
+        return [str(int(stone)*2024)]
+
+
+def blink(stones):
+    new_stones = []
+    for stone in stones:
+        next_stones = update_stone(stone)
+        new_stones.extend(next_stones)
+    return new_stones
+
+
+stones = load_data("input.txt")
+blinks = 25
+for i in range(blinks):
+    stones = blink(stones)
+
+print(len(stones))
+
+
+
+
+## Part two
+
+# Use a dict to keep track instead of a list
+
+def get_counts(stones):
+    counts = {}
+    for stone in stones:
+        counts[stone] = counts.get(stone, 0) + 1
+
+    return counts
+
+
+def blink(stone_counts):
+    new_counts = {}
+    for stone, count in stone_counts.items():
+        new_stones = update_stone(stone)
+
+        for s in new_stones:
+            new_counts[s] = new_counts.get(s, 0) + 1 * count
+
+    return new_counts
+
+
+def get_total_stones(stone_counts):
+    total = 0
+
+    for stone, count in stone_counts.items():
+        total += count
+    return total
+
+
+stones = load_data("input.txt")
+stone_counts = get_counts(stones)
+blinks = 75
+
+for idx in range(blinks):
+    stone_counts = blink(stone_counts)
+
+print(get_total_stones(stone_counts))

day12/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,84 @@
+def find_regions(grid):
+    height = len(grid)
+    width = len(grid[0])
+    visited = set()
+    regions = []
+    
+    def flood_fill(x, y, char):
+        if (x, y) in visited or x < 0 or y < 0 or x >= height or y >= width or grid[x][y] != char:
+            return set()
+        
+        region = {(x, y)}
+        visited.add((x, y))
+        
+        # Check all four directions
+        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
+            new_x, new_y = x + dx, y + dy
+            region.update(flood_fill(new_x, new_y, char))
+            
+        return region
+    
+    for i in range(height):
+        for j in range(width):
+            if (i, j) not in visited:
+                region = flood_fill(i, j, grid[i][j])
+                if region:
+                    regions.append((grid[i][j], region))
+    
+    return regions
+
+def calculate_perimeter(region_cells, grid_height, grid_width):
+    perimeter = 0
+    for x, y in region_cells:
+        # Check all four sides
+        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
+            new_x, new_y = x + dx, y + dy
+            if (new_x, new_y) not in region_cells:
+                if new_x < 0 or new_y < 0 or new_x >= grid_height or new_y >= grid_width:
+                    perimeter += 1
+                elif (new_x, new_y) not in region_cells:
+                    perimeter += 1
+    return perimeter
+
+def count_sides(region_cells, grid_height, grid_width):
+    edges = set()
+    for x, y in region_cells:
+        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
+            new_x, new_y = x + dx, y + dy
+            if (new_x, new_y) not in region_cells:
+                # Store the edge as a tuple of two points to make it unique
+                edge = tuple(sorted([(x, y), (x + dx/2, y + dy/2)]))
+                edges.add(edge)
+    return len(edges)
+
+def solve_part1(grid):
+    regions = find_regions(grid)
+    total_price = 0
+    height, width = len(grid), len(grid[0])
+    
+    for char, region in regions:
+        area = len(region)
+        perimeter = calculate_perimeter(region, height, width)
+        total_price += area * perimeter
+    
+    return str(total_price)
+
+def solve_part2(grid):
+    regions = find_regions(grid)
+    total_price = 0
+    height, width = len(grid), len(grid[0])
+    
+    for char, region in regions:
+        area = len(region)
+        sides = count_sides(region, height, width)
+        total_price += area * sides
+    
+    return str(total_price)
+
+# Read input
+with open('./input.txt', 'r') as file:
+    grid = [list(line.strip()) for line in file]
+
+# Print results
+print(solve_part1(grid))
+print(solve_part2(grid))

day12/solution_gemini-1.5-pro.py

@@ -0,0 +1,86 @@
+from collections import defaultdict
+
+def solve():
+    file = "input.txt"
+    grid = []
+    with open(file, 'r') as f:
+        for line in f:
+            grid.append(line.strip())
+
+    rows = len(grid)
+    cols = len(grid[0])
+
+    def get_neighbors(r, c):
+        neighbors = []
+        for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
+            nr, nc = r + dr, c + dc
+            if 0 <= nr < rows and 0 <= nc < cols:
+                neighbors.append((nr, nc))
+        return neighbors
+
+    def bfs(r, c, char):
+        q = [(r, c)]
+        visited = set([(r, c)])
+        area = 0
+        perimeter = 0
+        while q:
+            cr, cc = q.pop(0)
+            area += 1
+            for nr, nc in get_neighbors(cr, cc):
+                if (nr, nc) not in visited:
+                    if grid[nr][nc] == char:
+                        visited.add((nr, nc))
+                        q.append((nr, nc))
+                    else:
+                        perimeter += 1
+        return area, perimeter
+    
+    def bfs2(r, c, char):
+        q = [(r, c)]
+        visited = set([(r, c)])
+        area = 0
+        sides = 0
+        while q:
+            cr, cc = q.pop(0)
+            area += 1
+            
+            ns = 0
+            for nr, nc in get_neighbors(cr, cc):
+                if grid[nr][nc] != char:
+                    ns +=1
+            sides += ns
+            
+            for nr, nc in get_neighbors(cr, cc):
+                if (nr, nc) not in visited and grid[nr][nc] == char:
+                    visited.add((nr, nc))
+                    q.append((nr, nc))
+        return area, sides
+
+
+    total_price = 0
+    visited = set()
+    for r in range(rows):
+        for c in range(cols):
+            if (r, c) not in visited:
+                char = grid[r][c]
+                area, perimeter = bfs(r, c, char)
+                total_price += area * perimeter
+                for rr, cc in bfs(r,c, char)[2]:
+                    visited.add((rr,cc))
+
+    print(total_price)
+
+    total_price2 = 0
+    visited = set()
+    for r in range(rows):
+        for c in range(cols):
+            if (r, c) not in visited:
+                char = grid[r][c]
+                area, sides = bfs2(r, c, char)
+                total_price2 += area * sides
+                for rr, cc in bfs(r,c, char)[2]:
+                    visited.add((rr,cc))
+    print(total_price2)
+
+
+solve()

day12/solution_gpt-4o.py

@@ -0,0 +1,77 @@
+file = "input.txt"
+
+def read_input(file):
+    with open(file, 'r') as f:
+        return [line.strip() for line in f]
+
+def get_neighbors(x, y, max_x, max_y):
+    neighbors = []
+    if x > 0:
+        neighbors.append((x - 1, y))
+    if x < max_x - 1:
+        neighbors.append((x + 1, y))
+    if y > 0:
+        neighbors.append((x, y - 1))
+    if y < max_y - 1:
+        neighbors.append((x, y + 1))
+    return neighbors
+
+def flood_fill(grid, x, y, visited):
+    plant_type = grid[x][y]
+    stack = [(x, y)]
+    region = []
+    while stack:
+        cx, cy = stack.pop()
+        if (cx, cy) in visited:
+            continue
+        visited.add((cx, cy))
+        region.append((cx, cy))
+        for nx, ny in get_neighbors(cx, cy, len(grid), len(grid[0])):
+            if grid[nx][ny] == plant_type and (nx, ny) not in visited:
+                stack.append((nx, ny))
+    return region
+
+def calculate_perimeter(region, grid):
+    perimeter = 0
+    for x, y in region:
+        for nx, ny in get_neighbors(x, y, len(grid), len(grid[0])):
+            if grid[nx][ny] != grid[x][y]:
+                perimeter += 1
+    return perimeter
+
+def calculate_sides(region, grid):
+    sides = set()
+    for x, y in region:
+        for nx, ny in get_neighbors(x, y, len(grid), len(grid[0])):
+            if grid[nx][ny] != grid[x][y]:
+                sides.add(((x, y), (nx, ny)))
+    return len(sides)
+
+def calculate_total_price(grid, use_sides=False):
+    visited = set()
+    total_price = 0
+    for x in range(len(grid)):
+        for y in range(len(grid[0])):
+            if (x, y) not in visited:
+                region = flood_fill(grid, x, y, visited)
+                area = len(region)
+                if use_sides:
+                    sides = calculate_sides(region, grid)
+                    price = area * sides
+                else:
+                    perimeter = calculate_perimeter(region, grid)
+                    price = area * perimeter
+                total_price += price
+    return total_price
+
+def main():
+    grid = read_input(file)
+    # Part 1
+    total_price_part1 = calculate_total_price(grid, use_sides=False)
+    print(total_price_part1)
+    
+    # Part 2
+    total_price_part2 = calculate_total_price(grid, use_sides=True)
+    print(total_price_part2)
+
+main()

day12/solution_jerpint.py

@@ -0,0 +1,176 @@
+def load_data(file):
+    with open(file) as f:
+        data = f.readlines()
+    return [l.strip("\n") for l in data]
+
+
+def get_neighbours(pos, grid):
+    M = len(grid)
+    N = len(grid[0])
+
+    i, j = pos
+
+    directions = [(0,1), (1,0), (-1,0), (0, -1)]
+
+    n_positions = []
+    n_values = []
+    for dx, dy in directions:
+        if (i+dx) in range(M) and (j+dy) in range(N):
+            n_positions.append((i+dx,j+dy))
+            n_values.append(grid[i+dx][j+dy])
+
+    return n_positions, n_values
+
+
+def get_perimeter(num_equal_neighbors: int):
+    return 4 - num_equal_neighbors
+
+
+def bfs(pos, grid):
+    visited = set()
+    queue = [pos]
+
+    current_val = grid[pos[0]][pos[1]]
+    total_area = 0
+    total_perimeter = 0
+    while len(queue) > 0:
+
+        pos = queue.pop(0)
+
+        if pos in visited:
+            continue
+
+        n_positions, n_values = get_neighbours(pos, grid)
+
+        #  print(pos, grid[pos[0]][pos[1]])
+        #  print(n_positions)
+        #  print(n_values)
+
+        num_equal_neighbors = 0
+        for n_pos, n_val in zip(n_positions, n_values):
+            if n_val == current_val:
+                num_equal_neighbors += 1
+
+                if n_pos not in visited:
+                    queue.append(n_pos)
+
+        visited.add(pos)
+
+        total_area += 1
+        total_perimeter += get_perimeter(num_equal_neighbors)
+
+    price = total_area * total_perimeter
+    # print(f"Visited a region of {current_val} plants with price = {total_area}*{total_perimeter}={price}")
+    return visited, price
+
+
+
+# grid = load_data("test.txt")
+grid = load_data("input.txt")
+
+M = len(grid)
+N = len(grid[0])
+
+total_price = 0
+visited = set()
+for i in range(M):
+    for j in range(N):
+        pos = (i,j)
+        if pos not in visited:
+
+            next_visited, price = bfs(pos, grid)
+            visited = visited.union(next_visited)
+            total_price += price
+
+
+print(total_price)
+
+
+## Part two
+
+
+
+def bfs(pos, grid):
+    visited = set()
+    queue = [pos]
+
+    current_val = grid[pos[0]][pos[1]]
+    total_area = 0
+    total_perimeter = 0
+    while len(queue) > 0:
+
+        pos = queue.pop(0)
+
+        if pos in visited:
+            continue
+
+        n_positions, n_values = get_neighbours(pos, grid)
+
+        #  print(pos, grid[pos[0]][pos[1]])
+        #  print(n_positions)
+        #  print(n_values)
+
+        num_equal_neighbors = 0
+        for n_pos, n_val in zip(n_positions, n_values):
+            if n_val == current_val:
+                num_equal_neighbors += 1
+
+                if n_pos not in visited:
+                    queue.append(n_pos)
+
+        visited.add(pos)
+
+        #  total_area += 1
+        #  total_perimeter += get_perimeter(num_equal_neighbors)
+
+    #  price = total_area * total_perimeter
+    #  print(f"Visited a region of {current_val} plants with price = {total_area}*{total_perimeter}={price}")
+    return visited
+
+
+# grid = load_data("test.txt")
+# grid = load_data("input.txt")
+
+# M = len(grid)
+# N = len(grid[0])
+
+# total_price = 0
+# visited = set()
+# for i in range(M):
+#     for j in range(N):
+#         pos = (i,j)
+#         if pos not in visited:
+
+#             next_visited = bfs(pos, grid)
+#             #  visited = visited.union(next_visited)
+#             #  total_price += price
+#             break
+
+
+# #  print(total_price)
+
+# def get_perimeter(visited):
+#     # Horizontal
+#     visited = list(next_visited)
+#     visited.sort(key=lambda x: x[0])
+
+#     # First and last coords
+#     i_min = visited[0][0]
+#     i_max = visited[-1][0]
+
+#     h_perimeter = 0
+#     for i in range(i_min, i_max+1):
+#         js = [v[1] for v in visited if v[0] == i]
+#         js.sort()
+
+#         h_perimeter += 1
+#         for idx in range(len(js)-1):
+#             if js[idx+1] - js[idx] != 1:
+#                 h_perimeter += 1
+
+#     print(h_perimeter)
+
+# get_perimeter(next_visited)
+
+
+

day13/solution_claude-3-5-sonnet-20241022.py

@@ -0,0 +1,105 @@
+from math import gcd
+from typing import Optional, Tuple
+
+def extended_gcd(a: int, b: int) -> Tuple[int, int, int]:
+    if a == 0:
+        return b, 0, 1
+    gcd, x1, y1 = extended_gcd(b % a, a)
+    x = y1 - (b // a) * x1
+    y = x1
+    return gcd, x, y
+
+def find_solution(a: int, b: int, c: int) -> Optional[Tuple[int, int]]:
+    g = gcd(a, b)
+    if c % g != 0:
+        return None
+    
+    # Scale everything down by gcd
+    a, b, c = a//g, b//g, c//g
+    
+    # Find base solution using extended GCD
+    _, x0, y0 = extended_gcd(a, b)
+    x0 *= c
+    y0 *= c
+    
+    # Find the general solution
+    # x = x0 + k*(b/g)
+    # y = y0 - k*(a/g)
+    # We need both x and y to be non-negative
+    k_min = -(x0 // b) if x0 < 0 else -((y0) // a)
+    k_max = (y0 // a) if y0 > 0 else (x0 // b)
+    
+    # Find k that gives minimum positive solution
+    for k in range(k_min, k_max + 1):
+        x = x0 + k * b
+        y = y0 - k * a
+        if x >= 0 and y >= 0:
+            return (x, y)
+    return None
+
+def solve_machine(ax: int, ay: int, bx: int, by: int, px: int, py: int, max_presses: Optional[int] = None) -> Optional[int]:
+    # Find solution for x-coordinate
+    sol_x = find_solution(ax, bx, px)
+    if not sol_x:
+        return None
+    
+    # Find solution for y-coordinate
+    sol_y = find_solution(ay, by, py)
+    if not sol_y:
+        return None
+    
+    # Check if solutions match
+    if sol_x[0] != sol_y[0] or sol_x[1] != sol_y[1]:
+        return None
+    
+    # Check max presses constraint if specified
+    if max_presses and (sol_x[0] > max_presses or sol_x[1] > max_presses):
+        return None
+    
+    # Calculate tokens needed (3 for A, 1 for B)
+    return 3 * sol_x[0] + sol_x[1]
+
+def parse_input(filename: str):
+    machines = []
+    with open(filename, 'r') as f:
+        lines = f.read().strip().split('\n\n')
+        for machine in lines:
+            lines = machine.strip().split('\n')
+            ax = int(lines[0].split('X+')[1].split(',')[0])
+            ay = int(lines[0].split('Y+')[1])
+            bx = int(lines[1].split('X+')[1].split(',')[0])
+            by = int(lines[1].split('Y+')[1])
+            px = int(lines[2].split('X=')[1].split(',')[0])
+            py = int(lines[2].split('Y=')[1])
+            machines.append((ax, ay, bx, by, px, py))
+    return machines
+
+def solve_part1(machines):
+    total_tokens = 0
+    for machine in machines:
+        tokens = solve_machine(*machine, max_presses=100)
+        if tokens is not None:
+            total_tokens += tokens
+    return str(total_tokens)
+
+def solve_part2(machines):
+    offset = 10**13
+    total_tokens = 0
+    modified_machines = []
+    for ax, ay, bx, by, px, py in machines:
+        modified_machines.append((ax, ay, bx, by, px + offset, py + offset))
+    
+    for machine in modified_machines:
+        tokens = solve_machine(*machine)
+        if tokens is not None:
+            total_tokens += tokens
+    return str(total_tokens)
+
+# Read and parse input
+machines = parse_input("input.txt")
+
+# Solve part 1
+print(solve_part1(machines))
+
+# Solve part 2
+print(solve_part2(machines))

day13/solution_gemini-1.5-pro.py

@@ -0,0 +1,42 @@
+import re
+
+file = "input.txt"
+
+def solve():
+    with open(file, 'r') as f:
+        machines = []
+        for line in f:
+            match = re.match(r"Button A: X\+(\d+), Y\+(\d+)\nButton B: X\+(\d+), Y\+(\d+)\nPrize: X=(\d+), Y=(\d+)", line.strip())
+            if match:
+                ax, ay, bx, by, px, py = map(int, match.groups())
+                machines.append(((ax, ay), (bx, by), (px, py)))
+
+    def get_min_cost(machines):
+        min_costs = []
+        for (ax, ay), (bx, by), (px, py) in machines:
+            min_cost = float('inf')
+            for a in range(101):
+                for b in range(101):
+                    if a * ax + b * bx == px and a * ay + b * by == py:
+                        min_cost = min(min_cost, 3 * a + b)
+            min_costs.append(min_cost)
+        return min_costs
+    
+    min_costs = get_min_cost(machines)
+    total_cost = sum(cost for cost in min_costs if cost != float('inf'))
+    num_prizes = sum(1 for cost in min_costs if cost != float('inf'))
+
+    print(total_cost)
+
+    offset = 10000000000000
+    machines_part2 = []
+    for (ax, ay), (bx, by), (px, py) in machines:
+        machines_part2.append(((ax, ay), (bx, by), (px + offset, py + offset)))
+
+    min_costs_part2 = get_min_cost(machines_part2)
+    total_cost_part2 = sum(cost for cost in min_costs_part2 if cost != float('inf'))
+
+
+    print(total_cost_part2)
+
+solve()