DeaDvey day 4

oll korrect

.gitignore

@@ -0,0 +1,8 @@
+large.txt
+medium.txt
+small.txt
+
+target
+debug
+*.swp
+Cargo.lock

2025/1/deadvey/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "deadvey"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tokio = { version = "1.48.0", features = ["macros", "rt-multi-thread"] }
+trash_parallelism = "0.1.102"

2025/1/deadvey/src/main.rs

@@ -0,0 +1,59 @@
+use std::fs;
+use std::time::Instant;
+
+// Right = up/increase
+// Left = down/decrease
+#[tokio::main]
+async fn main()
+{
+    let mut position: i32 = 50;
+    let mut total1: i32 = 0;
+    let mut total2: i32 = 0;
+
+    let start = Instant::now();
+    let file_contents: String = fs::read_to_string("../large.txt").unwrap();
+    //let file_contents = read_file_to_string_async("large.txt").await.unwrap();
+    let file_read = start.elapsed();
+    let mut lines: Vec<&str> = file_contents
+        .split("\n")
+        .collect();
+    lines.pop();
+    let preamble = start.elapsed();
+
+    for line in lines
+    {
+        let movement = line.chars().next().unwrap();
+        let mut number: i32 = line[1..line.len()].parse().unwrap();
+
+        if movement == 'L' {
+            number = -number
+        };
+        if number < 0 {
+            total2 += (100 - position - number) / 100 - (position == 0) as i32
+        }
+        else {
+            total2 += (number+position) / 100
+        };
+        position = (position + number).rem_euclid(100);
+        if position == 0 {
+            total1 += 1;
+        }
+    }
+
+    let end = start.elapsed();
+    println!("part1: {total1}");
+    println!("part2: {total2}");
+    println!("Times: 
+    File read:    {:.2?}
+    Preamble:     {:.2?}
+    Loop:         {:.2?}
+    Average Loop: {:.2?}
+    Total:        {:.2?}
+    ",
+    file_read,
+    preamble,
+    end-preamble,
+    (end-preamble)/(100000).try_into().unwrap(),
+    end);
+}
+

2025/1/mememan/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "mememan"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

2025/1/mememan/src/main.rs

@@ -0,0 +1,46 @@
+use std::fs;
+
+fn main() {
+    let start = std::time::Instant::now();
+    let raw = fs::read_to_string("../large.txt").unwrap();
+    let mut formatted: Vec<&str> = raw.split("\n").collect();
+    formatted.pop();
+    let mut point: i32 = 50;
+    let mut password_one = 0;
+    let mut password_two = 0;
+    for rot in formatted {
+        let mut chars = rot.chars();
+        let dir = chars.next().unwrap();
+        let dist = chars.as_str().parse::<i32>().unwrap();
+        if dir == 'L' {
+            if point - dist < 1 {
+                password_two += ((point - dist).abs() as f32 / 100.0).ceil() as i32;
+                point = (point - dist).rem_euclid(100);
+                if point == 0 {
+                    password_one +=1;
+                }
+                // dbg!(point, ((point - dist).abs() as f32 / 100.0).ceil());
+                continue;
+            }
+            point = (point - dist).rem_euclid(100);
+
+        } else {
+            if point + dist > 99 {
+                password_two += ((point + dist) as f32 / 100.0).floor() as i32;
+                point = (point + dist).rem_euclid(100);
+                if point == 0 {
+                    password_one += 1;
+                }
+                // dbg!(point, ((point + dist) as f32 / 100.0).floor());
+                continue;
+            }
+            point = (point + dist).rem_euclid(100);
+        }
+        if point == 0 {
+            password_one += 1;
+            password_two += 1;
+        }
+        // dbg!(point);
+    }
+    dbg!(password_one, password_two, std::time::Instant::now() - start);
+}

2025/2/deadvey/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "deadvey"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

2025/2/deadvey/src/main.rs

