Advent of Code

[__blackjack__]

So kann eine BASIC-Lösung für Tag 1 aussehen:

Code: Alles auswählen

10 DEFINT A-Z:OPEN"I",#1,"INPUT.TXT":R1=0:R2=0:DI=50
20 WHILE NOT EOF(1):LINE INPUT #1,A$:D$=MID$(A$,1,1):D=VAL(MID$(A$,2))
30 R2=R2+D\100:D=D MOD 100:IF D=0 THEN 70
40 DO=DI:DI=DI+D*((D$="L")*2+1):IF DI=0 THEN R2=R2+1:GOTO 70
50 IF DI<0 THEN DI=DI+100:IF DO<>0 THEN R2=R2+1:GOTO 70
60 IF DI>=100 THEN DI=DI-100:R2=R2+1
70 IF DI=0 THEN R1=R1+1
80 WEND:PRINT R1;R2:SYSTEM

Das läuft so knapp 5 Minuten unter CP/M auf einem Intel 8080 mit 2Mhz.

[snafu]

Der Vollständigkeit halber hier meine Komplettlösung für Tag 1 in Rust:

Code: Alles auswählen

use std::fs::read_to_string;

fn instruction_to_int(instruction: &str) -> i32 {
    instruction
        .trim_start_matches("R")
        .replacen("L", "-", 1)
        .parse()
        .unwrap()
}

fn find_path(
    start: i32, instructions: impl Iterator<Item = i32>
) -> impl Iterator<Item = (i32, i32, i32)> {
    let state = (start, 0, 0);
    instructions.scan(state, |(pos, seen_zero, direct_hits), steps| {
        let next_pos = *pos + steps;
        *seen_zero += (next_pos / 100).abs();
        if *pos != 0 && next_pos <= 0 {
            *seen_zero += 1;
        }
        *pos = next_pos.rem_euclid(100);
        if *pos == 0 {
            *direct_hits += 1;
        }
        Some((*pos, *seen_zero, *direct_hits))
    })
}

fn main() {
    let input = read_to_string("input.txt").unwrap();
    let instructions = input.lines().map(instruction_to_int);
    let path = find_path(50, instructions);
    let (_, seen_zero, direct_hits) = path.last().unwrap();
    dbg!(seen_zero, direct_hits);
}

Laufzeit auf meinem Rechner: 0.02s

[kbr]

Interessant. Laufzeit für Lösung Tag 1, Teil 2 auf meinem Raspberry Pi 3 Model B+ (Python 3.12): 0.03s.

[narpfel]

Meine Lösung für Tag 6 sieht fast aus wie BASIC (193 Zeichen):

Code: Alles auswählen

from itertools import*;*a,o=open(0);s=str.split;b=map("".join,zip(*a));o=[o.join for o in s(o)]
print(sum(eval(o(a))for o,*a in zip(o,*map(s,a))),sum(eval(o(takewhile(str.strip,b)))for o in o))

[Manul]

Meine Lösung für Tag 6 sieht fast aus wie BASIC (193 Zeichen):

Ich habe 55 Zeilen mehr gebraucht.

Insgesamt finde ich die Aufgaben dieses Jahr bis jetzt relativ einfach, auch wenn ich heute ziemlich lang gebraucht habe - das Konzept war schnell klar, aber beim Umsetzen steckt dann der Teufel im Detail und ich komme unterm Jahr kaum zum Programmieren und bin entsprechend rostig. Bin gespannt, ob in den letzten 4 Tagen noch ein paar ähnlich harte Nüsse wie in den letzten Jahren kommen - ein paar zweite Teile habe ich aus fast jedem Jahr, in dem ich mitgespielt habe, noch offen.

Da ich meistens ziemlich schnell fertig war, bin ich auch noch ein paar Aufgaben aus den letzten Jahren, die ich noch nicht gemacht hatte, angegangen. Aktuell hänge ich bei Tag 22 aus 2015. Hat das hier jemand gelöst und könnte mir bei ein paar konkreten Fragen helfen?

Was ganz anderes: Ich finde die ASCII-Arte des Kalenders, die sich pro Aufgabe 2 mal ändert, mal wieder sehr liebevoll gemacht. Weiß jemand, ob's eine Möglichkeit gibt, sich die früheren Stadien noch mal anzuschauen, außer einen neuen Account anzulegen?

[Manul]

Was ganz anderes: Ich finde die ASCII-Arte(!) des Kalenders, die sich pro Aufgabe 2 mal ändert [...]

Ich korrigiere: 3 mal.

P.S. Meinen letzten Beitrag kann ich nicht mehr editieren, oder? Sonst hätte ich den Typo gerne noch korrigiert.

[snafu]

Tag 6 / Teil 1:

Code: Alles auswählen

use std::fs::read_to_string;

struct Zipper<T>(Vec<T>);

impl<T> Iterator for Zipper<T>
where
    T: Iterator,
{
    type Item = Vec<T::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.iter_mut().map(Iterator::next).collect()
    }
}

fn get_total(input: &str) -> i64 {
    let matrix = Zipper(input.lines().map(|line| line.split_whitespace()).collect());
    matrix.map(|column| calculate(&column)).sum()
}

fn calculate(strings: &[&str]) -> i64 {
    let numeric_strings = strings[..strings.len() - 1].iter();
    let numbers = numeric_strings.map(|s| s.parse().unwrap());
    let op = strings[strings.len() - 1];
    numbers.reduce(|a, b| {
        match op {
            "+" => a + b,
            "-" => a - b,
            "*" => a * b,
            "/" => a / b,
            _ => panic!("Unknown operation: {:?}", op),
        }
    }).unwrap()
}

fn main() {
    dbg!(get_total(&read_to_string("input.txt").unwrap()));
}

Wobei der Zipper von https://stackoverflow.com/a/55292215 abgekupfert ist. Vermutlich geht das auch ohne die Hilfsklasse.