import requests

DATA_FILE_NAME = '{}.txt'
AOC_URL = 'https://adventofcode.com/2021/day/{}/input'
SESSION = 'PASTE-IT-HERE'

def load_data(number: str, *, verbose: bool = False) -> str:

    def log(*args, **kwargs):
        if verbose:
            print(*args, **kwargs)
            
    filename = DATA_FILE_NAME.format(number)
    try:
        with open(filename) as file:
            log(f"Cached data found, reading {filename}")
            return file.read()
    except OSError:
        log(f"Cached data in {filename} not found")
    url = AOC_URL.format(number)
    cookies = {'session':SESSION}
    log(f"Sending request to {url}")
    request = requests.get(url, cookies=cookies)
    request.raise_for_status()
    log(f"Data revieved")
    with open(filename, 'w') as file:
        log(f"Caching retrieved {len(request.text)} bytes to {filename}")
        file.write(request.text)
    return request.text

import aoc

import os
 
def task1(data: str) -> int:
    depths = [int(depth) for depth in data.split()]
    return sum(1 for a, b in zip(depths, depths[1:]) if a<b)

def task2(data: str) -> int:
    depths = [int(depth) for depth in data.split()]
    sliding_windows = [sum(depths[i:i+3]) for i in range(len(depths)-2)]
    return sum(1 for a, b in zip(sliding_windows, sliding_windows[1:]) if a<b)

if __name__ == '__main__':
    data = aoc.load_data(os.path.basename(__file__).removesuffix('.py'), verbose=True)
    print(task1(data))
    print(task2(data))

Cached data in 1.txt not found
Sending request to https://adventofcode.com/2021/day/1/input
Data revieved
Caching retrieved 9775 bytes to 1.txt
1390
1457

import aoc

import os
import unittest

NUMBER = os.path.basename(__file__).removesuffix('.py')

def task1(data: str) -> int:
    SHIFTS = {'forward':(1,0),'up':(0,-1),'down':(0,1)}
    x, y = 0, 0
    for command in data.splitlines():
        command, argument = command.split()
        value = int(argument)
        dx, dy = SHIFTS[command]
        x, y = x+dx*value, y+dy*value
    return x*y
        

def task2(data: str) -> int:
    SHIFTS = {'forward':(1,1,0),'up':(0,0,-1),'down':(0,0,1)}
    x, y, aim = 0, 0, 0
    for command in data.splitlines():
        command, argument = command.split()
        value = int(argument)
        dx, dy, da = SHIFTS[command]
        x, y, aim = x + dx*value, y + dy*aim*value, aim + da*value
    return x*y

class TestDay2(unittest.TestCase):
    def test_task2(self):
        data = '''forward 5
down 5
forward 8
up 3
down 8
forward 2'''
        self.assertEqual(task2(data), 900, 'Example failed')

if __name__ == '__main__':
    #unittest.main()
    data = aoc.load_data(NUMBER, verbose=True)
    print('Task1:', task1(data))
    print('Task2:', task2(data))

import aoc

import os
import unittest

NUMBER = os.path.basename(__file__).removesuffix('.py')

def task1(data: str) -> int:
    numbers = data.splitlines()
    counter = [sum(int(n[i]) for n in numbers) for i in range(len(numbers[0]))]
    gamma = epsilon = ''
    for i, c in enumerate(counter):
        if c>len(numbers)/2:
            gamma += '1'
            epsilon += '0'
        else:
            gamma += '0'
            epsilon += '1'
        
    return int(gamma,2)*int(epsilon,2)
        

def task2(data: str) -> int:
    numbers = data.splitlines()
    oxygen = numbers[:]
    for i in range(len(numbers[0])):
        counter = sum(int(n[i]) for n in oxygen)
        oxygen = [number for number in oxygen if (number[i]=='1')==(counter>=len(oxygen)/2)]
        if len(oxygen)==1:
            break
    co2 = numbers[:]
    for i in range(len(numbers[0])):
        counter = sum(int(n[i]) for n in co2)
        co2 = [number for number in co2 if (number[i]=='0')!=(counter<len(co2)/2)]
        if len(co2)==1:
            break

    return int(oxygen[0],2)*int(co2[0],2)
    

