advent-2025 / src / 01.rs

use std::io::{Read, Write};
use std::{fmt::Display, io};

use anyhow::{Error, Result};
use log::debug;

enum Direction {
    RIGHT,
    LEFT,
}

impl Display for Direction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            Direction::LEFT => "Left",
            Direction::RIGHT => "Right",
        })?;
        Ok(())
    }
}

struct Instruction {
    direction: Direction,
    distance: i32,
}

impl Display for Instruction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("{} {}", self.direction, self.distance))?;
        Ok(())
    }
}

fn parse_line(line: &str) -> Result<Instruction> {
    let mut chars = line.chars();
    let direction = match chars.next() {
        Some('R') => Direction::RIGHT,
        Some('L') => Direction::LEFT,
        default => return Err(Error::msg(format!("Invalid direction: {:?}", default))),
    };

    let distance: i32 = line[1..].parse()?;

    Ok(Instruction {
        direction,
        distance,
    })
}

fn day_01_part1(input: &str) -> String {
    let mut dial: i32 = 50;
    let mut count: u32 = 0;
    for line in input.lines() {
        if line.len() == 0 {
            continue;
        };
        let instruction = match parse_line(line) {
            Ok(i) => i,
            Err(e) => panic!("{:?}", e),
        };
        match instruction.direction {
            Direction::LEFT => dial -= instruction.distance,
            Direction::RIGHT => dial += instruction.distance,
        }

        dial = dial.rem_euclid(100).abs();

        debug!("Moved {} to get to {}", instruction, dial);

        if dial == 0 {
            count += 1;
        }
    }

    format!("{}\n", count)
}

fn day_01_part2(input: &str) -> String {
    let mut dial: i32 = 50;
    let mut count: i32 = 0;
    for line in input.lines() {
        if line.len() == 0 {
            continue;
        };
        let instruction = match parse_line(line) {
            Ok(i) => i,
            Err(e) => panic!("{:?}", e),
        };
        let mut clicks = instruction.distance / 100;
        let offset = instruction.distance % 100;
        let original_dial = dial;

        match instruction.direction {
            Direction::LEFT => dial -= offset,
            Direction::RIGHT => dial += offset,
        }

        // We already took care of multiples of 100, so this should be valid:
        if dial > 99 || dial == 0 || (dial < 0 && original_dial != 0) {
            clicks += 1;
        }
        dial = dial.rem_euclid(100).abs();

        debug!(
            "Moved {} to get to {}, clicking {} times",
            instruction, dial, clicks
        );

        count += clicks;
    }

    format!("{}\n", count)
}

fn main() {
    env_logger::init();
    let mut input = String::new();
    let mut stdin = io::stdin();
    let mut stdout = io::stdout();
    stdin.read_to_string(&mut input).unwrap();
    println!("Part 1:");
    let output_1 = day_01_part1(&input);
    stdout.write(output_1.as_bytes()).unwrap();
    println!("Part 2:");
    let output_2 = day_01_part2(&input);
    stdout.write(output_2.as_bytes()).unwrap();
}

#[cfg(test)]
mod tests {
    use super::*;

    use std::sync::Once;
    static INIT: Once = Once::new();
    fn setup() {
        INIT.call_once(|| {
            env_logger::init();
        });
    }

    #[test]
    fn sample_part1() {
        setup();
        let input = r#"
L68
L30
R48
L5
R60
L55
L1
L99
R14
L82
"#;
        let expected = "3\n";

        let result = day_01_part1(&input);
        assert_eq!(result.as_str(), expected);
    }

    #[test]
    fn sample_part2() {
        setup();
        let input = r#"
L68
L30
R48
L5
R60
L55
L1
L99
R14
L82
"#;
        let expected = "6\n";

        let result = day_01_part2(&input);
        assert_eq!(result.as_str(), expected);
    }
    #[test]
    fn sample_part2_rot() {
        setup();
        let input = "R1000\nR50\nL1\nR2\n";
        let expected = "12\n";

        let result = day_01_part2(&input);
        assert_eq!(result.as_str(), expected);
    }
}