solve 2016 day 03

src/util/iter.rs

@@ -6,6 +6,7 @@ where
     k: usize,
     size: usize,
     pool: Vec<I::Item>,
+    first: bool,
 }
 
 impl<I, T> Combinations<I, T>
@@ -15,11 +16,20 @@ where
     pub fn new(iter: I, k: usize) -> Self {
         let pool: Vec<I::Item> = iter.collect();
 
+        if k > pool.len() {
+            panic!(
+                "No combinations possible for len {} and k {}",
+                pool.len(),
+                k
+            );
+        }
+
         Self {
             indices: (0..k).collect(),
             k,
             size: pool.len(),
             pool,
+            first: true,
         }
     }
 }
@@ -32,30 +42,26 @@ where
     type Item = Vec<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let mut out = Vec::with_capacity(self.size);
-        let mut indices = Vec::with_capacity(self.k);
-        let mut incremented = false;
+        if self.first {
+            self.first = false;
+        } else {
+            let mut i = self.k - 1;
 
-        for i in &self.indices {
-            out.push(self.pool[*i]);
-        }
-
-        self.indices.reverse();
-        let mut iter = self.indices.iter().enumerate();
-        while let Some((count, idx)) = iter.next() {
-            if incremented || *idx == self.size - (count + 1) {
-                indices.push(*idx);
-                continue;
+            while self.indices[i] == i + self.size - self.k {
+                if i > 0 {
+                    i -= 1;
+                } else {
+                    return None;
+                }
+            }
+
+            self.indices[i] += 1;
+            for j in i + 1..self.k {
+                self.indices[j] = self.indices[j - 1] + 1;
             }
-            indices.push(idx + 1);
-            incremented = true;
         }
-        if !incremented {
-            return None;
-        }
-        indices.reverse();
-        self.indices = indices;
-        Some(out)
+
+        Some(self.indices.iter().map(|i| self.pool[*i]).collect())
     }
 }
 
@@ -66,8 +72,3 @@ pub trait CombinationsIterator<T>: Iterator<Item = T> + Sized {
 }
 
 impl<I, T> CombinationsIterator<T> for I where I: Iterator<Item = T> {}
-
-#[test]
-fn test_iter() {
-    println!("{:?}", [1, 2, 3].iter().combinations(2).collect::<Vec<_>>());
-}

src/year2016/day03.rs

@@ -1,13 +1,47 @@
 use crate::util::parse::ParseExt;
 
-pub fn part1(input: &str) -> impl std::fmt::Display {
-    //let vec: Vec<Vec<u32>> = input.lines().map(|s| s.u32s().collect());
+fn valid_triangle(v: &[u32; 3]) -> bool {
+    v[0] + v[1] > v[2] && v[1] + v[2] > v[0] && v[0] + v[2] > v[1]
+}
 
-    ""
+pub fn part1(input: &str) -> impl std::fmt::Display {
+    input
+        .lines()
+        .map(|s| {
+            s.u32s()
+                .fold(([0u32; 3], 0), |(mut a, i), v| {
+                    a[i] = v;
+                    (a, i + 1)
+                })
+                .0
+        })
+        .filter(valid_triangle)
+        .count()
 }
 
 pub fn part2(input: &str) -> impl std::fmt::Display {
-    ""
+    fn get3<'a>(lines: &'a mut std::str::Lines<'_>) -> Option<(&'a str, &'a str, &'a str)> {
+        Some((lines.next()?, lines.next()?, lines.next()?))
+    }
+
+    let mut lines = input.lines();
+    let mut valid = 0;
+
+    while let Some((l1, l2, l3)) = get3(&mut lines) {
+        let l1: Vec<u32> = l1.u32s().collect();
+        let l2: Vec<u32> = l2.u32s().collect();
+        let l3: Vec<u32> = l3.u32s().collect();
+        if valid_triangle(&[l1[0], l2[0], l3[0]]) {
+            valid += 1;
+        }
+        if valid_triangle(&[l1[1], l2[1], l3[1]]) {
+            valid += 1;
+        }
+        if valid_triangle(&[l1[2], l2[2], l3[2]]) {
+            valid += 1;
+        }
+    }
+    valid
 }
 
 #[test]