Advent of Code

use std::{
    fs::File,
    io::{prelude::*, BufReader},
    path::Path,
    iter::zip
};
use itertools::Itertools;

fn read_lines(filepath: impl AsRef<Path>) -> Vec<String> {
    let file_content = File::open(filepath).expect("File not found");
    let buffer = BufReader::new(file_content);
    buffer.lines()
        .map(|l| l.expect("Can't read"))
        .collect()
}

fn format_input(lines: Vec<String>) -> (Vec<i32>, Vec<i32>) {
    let mut destinations: Vec<Vec<String>> = Vec::new();
    for line in lines {
        let line: Vec<String> = line.split_whitespace().map(str::to_string).collect();
        destinations.push(line);
    };

    let mut left_values: Vec<i32> = Vec::new();
    let mut right_values: Vec<i32> = Vec::new();
    for pair in destinations {
        let left:i32 = pair[0].parse::<i32>().unwrap();
        left_values.push(left);
        let right:i32 = pair[1].parse::<i32>().unwrap();
        right_values.push(right);
    };
    left_values.sort();
    right_values.sort();
    (left_values, right_values)
}

fn part_1(left_values: Vec<i32>, right_values: Vec<i32>) -> i32 {
    let mut calculated_values: Vec<i32> = Vec::new();
    for (left, right) in zip(left_values, right_values) {
        let result:i32 = left - right;
        calculated_values.push(result.abs());
    };
    let result: i32 = calculated_values.iter().sum();
    result
}

fn part_2(left_values: Vec<i32>, right_values: Vec<i32>) -> i32 {
    let counts = right_values.into_iter().counts();
    let mut calcualted_values: Vec<i32> = Vec::new();
    for value in left_values {
        if counts.contains_key(&value) {
            let result = value * counts[&value] as i32;
            calcualted_values.push(result);
        } 
    };
    let result: i32 = calcualted_values.iter().sum();
    result
}

fn main() {
    let lines = read_lines("/home/dennis/PycharmProjects/AdventofCode/2024/puzzel_input.txt");
    let (left_values, right_values)  = format_input(lines);
    println!("{:?}", part_1(left_values.clone(), right_values.clone()));
    println!("{:?}", part_2(left_values, right_values));
}

#!/usr/bin/env python3
"""
Advent of Code 2024 - Puzzle 05
"""

import sys
from pprint import pprint
from functools import cmp_to_key, partial

EXAMPLE_LINES = """\
47|53
97|13
97|61
97|47
75|29
61|13
75|53
29|13
97|29
53|29
61|53
97|53
61|29
47|13
75|47
97|75
47|61
75|61
47|29
75|13
53|13

75,47,61,53,29
97,61,53,29,13
75,29,13
75,97,47,61,53
61,13,29
97,13,75,29,47
""".splitlines()

EXAMPLE_SOLUTIONS = (143, 123)


def check_testsum(result, part=1):
    if result != EXAMPLE_SOLUTIONS[part-1]:
        print("Solution for EXAMPLE_LINES is not yet correct! Expected:", EXAMPLE_SOLUTIONS[part-1])


def is_update_ok(update, myrules, is_test=False):

    before_this = myrules["before_this"]
    after_this = myrules["after_this"]

    is_ok = True

    for i, page in enumerate(update):
        befores = update[0:i]
        afters = update[i+1:]
        for b in befores:
            try:
                if not b in before_this[page]:
                    is_ok = False
                    break
            except KeyError:
                is_ok = False
                break
        else:
            for a in afters:
                try:
                    if not a in after_this[page]:
                        is_ok = False
                        break
                except KeyError:
                    is_ok = False
                    break
            else:
                if is_test:
                    print("ok:", page)
    return is_ok


def mysort(a, b, rules=None):
    try:
        if b in rules["after_this"][a]:
            return -1
    except KeyError:
        if b in rules["before_this"][a]:
            return 1
    return 0


