Advent of Code

#!/usr/bin/env python3
"""
Advent of Code. Puzzle 03
"""

import sys


def check_neighbors(char, nlrow, nccol, schema, mb_gear):
    neigh_ch = schema[nlrow][nccol]
    if neigh_ch in "0123456789.":
        return neigh_ch, False

    if neigh_ch == "*":
        mb_gear.update({(nlrow,nccol)})
    return neigh_ch, True


def main():

    # read and expand the schema by one '.' row/col on each side
    with open("day03-input", "r") as f:
        schema = [f".{line.strip()}." for line in f.readlines()]

    hdr = (len(schema[0])) * "."
    schema.append(hdr)
    schema.insert(0, hdr)


    result = 0
    current = ""
    gears = {}

    for nl, line in enumerate(schema[1:-1], start=1):
        valid = False
        mb_gear = set()

        for nc, char in enumerate(line[1:-1], start=1):
            if not char.isdigit():
                continue

            current += char

            for rc_offset in ((-1, -1), (-1, +0), (-1, +1),
                              (+0, -1),
                              (+1, -1), (+1, +0), (+1, +1)):
                _, vx = check_neighbors(char,
                                        nl+rc_offset[0], nc+rc_offset[1],
                                        schema, mb_gear)
                if vx:
                    valid = True
                    break

            next_ch, vx = check_neighbors(char, nl, nc+1, schema, mb_gear)
            if vx:
                valid = True

            if next_ch.isdigit():
                continue

            if valid:
                if current:
                    result += int(current)
                    if mb_gear:
                        if len(mb_gear) == 1:
                            mbg = mb_gear.pop()
                            if mbg in gears:
                                gears[mbg].append(current)
                            else:
                                gears[mbg] = [current,]
                        mb_gear = set()
                valid = False

            current = ""

        valid = False
        current = ""

    print("Part one: Sum =", result)


    result = 0
    for g in gears:
        gg = gears[g]
        if len(gg) == 2:
            result += int(gg[0]) * int(gg[1])

    print("Part two: Sum =", result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
from pathlib import Path
import re


INPUT = Path("/home/dennis/AoC/2023/Day4/input.txt")

EXAMPLE_LINES = """\
Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11""".splitlines()


def parse_cards(input_lines):
    cards = {}
    for card in input_lines:
        card_number, numbers = card.split(":")
        my_numbers, winning_numbers = numbers.strip().split("|")
        my_numbers = set(map(int, re.findall(r"\d+", my_numbers)))
        winning_numbers = set(map(int, re.findall(r"\d+", winning_numbers)))
        cards[int(card_number.replace("Card ", ""))] = my_numbers & winning_numbers
    return cards


def calculate_points(winnings):
    return 2 ** (winnings - 1) if winnings >= 1 else 0


def update_number_of_cards(card_to_wins, wins, card_id):
    for extra_card in range(1, wins + 1):
        card_to_wins[card_id + extra_card] += card_to_wins[card_id]
    return card_to_wins


def main():
    cards = parse_cards(INPUT.read_text(encoding="UTF-8").splitlines())
    print(sum(calculate_points(len(winning)) for winning in cards.values()))
    cards = {int(card_id): len(win) for card_id, win in cards.items()}
    card_to_wins = {card_id: 1 for card_id, _ in enumerate(cards, 1)}
    for card_id, wins in cards.items():
        card_to_wins = update_number_of_cards(card_to_wins, wins, card_id)
    print(sum(card_to_wins.values()))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3                                                                                                                                                                                                                                                                                                                                                                    
"""                                                                                                                                                                                                                                                                                                                                                                                       
Advent of Code. Puzzle 04                                                                                                                                                                                                                                                                                                                                                                 
"""                                                                                                                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                                                                                                                                          
import sys                                                                                                                                                                                                                                                                                                                                                                                
import re                                                                                                                                                                                                                                                                                                                                                                                 
import fileinput                                                                                                                                                                                                                                                                                                                                                                          
from pathlib import Path                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          
EXAMPLE_LINES = """\                                                                                                                                                                                                                                                                                                                                                                      
Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53                                                                                                                                                                                                                                                                                                                                          
Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19                                                                                                                                                                                                                                                                                                                                          
Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1                                                                                                                                                                                                                                                                                                                                          
Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83                                                                                                                                                                                                                                                                                                                                          
Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36                                                                                                                                                                                                                                                                                                                                          
Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11                                                                                                                                                                                                                                                                                                                                          
""".splitlines()                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          
def main():                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                          
    if len(sys.argv) == 1:                                                                                                                                                                                                                                                                                                                                                                
        lines = EXAMPLE_LINES                                                                                                                                                                                                                                                                                                                                                             
    else:                                                                                                                                                                                                                                                                                                                                                                                 
        with fileinput.input(encoding="utf-8") as f:                                                                                                                                                                                                                                                                                                                                      
            lines = list(line.rstrip() for line in f)                                                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                                                                                          
    cards = [(),]                                                                                                                                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                                                                                          
    for line in lines:                                                                                                                                                                                                                                                                                                                                                                    
        card_text, data = line.split(":")                                                                                                                                                                                                                                                                                                                                                 
        card = card_text.split()[1]                                                                                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                                                                                                                                          
        winning_text, play_text = data.split("|")                                                                                                                                                                                                                                                                                                                                         
        winning = winning_text.strip().split()                                                                                                                                                                                                                                                                                                                                            
        play = play_text.strip().split()                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                          
        winners = [p for p in play if p in winning]                                                                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                                                                                                                                          
        cards.append((winning, play, winners, len(winners)))                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                          
    result = 0                                                                                                                                                                                                                                                                                                                                                                            
    card_counter = {}                                                                                                                                                                                                                                                                                                                                                                     
    for n, card in enumerate(cards[1:], start=1):                                                                                                                                                                                                                                                                                                                                         
        card_counter[n] = 0                                                                                                                                                                                                                                                                                                                                                               
        num_winners = card[3]                                                                                                                                                                                                                                                                                                                                                             
        if num_winners:                                                                                                                                                                                                                                                                                                                                                                   
            result += 2**(num_winners-1)                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                          
    print("Part one: Sum =", result)                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          
    result = 0                                                                                                                                                                                                                                                                                                                                                                            
    for n, card in enumerate(cards[1:], start=1):                                                                                                                                                                                                                                                                                                                                         
        card_counter[n] += 1                                                                                                                                                                                                                                                                                                                                                              
        for c in range(card_counter[n]):                                                                                                                                                                                                                                                                                                                                                  
            num_winners = card[3]                                                                                                                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                                                                                          
            for i in range(1, num_winners+1):                                                                                                                                                                                                                                                                                                                                             
                card_counter[n+i] += 1                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                          
    result = sum(list(card_counter.values()))                                                                                                                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                                                                                                                                                          
    print("Part two: Sum =", result)                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          
if __name__ == "__main__":                                                                                                                                                                                                                                                                                                                                                                
    main()