Day 3 - cleanup

src/day3/main.rs

@@ -1,38 +1,11 @@
 use anyhow::Result;
-use std::{collections::HashMap, fs};
+use std::fs;
 
-fn sol1(text: &String) {
-    let sum = text
-        .split("\n")
-        .filter(|s| s.len() > 0)
-        .fold(0, |sum, line| {
-            let line_len = line.len() - 1;
-            let (f, l) = line.split("").filter(|s| s.len() > 0).enumerate().fold(
-                (0, 0),
-                |(f, l), (index, st)| {
-                    let c = st.chars().nth(0).unwrap();
-                    let n = (c as u8) - (48 as u8);
-                    if n > f && index != line_len {
-                        (n, 0)
-                    } else if n > l {
-                        (f, n)
-                    } else {
-                        (f, l)
-                    }
-                },
-            );
-            //println!("{} -> {} {}", line, f, l);
-            sum + (f * 10 + l) as i64
-        });
-    println!("sol1: {}", sum);
-}
-
-trait NiceSum<T> {
+trait NiceSum {
     fn nice_sum(&self) -> u64;
-    fn nice_max<'a>(&'a self, other: &'a T) -> &'a T;
 }
 
-impl NiceSum<Vec<u8>> for Vec<u8> {
+impl NiceSum for Vec<u8> {
     fn nice_sum(&self) -> u64 {
         self.iter()
             .rfold((0 as u64, 1 as u64), |(s, it), i| {
@@ -40,110 +13,35 @@ impl NiceSum<Vec<u8>> for Vec<u8> {
             })
             .0
     }
-    fn nice_max<'a>(&'a self, other: &'a Vec<u8>) -> &'a Vec<u8> {
-        if other.nice_sum() > self.nice_sum() {
-            return other;
-        }
-        return self;
-    }
 }
 
-// To slow
-fn greedy(line: &str, cur_best: &Vec<u8>, index: usize) -> Vec<u8> {
-    if line.len() <= index {
-        return cur_best.clone();
-    }
-    let cur_number = line.chars().nth(index).unwrap() as u8 - 48;
-
-    // What happens if we skip
-    let mut best = greedy(line, cur_best, index + 1);
-
-    let how_much_can_we_go_back = ((line.len() as i64 - 12) as i64).max(0) as usize;
-
-    if cur_best.len() == 0 {
-        if index + 12 < line.len() {
-            let mut new_best: Vec<u8> = (0..12).collect();
-            new_best.fill(0);
-            new_best[0] = cur_number;
-            return greedy(line, &new_best, index + 1)
-                .nice_max(&best)
-                .nice_max(cur_best)
-                .clone();
-        } else {
-            // There is no point in trying to expand is not bigger
-            return cur_best.clone();
-        }
-    }
-
-    for i in 1..cur_best.len().min(how_much_can_we_go_back) {
-        let mut new_best: Vec<u8> = cur_best.clone().into_iter().take(i).collect();
-        new_best.push(cur_number);
-        best = greedy(line, &new_best, index + 1).nice_max(&best).clone();
-    }
-
-    if cur_best.len() < 12 {
-        let mut new_best: Vec<u8> = cur_best.clone();
-        new_best.push(cur_number);
-        best = greedy(line, &new_best, index + 1).nice_max(&best).clone();
-    }
-
-    return cur_best.max(&best).clone();
-}
-
-fn sol2(text: &String) {
-    let sum = text
-        .split("\n")
+fn sol(text: &String, bat_size: usize) -> u64 {
+    text.split("\n")
         .filter(|s| s.len() > 0)
         .fold(0, |sum, sline| {
-            let line = sline.chars().map(|a| (a as u8) - 48);
-            let mut best: Vec<u8> = line
-                .clone()
-                .rev()
-                .take(12)
-                .collect::<Vec<u8>>()
-                .into_iter()
-                .rev()
-                .collect();
-            println!("{}", sline);
-            println!("init {}", best.nice_sum());
-            for i in line.rev().skip(12) {
+            let line: Vec<u8> = sline.chars().map(|a| (a as u8) - 48).collect();
+            let mut best: Vec<u8> = Vec::from(&line[line.len() - bat_size..]);
+            for i in line.into_iter().rev().skip(bat_size) {
                 if i >= best[0] {
-                    let p = best[0];
-                    let old_best = best.nice_sum();
                     'removed: {
-                        for j in 1..12 {
+                        for j in 1..bat_size {
                             if best[j] > best[j - 1] {
                                 best.remove(j - 1);
-                                best.insert(0, i);
                                 break 'removed;
                             }
                         }
-                        best.remove(11);
+                        best.remove(bat_size - 1);
+                    }
                     best.insert(0, i);
                 }
-                    println!(
-                        "{} is bigger than {} {} new best {}",
-                        i,
-                        p,
-                        old_best,
-                        best.nice_sum()
-                    );
-                    assert!(old_best <= best.nice_sum());
             }
-            }
-            let lr = best.nice_sum();
-            println!("{} -> {}", sline, lr);
-            sum + lr
-        });
-    println!("sol2: {}", sum);
+            sum + best.nice_sum()
+        })
 }
 
 fn main() -> Result<()> {
     let text = fs::read_to_string("src/day3/day3-act.txt")?;
 
-    sol1(&text);
-
-    sol2(&text);
-
+    println!("sol1: {}, sol2: {}", sol(&text, 2), sol(&text, 12));
     Ok(())
 }

tmp

@@ -1,2 +0,0 @@
-93231236367517
-543534343745