2020/src/day9.rs

@@ -75,6 +75,8 @@
 //!
 //! What is the encryption weakness in your XMAS-encrypted list of numbers?
 
+use std::collections::HashSet;
+
 use aoc_runner_derive::{aoc, aoc_generator};
 
 #[aoc_generator(day9)]
@@ -87,6 +89,7 @@ fn parse(input: &str) -> Vec<usize> {
 
 fn solution1_impl(nums: &[usize], win_size: usize) -> usize {
     nums.windows(win_size + 1)
+        // TODO(wathiede): try soring and/or hashmap for speed.
         .skip_while(|chunk| {
             let past = &chunk[..win_size];
             let cur = chunk[win_size];
@@ -99,26 +102,9 @@ fn solution1_impl(nums: &[usize], win_size: usize) -> usize {
 
             false
         })
-        .find_map(|chunk| Some(chunk[win_size]))
+        // TODO(wathiede): try find_map()
-        .unwrap()
+        .map(|chunk| chunk[win_size])
-}
+        .nth(0)
-
-fn solution1_impl_sorted(nums: &[usize], win_size: usize) -> usize {
-    nums.windows(win_size + 1)
-        .skip_while(|chunk| {
-            let mut past = (&chunk[..win_size]).clone().to_owned();
-            past.sort_unstable();
-            let cur = chunk[win_size];
-            for p in &past {
-                let diff = if cur > *p { cur - p } else { p - cur };
-                if past.binary_search(&diff).is_ok() {
-                    return true;
-                }
-            }
-
-            false
-        })
-        .find_map(|chunk| Some(chunk[win_size]))
         .unwrap()
 }
 
@@ -127,18 +113,9 @@ fn solution1(nums: &[usize]) -> usize {
     solution1_impl(nums, 25)
 }
 
-#[aoc(day9, part1, sorted)]
-fn solution1_sorted(nums: &[usize]) -> usize {
-    solution1_impl_sorted(nums, 25)
-}
-
 fn sum_min_max(low: usize, hi: usize, nums: &[usize]) -> usize {
-    let (min, max) = nums[low..hi]
+    // TODO(wathiede): rewrite with fold to do it in one pass.
-        .iter()
+    nums[low..hi].iter().min().unwrap() + nums[low..hi].iter().max().unwrap()
-        .fold((usize::MAX, 0), |(min, max), &n| {
-            (std::cmp::min(min, n), std::cmp::max(max, n))
-        });
-    min + max
 }
 
 // If contiguous numbers adding up to `sum` are found, the hi index (inclusive) is returned.
@@ -159,6 +136,7 @@ fn find_sum_at(low: usize, nums: &[usize], sum: usize) -> Option<usize> {
 
 fn solution2_impl(nums: &[usize], win_size: usize) -> usize {
     let sum = solution1_impl(nums, win_size);
+    dbg!(sum);
     for low in 0..nums.len() - 1 {
         if let Some(hi) = find_sum_at(low, nums, sum) {
             return sum_min_max(low, hi, nums);