const BINGO_SIZE :usize = 5;

struct Board ([[usize; BINGO_SIZE];BINGO_SIZE] );

impl Board {
    fn position(&self, value: usize) -> Option<(usize, usize)> {
        for row in 0..BINGO_SIZE {
            for col in 0..BINGO_SIZE {
                if self.0[row][col] == value {
                    return Some((row, col));
                }
            }
        }
        None
    }
}

struct BingoSettings
{
    calls: Vec<usize>,
    boards: Vec<Board>,
}

impl BingoSettings
{
    fn from_str(s: &str) -> BingoSettings {
        let mut s = s.lines();
        let calls = s.next()
                     .unwrap()
                     .split(",")
                     .map(|s|s.parse().unwrap())
                     .collect();
        let mut boards = Vec::new();
        let mut idx = 0;
        for line in s {
            if line.is_empty() {
                boards.push(Board([[0, 0, 0, 0, 0, ],
                                   [0, 0, 0, 0, 0, ],
                                   [0, 0, 0, 0, 0, ],
                                   [0, 0, 0, 0, 0, ],
                                   [0, 0, 0, 0, 0, ],]));
                idx = 0;
            } else {
                let mut board = boards.last_mut().unwrap();
                for (i, n) in line.split_whitespace().enumerate() {
                    board.0[idx][i] = n.parse().unwrap();
                }
                idx = (idx+1) % 5;
            }
        }
        BingoSettings {
            calls,
            boards,
        }
    }
}

type StrikeBoard = [[bool; BINGO_SIZE];BINGO_SIZE];

struct Bingo<'a>
{
    settings: &'a BingoSettings,
    winners: Vec<(usize, usize)>,
    striked: Vec<StrikeBoard>,
}

impl Bingo<'_>
{
    fn new(settings: &BingoSettings) -> Bingo
    {
        Bingo {
            settings,
            winners: Vec::new(),
            striked: std::iter::repeat([[false, false, false, false, false, ],
                                        [false, false, false, false, false, ],
                                        [false, false, false, false, false, ],
                                        [false, false, false, false, false, ],
                                        [false, false, false, false, false, ],])
            .take(settings.boards.len())
            .collect(),
        }
    }

    fn task(&mut self, nwinner:usize) -> usize {
        for &call in &self.settings.calls {
            self.strikeout(call);
            if self.winners.len() == nwinner {
                break;
            }
        }
        self.last_winner_score()
    }

    fn strikeout(&mut self, call: usize) {
        for board_idx in 0..self.striked.len() {
            if let Some((row, col)) = self.settings.boards[board_idx].position(call) {
                self.striked[board_idx][row][col] = true;
                self.check_winner(board_idx, row, col, call);
            };
        }
    }

    fn check_winner(&mut self, board_idx:usize, row_idx: usize, col_idx:usize, call: usize)
    {
        if !self.winners.iter().find(|&&(board, _)|board == board_idx).is_some() {
            if     (0..BINGO_SIZE).map(|i|self.striked[board_idx][row_idx][i])
                                  .all(|striked|striked)
                || (0..BINGO_SIZE).map(|i|self.striked[board_idx][i][col_idx])
                                  .all(|striked|striked) {
                let mut score = 0;
                for row in 0..BINGO_SIZE {
                    for col in 0..BINGO_SIZE {
                        if !self.striked[board_idx][row][col] {
                            score += self.settings.boards[board_idx].0[row][col];
                        }

                    }
                }
                self.winners.push((board_idx, call * score));
            }
        }
    }

    fn last_winner_score(&self) -> usize {
        self.winners.last().unwrap().1
    }
}

fn task1(bingo: &BingoSettings) -> usize
{
    Bingo::new(bingo).task(1)
}

fn task2(bingo: &BingoSettings) -> usize
{
    Bingo::new(bingo).task(bingo.boards.len())
}

#[cfg(test)]
mod tests {
    // Note this useful idiom: importing names from outer (for mod tests) scope.
    use super::*;
    const DATA: &str = "7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1

22 13 17 11  0
 8  2 23  4 24
21  9 14 16  7
 6 10  3 18  5
 1 12 20 15 19

 3 15  0  2 22
 9 18 13 17  5
19  8  7 25 23
20 11 10 24  4
14 21 16 12  6

14 21 17 24  4
10 16 15  9 19
18  8 23 26 20
22 11 13  6  5
 2  0 12  3  7";

    #[test]
    fn test_task1() {
        let bingo = BingoSettings::from_str(&DATA);
        assert_eq!(task1(&bingo), 4512);
    }


