import re

data = list()

with open("input.txt") as file:
    for line in file:
        entry = ["".join(sorted(i)) for i in re.findall(r"\w+", line)]
        data.append((entry[:10], entry[10:]))

#  tttt
# l    r
# t    t
#  mmmm
# l    r
# b    b
#  bbbb

count = 0
sum = 0

for patterns, outputs in data:
    digits = dict()
    fives = list()
    sixs = list()

    # get basic numbers as 1, 4, 7, 8
    # and collect digits by segments
    for pattern in patterns:
        if len(pattern) == 2:
            digits["1"] = list(pattern)
        elif len(pattern) == 4:
            digits["4"] = list(pattern)
        elif len(pattern) == 3:
            digits["7"] = list(pattern)
        elif len(pattern) == 7:
            digits["8"] = list(pattern)
        elif len(pattern) == 5:
            fives.append(list(pattern))
        else:
            sixs.append(list(pattern))

    for one in digits["1"]:
        # get 6, rt
        for six in sixs[:]:
            if one not in six:
                digits["6"] = six
                rt = one
                sixs.remove(six)
                break
        if len(six) == 2:
            break

    # get rb
    for one in digits["1"]:
        if one is not rt:
            rb = one
            break

    # get 2, 3, 5
    for one in digits["1"]:
        for five in fives:
            if rt not in five:
                digits["5"] = five
            elif rb not in five:
                digits["2"] = five
            else:
                digits["3"] = five

    lb = (set(digits["6"]) - set(digits["5"])).pop()

    # get 0, 9
    for six in sixs:
        if lb in six:
            digits["0"] = six
        else:
            digits["9"] = six

    digits = dict(zip(["".join(i) for i in digits.values()], digits.keys()))
    numbers = str()

    for output in outputs:
        if digits[output] in ["1", "4", "7", "8"]:
            count += 1
        numbers += digits[output]
    sum += int(numbers)

print("Part One:", count)
print("Part Two:", sum)

import aoc

import os

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

def task1(data: str) -> int:
    data = [[int(height) for height in line] for line in data.splitlines()]
    result = 0
    for i, line in enumerate(data):
        for j, height in enumerate(line):
            if (    (i==0              or height<data[i-1][j])
                and (j==0              or height<data[i][j-1])
                and (i==len(data)-1    or height<data[i+1][j])
                and (j==len(data[0])-1 or height<data[i][j+1])
                ):
                result += height+1
    return result

def floodfill(cave, y, x):
    if y<0 or x<0 or y==len(cave) or x==len(cave[0]) or cave[y][x]==9:
        return 0
    cave[y][x] = 9
    return (  floodfill(cave, y+1, x) + floodfill(cave, y-1, x)
            + floodfill(cave, y, x+1) + floodfill(cave, y, x-1)) + 1

def task2(data: str) -> int:
    data = [[int(height) for height in line] for line in data.splitlines()]
    basins = []
    for i in range(len(data)):
        for j in range(len(data[0])):
            basins.append(floodfill(data, i, j))
    basins.sort()
    return basins[-1]*basins[-2]*basins[-3]
    

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

fn task1(map: &Vec<Vec<u8>>) -> usize {
    map.iter()
        .enumerate()
        .map(|(i, line)| {
            line.iter()
                .enumerate()
                .filter_map(|(j, &height)| {
                    if (i == 0 || height < map[i - 1][j])
                        && (j == 0 || height < map[i][j - 1])
                        && (i == map.len() - 1 || height < map[i + 1][j])
                        && (j == line.len() - 1 || height < map[i][j + 1])
                    {
                        Some(height as usize + 1)
                    } else {
                        None
                    }
                })
                .sum::<usize>()
        })
        .sum()
}

fn floodfill(map: &mut Vec<Vec<u8>>, i: i32, j: i32) -> usize {
    if i < 0
        || j < 0
        || i >= map.len() as i32
        || j >= map[i as usize].len() as i32
        || map[i as usize][j as usize] == 9
    {
        0
    } else {
        map[i as usize][j as usize] = 9;
        1 + floodfill(map, i - 1, j)
            + floodfill(map, i + 1, j)
            + floodfill(map, i, j - 1)
            + floodfill(map, i, j + 1)
    }
}

fn task2(map: &Vec<Vec<u8>>) -> usize {
    let mut map = map.clone();
    let mut result = Vec::new();
    for i in 0..map.len() {
        for j in 0..map[i].len() {
            result.push(floodfill(&mut map, i as i32, j as i32));
        }
    }
    result.sort();
    result.iter().rev().take(3).fold(1, |x, acc| acc * x)
}

fn main() {
    let input = aoc::get_input_from_ini_with_year("9", "2021").unwrap();
    let map: Vec<Vec<_>> = input
        .lines()
        .map(|line| {
            line.chars()
                .map(|digit| digit.to_digit(10).unwrap() as u8)
                .collect()
        })
        .collect();
    println!("Result1: {}", task1(&map));
    println!("Result2: {}", task2(&map));
}

enum Brackets {
    Correct(Vec<char>),
    Incorrect(char),
}

fn check_brackets(line: &str) -> Brackets {
    let mut stack = Vec::new();
    for symbol in line.chars() {
        match symbol {
            '(' => stack.push(')'),
            '[' => stack.push(']'),
            '{' => stack.push('}'),
            '<' => stack.push('>'),
            closing => {
                if symbol != stack.pop().unwrap() {
                    return Brackets::Incorrect(closing);
                }
            }
        }
    }
    Brackets::Correct(stack)
}

