C

Surprise, O(n^12) solutions don’t scale! But then it was delightful when the realization hit that the solution is actually very simple to implement - just keep removing the first digit that is followed by a higher one.

static uint64_t joltage(char *s, int len, int target) {
	int i;

	for (; len > target; len--) {
		for (i=0; i<len-1 && s[i] >= s[i+1]; i++) ;
		memmove(s+i, s+i+1, len-i);
	}

	return strtoul(s, NULL, 10);
}

int main() {
	char buf[1024];
	uint64_t p1=0,p2=0;
	int len;

	while (fgets(buf, sizeof(buf), stdin)) {
		for (len=0; isdigit(buf[len]); len++) ;
		buf[len] = '\0';
		p2 += joltage(buf, len, 12);
		p1 += joltage(buf, 12, 2);
	}

	printf("03: %lu %lu\n", p1, p2);
}

Repo link

I’m still having to finish yesterday’s x86-16 assembly implementation, for which I had to write some support code to deal with large numbers as strings. That will come in useful today, too!

Nim

type
  AOCSolution[T,U] = tuple[part1: T, part2: U]

proc maxJoltage(bank: string, n: int): int =
  var index = 0
  for leftover in countDown(n-1, 0):
    var best = bank[index]
    for batteryInd in index+1 .. bank.high-leftover:
      let batt = bank[batteryInd]
      if batt > best: (best = batt; index = batteryInd)
      if best == '9': break # max for single battery
    result += (best.ord - '0'.ord) * 10^leftover
    inc index

proc solve(input: string): AOCSolution[int, int] =
  for line in input.splitLines:
    result.part1 += line.maxJoltage 2
    result.part2 += line.maxJoltage 12

Runtime: ~240 μs

Day 3 was very straightforward, although I did wrestle a bit with the indexing.
Honestly, I expected part 2 to require dynamic programming, but it turned out I only needed to tweak a few numbers in my part 1 code.

Full solution at Codeberg: solution.nim