···

       
1
       
1
       
-
       
fn solve(input: &Vec<Vec<u32>>, digits: usize) {

     

       
1
       
1
       
+
       
// fun fact for this version, my biggest bug was integer overflow when i was using u32 because im not accustumed to this shit

     

       
2
       
2
       
+
       


     

       
3
       
3
       
+
       
fn solve(input: &Vec<Vec<u64>>, digits: usize) -> u64 {

     

       
2
       
4
       
 
       
    input.iter().fold(0, |acc, bank| {

     

       
3
       
3
       
-
       
        let n = (0..digits).fold((0, bank), |(number, bank), i| {

     

       
4
       
4
       
-
       
            let max = bank[0..bank.len() - i]

     

       
5
       
5
       
-
       
                .iter()

     

       
6
       
6
       
-
       
                .max()

     

       
7
       
7
       
-
       
                .unwrap_or(bank.last().unwrap());

     

       
5
       
5
       
+
       
        let bank_len = bank.len();

     

       
6
       
6
       
+
       
        let (n, _) = (0..digits).rfold((0, 0), |(number, bank_index), i| {

     

       
7
       
7
       
+
       
            let (loc, max) = bank[bank_index..bank_len - i].iter().enumerate().fold(

     

       
8
       
8
       
+
       
                (0_usize, &0_u64),

     

       
9
       
9
       
+
       
                |(maxi, max), (i, n)| {

     

       
10
       
10
       
+
       
                    if n > max { (i, n) } else { (maxi, max) }

     

       
11
       
11
       
+
       
                },

     

       
12
       
12
       
+
       
            );

     

       
8
       
13
       
 
       


     

       
9
       
9
       
-
       
            return (number * 10 + max, bank[0..bank.len() - max_loc - 1]);

     

       
14
       
14
       
+
       
            ((number * 10) + max, bank_index + loc + 1)

     

       
10
       
15
       
 
       
        });

     

       
11
       
16
       
 
       
        acc + n

     

       
12
       
17
       
 
       
    })

     

       
13
       
18
       
 
       
}

     

       
14
       
19
       
 
       


     

       
15
       
20
       
 
       
fn main() {

     

       
16
       
16
       
-
       
    let input: Vec<Vec<u32>> = include_str!("../../input.txt")

     

       
21
       
21
       
+
       
    let input: Vec<Vec<u64>> = include_str!("../../input.txt")

     

       
17
       
22
       
 
       
        .trim()

     

       
18
       
23
       
 
       
        .split("\n")

     

       
19
       
19
       
-
       
        .map(|bank| bank.chars().map(|s| s.to_digit(10).unwrap()).collect())

     

       
24
       
24
       
+
       
        .map(|bank| {

     

       
25
       
25
       
+
       
            bank.chars()

     

       
26
       
26
       
+
       
                .map(|s| s.to_digit(10).unwrap() as u64)

     

       
27
       
27
       
+
       
                .collect()

     

       
28
       
28
       
+
       
        })

     

       
20
       
29
       
 
       
        .collect();

     

       
30
       
30
       
+
       


     

       
31
       
31
       
+
       
    println!("Part 1: {}", solve(&input, 2));

     

       
32
       
32
       
+
       
    println!("Part 1: {}", solve(&input, 12));

     

       
21
       
33
       
 
       
}