@@ -0,0 +1,73 @@
+use std::fs;
+use std::time::Instant;
+
+fn algorithm(vector: &Vec<Vec<&str>>) -> (u64, u64) {
+    let mut total1: u64 = 0;
+    let mut total2: u64 = 0;
+    for pair in vector
+    {
+        let num_1: u64 = pair[0].parse().unwrap();
+        let num_2: u64 = pair[1].parse().unwrap();
+        for num in num_1..=num_2 { // Loop over each number in the range
+            let num_string = num.to_string();
+            let num_length = num_string.len();
+            for chunk_width in (1..=(num_length/2)).rev() {
+                if num_length % chunk_width == 0 {
+                    let chunks = num_length / chunk_width;
+                    let mut same: bool = true;
+                    let mut previous = &num_string[0..chunk_width];
+                    for i in 0..chunks {
+                        let current = &num_string[i*chunk_width..i*chunk_width+chunk_width];
+                        if current != previous {
+                            same = false;
+                            break;
+                        }
+                        previous = current;
+                    }
+                    if same {
+                        total2 += num;
+                        if chunks == 2 {
+                            total1 += num;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    (total1, total2)
+}
+
+// you can find the invalid IDs by looking for any ID which is made only of some sequence of digits repeated twice.
+// So, 55 (5 twice), 6464 (64 twice), and 123123 (123 twice) would all be invalid IDs.
+fn main() {
+    let start = Instant::now();
+
+    let mut file_contents: String = fs::read_to_string("../large.txt").unwrap();
+    file_contents.pop();// Remove \n
+    // Split it up
+    let pairs: Vec<Vec<&str>> = file_contents
+        .split(",")
+        .collect::<Vec<&str>>()
+        .iter()
+        .map(|s| s.split('-').collect())
+        .collect();
+    let file_read = start.elapsed();
+
+    let (total1, total2) = algorithm(&pairs);
+
+    // There's a lot of converting between int and string
+    let end = start.elapsed();
+    println!("part1: {total1}");
+    println!("part2: {total2}");
+    println!("Times:
+    File read:          {:.2?}
+    Loop:               {:.2?}
+    Avg time per pair:  {:.2?}
+    Total:              {:.4?}
+    ",
+    file_read,
+    end-file_read,
+    (end-file_read)/(100).try_into().unwrap(),
+    end);
+}

2025/3/danmax/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "danmax"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

2025/3/danmax/src/main.rs

@@ -0,0 +1,18 @@
+fn main() {
+    let raw = std::fs::read_to_string("../large.txt").unwrap();
+    let start = std::time::Instant::now();
+    let mut banks = raw.split('\n').collect::<Vec<&str>>();
+    banks.pop();
+    let mut sol = 0;
+    for bank in banks {
+        let batteries = bank.chars().map(|x| (x as u8) - 48).collect::<Vec<u8>>();
+        let mut combos = vec![];
+        for i in 0..batteries.len() - 1 {
+            let num = (batteries[i] * 10) + batteries[(i + 1)..batteries.len()].iter().max().unwrap();
+            combos.push(num);
+        }
+        sol += *combos.iter().max().unwrap() as u64;
+    }
+    let end = start.elapsed();
+    dbg!(sol, end);
+}

2025/3/deadvey/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "deadvey"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

2025/3/deadvey/src/main.rs

@@ -0,0 +1,94 @@
+use std::fs;
+use std::time::Instant;
+use std::ptr;
+
+fn algorithm(banks: &Vec<&str>) -> (u64, u64)
+{
+    let bank_length = banks[0].len();
+    let mut total1: u64 = 0;
+    let mut total2: u64 = 0;
+    for bank in banks {
+        let mut prev_index = 0;
+        let mut joltages: [u64; 12] = [0; 12];
+        let mut highest: u64 = 0;
+        let mut overall_index = 0;
+        // part 2
+        for i in 0..=11 {
+            for joltage in bank[prev_index..(bank_length-(11-i))].bytes() {
+                overall_index += 1;
+                if joltage as u64 > highest {
+                    prev_index = overall_index;
+                    unsafe {ptr::write(&mut highest as *mut u64, joltage as u64);}
+                    if joltage == 57 { break; }
+                }
+            }
+            overall_index = prev_index;
+            joltages[i] = highest ^ 48;
+            highest = 0;
+        }
+        total2 += joltages[0] * 10_u64.pow(11)
+            + joltages[1] * 10_u64.pow(10)
+            + joltages[2] * 10_u64.pow(9)
+            + joltages[3] * 10_u64.pow(8)
+            + joltages[4] * 10_u64.pow(7)
+            + joltages[5] * 10_u64.pow(6)
+            + joltages[6] * 10_u64.pow(5)
+            + joltages[7] * 10_u64.pow(4)
+            + joltages[8] * 10_u64.pow(3)
+            + joltages[9] * 10_u64.pow(2)
+            + joltages[10] * 10_u64
+            + joltages[11];
+        // part 1
+        prev_index = 0;
+        for i in 0..=10 {
+            if joltages[i] > highest.into() {
+                unsafe {ptr::write(&mut highest as *mut u64, joltages[i] as u64);}
+                prev_index = i+1;
+                if joltages[i] == 9 { break; }
+            }
+        }
+        total1 += highest * 10;
+        highest = 0;
+        for i in prev_index..=11 {
+            if joltages[i] > highest.into() {
+                unsafe {
+                    ptr::write(&mut highest as *mut u64, joltages[i] as u64);}
+                if joltages[i] == 9 { break; }
+            }
+        }
+        total1 += highest;
+    }
+
+    (total1, total2)
+}
+
+// 987654321111111 = 1 bank
+// 811111111111119
+// 234234234234278
+// 818181911112111
+fn main() {
+    let file_contents: String = fs::read_to_string("../large.txt").unwrap();
+    let start = Instant::now();
+
+    let mut banks: Vec<&str> = file_contents
+        .split('\n')
+        .collect::<Vec<&str>>();
+    banks.pop();
+    let preamble = start.elapsed();
+
+    let (total1, total2) = algorithm(&banks);
+    let end = start.elapsed();
+
+    println!("part1: {total1}");
+    println!("part2: {total2}");
+    println!("Times:
+    Preamble:           {:.2?}
+    Loop:               {:.2?}
+    Avg time per bank:  {:.2?}
+    Total:              {:.4?}
+    ",
+    preamble,
+    end-preamble,
+    (end-preamble)/(10000).try_into().unwrap(),
+    end);
+}

2025/4/deadvey/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "deadvey"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

2025/4/deadvey/src/main.rs

@@ -0,0 +1,124 @@
+use std::fs;
+use std::time::Instant;
+
+fn remove_dem(rows: &mut Vec<Vec<char>>, i: usize, j: usize) {
+    rows[i][j] = 'x';
+}
+
+fn algorithm(rows: &mut Vec<Vec<char>>) -> (u64, u64) {
+    let mut total1: u64 = 0;
+    let mut total2: u64 = 0;
+    let grid_width: usize = rows[0].len().try_into().unwrap();
+    let grid_height: usize = rows.len().try_into().unwrap();
+    let directions = vec![(-1,0),(1,0),(0,-1),(0,1),(-1,-1),(-1,1),(1,-1),(1,1)]; 
+    let mut removed: bool = true;
+    let mut count: u8 = 66;
+    // First loop
+    for i in 0usize..(grid_height) {
+        for j in 0usize..(grid_width) {
+            if rows[i][j] == '@' { // @
+                let mut surrounded_by = 0;
+                for (dr, dc) in &directions {
+                    let new_row = i as isize + dr;
+                    let new_column = j as isize + dc;
+                    if new_row >= grid_height as isize {
+                        continue
+                    }
+                    if new_row < 0 {
+                        continue
+                    }
+                    if new_column >= grid_width as isize {
+                        continue
+                    }
+                    if new_column < 0 {
+                        continue
+                    }
+                    if rows[new_row as usize][new_column as usize] == '@'
+                    || rows[new_row as usize][new_column as usize] == 'A'
+                    {
+                        surrounded_by += 1;
+                    }
+                    if surrounded_by >= 4 {
+                        break
+                    }
+                }
+                if surrounded_by < 4 {
+                    rows[i][j] = 'A';
+                    total2 += 1;
+                    total1 += 1;
+                    removed = true;
+                }
+            }
+        }
+    }
+    // All other loops
+    while removed {
+        removed = false;
+        for i in 0usize..(grid_height) {
+            for j in 0usize..(grid_width) {
+                if rows[i][j] == '@' { // @
+                    let mut surrounded_by = 0;
+                    for (dr, dc) in &directions {
+                        let new_row = i as isize + dr;
+                        let new_column = j as isize + dc;
+                        if new_row >= grid_height as isize {
+                            continue
+                        }
+                        if new_row < 0 {
+                            continue
+                        }
+                        if new_column >= grid_width as isize {
+                            continue
+                        }
+                        if new_column < 0 {
+                            continue
+                        }
+                        if rows[new_row as usize][new_column as usize] == '@'
+                        {
+                            surrounded_by += 1;
+                        }
+                        else if rows[new_row as usize][new_column as usize] == count as char
+                        {
+                            surrounded_by += 1;
+                        }
+                        if surrounded_by >= 4 { break }
+                    }
+                    if surrounded_by < 4 {
+                        rows[i][j] = count as char;
+                        total2 += 1;
+                        removed = true;
+                    }
+                }
+            }
+        }
+        count += 1;
+    }
+
+    (total1, total2)
+}
+fn main() {
+    let file_contents: String = fs::read_to_string("../large.txt").unwrap();
+    let start = Instant::now();
+    let mut grid: Vec<Vec<char>> = file_contents
+        .lines()
+        .map(|line| line.chars().collect())
+        .collect();
+    let preamble = start.elapsed();
+
+
+    let (total1, total2) = algorithm(&mut grid);
+    let end = start.elapsed();
+
+    println!("part1: {total1}");
+    println!("part2: {total2}");
+    println!("Times:
+    Preamble:           {:.2?}
+    Loop:               {:.2?}
+    Avg time per bank:  {:.2?}
+    Total:              {:.4?}
+    ",
+    preamble,
+    end-preamble,
+    (end-preamble)/(grid.len()).try_into().unwrap(),
+    end);
+}