    #[test]
    fn test_task2() {
        let bingo = BingoSettings::from_str(&DATA);
        assert_eq!(task2(&bingo), 1924);
    }
}

fn main() {
    let input = aoc::get_input_from_ini_with_year("4","2021").unwrap();
    let bingo = BingoSettings::from_str(&input);
    println!("Result1: {}", task1(&bingo));
    println!("Result2: {}", task2(&bingo));
}

type Line = ((i32, i32),(i32, i32));

const FIELD_SIZE: usize = 1000;

fn parse_vents(lines: &str) -> Vec<Line> {
    lines.lines()
         .map(|line|{
            let mut line = line.split(" -> ");
            let mut pt1 = line.next().unwrap().split(',');
            let mut pt2 = line.next().unwrap().split(',');
            ((pt1.next().unwrap().parse().unwrap(), pt1.next().unwrap().parse().unwrap()),
             (pt2.next().unwrap().parse().unwrap(), pt2.next().unwrap().parse().unwrap()))
        })
        .collect()
}

fn is_diagonal(line: &Line) -> bool {
    line.0.0 != line.1.0 && line.0.1 != line.1.1
}

fn ordering_to_i32(order: std::cmp::Ordering) -> i32{
    match order {
        std::cmp::Ordering::Greater =>  1,
        std::cmp::Ordering::Equal   =>  0,
        std::cmp::Ordering::Less    => -1,
    }
}

fn task(vents: &[Line], is_diagonals_needed: bool) -> i32
{
    let mut field: Vec<Vec<i32>> = std::iter::repeat(std::iter::repeat(0).take(FIELD_SIZE).collect()).take(FIELD_SIZE).collect();
    for vent in vents {
        if is_diagonals_needed || !is_diagonal(vent) {
            let (mut x, mut y) = vent.0;
            let (dx, dy) = (-ordering_to_i32(x.cmp(&vent.1.0)),-ordering_to_i32(y.cmp(&vent.1.1)));
            loop {
                field[x as usize][y as usize] += 1;
                if (x,y) == vent.1 {
                    break;
                }
                x += dx;
                y += dy;
            }
        }
    }
    field.iter().map(|line|line.iter().filter(|&&x|x>1).count() as i32).sum()
}

fn task1(vents: &[Line]) -> i32
{
    task(vents, false)
}


fn task2(vents: &[Line]) -> i32
{
    task(vents, true)
}

fn main() {
    let input = aoc::get_input_from_ini_with_year("5","2021").unwrap();
    let vents = parse_vents(&input);
    println!("Result1: {}", task1(&vents));
    println!("Result2: {}", task2(&vents));
}

import aoc

import os
from collections import defaultdict

NUMBER = os.path.basename(__file__).removesuffix('a.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:
    vents = defaultdict(int)
    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:
            vents[(x,y)]+=1
            if [x,y]==line[1]:
                break
            x += dx
            y += dy
    return sum(1 for count in vents.values() if count>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 aoc

import os

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

def simulate(data: str, time: int) -> int:
    fishes = [0]*9
    for age in data.split(','):
        fishes[int(age)] += 1
    for _ in range(time):
        fishes = fishes[1:]+fishes[:1]
        fishes[6] += fishes[8]
    return sum(fishes)

def task1(data: str) -> int:
    return simulate(data, 80)
        
def task2(data: str) -> int:
    return simulate(data, 256)

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

fn simulate(mut state: [usize; 9], time: usize) -> usize
{
    for _ in 0..time {
        let giving_birth = state[0];
        for i in 0..8 {
            state[i] = state[i+1];
        }
        state[6] += giving_birth;
        state[8] = giving_birth;
    }
    state.iter().sum()
}

fn task1(state: &[usize; 9]) -> usize
{
    simulate(*state, 80)
}


fn task2(state: &[usize; 9]) -> usize
{
    simulate(*state, 256)
}

fn main() {
    let input = aoc::get_input_from_ini_with_year("6","2021").unwrap();
    let mut state = [0; 9];
    for fish in input.split(',').map(|x|x.parse::<usize>().unwrap()) {
        state[fish] += 1;
    };
    println!("Result1: {}", task1(&state));
    println!("Result2: {}", task2(&state));
}

data = list(map(int, open("input.txt").read().split(",")))
one = list()
two = list()

for t in data:
    one.append(0)
    two.append(0)
    for f in data:
        one[-1] += abs(f - t)
        two[-1] += sum(range(1, abs(f - t) + 1))

print("Part One:", min(one))
print("Part Two:", min(two))