feat: day 2

2025/src/days/mod.rs

···
 pub mod one;
+pub mod two;

2025/src/days/one/mod.rs

···
-pub mod secret_entrance;
+use atoi_simd::parse as parse_i32;
+
+pub fn main() -> anyhow::Result<()> {
+    crate::run("Secret Entrance", "inputs/day1.txt", parse, part_a, part_b)
+}
+
+fn parse(input: &[u8]) -> Vec<i32> {
+    let mut out = Vec::with_capacity(input.iter().filter(|&b| *b == b'\n').count());
+    let mut start = 0;
+
+    while start < input.len() {
+        let end = match memchr::memchr(b'\n', &input[start..]) {
+            Some(index) => start + index,
+            None => input.len(),
+        };
+        let line = &input[start..end];
+
+        if !line.is_empty() {
+            let mut buf = [0u8; 4];
+            let mut len = 0usize;
+            let mut seen_digit = false;
+
+            for &b in line {
+                match b {
+                    b'L' => {
+                        if len == 0 {
+                            buf[len] = b'-';
+                            len += 1;
+                        }
+                    }
+                    b'0'..=b'9' => {
+                        seen_digit = true;
+                        buf[len] = b;
+                        len += 1;
+                    }
+                    _ => {
+                        len = 0;
+                        break;
+                    }
+                }
+            }
+            if seen_digit && len > 0 {
+                if let Ok(num) = parse_i32(&buf[..len]) {
+                    out.push(num);
+                }
+            }
+        }
+
+        start = end + 1;
+    }
+
+    out
+}
+
+fn part_a(input: Vec<i32>) -> usize {
+    input
+        .iter()
+        .scan(50, |state, &rotation| {
+            *state += rotation;
+            Some(*state)
+        })
+        .filter(|&state| state % 100 == 0)
+        .count()
+}
+
+fn part_b(input: Vec<i32>) -> usize {
+    input
+        .iter()
+        .scan(50, |state, &rotation| {
+            let mut passes = (rotation / 100).abs() as usize;
+            let turn = rotation % 100;
+            if *state + turn <= 0 && *state != 0 || 99 < *state + turn {
+                passes += 1;
+            }
+            *state = (*state + turn).rem_euclid(100);
+            Some(passes)
+        })
+        .sum()
+}

2025/src/days/one/secret_entrance.rs

···
-use atoi_simd::parse as parse_i32;
-
-pub fn main() -> anyhow::Result<()> {
-    crate::run("Secret Entrance", "inputs/day1.txt", parse, part_a, part_b)
-}
-
-fn parse(input: &[u8]) -> Vec<i32> {
-    let mut out = Vec::with_capacity(4503);
-    let mut start = 0;
-
-    while start < input.len() {
-        let end = match memchr::memchr(b'\n', &input[start..]) {
-            Some(index) => start + index,
-            None => input.len(),
-        };
-        let line = &input[start..end];
-
-        if !line.is_empty() {
-            let mut buf = [0u8; 4];
-            let mut len = 0usize;
-            let mut seen_digit = false;
-
-            for &b in line {
-                match b {
-                    b'L' => {
-                        if len == 0 {
-                            buf[len] = b'-';
-                            len += 1;
-                        }
-                    }
-                    b'0'..=b'9' => {
-                        seen_digit = true;
-                        buf[len] = b;
-                        len += 1;
-                    }
-                    _ => {
-                        len = 0;
-                        break;
-                    }
-                }
-            }
-            if seen_digit && len > 0 {
-                if let Ok(num) = parse_i32(&buf[..len]) {
-                    out.push(num);
-                }
-            }
-        }
-
-        start = end + 1;
-    }
-
-    out
-}
-
-fn part_a(input: Vec<i32>) -> usize {
-    input
-        .iter()
-        .scan(50, |state, &rotation| {
-            *state += rotation;
-            Some(*state)
-        })
-        .filter(|&state| state % 100 == 0)
-        .count()
-}
-
-fn part_b(input: Vec<i32>) -> usize {
-    input
-        .iter()
-        .scan(50, |state, &rotation| {
-            let mut passes = (rotation / 100).abs() as usize;
-            let turn = rotation % 100;
-            if *state + turn <= 0 && *state != 0 || 99 < *state + turn {
-                passes += 1;
-            }
-            *state = (*state + turn).rem_euclid(100);
-            Some(passes)
-        })
-        .sum()
-}

