Today's task was easy for me, though as usual I had to relearn a few things after almost a year without coding, such as how to capture patterns with regular expressions.

I admit it would be a lot harder if one did the full parsing oneself, which on the other hand would be cool. It is a good excuse to relearn combinatorial parsing.

This is my code for today.

Task 1:

use regex::Regex;
use std::fs::read_to_string;

fn main() {
    let s = read_to_string("input.txt").unwrap();
    let re = Regex::new(r"mul\((\d+),(\d+)\)").unwrap();
    let prod: Vec<(u32, u32)>;
    prod = re
        .captures_iter(&s)
        .map(|caps| {
            let (_, [m1, m2]) = caps.extract();
            (m1.parse::<u32>().unwrap(), m2.parse::<u32>().unwrap())
        })
        .collect();
    let r = prod.iter().fold(0, |acc, (m1, m2)| acc + (m1 * m2));
    println!("{}", r);
}

And task 2, for which I was going to write a full regexp then went lazy and used the split method:

use regex::Regex;
use std::fs::read_to_string;

fn main() {
    let s = read_to_string("input.txt").unwrap();
    let re = Regex::new(r"mul\((\d+),(\d+)\)").unwrap();
    let mut prod: Vec<(u32, u32)> = Vec::new();
    let s = s.split("do()");
    for i in s {
        if let Some(i) = i.split("don't()").next() {
            prod.extend(
                re.captures_iter(i)
                    .map(|caps| {
                        let (_, [m1, m2]) = caps.extract();
                        (m1.parse::<u32>().unwrap(), m2.parse::<u32>().unwrap())
                    })
                    .collect::<Vec<(u32, u32)>>(),
            );
        }
    }
    let r = prod.iter().fold(0, |acc, (m1, m2)| acc + (m1 * m2));
    println!("{}", r);
}

#aoc24

Today's AoC was weird. I finished the first task fairly quickly, but got stuck on the second because I was trying an approach that should work in principle, but is fiddly to get right.

In the end I extracted the verification code out into a function and just progressively removed an element until it verifies, or the loop ends. I'll post both tasks here:

Task 1:

use std::fs::read_to_string;

fn main() {
    let mut numbers: Vec<Vec<i32>> = Vec::new();
    let f = read_to_string("input.txt").unwrap();
    let f = f.split('\n');
    for i in f {
        if i.is_empty() {
            break;
        }
        let v: Vec<i32> = i
            .split_whitespace()
            .map(|n| n.parse::<i32>().unwrap())
            .collect();
        numbers.push(v);
    }
    let mut safe = 0;
    'count: for i in numbers {
        let mut v = Vec::new();
        for j in 0..(i.len() - 1) {
            let diff = i[j] - i[j + 1];
            if (diff.abs() > 3) | (diff == 0) {
                continue 'count;
            }
            v.push(diff);
        }
        if v.iter().all(|n| *n > 0) | v.iter().all(|n| *n < 0) {
            safe += 1;
        }
    }
    println!("{}", safe);
}

And task 2:

use std::fs::read_to_string;

fn verify(v: &[i32]) -> bool {
    let mut d = Vec::new();
    for i in 0..(v.len() - 1) {
        let diff = v[i] - v[i + 1];
        if (diff == 0) | (diff.abs() > 3) {
            return false;
        }
        d.push(diff);
    }
    d.iter().all(|n| n.signum() == d[0].signum())
}

fn main() {
    let mut numbers: Vec<Vec<i32>> = Vec::new();
    let f = read_to_string("input.txt").unwrap();
    let f = f.split('\n');
    for i in f {
        if i.is_empty() {
            break;
        }
        let v: Vec<i32> = i
            .split_whitespace()
            .map(|n| n.parse::<i32>().unwrap())
            .collect();
        numbers.push(v);
    }
    let mut safe = 0;
    'numbers: for i in numbers {
        if verify(&i) {
            safe += 1;
            continue;
        }
        for j in 0..i.len() {
            let mut v = i.clone();
            v.remove(j);
            if verify(&v) {
                safe += 1;
                continue 'numbers;
            }
        }
    }
    println!("{}", safe);
}

I am noticing how rusty I am though. Too long without coding.

#aoc24

Now comes day 1, task 2.

use std::fs::read_to_string;

fn main() {
    let mut l1 = Vec::<u32>::new();
    let mut l2 = Vec::<u32>::new();
    let f = read_to_string("input.txt").unwrap();
    let f = f.split('\n');
    for i in f {
        if i.is_empty() {
            break;
        }
        let mut s = i.split_whitespace().map(|s| s.parse::<u32>().unwrap());
        l1.push(s.next().unwrap());
        l2.push(s.next().unwrap());
    }
    let mut similarity: u32 = 0;
    for i in l1.iter() {
        similarity += (l2.iter().filter(|n| *n == i).count() as u32) * i;
    }
    println!("{}", similarity);
}

Also pretty straightforward.

The problem is I didn't remember tons of rust, for example how to select a type for Vec::new() or how to do the type casting, so it took me a bit longer than I hoped.

But I still can code! Programmer forever!

#aoc24

Hi everyone.

Welcome to Advent of Code 2024.

first off, I'm going to be doing this for a bit, so if you find this annoying, feel free to filter #aoc24 which will always appear in these posts.

I'm using Rust, as usual.

I solved both tasks. Let's start with task 1:

use std::cmp::{max, min};
use std::fs::read_to_string;

fn main() {
    let mut l1 = Vec::<u32>::new();
    let mut l2 = Vec::<u32>::new();
    let f = read_to_string("input.txt").unwrap();
    let f = f.split('\n');
    for i in f {
        if i.is_empty() {
            break;
        }
        let mut s = i.split_whitespace().map(|s| s.parse::<u32>().unwrap());
        l1.push(s.next().unwrap());
        l2.push(s.next().unwrap());
    }
    l1.sort();
    l2.sort();
    let mut dist = 0;
    for i in 0..l1.len() {
        let n1 = l1[i];
        let n2 = l2[i];
        dist += max(n1, n2) - min(n1, n2);
    }
    println!("{}", dist);
}

Pretty straightforward, though I can already see some places that could be optimised, for example, n1 and n2 don't need to be used at all, and I could directly min and max the vector elements. Likewise, I could use a single comparison instead of both max and min, but I was lazy.