day2: add mostly arithmetic solution for part1

src/day2.rs

@@ -1,5 +1,6 @@
 use aoc_runner_derive::{aoc, aoc_generator};
 use itertools::Itertools;
+use std::cmp::{max, min};
 use std::ops::RangeInclusive;
 
 #[aoc_generator(day2)]
@@ -56,6 +57,82 @@ fn part2(input: &[RangeInclusive<u64>]) -> u64 {
     invalid_sum
 }
 
+#[aoc(day2, part1, ArithmeticBrute)]
+fn part1_arithmetic_brute(input: &[RangeInclusive<u64>]) -> u64 {
+    let mut invalid_sum = 0;
+    for r in input {
+        // println!("Range: {:?}", r);
+        for product in r.clone() {
+            let n_digits = product.ilog10() + 1;
+            if n_digits % 2 != 0 {
+                continue;
+            }
+
+            let decade = 10u64.pow(n_digits / 2);
+            let lhs = product / decade;
+            let rhs = product % decade;
+            // println!("{product} {n_digits}: D:{decade} L:{lhs} R:{rhs}");
+            if lhs == rhs {
+                invalid_sum += product
+            }
+        }
+    }
+    invalid_sum
+}
+
+#[aoc(day2, part2, ArithmeticBrute)]
+fn part2_arithmetic_brute(input: &[RangeInclusive<u64>]) -> u64 {
+    let mut invalid_sum = 0;
+    for r in input {
+        for product in r.clone() {
+            let n_digits = product.ilog10() + 1;
+
+            for n in 1..=n_digits / 2 {
+                if n_digits % n != 0 {
+                    continue;
+                }
+                let decade = 10u64.pow(n);
+                let lhs = product / decade;
+                let rhs = product % decade;
+                if lhs == rhs {
+                    invalid_sum += product
+                }
+            }
+        }
+    }
+    invalid_sum
+}
+
+#[aoc(day2, part1, Clever)]
+fn part1_clever(input: &[RangeInclusive<u64>]) -> u64 {
+    let mut invalid_sum = 0;
+    for r in input {
+        let n_digits = r.start().ilog10() + 1;
+
+        let mut lhs = if n_digits % 2 != 0 {
+            // If the number of digits is odd, we start our guess at the first possibility in the next decade
+            10u64.pow(n_digits / 2)
+        } else {
+            let start_decade = 10u64.pow(n_digits / 2);
+            r.start() / start_decade
+        };
+
+        // we will guess the next repeater, and check if it's in range, if not we are done.
+        loop {
+            let repeater = lhs * 10u64.pow(lhs.ilog10() + 1) + lhs;
+            if repeater < *r.start() {
+                lhs += 1
+            } else if r.contains(&repeater) {
+                invalid_sum += repeater;
+                lhs += 1
+            } else {
+                break;
+            }
+        }
+    }
+    invalid_sum
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -71,4 +148,17 @@ mod tests {
     fn part2_example() {
         assert_eq!(part2(&parse(EXAMPLE)), 4174379265);
     }
+
+    #[test]
+    fn part1_arithmetic_example() {
+        assert_eq!(part1_arithmetic_brute(&parse(EXAMPLE)), 1227775554);
+    }
+    #[test]
+    fn part2_arithmetic_example() {
+        assert_eq!(part2_arithmetic_brute(&parse(EXAMPLE)), 1227775554);
+    }
+    #[test]
+    fn part1_clever_example() {
+        assert_eq!(part1_clever(&parse(EXAMPLE)), 1227775554);
+    }
 }