2025/src/days/two/mod.rs

···
+use atoi_simd::parse as parse_u64;
+
+pub fn main() -> anyhow::Result<()> {
+    crate::run("Gift Shop", "inputs/day2.txt", parse, part_a, part_b)
+}
+
+fn parse(input: &[u8]) -> Vec<u64> {
+    let mut out = Vec::new();
+    let mut start = 0;
+
+    while start < input.len() {
+        let end = match memchr::memchr2(b',', b'\n', &input[start..]) {
+            Some(index) => start + index,
+            None => input.len(),
+        };
+        let range = &input[start..end];
+
+        let [min, max, ..] = range
+            .split(|&b| b == b'-')
+            .map(|s| parse_u64::<u64>(s).unwrap())
+            .collect::<Vec<_>>()[..]
+        else {
+            panic!("invalid input")
+        };
+
+        for i in min.clone()..=max.clone() {
+            out.push(i);
+        }
+        start += range.len() + 1;
+    }
+
+    out
+}
+
+fn part_a(input: Vec<u64>) -> usize {
+    println!("{}", input.len());
+    input.iter().fold(0, |acc, x| {
+        acc + if is_valid_id_a(x.clone()) {
+            0usize
+        } else {
+            *x as usize
+        }
+    })
+}
+
+fn is_valid_id_a(id: u64) -> bool {
+    // invalid ID's are identifiable due to them being made up from some sequences being repeated
+    // eg: 11 -> [1, 1] invalid
+    // eg: 123123 -> [123, 123] invalid
+    // eg: 123456 -> [123456] valid
+    let id_str = id.to_string();
+    let id_len = id_str.len();
+
+    let (left, right) = id_str.split_at(id_len / 2);
+    left != right
+}
+
+fn is_valid_id_b(id: &u64) -> bool {
+    // invalid ID's are identifiable due to them being made up from some sequences being repeated
+    // eg: 11 -> [1, 1] invalid
+    // eg: 123123 -> [123, 123] invalid
+    // eg: 121212 -> [12, 12, 12] invalid
+    // eg: 111 -> [1, 1, 1] invalid
+    // eg: 123456 -> [123456] valid
+    let id_str = id.to_string();
+    let id_len = id_str.len();
+    let mut needle = id_str.chars().next().unwrap().to_string();
+
+    while needle.len() != id_str.len() {
+        if id_len % needle.len() != 0 {
+            needle.push(id_str.chars().nth(needle.len()).unwrap());
+            continue;
+        };
+        let count = id_str.matches(&needle).count();
+        if count * needle.len() == id_len {
+            return false;
+        };
+        needle.push(id_str.chars().nth(needle.len()).unwrap());
+    }
+
+    true
+}
+
+fn part_b(input: Vec<u64>) -> usize {
+    input.iter().fold(0, |acc, x| {
+        acc + if is_valid_id_b(x) {
+            0usize
+        } else {
+            *x as usize
+        }
+    })
+}

2025/src/main.rs

···
 extern crate test;
 
 fn main() -> anyhow::Result<()> {
-    aoc2025::days::one::secret_entrance::main()?;
+    aoc2025::days::two::main()?;
     Ok(())
 }
 
···
 
     #[bench]
     fn day1(b: &mut Bencher) {
-        b.iter(|| days::one::secret_entrance::main())
+        b.iter(|| days::one::main())
+    }
+
+    #[bench]
+    fn day2(b: &mut Bencher) {
+        b.iter(|| days::two::main())
     }
 }