def main(is_test=False):

    if is_test:
        lines = EXAMPLE_LINES
    else:
        lines = [line.rstrip() for line in sys.stdin]

    divider = lines.index("")
    rules = [list(map(int, rule.split("|"))) for rule in lines[:divider]]
    updates = [list(map(int, update.split(","))) for update in lines[divider+1:]]

    if is_test:
        print("    TEST MODE")
        print("Rules")
        for rule in rules:
            print("   ", rule)
        print("Updates")
        for update in updates:
            print("   ", update)

    print("\n***Part one ***\n")

    myrules = { "before_this" : {},
                "after_this" : {}
              }

    for rule in rules:
        left, right = rule
        if left in myrules["after_this"]:
            myrules["after_this"][left].append(right)
            myrules["after_this"][left].sort()
        else:
            myrules["after_this"][left] = [right,]

        if right in myrules["before_this"]:
            myrules["before_this"][right].append(left)
            myrules["before_this"][right].sort()
        else:
            myrules["before_this"][right] = [left,]

    if is_test:
        print("before_this")
        pprint(myrules["before_this"])
        print()
        print("after_this")
        pprint(myrules["after_this"])
        print()
        print()


    sum_middle_pages = 0
    incorrect_updates = []

    for update in updates:
        if is_test:
            print("Update:", update)
        if is_update_ok(update, myrules, is_test=is_test):
            middle_page = update[len(update)//2]
            if is_test:
                print("Update okay!", end="  ")
                print("Middle page:", middle_page)
            sum_middle_pages += middle_page
        else:
            incorrect_updates.append(update)
    if is_test:
        print()

    print("Result:", sum_middle_pages)
    if is_test:
        check_testsum(sum_middle_pages, part=1)

    print("\n***Part two ***\n")

    sum_middle_pages = 0

    if is_test:
        print("Incorrect updates:")

    for update in incorrect_updates:
        if is_test:
            print(update)
        new_update = sorted(update, key=cmp_to_key(partial(mysort, rules=myrules)))
        middle_page = new_update[len(new_update)//2]
        sum_middle_pages += middle_page
        if is_test:
            print(new_update)
            print()


    print("Result:", sum_middle_pages)
    if is_test:
        check_testsum(sum_middle_pages, part=2)


if __name__ == "__main__":

    is_test = False
    try:
        if sys.argv[1] == "-t":
            is_test = True
    except IndexError:
        pass

    main(is_test=is_test)

#!/usr/bin/env python3
"""
Advent of Code 2024 - Puzzle 05
"""

import sys
import bisect
from pprint import pprint
from functools import cmp_to_key, partial
# from collections import defaultdict

EXAMPLE_LINES = """\
47|53
97|13
97|61
97|47
75|29
61|13
75|53
29|13
97|29
53|29
61|53
97|53
61|29
47|13
75|47
97|75
47|61
75|61
47|29
75|13
53|13

75,47,61,53,29
97,61,53,29,13
75,29,13
75,97,47,61,53
61,13,29
97,13,75,29,47
""".splitlines()

EXAMPLE_SOLUTIONS = (143, 123)


def check_testsum(result, part=1):
    if result != EXAMPLE_SOLUTIONS[part-1]:
        print("Solution for EXAMPLE_LINES is not yet correct! Expected:", EXAMPLE_SOLUTIONS[part-1])


def is_update_ok(update, rules, is_test=False):

    is_ok = True

    for i, page in enumerate(update):
        befores = update[0:i]
        afters = update[i+1:]
        for b in befores:
            try:
                if not b in rules[page]["before"]:
                    is_ok = False
                    break
            except KeyError:
                is_ok = False
                break
        else:
            for a in afters:
                try:
                    if not a in rules[page]["after"]:
                        is_ok = False
                        break
                except KeyError:
                    is_ok = False
                    break
            else:
                if is_test:
                    print("ok:", page)
    return is_ok


def compare_pages(a, b, rules):
    try:
        if b in rules[a]["after"]:
            return -1
    except KeyError:
        if b in rules[a]["before"]:
            return 1
    return 0


def main(is_test=False):

    if is_test:
        lines = EXAMPLE_LINES
    else:
        lines = [line.rstrip() for line in sys.stdin]

    divider = lines.index("")
    single_rules = [list(map(int, rule.split("|"))) for rule in lines[:divider]]
    updates = [list(map(int, update.split(","))) for update in lines[divider+1:]]

    if is_test:
        print("    TEST MODE")
        print("Rules")
        for rule in single_rules:
            print("   ", rule)
        print("Updates")
        for update in updates:
            print("   ", update)


    print("\n***Part one ***\n")

    # The old structure of the rules dict, already with defaultdict:
    #
    #rules = { "before_this" : defaultdict(list),
    #          "after_this" : defaultdict(list)
    #        }
    #
    #for left, right in single_rules:
    #    bisect.insort(rules["after_this"][left], right)
    #    bisect.insort(rules["before_this"][right], left)


    rules = {}

    for left, right in single_rules:
        try:
            bisect.insort(rules[left]["after"], right)
        except KeyError:
            rules[left] = {"before": [],
                           "after" : [right,]}
        try:
            bisect.insort(rules[right]["before"], left)
        except KeyError:
            rules[right] = {"before": [left,],
                            "after" : []}


    if is_test:
        print("Rules:")
        pprint(rules)
        print()


    sum_middle_pages = 0
    incorrect_updates = []

    for update in updates:
        if is_test:
            print("Update:", update)
        if is_update_ok(update, rules, is_test=is_test):
            middle_page = update[len(update)//2]
            if is_test:
                print("Update okay!", end="  ")
                print("Middle page:", middle_page)
            sum_middle_pages += middle_page
        else:
            incorrect_updates.append(update)

    if is_test:
        print()

    print("Result:", sum_middle_pages)
    if is_test:
        check_testsum(sum_middle_pages, part=1)

    print("\n***Part two ***\n")

    sum_middle_pages = 0

    if is_test:
        print("Incorrect updates:")

    for update in incorrect_updates:
        if is_test:
            print(update)
        new_update = sorted(update, key=cmp_to_key(partial(compare_pages, rules=rules)))
        middle_page = new_update[len(new_update)//2]
        sum_middle_pages += middle_page
        if is_test:
            print(new_update)
            print()


    print("Result:", sum_middle_pages)
    if is_test:
        check_testsum(sum_middle_pages, part=2)


if __name__ == "__main__":

    is_test = False
    try:
        if sys.argv[1] == "-t":
            is_test = True
    except IndexError:
        pass

    main(is_test=is_test)