Some rewrites, prefer using iters over .collect::<Vec<_>>

An unfortunate find is that .skip(1) is actually slower than .collect::<Vec<_>>[1..].to_vec(), poor performance of .skip() has already been noted here rust-lang/rust/issues/101814.

Author: Nekuskus

src/01.rs

@@ -85,9 +85,8 @@ fn part1(lines: &Vec::<String>) -> i32 {
             nums.push(sum.parse::<i32>().unwrap());
         }
     }
-    let sum = nums.iter().sum::<i32>();
 
-    return sum
+    nums.iter().sum()
 }
 
 // one, two, three, four, five, six, seven, eight, nine
@@ -138,11 +137,6 @@ fn part2(lines: &Vec::<String>) -> i32 {
         let sum = first + &last;
         sums.push(sum);
     }
-    let mut nums = Vec::new();
-    for sum in sums {
-        nums.push(sum.parse::<i32>().unwrap());
-    }
-    let sum = nums.iter().sum::<i32>();
 
-    return sum
+    sums.iter().map(|s| s.parse::<i32>().expect(format!("Incorrect integer value: {}", s).as_str())).sum()
 }

src/02.rs

@@ -62,7 +62,11 @@ fn part1(lines: &Vec::<String>) -> i32 {
     for i in 0..lines.len() {
         let line_id = i as i32 + 1;
         let mut line_record: HashMap<String, i32> = HashMap::new();
-        let line_of_balls = lines[i].split(' ').map(String::from).collect::<Vec<String>>()[2..].join(" ");
+        let line_of_balls = lines[i]
+            .split(' ')
+            .skip(2)
+            .collect::<Vec<_>>()
+            .join(" ");
         let replaced_line = line_of_balls.replace(";", &",");
         let arr_of_balls = replaced_line.split(",").map(|s| s.trim().split(' ')).map(|spl| spl.collect::<Vec<&str>>()).collect::<Vec<Vec<&str>>>();
         for arr in arr_of_balls {
@@ -75,9 +79,9 @@ fn part1(lines: &Vec::<String>) -> i32 {
                 *line_record.get_mut(color).unwrap() = amount;
             }
         }
-        if  line_record.get("red").unwrap_or(&99) <= &12
-            && line_record.get("green").unwrap_or(&99) <= &13 
-            && line_record.get("blue").unwrap_or(&99) <= &14  {
+        if  line_record.get("red").unwrap_or(&0) <= &12
+            && line_record.get("green").unwrap_or(&0) <= &13 
+            && line_record.get("blue").unwrap_or(&0) <= &14  {
             //println!("id: {}, red: {}, green: {}, blue: {}", line_id, line_record.get("red").unwrap(), line_record.get("green").unwrap(), line_record.get("blue").unwrap());
             sum_of_ids += line_id;
         }
@@ -90,7 +94,11 @@ fn part2(lines: &Vec::<String>) -> i32 {
     for i in 0..lines.len() {
         //let line_id = i as i32 + 1;
         let mut line_record: HashMap<String, i32> = HashMap::new();
-        let line_of_balls = lines[i].split(' ').map(String::from).collect::<Vec<String>>()[2..].join(" ");
+        let line_of_balls = lines[i]
+            .split(' ')
+            .skip(2)
+            .collect::<Vec<_>>()
+            .join(" ");
         let replaced_line = line_of_balls.replace(";", &",");
         let arr_of_balls = replaced_line.split(",").map(|s| s.trim().split(' ')).map(|spl| spl.collect::<Vec<&str>>()).collect::<Vec<Vec<&str>>>();
         for arr in arr_of_balls {
@@ -103,7 +111,7 @@ fn part2(lines: &Vec::<String>) -> i32 {
                 *line_record.get_mut(color).unwrap() = amount;
             }
         }
-        let (red, blue, green) = (line_record.get("red").unwrap_or(&99), line_record.get("green").unwrap_or(&99), line_record.get("blue").unwrap_or(&99));
+        let (red, blue, green) = (line_record.get("red").unwrap_or(&0), line_record.get("green").unwrap_or(&0), line_record.get("blue").unwrap_or(&0));
         //println!("id: {}, red: {}, green: {}, blue: {}, power: {}", line_id, red, blue, green, red * blue * green);
 
         sum_of_powers += red * green * blue;

src/04.rs

@@ -74,25 +74,21 @@ fn main() {
 fn part1(lines: &Vec<String>) -> i32 {
     let mut sum_of_points = 0;
     for line in lines {
-        let nums_line = line.split(":").collect::<Vec<_>>()[1]
+        let mut nums_line = line.split(":").nth(1).expect(format!("Improperly formatted line: {}", line).as_str())
             .trim()
             .split('|')
-            .map(|s| s.trim())
-            .collect::<Vec<_>>();
-        let winning = nums_line[0]
+            .map(|s| s.trim());
+        let winning = nums_line.next().expect(format!("Improperly formatted line, missing winning numbers: {}", line).as_str())
             .trim()
             .split_ascii_whitespace()
             .map(|s| s.trim().parse::<i32>().expect(&format!("bad int error num={}", s)))
             .collect::<HashSet<_>>();
-        let scratched = nums_line[1]
+        let scratched = nums_line.next().expect(format!("Improperly formatted line, missing scratched numbers: {}", line).as_str())
             .trim()
             .split_ascii_whitespace()
             .map(|s| s.parse::<i32>().expect(&format!("bad int error num={}", s)))
             .collect::<HashSet<_>>();
-        let found: HashSet<i32> = winning
-            .intersection(&scratched)
-            .copied()
-            .collect();
+        let found = &winning & &scratched;
         if len!(found) > 0 {
             let score = 2_i32.pow(len!(found) as u32 - 1);
             sum_of_points += score;
@@ -104,30 +100,27 @@ fn part1(lines: &Vec<String>) -> i32 {
 fn part2(lines: &Vec<String>) -> i32 {
     let mut total_count = 0;
     let lines_parsed = lines.iter().map(|line| {
-        let split_line = line.split(":").collect::<Vec<_>>();
-        let nums_line = split_line[1]
+        let mut split_line = line.split(":");
+        let game_id = split_line.next().expect(format!("Improperly formatted line, missing game_id: {}", line).as_str())
+            .split_ascii_whitespace()
+            .nth(1).unwrap()
+            .parse::<usize>().expect(&format!("bad int error num={}", line));
+        let mut nums_line = split_line.next().expect(format!("Improperly formatted line: {}", line).as_str())
             .trim()
             .split('|')
-            .map(|s| s.trim())
-            .collect::<Vec<_>>();
-        let game_id = split_line[0].split_ascii_whitespace().collect::<Vec<_>>()[1]
-            .parse::<usize>()
-            .unwrap();
-        let winning = nums_line[0]
+            .map(|s| s.trim());
+        let winning = nums_line.next().expect(format!("Improperly formatted line, missing winning numbers: {}", line).as_str())
             .trim()
             .split_ascii_whitespace()
             .map(|s| s.trim().parse::<i32>().expect(&format!("bad int error num={}", s)))
             .collect::<HashSet<_>>();
-        let scratched = nums_line[1]
+        let scratched = nums_line.next().expect(format!("Improperly formatted line, missing scratched numbers: {}", line).as_str())
             .trim()
             .replace("  ", " ")
             .split_ascii_whitespace()
             .map(|s| s.parse::<i32>().expect(&format!("bad int error num={}", s)))
             .collect::<HashSet<_>>();
-        let found: HashSet<i32> = winning
-            .intersection(&scratched)
-            .copied()
-            .collect();
+        let found = &winning & &scratched;
         return (game_id - 1, len!(found));
     }).collect::<Vec<_>>();
 

src/05.rs

@@ -222,7 +222,7 @@ fn part2(lines: &Vec<String>) -> u64 {
                     let mut num_of_iters: u64 = 0;
                     return (seed_range
                         .map(|seed| {
-                            let mut current_val = seed.clone();
+                            let mut current_val = seed;
                             //print!("{current_val}");
                             for mapset in &mappings {
                                 let mut found = false;

src/06.rs

@@ -60,37 +60,43 @@ fn main() {
 }
 
 fn part1(lines: &Vec::<String>) -> u128 {
-    let mut power = 1;
+    let power = 1;
     let mut counts = Vec::new();
 
-    let times = lines[0].split_ascii_whitespace().collect::<Vec<_>>()[1..].iter().map(|s| s.parse::<u128>().unwrap()).collect::<Vec<_>>();
-    let distances = lines[1].split_ascii_whitespace().collect::<Vec<_>>()[1..].iter().map(|s| s.parse::<u128>().unwrap()).collect::<Vec<_>>();
+    let times = lines[0].split_ascii_whitespace()
+        .skip(1)
+        .map(|s| s.parse::<u128>().unwrap());
+    let distances = lines[1].split_ascii_whitespace()
+        .skip(1)
+        .map(|s| s.parse::<u128>().unwrap());
 
-    let zip = times.iter().zip(distances.iter());
+    let zip = times.zip(distances);
 
     for (time, distance) in zip {
-        let mut vec = Vec::with_capacity(*time as usize);
+        let mut vec = Vec::with_capacity(time as usize);
 
-        for delay in 1..*time {
-            let val = delay * (*time - delay);
+        for delay in 1..time {
+            let val = delay * (time - delay);
             vec.push(val)
         }
 
-        vec = vec.iter().filter(|res| *res > distance).copied().collect::<Vec<_>>();
+        vec = vec.iter().filter(|res| **res > distance).copied().collect::<Vec<_>>();
         counts.push(len!(vec) as u128);
     }
 
-    counts.iter().for_each(|count| {
-        power *= count;
-    });
-
-    return power;
+    counts.iter().fold(power, |cur_power, count| {
+        cur_power * count
+    })
 }
 
 fn part2(lines: &Vec::<String>) -> u128 {
     let mut newlines = lines.clone();
-    newlines[0] = "Time: ".to_owned() + &newlines[0].split_ascii_whitespace().collect::<Vec<_>>()[1..].to_vec().join("");
-    newlines[1] = "Distance: ".to_owned() + &newlines[1].split_ascii_whitespace().collect::<Vec<_>>()[1..].to_vec().join("");
+    newlines[0] = "Time: ".to_owned() + &newlines[0].split_ascii_whitespace()
+        .collect::<Vec<_>>()[1..].to_vec() // Somehow faster than using .skip(1) on the iter
+        .join("");
+    newlines[1] = "Distance: ".to_owned() + &newlines[1].split_ascii_whitespace()
+        .collect::<Vec<_>>()[1..].to_vec()
+        .join("");
     println!("{}", newlines[0]);
     println!("{}", newlines[1]);
     return part1(&newlines);

src/18.rs

@@ -226,9 +226,9 @@ fn part2(lines: &Vec<String>) -> i64 {
             },
             "L" => {
                 if grid_lines.contains_key(&y_pointer) {
-                    grid_lines.get_mut(&y_pointer).unwrap().push((x_pointer, x_pointer - count));
+                    grid_lines.get_mut(&y_pointer).unwrap().push((x_pointer - count, x_pointer));
                 } else {
-                    grid_lines.insert(y_pointer, vec![((x_pointer, x_pointer - count))]);
+                    grid_lines.insert(y_pointer, vec![((x_pointer - count, x_pointer))]);
                 }
                 x_pointer -= count;
             },
@@ -242,35 +242,41 @@ fn part2(lines: &Vec<String>) -> i64 {
     }
 
     let mut counter: i64 = 0;
-    let mut line_iter = vec.iter();
+    let line_iter = vec.iter();
 
     // These correspond to each other
     let mut pointers: Vec<(i64, i64)> = Vec::new();
     let mut prev_lens: Vec<i64> = Vec::new();
     let mut prev_line_num = i64::MIN;
 
-    for (line_num, line) in line_iter {
+    for (&line_num, ref line) in line_iter {
         if prev_line_num == i64::MIN {
-            let mut cloned = (*line).clone();
+            let mut cloned = (**line).clone();
             let mut lens: Vec<i64> = line.iter().map(|(_x1, _x2)| _x2 - _x1 + 1).collect();
             lens.iter().for_each(|&length| {counter += length});
             //debugln!("{cloned:?}\n{lens:?}");
             prev_lens.append(&mut lens);
             pointers.append(&mut cloned);
-            prev_line_num = **line_num;
+            prev_line_num = line_num;
+            continue;
         }
-        for ((x1, x2), lines_count) in pointers.iter().zip(prev_lens.iter()) {
-
+        for (&(x1, x2), &lines_count) in pointers.iter().zip(prev_lens.iter()) {
+            
         }
-        for (x1, x2) in line.clone() {
-            let found_matches = pointers.iter().filter(|l|  (**l).0 == *x1 || (**l).1 == *x2).collect::<Vec<_>>();
+        for (x1, x2) in (*line).clone() {
+            let found_matches = pointers.iter().enumerate().filter(|(_, &l)|  l.0 == x1 || l.1 == x2).collect::<Vec<_>>();
             match found_matches.len() {
                 2 => todo!(),
                 1 => todo!(),
-                0 => todo!(),
+                0 => {
+                    pointers.push((x1, x2));
+                    prev_lens.push(x2 - x1 + 1);
+                    counter += x2 - x1 + 1 //no need for abs, it's ordered properly
+                },
                 _ => unreachable!()
             }
         }
+        prev_line_num = line_num
     }
 
     return counter;