From 88b70450d413d5cdbb7f920da68da997273e7b30 Mon Sep 17 00:00:00 2001
From: Maciej Jur <maciej@kamoshi.org>
Date: Tue, 20 Dec 2022 12:15:16 +0100
Subject: [PATCH] 2022 day 20 rust

---
 2022/rust/src/solutions/day20.rs | 36 +++++++++++++++-----------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/2022/rust/src/solutions/day20.rs b/2022/rust/src/solutions/day20.rs
index 57a30db..d278cb3 100644
--- a/2022/rust/src/solutions/day20.rs
+++ b/2022/rust/src/solutions/day20.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 use std::collections::VecDeque;
 use crate::utils;
 
@@ -6,19 +7,21 @@ pub fn run() -> () {
     let data = parse_data(&utils::read_lines(utils::Source::Day(20)));
 
     println!("Day 20");
-    println!("Part 1: {}", solve1(&data));
-    println!("Part 2: {}", solve2(&data));
+    println!("Part 1: {}", solve::<1, 1>(&data));
+    println!("Part 2: {}", solve::<811589153, 10>(&data));
 }
 
 
-fn reorder(data: &[(usize, i32)]) -> Vec<i32> {
-    let mut array = data.iter().copied().collect::<VecDeque<_>>();
+fn reorder(data: &[(usize, i64)], reps: i32) -> Vec<i64> {
+    let mut array = VecDeque::from_iter(data.iter().copied());
 
-    for item in data {
-        let index = array.iter().position(|item_ref| item == item_ref).unwrap();
-        array.remove(index);
-        let index = (index as i32 + item.1).rem_euclid(array.len() as i32) as usize;
-        array.insert(index, *item);
+    for _ in 0..reps {
+        for item in data {
+            let index = array.iter().position(|item_ref| item == item_ref).unwrap();
+            array.remove(index);
+            let index = (index as i64 + item.1).rem_euclid(array.len() as i64) as usize;
+            array.insert(index, *item);
+        }
     }
 
     let zero_offset = array.iter().position(|item_ref| 0 == item_ref.1).unwrap();
@@ -26,19 +29,14 @@ fn reorder(data: &[(usize, i32)]) -> Vec<i32> {
     array.into_iter().map(|x| x.1).collect()
 }
 
-fn solve1(data: &[(usize, i32)]) -> i32 {
-    let array = reorder(data);
+fn solve<const KEY: i64, const REPS: i32>(data: &[(usize, i64)]) -> i64 {
+    let array = reorder(&Vec::from_iter(data.iter().map(|&(index, value)| (index, value * KEY))), REPS);
     let len = array.len();
     array[1000 % len] + array[2000 % len] + array[3000 % len]
 }
 
-fn solve2(data: &[(usize, i32)]) -> i32 {
-    reorder(data);
-    2
-}
 
-
-fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<(usize, i32)> {
+fn parse_data<T: AsRef<str>>(data: &[T]) -> Vec<(usize, i64)> {
     data.iter()
         .enumerate()
         .map(|(index, line)| (index, line.as_ref().parse().unwrap()))
@@ -54,11 +52,11 @@ mod tests {
 
     #[test]
     fn part1() {
-        assert_eq!(3, solve1(&parse_data(DATA)));
+        assert_eq!(3, solve::<1, 1>(&parse_data(DATA)));
     }
 
     #[test]
     fn part2() {
-        assert_eq!(2, solve2(&parse_data(DATA)));
+        assert_eq!(1623178306, solve::<811589153, 10>(&parse_data(DATA)));
     }
 }