···

       
19
       
19
       
 
       
        })

     

       
20
       
20
       
 
       
        .collect();

     

       
21
       
21
       
 
       


     

       
22
       
22
       
+
       
    let powers_of_ten: Vec<u64> = (0..10).map(|i| 10_u64.pow(i)).collect();

     

       
23
       
23
       
+
       


     

       
22
       
24
       
 
       
    let part_1 = &input.iter().fold(0_u64, |acc, v| {

     

       
23
       
25
       
 
       
        (v.start..=v.end).fold(acc, |acc, n| {

     

       
24
       
26
       
 
       
            if n <= 10 {

     

       
25
       
27
       
 
       
                return acc;

     

       
26
       
28
       
 
       
            }

     

       
27
       
27
       
-
       
            let len = n.ilog10() + 1;

     

       
29
       
29
       
+
       
            let len = (n.ilog10() + 1) as usize;

     

       
28
       
30
       
 
       
            if len % 2 == 1 {

     

       
29
       
31
       
 
       
                return acc;

     

       
30
       
32
       
 
       
            }

     

       
31
       
31
       
-
       
            let pow = 10_u64.pow(len / 2);

     

       
33
       
33
       
+
       
            let pow = powers_of_ten.get(len / 2).unwrap();

     

       
32
       
34
       
 
       
            if n / pow == n % pow {

     

       
33
       
35
       
 
       
                return acc + n;

     

       
34
       
36
       
 
       
            }

     
···

       
42
       
44
       
 
       
            if n <= 10 {

     

       
43
       
45
       
 
       
                return acc;

     

       
44
       
46
       
 
       
            }

     

       
45
       
45
       
-
       
            let len = n.ilog10() + 1;

     

       
47
       
47
       
+
       
            let len = (n.ilog10() + 1) as usize;

     

       
46
       
48
       
 
       
            match (1..=len / 2).rfind(|clen| {

     

       
47
       
47
       
-
       
                let num = n % 10_u64.pow(*clen);

     

       
48
       
48
       
-
       
                let res = (0..len / clen).fold(0, |acc, i| acc + num * 10_u64.pow(i * clen));

     

       
49
       
49
       
+
       
                let num = n % powers_of_ten.get(*clen).unwrap();

     

       
50
       
50
       
+
       
                let res = (0..len / clen)

     

       
51
       
51
       
+
       
                    .fold(0, |acc, i| acc + num * powers_of_ten.get(i * clen).unwrap());

     

       
49
       
52
       
 
       
                res == n

     

       
50
       
53
       
 
       
            }) {

     

       
51
       
54
       
 
       
                Some(_) => acc + n,