Add (much slower) sort and binary search day 9 part 1

2020/src/day9.rs

@@ -75,8 +75,6 @@
 //!
 //! 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)]
@@ -89,7 +87,6 @@ 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];
@@ -102,9 +99,26 @@ fn solution1_impl(nums: &[usize], win_size: usize) -> usize {
 
             false
         })
-        // TODO(wathiede): try find_map()
-        .map(|chunk| chunk[win_size])
-        .nth(0)
+        .find_map(|chunk| Some(chunk[win_size]))
+        .unwrap()
+}
+
+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()
 }
 
@@ -113,9 +127,18 @@ 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 {
-    // TODO(wathiede): rewrite with fold to do it in one pass.
-    nums[low..hi].iter().min().unwrap() + nums[low..hi].iter().max().unwrap()
+    let (min, max) = nums[low..hi]
+        .iter()
+        .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.
@@ -136,7 +159,6 @@ 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);