class TestDay3(unittest.TestCase):
    def test_task2(self):
        data = '''00100
11110
10110
10111
10101
01111
00111
11100
10000
11001
00010
01010'''
        self.assertEqual(task2(data), 230, 'Example failed')

if __name__ == '__main__':
    #unittest.main()
    data = aoc.load_data(NUMBER, verbose=True)
    print('Task1:', task1(data))
    print('Task2:', task2(data))

with open("input.txt") as file:
    diagnostic = [[int(i) for i in line.strip()] for line in file]

γ = list()
ε = list()

for i in zip(*diagnostic):
    most = max(i, key=i.count)
    γ.append(str(most))
    ε.append(str(abs(most - 1)))

print("Part One:", int("".join(ε), 2) * int("".join(γ), 2))


def bit_criteria(variation: str) -> int:
    variation = 1 if variation == "oxygen" else 0
    rating = diagnostic.copy()

    for l in range(len(list(zip(*diagnostic)))):
        bit = list()

        for i in rating[:]:
            bit.append(i[l])

        ones = bit.count(1)
        zeros = bit.count(0)

        if ones == zeros:
            number = 1 if variation else 0
        elif ones > zeros:
            number = 1 if variation else 0
        else:
            number = 0 if variation else 1

        for k in rating[:]:
            if k[l] != number:
                rating.remove(k)

        if len(rating) == 1:
            rating = rating[0]
            break

    return int("".join([str(i) for i in rating]), 2)


print("Part Two:", bit_criteria("oxygen") * bit_criteria("carbon dioxide"))

import aoc

import os

NUMBER = os.path.basename(__file__).removesuffix('.py')

class Bingo:
    def __init__(self, data:str):
        data = data.splitlines()
        self.numbers = [int(x) for x in data[0].split(',')]
        self.boards = []
        for line in data[1:]:
            if not line.strip():
                self.boards.append([])
            else:
                self.boards[-1].append([int(x) for x in line.split()])
        self.strikedout = [[[False for _ in line] for line in board] for board in self.boards]
        self.winners = []

    def strikeout(self, n: int):
        for board_idx, board in enumerate(self.boards):
            for line_idx, line in enumerate(board):
                if n in line:
                    self.strikedout[board_idx][line_idx][line.index(n)] = True
                    self.check_winner(board_idx)

    def check_winner(self, idx: int):
        if idx in self.winners:
            return
        board = self.strikedout[idx]
        for line in board:
            if all(line):
                self.winners.append(idx)
                return
        for i in range(len(board[0])):
            if all(line[i] for line in board):
                self.winners.append(idx)
                return

    def score(self, idx: int, n: int) -> int:
        board = self.boards[idx]
        sboard = self.strikedout[idx]
        s = 0
        for line, sline in zip(board, sboard):
            for field, sfield in zip(line, sline):
                if not sfield:
                    s += field
        return s*n

    def task(self, criterion) -> int:
        for n in self.numbers:
            self.strikeout(n)
            if criterion(self):
                result = self.score(self.winners[-1], n)
                self.strikedout = [[[False for _ in line] for line in board] for board in self.boards]
                return result
        result = self.score(self.winners[-1], self.numbers[-1])
        self.strikedout = [[[False for _ in line] for line in board] for board in self.boards]
        return result

    def task1(self) -> int:
        return self.task(lambda b:b.winners)

    def task2(self) -> int:
        return self.task(lambda b:len(b.winners)==len(b.boards))


if __name__ == '__main__':
    board = Bingo(aoc.load_data(NUMBER, verbose=True))
    print('Task1:', board.task1())
    print('Task2:', board.task2())