Day 2

Cargo.lock

@@ -3,3 +3,7 @@
 [[package]]
 name = "day_1"
 version = "0.1.0"
+
+[[package]]
+name = "day_2"
+version = "0.1.0"

Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
 members = [
     "day_1",
+    "day_2",
 ]

day_2/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "day_2"
+version = "0.1.0"
+authors = ["Smaug123 <patrick+github@patrickstevens.co.uk>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

day_2/input.txt

@@ -0,0 +1,16 @@
+409	194	207	470	178	454	235	333	511	103	474	293	525	372	408	428
+4321	2786	6683	3921	265	262	6206	2207	5712	214	6750	2742	777	5297	3764	167
+3536	2675	1298	1069	175	145	706	2614	4067	4377	146	134	1930	3850	213	4151
+2169	1050	3705	2424	614	3253	222	3287	3340	2637	61	216	2894	247	3905	214
+99	797	80	683	789	92	736	318	103	153	749	631	626	367	110	805
+2922	1764	178	3420	3246	3456	73	2668	3518	1524	273	2237	228	1826	182	2312
+2304	2058	286	2258	1607	2492	2479	164	171	663	62	144	1195	116	2172	1839
+114	170	82	50	158	111	165	164	106	70	178	87	182	101	86	168
+121	110	51	122	92	146	13	53	34	112	44	160	56	93	82	98
+4682	642	397	5208	136	4766	180	1673	1263	4757	4680	141	4430	1098	188	1451
+158	712	1382	170	550	913	191	163	459	1197	1488	1337	900	1182	1018	337
+4232	236	3835	3847	3881	4180	4204	4030	220	1268	251	4739	246	3798	1885	3244
+169	1928	3305	167	194	3080	2164	192	3073	1848	426	2270	3572	3456	217	3269
+140	1005	2063	3048	3742	3361	117	93	2695	1529	120	3480	3061	150	3383	190
+489	732	57	75	61	797	266	593	324	475	733	737	113	68	267	141
+3858	202	1141	3458	2507	239	199	4400	3713	3980	4170	227	3968	1688	4352	4168

day_2/src/main.rs

@@ -0,0 +1,138 @@
+use std::collections::HashSet;
+
+fn input() -> Vec<Vec<u32>> {
+    let input = include_str!("../input.txt");
+    input
+        .lines()
+        .map(|l| {
+            l.trim()
+                .split_whitespace()
+                .map(|i| i.parse().expect(&format!("{} wasn't a valid u32", i)))
+                .collect::<Vec<u32>>()
+        })
+        .collect::<Vec<Vec<u32>>>()
+}
+
+fn min_max<T, I>(i: &mut I) -> Option<(T, T)>
+where
+    I: Iterator<Item = T>,
+    T: Copy + Ord,
+{
+    if let Some(fst) = i.next() {
+        let mut top = fst;
+        let mut bot = fst;
+        while let Some(next) = i.next() {
+            if next > top {
+                top = next;
+            }
+            if next < bot {
+                bot = next;
+            }
+        }
+        Some((bot, top))
+    } else {
+        None
+    }
+}
+
+fn even_divisor<I>(iter: &mut I) -> Option<(u32, u32)>
+where
+    I: Iterator<Item = u32>,
+{
+    let mut seen = HashSet::new();
+    for i in iter {
+        for s in &seen {
+            let s = *s;
+            if s > i {
+                if s % i == 0 {
+                    return Some((s, i));
+                }
+            } else if i > s {
+                if i % s == 0 {
+                    return Some((i, s));
+                }
+            }
+        }
+        seen.insert(i);
+    }
+    None
+}
+
+pub fn part_1<I, J>(numbers: &mut I) -> u32
+where
+    I: Iterator<Item = J>,
+    J: Iterator<Item = u32>,
+{
+    numbers
+        .map(|mut row| {
+            if let Some((min, max)) = min_max(&mut row) {
+                max - min
+            } else {
+                0
+            }
+        })
+        .sum()
+}
+
+pub fn part_2<I, J>(numbers: &mut I) -> u32
+where
+    I: Iterator<Item = J>,
+    J: Iterator<Item = u32>,
+{
+    numbers
+        .map(|mut row| {
+            let (bigger, smaller) = even_divisor(&mut row).unwrap();
+            bigger / smaller
+        })
+        .sum()
+}
+
+fn main() {
+    let input = input();
+    println!(
+        "part 1 => {}",
+        part_1(&mut input.iter().map(|r| r.iter().cloned()))
+    );
+    println!(
+        "part 2 => {}",
+        part_2(&mut input.iter().map(|r| r.iter().cloned()))
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn part1_known() {
+        assert_eq!(
+            part_1(
+                &mut vec![vec![5, 1, 9, 5], vec![7, 5, 3], vec![2, 4, 6, 8]]
+                    .iter()
+                    .map(|r| r.iter().cloned())
+            ),
+            18
+        );
+    }
+
+    #[test]
+    fn part2_known() {
+        assert_eq!(
+            part_2(
+                &mut vec![vec![5, 9, 2, 8], vec![9, 4, 7, 3], vec![3, 8, 6, 5]]
+                    .iter()
+                    .map(|r| r.iter().cloned())
+            ),
+            9
+        );
+    }
+
+    #[test]
+    fn test_day_1() {
+        let input = input();
+        let answer = part_1(&mut input.iter().map(|r| r.iter().cloned()));
+        assert_eq!(answer, 44887);
+        let answer = part_2(&mut input.iter().map(|r| r.iter().cloned()));
+        assert_eq!(answer, 242);
+    }
+}