day 20 cleanup

2022/src/bin/day20.rs

@@ -1,7 +1,10 @@
 #![feature(test)]
 extern crate test;
 use aoc2022::{boilerplate, common::*};
-use std::{collections::VecDeque, iter::repeat};
+use std::{
+    collections::VecDeque,
+    iter::{repeat, repeat_with},
+};
 
 const DAY: usize = 20;
 type Parsed = Vec<isize>;
@@ -11,54 +14,49 @@ fn parse_input(raw: &str) -> Parsed {
 }
 
 fn part1(parsed: &Parsed) -> isize {
-    let mut xs: VecDeque<_> = parsed.iter().copied().zip(repeat(false)).collect();
+    let mut xs: VecDeque<_> = repeat(false).zip(parsed.iter().copied()).collect();
     let mut moved = 0;
     while moved < parsed.len() {
         let x = xs.pop_front().unwrap();
-        if x.1 {
+        if x.0 {
+            // already processed, just put it in the back
             xs.push_back(x);
         } else {
-            xs.insert(((x.0 + (xs.len() * 2) as isize) % xs.len() as isize) as usize, (x.0, true));
+            // casting :notLikeMiya:
+            xs.insert(((x.1 + (xs.len() * 2) as isize) % xs.len() as isize) as usize, (true, x.1));
             moved += 1;
         }
     }
-    let i = xs.iter().position(|(x, _)| x == &0).unwrap();
+    get_coords(&mut xs)
-    xs.rotate_left(i);
-    xs.rotate_left(1000 % parsed.len());
-    let a = xs.front().unwrap().0;
-    xs.rotate_left(1000 % parsed.len());
-    let b = xs.front().unwrap().0;
-    xs.rotate_left(1000 % parsed.len());
-    let c = xs.front().unwrap().0;
-    a + b + c
 }
 
 const DECRYPTION_KEY: isize = 811589153;
 
 fn part2(parsed: &Parsed) -> isize {
     let mut xs: VecDeque<_> = parsed.iter().enumerate().map(|(p, x)| (p, x * DECRYPTION_KEY)).collect();
-    for i in 0..10 {
+    // Effective length is reduced by one because the element that’s being moved is no longer in the collection.
-        dbg!(i, &xs);
+    let len = xs.len() as isize - 1;
-        let mut moved = 0;
+    // Add this to each element to make it guaranteed positive before modulo-ing for the index.
-        while moved < parsed.len() {
+    let make_positive = len * 2 * DECRYPTION_KEY;
-            let i = xs.iter().position(|(x, _)| x == &moved).unwrap();
+    for _ in 0..10 {
+        for current in 0..parsed.len() {
+            let i = xs.iter().position(|(x, _)| x == &current).unwrap();
             xs.rotate_left(i);
             let x = xs.pop_front().unwrap();
-            let idx = ((x.1 + (xs.len() * 2 * DECRYPTION_KEY as usize) as isize) % xs.len() as isize) as usize;
+            xs.insert(((x.1 + make_positive) % len) as usize, x);
-            dbg!("Inserting at", idx);
-            xs.insert(idx, x);
-            moved += 1;
         }
     }
-    let i = xs.iter().position(|(_, x)| x == &0).unwrap();
+    get_coords(&mut xs)
-    xs.rotate_left(i);
+}
-    xs.rotate_left(1000 % parsed.len());
+
-    let a = xs.front().unwrap().1;
+fn get_coords<T>(xs: &mut VecDeque<(T, isize)>) -> isize {
-    xs.rotate_left(1000 % parsed.len());
+    xs.rotate_left(xs.iter().position(|(_, x)| x == &0).unwrap());
-    let b = xs.front().unwrap().1;
+    repeat_with(|| {
-    xs.rotate_left(1000 % parsed.len());
+        xs.rotate_left(1000 % xs.len());
-    let c = xs.front().unwrap().1;
+        xs.front().unwrap().1
-    a + b + c
+    })
+    .take(3)
+    .sum()
 }
 
 boilerplate! {