fn task1(data: &str) -> usize {
    data.lines()
        .map(|line| match check_brackets(line) {
            Brackets::Incorrect(')') => 3,
            Brackets::Incorrect(']') => 57,
            Brackets::Incorrect('}') => 1197,
            Brackets::Incorrect('>') => 25137,
            _ => 0,
        })
        .sum()
}

fn task2(data: &str) -> usize {
    let mut scores: Vec<_> = data
        .lines()
        .filter_map(|line| match check_brackets(line) {
            Brackets::Correct(rest) => Some(rest.iter().rev().fold(0, |acc, br| {
                5 * acc
                    + match br {
                        ')' => 1,
                        ']' => 2,
                        '}' => 3,
                        '>' => 4,
                        _ => panic!("wrong char in ending!"),
                    }
            })),
            _ => None,
        })
        .collect();
    scores.sort();
    scores[scores.len() / 2]
}

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

octopuses = [[int(x) for x in l] for l in open("input.txt").read().split()]
grid = {(x, y) for y, l in enumerate(octopuses) for x, _ in enumerate(l)}
count = int()
step = int()

while octopuses != [[0] * 10] * 10:
    octopuses = [[e + 1 for e in l] for l in octopuses]
    fresh = {(x, y) for y, l in enumerate(octopuses) for x, e in enumerate(l) if e > 9}
    exhausted = set()

    sides = lambda x, y: {
        (_x, _y) for _x in (x - 1, x, x + 1) for _y in (y - 1, y, y + 1) if (_x, _y) != (x, y) and (_x, _y) in grid
    }

    while fresh:
        exhausted |= fresh.copy()
        charge = set()
        for f in fresh:
            for x, y in sides(*f):
                octopuses[y][x] += 1
                if octopuses[y][x] > 9 and (x, y) not in exhausted:
                    charge.add((x, y))
        fresh = charge

    for y, l in enumerate(octopuses):
        for x, e in enumerate(l):
            if e > 9:
                octopuses[y][x] = 0
                count += 1

    if step == 99:
        print("Part One", count)

    step += 1

print("Part Two", step)

use unicode_categories::UnicodeCategories;

type CaveName = String;

#[derive(Clone)]
pub struct CaveNode {
    ways_out: Vec<CaveName>,
    visited: Option<bool>,
}

impl CaveNode {
    fn new(name: &str, neighbor: &str) -> CaveNode {
        CaveNode{
            ways_out: vec![neighbor.to_owned()],
            visited: if name.chars().all(|c|c.is_letter_uppercase())  {
                None
            } else {
                Some(false)
            },
        }
    }
}

type CaveMap = std::collections::HashMap<CaveName, CaveNode>;

pub fn parse_input(input: &str) -> CaveMap {
    let mut map = CaveMap::new();
    for line in input.lines() {
        if let Some(dash) = line.find('-') {
            let left = line[..dash].to_string();
            let right = line[dash+1..].to_string();
            map.entry(left.to_owned())
               .and_modify(|node|node.ways_out.push(right.to_owned()))
               .or_insert(CaveNode::new(&left, &right));
            map.entry(right.to_owned())
               .and_modify(|node|node.ways_out.push(left.to_owned()))
               .or_insert(CaveNode::new(&right, &left));
        }
    }
    map
}

fn count_ways(map: &mut CaveMap, start: &str, end: &str) -> usize {
    if start == end {
        return 1;
    }
    if map[start].visited == Some(true) {
            return 0;
    }
    let start = start.to_string();
    if map[&start].visited.is_some() {
        map.entry(start.to_owned()).and_modify(|node|node.visited = Some(true));
    }
    let result = (0..map[&start].ways_out.len()).map(|i|{
        let name = map[&start].ways_out[i].to_owned();
        count_ways(map, &name, end)
    }).sum();
    if map[&start].visited.is_some() {
        map.entry(start).and_modify(|node|node.visited = Some(false));
    }
    result
}

pub fn task1(map: &CaveMap) -> usize {
    let mut map = map.clone();
    count_ways(&mut map, "start", "end")
}

fn count_ways2(map: &mut CaveMap, start: &str, end: &str, start_visited: bool, small_visited_twice: bool) -> usize {
    if start == end {
        return 1;
    }
    if start=="start" && start_visited {
        return 0;
    }
    let in_visited_small = map[start].visited.unwrap_or(false);
    if small_visited_twice && in_visited_small {
        return 0;
    }
    let start = start.to_string();
    if map[&start].visited.is_some() {
        map.entry(start.to_owned()).and_modify(|node|node.visited = Some(true));
    }
    let result = (0..map[&start].ways_out.len()).map(|i|{
        let name = map[&start].ways_out[i].to_owned();
        count_ways2(map, &name, end, true, small_visited_twice || in_visited_small)
    }).sum();
    if !in_visited_small && map[&start].visited.is_some() {
        map.entry(start).and_modify(|node|node.visited = Some(false));
    }
    result
}

pub fn task2(map: &CaveMap) -> usize {
    let mut map = map.clone();
    count_ways2(&mut map, "start", "end", false, false)
}