reorg+optim

Author: rene-d

2015/day1/day1.rs

@@ -1,26 +1,57 @@
 //! [Day 1: Not Quite Lisp](https://adventofcode.com/2015/day/1)
 
-/// main function
-fn main() {
-    let args = aoc::parse_args();
-    let data = &args.input;
-
-    for line in data.lines() {
-        let mut floor = 0;
-        let mut position = 0;
-        let mut enter = 0;
-        for c in line.chars() {
-            position += 1;
-            match c {
-                '(' => floor += 1,
-                ')' => floor -= 1,
-                _ => panic!("invalid character"),
-            }
-            if floor == -1 && enter == 0 {
-                enter = position;
-            }
+/// Solve the puzzle.
+fn solve(data: &str) -> (i32, i32) {
+    let mut floor = 0;
+    let mut position = 0;
+    let mut enter = 0;
+
+    for c in data.chars() {
+        position += 1;
+        match c {
+            '(' => floor += 1,
+            ')' => floor -= 1,
+            _ => {}
+        }
+        if floor == -1 && enter == 0 {
+            enter = position;
         }
-        println!("{floor}");
-        println!("{enter}");
+    }
+
+    (floor, enter)
+}
+
+/// Main function.
+fn main() {
+    let mut args = aoc::parse_args();
+
+    args.run(solve);
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test01() {
+        assert_eq!(solve("(())").0, 0);
+        assert_eq!(solve("()()").0, 0);
+
+        assert_eq!(solve("(((").0, 3);
+        assert_eq!(solve("(()(()(").0, 3);
+
+        assert_eq!(solve("))(((((").0, 3);
+
+        assert_eq!(solve("())").0, -1);
+        assert_eq!(solve("))(").0, -1);
+
+        assert_eq!(solve(")))").0, -3);
+        assert_eq!(solve(")())())").0, -3);
+    }
+
+    #[test]
+    fn test02() {
+        assert_eq!(solve(")").1, 1);
+        assert_eq!(solve("()())").1, 5);
     }
 }

2015/day10/day10.rs

@@ -2,39 +2,55 @@
 
 /// main function
 fn main() {
-    let args = aoc::parse_args();
-    let data = args
-        .input
-        .lines()
-        .map(std::string::ToString::to_string)
-        .collect::<Vec<String>>();
-
-    solve(&data[0], 40);
-    solve(&data[0], 50);
+    let mut args = aoc::parse_args();
+
+    args.run(|data| {
+        let data = data.trim_ascii();
+
+        (solve(data, 40), solve(data, 50))
+    });
 }
 
-fn solve(start_sequence: &str, turns: u32) {
-    let mut look = start_sequence.chars().collect::<Vec<char>>();
+fn solve(start_sequence: &str, turns: u32) -> usize {
+    let mut look = start_sequence.bytes().collect::<Vec<_>>();
 
     for _ in 0..turns {
-        let mut say: Vec<char> = Vec::new();
+        let mut say: Vec<_> = Vec::new();
 
         let mut count = 0;
-        let mut previous = '\0';
+        let mut previous = 0;
         for current in &look {
-            if previous != '\0' && previous != *current {
-                say.extend(count.to_string().chars());
+            if previous != 0 && previous != *current {
+                extend(&mut say, count);
                 say.push(previous);
                 count = 0;
             }
             count += 1;
             previous = *current;
         }
 
-        say.extend(count.to_string().chars());
+        extend(&mut say, count);
         say.push(previous);
 
         look.clone_from(&say);
     }
-    println!("{}", look.len());
+
+    look.len()
+}
+
+fn extend(say: &mut Vec<u8>, num: u32) {
+    let mut tmp: u32 = num;
+    let mut base = 1;
+    loop {
+        tmp /= 10;
+        if tmp == 0 {
+            break;
+        }
+        base *= 10;
+    }
+
+    while base != 0 {
+        say.push(b'0' + ((num / base) % 10) as u8);
+        base /= 10;
+    }
 }

2015/day2/day2.rs

@@ -1,18 +1,10 @@
 //! [Day 2: I Was Told There Would Be No Math](https://adventofcode.com/2015/day/2)
 
-/// main function
-fn main() {
-    let args = aoc::parse_args();
-    let data = args
-        .input
-        .lines()
-        .map(std::string::ToString::to_string)
-        .collect::<Vec<String>>();
-
+fn solve(data: &str) -> (u32, u32) {
     let mut total_paper = 0;
     let mut total_ribbon = 0;
 
-    for line in data {
+    for line in data.lines() {
         let mut dimensions = line
             .split('x')
             .map(|s| s.parse::<u32>().unwrap())
@@ -47,6 +39,28 @@ fn main() {
         total_ribbon += ribbon + bow;
     }
 
-    println!("{total_paper}");
-    println!("{total_ribbon}");
+    (total_paper, total_ribbon)
+}
+
+/// main function
+fn main() {
+    let mut args = aoc::parse_args();
+    args.run(solve);
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test01() {
+        assert_eq!(solve("2x3x4").0, 58);
+        assert_eq!((solve("1x1x10").0), 43);
+    }
+
+    #[test]
+    fn test02() {
+        assert_eq!(solve("2x3x4").1, 34);
+        assert_eq!((solve("1x1x10").1), 14);
+    }
 }

2015/day2/demo.txt

@@ -5,12 +5,10 @@ struct Puzzle {
 }
 
 impl Puzzle {
-    const fn new() -> Self {
-        Self { house_present: 0 }
-    }
-
-    fn configure(&mut self, data: &str) {
-        self.house_present = data.trim_ascii().parse::<usize>().unwrap();
+    fn new(data: &str) -> Self {
+        Self {
+            house_present: data.trim_ascii().parse::<usize>().unwrap(),
+        }
     }
 
     fn part1(&self) -> usize {
@@ -70,96 +68,81 @@ impl Puzzle {
 }
 
 fn main() {
-    let args = aoc::parse_args();
-
-    let mut puzzle = Puzzle::new();
-
-    puzzle.configure(&args.input);
-
-    let result = puzzle.part1();
-    println!("{result}");
-
-    let result = puzzle.part2();
-    println!("{result}");
+    let mut args = aoc::parse_args();
+    args.run(|data| {
+        let puzzle = Puzzle::new(data);
+        (puzzle.part1(), puzzle.part2())
+    });
 }
 
 /// Test from puzzle input
 #[test]
 fn test01() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 10;
+    let puzzle = Puzzle::new("10");
     assert_eq!(puzzle.part1(), 1);
     assert_eq!(puzzle.part2(), 1);
 }
 
 /// Test from puzzle input
 #[test]
 fn test02() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 30;
+    let puzzle = Puzzle::new("30");
     assert_eq!(puzzle.part1(), 2);
     assert_eq!(puzzle.part2(), 2);
 }
 
 /// Test from puzzle input
 #[test]
 fn test03() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 40;
+    let puzzle = Puzzle::new("40");
     assert_eq!(puzzle.part1(), 3);
     assert_eq!(puzzle.part2(), 3);
 }
 
 /// Test from puzzle input
 #[test]
 fn test04() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 60;
+    let puzzle = Puzzle::new("60");
     assert_eq!(puzzle.part1(), 4);
     assert_eq!(puzzle.part2(), 4);
 }
 
 /// Test from puzzle input
 #[test]
 fn test05() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 70;
+    let puzzle = Puzzle::new("70");
     assert_eq!(puzzle.part1(), 4);
     assert_eq!(puzzle.part2(), 4);
 }
 
 /// Test from puzzle input
 #[test]
 fn test06() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 80;
+    let puzzle = Puzzle::new("80");
     assert_eq!(puzzle.part1(), 6);
     assert_eq!(puzzle.part2(), 6);
 }
 
 /// Test from puzzle input
 #[test]
 fn test07() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 120;
+    let puzzle = Puzzle::new("120");
     assert_eq!(puzzle.part1(), 6);
     assert_eq!(puzzle.part2(), 6);
 }
 
 /// Test from puzzle input
 #[test]
 fn test08() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 130;
+    let puzzle = Puzzle::new("130");
     assert_eq!(puzzle.part1(), 8);
     assert_eq!(puzzle.part2(), 6);
 }
 
 /// Test from puzzle input
 #[test]
 fn test09() {
-    let mut puzzle = Puzzle::new();
-    puzzle.house_present = 150;
+    let puzzle = Puzzle::new("150");
     assert_eq!(puzzle.part1(), 8);
     assert_eq!(puzzle.part2(), 8);
 }

2015/day20/day20.rs

@@ -4,15 +4,13 @@ use rustc_hash::FxHashSet;
 
 /// main function
 fn main() {
-    let args = aoc::parse_args();
-    let data = args
-        .input
-        .lines()
-        .map(std::string::ToString::to_string)
-        .collect::<Vec<String>>();
-
-    println!("{}", part1(&data[0]));
-    println!("{}", part2(&data[0]));
+    let mut args = aoc::parse_args();
+
+    args.run(|data| {
+        let line = data.trim_ascii();
+
+        (part1(line), part2(line))
+    });
 }
 
 fn part2(line: &str) -> usize {