Das deutsche Python-Forum

Code: Alles auswählen

import os
from dataclasses import dataclass

@dataclass
class Instruction:
  direction: str
  length: int
  text: str


def parse_data_01(data):
  instructions = []
  for line in data.split("\n"):
    first_char = line[0]
    if first_char == "R":
      direction = +1
    elif first_char == "L":
      direction = -1
    else:
      raise ValueError("Direction must be coded as L or R, but found: {first_char}.")

    other_chars = line[1:]
    length = int(other_chars)
    instructions.append(Instruction(direction, length, line))

  return instructions


def solve_01(data):
  zeroes_hit = 0
  zeroes_passed = 0
  position = 50

  print(f"- The dial starts by pointing at {position}.")

  instructions = parse_data_01(data)
  for i in instructions:
    position = (position + (i.direction * i.length))

    while position < 0:
      zeroes_passed += 1
      position += + 100

    while position > 100:
      zeroes_passed += 1
      position -= 100

    if position in (0, 100):
      position = 0
      zeroes_hit += 1
      zeroes_passed += 1

    print(f"- The dial is rotated {i.text} to point at {position}.")

  print(f"- Hit position 0 a total of {zeroes_hit} times.")
  print(f"- Passed position 0 a total of {zeroes_passed} times.")

if __name__ == "__main__":
  folder = "C:/data/py/26-aoc2025"
  number = "01"
  file_path = os.path.join(folder, f"{number}.txt")

  with open(file_path) as f:
    data = f.read().strip()

  solve_01(data)

Code: Alles auswählen

n=50; < input tr LR -+ | while read line; do ((n = (n $line + 100) % 100)); echo $n; done | grep -c '^0$'

Code: Alles auswählen

n=50;tr LR -+<i|while read l;do((n=(n$l+100)%100));echo $n;done|grep -c '^0$'

Code: Alles auswählen

n=50
part_2=0
while read line; do
    ((step = line < 0 ? -1 : 1))
    ((step_count = line < 0 ? -line : line))
    for ((i = 0; i < step_count; ++i)); do
        ((n = (n + step + 100) % 100, n == 0 && ++part_2))
    done
done < <(tr LR -+ < input)
echo $part_2

Code: Alles auswählen

- The dial starts by pointing at 50.
- The dial is rotated R50 to point at 0.
- Passed zero: 2 times. 
- Hit zero: 1 time.

Code: Alles auswählen

    zeroes_passed += abs(position // 100)
    position = position % 100
    zeroes_hit += (position == 0)

Code: Alles auswählen

- The dial starts by pointing at 1.
- The dial is rotated L1  to point at 0.        Passed 0: 0 times. Hit 0: 1 times.

Code: Alles auswählen

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

fn find_path(start: i32, instructions: Vec<&str>) -> impl Iterator<Item = i32> {
    instructions.into_iter().map(parse_steps)
                .scan(start, |position, steps| {
                    *position = (*position + steps).rem_euclid(100);
                    dbg!(&position);
                    Some(*position)
                })
}

fn main() {
    let instructions = vec!["L68", "L30", "R48", "L5", "R60", "L55", "L1", "L99", "R14", "L82"];
    let zeros = find_path(50, instructions).filter(|n| *n == 0);
    dbg!(zeros.count());
}

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 div_floor(a: i32, b: i32) -> i32 {
    (a as f32 / b as f32).floor() as i32
}

fn find_path(
    start: i32,
    instructions: impl Iterator<Item = i32>,
) -> impl Iterator<Item = (i32, i32)> {
    let state = (start, 0);
    instructions.scan(state, |(pos, null_hits), steps| {
        let shift = *pos + steps;
        *pos = shift.rem_euclid(100);
        *null_hits += div_floor(shift, 100).abs();
        Some((*pos, *null_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);
    //dbg!(path.last().unwrap());
    let zeros = path.filter(|(pos, _)| *pos == 0);
    dbg!(zeros.count());
}

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)> {
    let state = (start, 0);
    instructions.scan(state, |(pos, hits_zero), steps| {
        let next_pos = *pos + steps;
        *hits_zero += next_pos.div_euclid(100).abs();
        if next_pos == 0 {
            *hits_zero += 1;
        }
        if next_pos < 0 && *pos == 0 {
            *hits_zero -= 1;
        }
        *pos = next_pos.rem_euclid(100);
        Some((*pos, *hits_zero))
    })
}

fn main() {
    let input = read_to_string("input.txt").unwrap();
    let instructions = input.lines().map(instruction_to_int);
    let path = find_path(50, instructions);
    //dbg!(Vec::from_iter(path));
    dbg!(path.last().unwrap());
}

Code: Alles auswählen

    assert links(start=5,anzahl_schritte=5) == (0,1) # neuer Start: 0, gezählte Nuller: 1 
    assert links(start=5,anzahl_schritte=6) == (99,1)
    assert links(start=5,anzahl_schritte=105) == (0,2)
    assert links(start=5,anzahl_schritte=100) == (5,1)