pairs = {"(": ")", "[": "]", "{": "}", "<": ">"}
illegal = int()
incomplete = list()

for chunk in [line for line in open("input.txt").read().split()]:
    history = list()
    for ch in chunk:
        if ch not in pairs.keys():
            if ch == pairs[history[-1]]:
                history.pop(-1)
            else:
                illegal += {")": 3, "]": 57, "}": 1197, ">": 25137}[ch]
                history.clear()
                break
        else:
            history.append(ch)
    if history:
        points = int()
        for h in history[::-1]:
            points = points * 5 + {")": 1, "]": 2, "}": 3, ">": 4}[pairs[h]]
        incomplete.append(points)

print("Part One:", illegal)
print("Part Two:", sorted(incomplete)[len(incomplete) // 2])

import aoc

import os
import unittest

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

def check_brackets(line):
    stack = []
    PAIRS = {'(':')','[':']','{':'}','<':'>'}
    for symb in line:
        if symb in PAIRS:
            stack.append(PAIRS[symb])
        else:
            if not stack or stack.pop()!=symb:
                return (symb, [])
    return ('', stack)

def task1(data: str) -> int:
    VALUES = {'':0,')':3,']':57,'}':1197,'>':25137}
    return sum(VALUES[check_brackets(line)[0]] for line in data.splitlines())
        
def task2(data: str) -> int:
    VALUES = {')':1,']':2,'}':3,'>':4}
    results = []
    for line in data.splitlines():
        result = 0
        symb, closing = check_brackets(line)
        if not symb:
            for brack in reversed(closing):
                result = 5*result + VALUES[brack]
            #print(''.join(closing), result)
            results.append(result)
    results.sort()
    return results[len(results)//2]

class Test(unittest.TestCase):
    def test_brack(self):
        symb, stack = check_brackets('[({(<(())[]>[[{[]{<()<>>')
        self.assertEqual(symb, '')
        self.assertEqual(''.join(reversed(stack)),'}}]])})]')
    def test_task2(self):
        inp = '''[({(<(())[]>[[{[]{<()<>>
[(()[<>])]({[<{<<[]>>(
{([(<{}[<>[]}>{[]{[(<()>
(((({<>}<{<{<>}{[]{[]{}
[[<[([]))<([[{}[[()]]]
[{[{({}]{}}([{[{{{}}([]
{<[[]]>}<{[{[{[]{()[[[]
[<(<(<(<{}))><([]([]()
<{([([[(<>()){}]>(<<{{
<{([{{}}[<[[[<>{}]]]>[]]'''
        self.assertEqual(task2(inp), 288957)

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

#[derive(Clone)]
pub struct Octopuses {
    map: Vec<Vec<u8>>,
    last_flashed: usize,
}

impl Octopuses {
    fn new(input: &str) -> Octopuses {
        Octopuses {
            map: input.lines()
                      .map(|line|line.chars()
                                     .map(|c|c.to_digit(10).unwrap() as u8)
                                     .collect()
                      ).collect(),
            last_flashed: 0,
        }
    }
    
    fn step(&mut self) -> usize {
        for y in 0..self.map.len() {
            for x in 0..self.map[y].len() {
                self.map[y][x] += 1;
            }
        }
        self.last_flashed = 0;
        loop {
            let mut flashed = 0;
            for y in 0..self.map.len() {
                for x in 0..self.map[y].len() {
                    if self.try_flash(y, x) {
                        flashed += 1;
                    }
                }
            }
            if flashed == 0 {
                break;
            } else {
                self.last_flashed += flashed;
            }
        }
        self.last_flashed
    }

    fn try_flash(&mut self, y: usize, x: usize) -> bool {
        use std::cmp::{min, max};
        if self.map[y][x]<=9 {
            false
        } else {
            self.map[y][x] = 0;
            for dy in max(0, y as i32-1) as usize..min(self.map.len(), y+2) {
                for dx in max(0, x as i32-1) as usize..min(self.map[y].len(), x+2) {
                    if self.map[dy][dx] != 0 {
                        self.map[dy][dx] += 1;
                    }
                }
            }
            true
        }
    }

    fn area(&self) -> usize {
        self.map.len() * self.map[0].len()
    }
}

pub fn parse_input(input: &str) -> Octopuses {
    Octopuses::new(input)
}

pub fn task1(octopuses: &Octopuses) -> usize {
    let mut octopuses = octopuses.clone();
    (0..100).map(|_|octopuses.step()).sum()
}

pub fn task2(octopuses: &Octopuses) -> usize {
    let mut octopuses = octopuses.clone();
    let area = octopuses.area();
    (0..).take_while(|_|octopuses.step() != area).count() + 1
}

pub fn task1(instructions: &str) -> i32 {
    instructions.chars()
                .map(|c|match c {
                    '(' =>  1,
                    ')' => -1,
                    _ => panic!("Wrong input"),
                })
                .sum()
}

f = open("input.txt", "r")
floor = pos = 0

for s in f.read():
    if s == '(':
        floor += 1
    else:
        floor -= 1
    pos += 1
    if floor == -1:
        print(f"Basement: {pos}") # Part Two

print(f"Floor: {floor}")  # Part One
f.close()

from re import findall


def folding(axis: str, number: int) -> list:
    folded = list()
    for n in range(1, number + 1):
        for x, y in set(dots):
            if axis == "x" and x in (number - n, number + n):
                folded.append((number - n, y))
            elif axis == "y" and y in (number - n, number + n):
                folded.append((x, number - n))
    return folded


def visualing() -> None:
    max_x, max_y = [max(el) + 1 for el in [*zip(*dots)]]
    for y in range(max_y):
        for x in range(max_x):
            print("#" if (x, y) in dots else " ", end="")
        print("\n", end="")
    print()


dots = list()
actions = list()
instructions = False

for line in open("input.txt").read().splitlines():
    if not line:
        instructions = True
        continue
    if instructions:
        axis, number = findall(r"([xy])=(\d+)", line)[0]
        actions.append((axis, int(number)))
    else:
        dots.append(tuple(map(int, findall(r"\d+", line))))

for number, action in enumerate(actions):
    dots = folding(*action)
    if number == 1:
        print("Part One:", len(dots))

print("Part Two:")
visualing()

from collections import Counter

polymer, _, *rules = open("input.txt").read().splitlines()
rules = dict(rule.split(" -> ") for rule in rules)
pairs = Counter(polymer[i] + polymer[i + 1] for i in range(len(polymer) - 1))
chars = Counter(polymer)
steps = (10, 40)

for i in range(1, steps[-1] + 1):
    for (a, b), count in pairs.copy().items():
        if a + b in rules.keys():
            insert = rules[a + b]
            pairs[a + b] -= count
            pairs[a + insert] += count
            pairs[insert + b] += count
            chars[insert] += count
    if i in steps:
        print("Answer:", max(chars.values()) - min(chars.values()))

#[derive(Copy, Clone)]
pub enum Fold {
    X,
    Y,
}

#[derive(Clone)]
pub struct InvisiblePaper {
    dots: std::collections::HashSet<(i32, i32)>,
    folds: Vec<(Fold, i32)>,
}

impl InvisiblePaper {
    fn do_fold(&mut self, fold: (Fold, i32)) {
        self.dots = self.dots
                        .iter()
                        .map(|dot|
                            match fold.0 {
                                Fold::X => (fold.1 - (fold.1-dot.0).abs(), dot.1),
                                Fold::Y => (dot.0, fold.1 - (fold.1-dot.1).abs()),
                            })
                        .collect();
    }
}

pub fn parse_input(input: &str) -> InvisiblePaper {
    let lines = input.lines();
    let mut dots_done = false;
    let mut data = InvisiblePaper {
        dots: std::collections::HashSet::new(), 
        folds: Vec::new(),
    };
    for line in lines {
        if line.is_empty() {
            dots_done = true;
        } else {
            if !dots_done {
                let mut dot = line.split(',');
                data.dots.insert((dot.next().unwrap().parse().unwrap(),
                                dot.next().unwrap().parse().unwrap()));
            } else {
                let mut fold = line.split('=');
                let fold_type = if fold.next().unwrap().chars().nth(11)==Some('x') {
                    Fold::X
                } else {
                    Fold::Y
                };
                data.folds.push((fold_type,fold.next().unwrap().parse().unwrap()));
            }
        }
    }
    data
}

pub fn task1(data: &InvisiblePaper) -> usize {
    let mut data = data.clone();
    data.do_fold(data.folds[0]);
    data.dots.len()
}

pub fn task2(data: &InvisiblePaper) -> usize {
    let folds = &data.folds;
    let mut data = data.clone();
    for &fold in folds {
        data.do_fold(fold);
    }
    let max_x = data.dots.iter().map(|(x, _)|x).max().unwrap() + 1;
    let max_y = data.dots.iter().map(|(_, y)|y).max().unwrap() + 1;
    for y in 0..max_y {
        for x in 0..max_x {
            print!("{}", if data.dots.contains(&(x,y)) {"#"} else {"."});
        }
        println!("");
    }
    0
}