Move code into a single cargo module with an execution harness.

2022/src/day01.rs

@@ -0,0 +1,52 @@
+use std::env;
+use std::io;
+use std::io::prelude::*;
+use std::fs::File;
+use sorted_vec::SortedVec;
+
+fn read_lines(filename: &str) -> io::Result<io::Lines<io::BufReader<File>>> {
+    let file = File::open(filename)?;
+    Ok(io::BufReader::new(file).lines())
+}
+
+fn get_step() -> i32 {
+    for arg in env::args() {
+        if arg == "2" { return 2 }
+    }
+    return 1
+}
+
+fn update_max(max: &mut SortedVec<i32>, current: i32, step: i32) {
+    if max.is_empty() {
+        max.insert(current);
+        return
+    }
+    if current <= max[0] { return }
+
+    max.insert(current);
+    match step {
+        2 => { if max.len() > 3 { max.remove_index(0); } },
+        _ => { max.remove_index(0); },
+    }
+}
+
+pub fn execute() -> Result<(), io::Error> {
+    let step = get_step();
+
+    let mut max: SortedVec<i32> = SortedVec::new();
+    let mut current = 0;
+
+    for line in read_lines("input/day01.txt")? {
+        let text = line?;
+        current = match text.parse::<i32>() {
+            Ok(value) => current + value,
+            Err(_) => {
+                update_max(&mut max, current, step);
+                0
+            },
+        }
+    }
+
+    println!("{}", max.iter().fold(0i32, |sum, i| sum + (*i as i32)));
+    Ok(())
+}

2022/src/day02.rs

@@ -0,0 +1,58 @@
+use std::io;
+use std::io::prelude::*;
+use std::fs::File;
+
+fn read_lines(filename: &str) -> io::Result<io::Lines<io::BufReader<File>>> {
+    let file = File::open(filename)?;
+    Ok(io::BufReader::new(file).lines())
+}
+
+fn print_step(step: i8, value: u64) {
+    println!("Step {} solution: {}", step, value);
+}
+
+pub fn execute() -> Result<(), io::Error> {
+    let mut score1: u64 = 0;
+    let mut score2: u64 = 0;
+
+    for line in read_lines("input/day02.txt")? {
+        let text = line?;
+        let opp = parse_move(text.chars().nth(0).unwrap());
+
+        score1 += step1(opp, text.chars().nth(2).unwrap());
+        score2 += step2(opp, text.chars().nth(2).unwrap());
+    }
+
+    print_step(1, score1);
+    print_step(2, score2);
+    Ok(())
+}
+
+fn step1(opp: i8, text: char) -> u64 {
+    let me = parse_move(text);
+    return match me - opp {
+        1 | -2 => me + 6,
+        0 => me + 3,
+        -1 | 2 => me,
+        _ => panic!("Received impossible result in a match."),
+    } as u64;
+}
+
+fn step2(opp: i8, text: char) -> u64 {
+    return match text {
+        'X' => ((opp + 4) % 3) + 1,
+        'Y' => opp + 3,
+        'Z' => (opp  % 3) + 7,
+        _ => panic!("Received impossible strategy code."),
+    } as u64;
+}
+
+// Parses the second command in the input incorrectly.
+fn parse_move(x: char) -> i8 {
+    return match x {
+        'A' | 'X' => 1,
+        'B' | 'Y' => 2,
+        'C' | 'Z' => 3,
+        _ => 0,
+    };
+}

2022/src/main.rs

@@ -0,0 +1,73 @@
+use std::env;
+use std::io;
+
+const LATEST: u8 = 2;
+
+mod day01;
+mod day02;
+// mod day03;
+// mod day04;
+// mod day05;
+// mod day06;
+// mod day07;
+// mod day08;
+// mod day09;
+// mod day10;
+// mod day11;
+// mod day12;
+// mod day13;
+// mod day14;
+// mod day15;
+// mod day16;
+// mod day17;
+// mod day18;
+// mod day19;
+// mod day20;
+// mod day21;
+// mod day22;
+// mod day23;
+// mod day24;
+// mod day25;
+
+fn main() -> io::Result<()> {
+    let day = determine_day(LATEST);
+    match day {
+        1 => day01::execute(),
+        2 => day02::execute(),
+        // 3 => day03::execute(),
+        // 4 => day04::execute(),
+        // 5 => day05::execute(),
+        // 6 => day06::execute(),
+        // 7 => day07::execute(),
+        // 8 => day08::execute(),
+        // 9 => day09::execute(),
+        // 10 => day10::execute(),
+        // 11 => day11::execute(),
+        // 12 => day12::execute(),
+        // 13 => day13::execute(),
+        // 14 => day14::execute(),
+        // 15 => day15::execute(),
+        // 16 => day16::execute(),
+        // 17 => day17::execute(),
+        // 18 => day18::execute(),
+        // 19 => day19::execute(),
+        // 20 => day20::execute(),
+        // 21 => day21::execute(),
+        // 22 => day22::execute(),
+        // 23 => day23::execute(),
+        // 24 => day24::execute(),
+        // 25 => day25::execute(),
+        _ => panic!("Couldn't execute day {day}")
+    }
+}
+
+fn determine_day(latest: u8) -> u8 {
+    let mut day = latest;
+    for arg in env::args() {
+        if let Ok(x) = arg.parse::<u8>() {
+            day = x;
+            break;
+        }
+    }
+    return day;
+}