An unofficial home for the advent of code community on programming.dev!
Advent of Code is an annual Advent calendar of small programming puzzles for a variety of skill sets and skill levels that can be solved in any programming language you like.
Solution Threads
| M | T | W | T | F | S | S |
|---|---|---|---|---|---|---|
| 1 | ||||||
| 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| 16 | 17 | 18 | 19 | 20 | 21 | 22 |
| 23 | 24 | 25 |
Icon base by Lorc under CC BY 3.0 with modifications to add a gradient
console.log('Hello World')
defmodule AdventOfCode.Solution.Year2024.Day03 do
def part1(input) do
Regex.scan(~r/mul\((?<l>\d+),(?<r>\d+)\)/, input, capture: ["l", "r"])
|> Stream.map(fn l -> Enum.reduce(l, 1, &(&2 * String.to_integer(&1))) end)
|> Enum.sum()
end
def part2(input) do
input |> String.replace(~r/don't\(\).*(do\(\)|$)/Us, "") |> part1
end
end
Just did some basic regex stuff.
Part 1 and 2
(defun p1-mult (str)
"pulls out numbers and multiplies them, assumes already filtered by size"
(let ((vals (ppcre:all-matches-as-strings "\\d+" str)))
(apply #'* (or (mapcar #'parse-integer vals) '(0)))))
(defun p1-process-line (line)
"look for mul, do the mul, and sum"
(let ((ptrn "mul\\(\\d?\\d?\\d,\\d?\\d?\\d\\)"))
(apply #'+ (mapcar #'p1-mult (ppcre:all-matches-as-strings ptrn line)))))
(defun run-p1 (file)
(let ((data (read-file file #'p1-process-line)))
(apply #'+ data)))
(defun p2-process-line (line)
"looks for mul, do, and don't"
(let ((ptrn "(mul\\(\\d?\\d?\\d,\\d?\\d?\\d\\))|(do\\(\\))|(don't\\(\\))"))
(ppcre:all-matches-as-strings ptrn line)))
(defun p2-filter (data)
"expects list containing the string tokens (mul, do, don't) from the file"
(let ((process t))
(loop for x in data
when (string= "don't()" x)
do (setf process nil)
when (string= "do()" x)
do (setf process t)
when process
sum (p1-mult x))))
(defun run-p2 (file)
(let ((data (read-file file #'p2-process-line)))
;; treat the input as one line to make processing the do's and don't's easier
(p2-filter (flatten data))))
No Zalgo here! I wasted a huge amount of time by not noticing that the second part's example input was different - my code worked fine but my test failed ๐คฆโโ๏ธ
pest.rs is lovely, although part two made my PEG a bit ugly.
part1 = { SOI ~ (mul_expr | junk)+ ~ EOI }
part2 = { (enabled | disabled)+ ~ EOI }
mul_expr = { "mul(" ~ number ~ "," ~ number ~ ")" }
number = { ASCII_DIGIT{1,3} }
junk = _{ ASCII }
on = _{ "do()" }
off = _{ "don't()" }
enabled = _{ (SOI | on) ~ (!(off) ~ (mul_expr | junk))+ }
disabled = _{ off ~ (!(on) ~ junk)+ }
use std::fs;
use color_eyre::eyre;
use pest::Parser;
use pest_derive::Parser;
#[derive(Parser)]
#[grammar = "memory.pest"]
pub struct MemoryParser;
fn parse(input: &str, rule: Rule) -> eyre::Result<usize> {
let sum = MemoryParser::parse(rule, input)?
.next()
.expect("input must be ASCII")
.into_inner()
.filter(|pair| pair.as_rule() == Rule::mul_expr)
.map(|pair| {
pair.into_inner()
.map(|num| num.as_str().parse::<usize>().unwrap())
.product::<usize>()
})
.sum();
Ok(sum)
}
fn part1(filepath: &str) -> eyre::Result<usize> {
let input = fs::read_to_string(filepath)?;
parse(&input, Rule::part1)
}
fn part2(filepath: &str) -> eyre::Result<usize> {
let input = fs::read_to_string(filepath)?;
parse(&input, Rule::part2)
}
fn main() -> eyre::Result<()> {
color_eyre::install()?;
let part1 = part1("d03/input.txt")?;
let part2 = part2("d03/input.txt")?;
println!("Part 1: {part1}\nPart 2: {part2}");
Ok(())
}
Solution
import { AdventOfCodeSolutionFunction } from "./solutions";
export const solution_3: AdventOfCodeSolutionFunction = (input) => {
const mul_regex = /mul\((\d+),(\d+)\)/g; // mul()
const do_regex = /do\(\)/g; // do()
const do_not_regex = /don\'t\(\)/g; // don't()
const doLength = "do()".length;
const doNotLength = "don't()".length;
let input_copy = "" + input;
let part_1 = 0;
let part_2 = 0;
let isEnabled = true;
while (true) {
const nextMul = input_copy.search(mul_regex);
const nextDo = input_copy.search(do_regex);
const nextDoNot = input_copy.search(do_not_regex);
let pointer = Number.POSITIVE_INFINITY;
// find the smallest while ignoring items that are not found
if (nextMul != -1)
pointer = Math.min(pointer, nextMul);
if (nextDo != -1)
pointer = Math.min(pointer, nextDo);
if (nextDoNot != -1)
pointer = Math.min(pointer, nextDoNot);
// no matches
if (pointer == Number.POSITIVE_INFINITY)
break
// handle found command
switch (pointer) {
case nextDo: {
pointer += doLength;
isEnabled = true;
break;
}
case nextDoNot: {
pointer += doNotLength;
isEnabled = false;
break;
}
case nextMul: {
const res = input_copy.matchAll(mul_regex).next().value;
if (!res) {
// this should never happen but here's an escape hatch
throw Error("regex result is undefined or null");
}
// add the length of the whole capture to the pointer
pointer += res[0].length;
// multiply capture groups
const comp = Number(res[1]) * Number(res[2]);
// part 1 sum
part_1 += comp;
// part 2 sum
if(isEnabled)
part_2 += comp;
break;
}
}
// shorten the start of the string
input_copy = input_copy.slice(pointer);
}
return {
part_1,
part_2,
};
}
This one was harder but still. I feel like I can improve it for sure :)