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())

fn task1(numbers: &[usize], size: usize) -> usize
{
    let (gamma, epsilon) = (0..size).rev()
                                    .map(|i|numbers.iter()
                                                   .filter(|&n|(n>>i)&1==1)
                                                   .count())
                                    .fold((0,0),|(gamma, epsilon), count|
                                    (
                                        (gamma  <<1) | (2*count> numbers.len()) as usize, 
                                        (epsilon<<1) | (2*count<=numbers.len()) as usize,
                                    ));
    gamma*epsilon
}

fn find_by_bit_criteria<F>(numbers: &[usize], size: usize, criteria: F) -> usize
    where F: Fn(usize, bool) -> bool
{
    let mut numbers = Vec::from(numbers);
    for i in (0..size).rev() {
        if numbers.len() == 1 {
            break;
        }
        let more_ones = numbers.iter()
                               .filter(|&n|(n>>i)&1==1)
                               .count()*2 >= numbers.len();
        numbers = numbers.into_iter()
                         .filter(|&n|criteria((n>>i)&1, more_ones))
                         .collect();
    }
    numbers[0]
}

fn task2(numbers: &[usize], size: usize) -> usize
{
    let oxygen = find_by_bit_criteria(numbers, size, 
        |digit, more_ones| (digit == 1) == more_ones);
    let co2 = find_by_bit_criteria(numbers, size, 
        |digit, more_ones| (digit == 0) == more_ones);
    oxygen * co2
}

fn main() {
    let input = aoc::get_input_from_ini_with_year("3","2021").unwrap();
    let mut size = 0;
    let numbers:Vec<_> = input.lines()
                              .map(|line|{size=line.len();usize::from_str_radix(line, 2).unwrap()})
                              .collect();
    println!("Result1: {}", task1(&numbers, size));
    println!("Result2: {}", task2(&numbers, size));
}

import aoc

import os

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

def is_non_diagonal(pts: list[list[int]]) -> bool:
    diff = [pts[0][0]-pts[1][0], pts[0][1]-pts[1][1]]
    return 0 in diff


def task(data: str, *, filter: bool) -> int:
    field = [[0]*1000 for _ in range(1000)]
    for line in data.splitlines():
        line = [[int(x) for x in part.split(',')] for part in line.split('->')]
        if filter and not is_non_diagonal(line):
            continue
        x,y = line[0]
        dx = 1 if line[1][0]>x else -1 if line[1][0]<x else 0
        dy = 1 if line[1][1]>y else -1 if line[1][1]<y else 0
        while True:
            field[x][y] += 1
            if [x,y]==line[1]:
                break
            x += dx
            y += dy
    return sum(1 for line in field for vent in line if vent>1)


def task1(data: str) -> int:
    return task(data, filter=True)
        
def task2(data: str) -> int:
    return task(data, filter=False)

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

import re, itertools

vents = list()

with open("input.txt") as file:
    for line in file:
        x1, y1, x2, y2 = map(int, re.findall(r"\d+", line))
        xo = 1 if x1 <= x2 else -1
        yo = 1 if y1 <= y2 else -1

        # For Part One
        # if x1 == x2 or y1 == y2:

        for x, y in itertools.zip_longest(
            range(x1, x2 + xo, xo),
            range(y1, y2 + yo, yo),
            fillvalue=x1 if x1 == x2 else y1 if y1 == y2 else None,
        ):
            vents.append((x, y))

overlaps = {}

for e in vents:
    overlaps[e] = overlaps.get(e, 0) + 1

points = 0

for _, o in overlaps.items():
    if o > 1:
        points += 1

print("Answer:", points)  # 7436, 21104