1 files changed, 61 insertions, 7 deletions

diff --git a/day2/src/main.rs b/day2/src/main.rs
index 5bb661f..2acc32d 100644
--- a/day2/src/main.rs
+++ b/day2/src/main.rs
@@ -57,13 +57,40 @@ impl IntoIterator for IDRange {
 struct ID(u64);
 
 impl ID {
-    fn is_invalid(&self) -> bool {
+    fn is_invalid_simple(&self) -> bool {
         let s = self.0.to_string();
         s.len() % 2 == 0 && {
             let (a, b) = s.split_at(s.len() / 2);
             a == b
         }
     }
+
+    fn is_invalid(&self) -> bool {
+        let s = self.0.to_string();
+
+        if s.len() <= 1 {
+            return false;
+        }
+
+        let chars: Vec<char> = s.chars().collect();
+
+        let mut i = 1;
+        let mut j = 0;
+
+        loop {
+            if i == chars.len() - 1 {
+                return chars[i] == chars[j] && chars.len() % (i - j) == 0;
+            }
+
+            if chars[i] == chars[j] {
+                j += 1;
+            } else {
+                j = 0;
+            }
+
+            i += 1;
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -91,11 +118,22 @@ fn main() -> Result<(), Error> {
         .map(|s| s.parse().map_err(|_| Error::BadRange(s.into())))
         .collect::<Result<_, _>>()?;
 
+    let result_simple: u64 = ranges
+        .iter()
+        .flat_map(|range| {
+            range
+                .into_iter()
+                .filter(ID::is_invalid_simple)
+                .map(|id| id.0)
+        })
+        .sum();
+
     let result: u64 = ranges
         .iter()
         .flat_map(|range| range.into_iter().filter(ID::is_invalid).map(|id| id.0))
         .sum();
 
+    println!("Result (simple): {}", result_simple);
     println!("Result: {}", result);
 
     Ok(())
@@ -121,15 +159,31 @@ mod tests {
     }
 
     #[test]
-    fn id_is_valid() {
-        assert!(!ID(0).is_invalid());
+    fn id_is_invalid_simple() {
+        assert!(!ID(0).is_invalid_simple());
+        assert!(!ID(1).is_invalid_simple());
+        assert!(!ID(2).is_invalid_simple());
+        assert!(!ID(10).is_invalid_simple());
+        assert!(!ID(12).is_invalid_simple());
+        assert!(!ID(21).is_invalid_simple());
+
+        assert!(ID(11).is_invalid_simple());
+        assert!(ID(5555).is_invalid_simple());
+    }
+
+    #[test]
+    fn id_is_invalid() {
         assert!(!ID(1).is_invalid());
-        assert!(!ID(2).is_invalid());
-        assert!(!ID(10).is_invalid());
         assert!(!ID(12).is_invalid());
-        assert!(!ID(21).is_invalid());
+        assert!(!ID(121).is_invalid());
+        assert!(!ID(1214).is_invalid());
+        assert!(!ID(123121).is_invalid());
 
         assert!(ID(11).is_invalid());
-        assert!(ID(5555).is_invalid());
+        assert!(ID(1212).is_invalid());
+        assert!(ID(111).is_invalid());
+        assert!(ID(123123).is_invalid());
+        assert!(ID(121212).is_invalid());
+        assert!(ID(1010).is_invalid());
     }
 }