I had to give Uiua another go today. (run it here)

{"Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53"
 "Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19"
 "Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1"
 "Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83"
 "Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36"
 "Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11"}

LtoDec ← ∧(+ ×10:) :0
StoDec ← LtoDec▽≥0. ▽≤9. -@0

# Split on spaces, drop dross, parse ints
≡(⊜□≠0.⊐∵(StoDec)↘ 2⊜(□)≠@\s.⊔)

# Find matches
≡(/+/+⊠(⌕)⊃(⊔⊢↙ 1)(⊔⊢↙¯1))

# part 1
/+ⁿ:2-1 ▽±..

# part 2 - start with matches and initial counts
=..:
# len times: get 1st of each, rotate both, add new counts
⍥(⬚0+↯: ⊙⊙∩(↻1) ⊙:∩(⊢.))⧻.
/+⊙;

Rust

This one wasn’t too bad. The example for part 2 even tells you how to process everything by visiting each card once in order. Another option could be to recursively look at all won copies, but that’s probably much less efficient.

Nim

This one was pretty simple, just parse the numbers into sets and check the size of the intersection. Part 2 just made the scoring mechanism a little more complicated.

• Day 4, part 1
• Day 4, part 2

LANGUAGE: Nim

Welcome to the advent of parsing!
Took me a lot more time than it should (Please, don’t check prior commits 😅).

day_04.nim

Haskell

11:39 – I spent most of the time reading the scoring rules and (as usual) writing a parser…

import Control.Monad
import Data.Bifunctor
import Data.List

readCard :: String -> ([Int], [Int])
readCard =
  join bimap (map read) . second tail . break (== "|") . words . tail . dropWhile (/= ':')

countShared = length . uncurry intersect

part1 = sum . map ((\n -> if n > 0 then 2 ^ (n - 1) else 0) . countShared)

part2 = sum . foldr ((\n a -> 1 + sum (take n a) : a) . countShared) []

main = do
  input <- map readCard . lines <$> readFile "input04"
  print $ part1 input
  print $ part2 input

APL

I’m using this years’ AoC to learn (Dyalog) APL, so this is probably terrible code. I’m happy to receive pointers for improvement, particularly if there is a way to write the same logic with tacit functions or inner/outer products that I missed.

input←⊃⎕NGET'inputs/day4.txt'1
num_matches←'Card [ \d]+: ([ 0-9]+) \| ([ 0-9]+)'⎕S{≢↑∩/0~⍨¨{,⎕CSV⍠'Separator' ' '⊢⍵'S'3}¨⍵.(1↓Lengths↑¨Offsets↓¨⊂Block)} input
⎕←+/2*1-⍨0~⍨num_matches ⍝ part 1
⎕←+/{⍺←0 ⋄ ⍺=≢⍵:⍵ ⋄ (⍺+1)∇⍵ + (≢⍵)↑∊((⍺+1)⍴0)(num_matches[⍺]⍴⍵[⍺])((≢⍵)⍴0)}(≢num_matches)⍴1 ⍝ part 2

I enjoyed this one. It was a nice simple break after Days 1 and 3; the type of basic puzzle I expect from the first few days of Advent of Code. Pretty simple logic in this one, I don’t think I would change too much. I’m sure I’ll find a way to clean up how it’s written a bit, but I’m happy with this one today.

https://github.com/capitalpb/advent_of_code_2023/blob/main/src/solvers/day04.rs

struct Scratchcard {
    winning_numbers: HashSet,
    player_numbers: HashSet,
}

impl Scratchcard {
    fn from(input: &str) -> Scratchcard {
        let (_, numbers) = input.split_once(':').unwrap();
        let (winning_numbers, player_numbers) = numbers.split_once('|').unwrap();
        let winning_numbers = winning_numbers
            .split_ascii_whitespace()
            .filter_map(|number| number.parse::().ok())
            .collect::>();
        let player_numbers = player_numbers
            .split_ascii_whitespace()
            .filter_map(|number| number.parse::().ok())
            .collect::>();

        Scratchcard {
            winning_numbers,
            player_numbers,
        }
    }

    fn matches(&self) -> u32 {
        self.winning_numbers
            .intersection(&self.player_numbers)
            .count() as u32
    }
}

pub struct Day04;

impl Solver for Day04 {
    fn star_one(&self, input: &str) -> String {
        input
            .lines()
            .map(Scratchcard::from)
            .map(|card| {
                let matches = card.matches();
                if matches == 0 {
                    0
                } else {
                    2u32.pow(matches - 1)
                }
            })
            .sum::()
            .to_string()
    }

    fn star_two(&self, input: &str) -> String {
        let cards: Vec = input.lines().map(Scratchcard::from).collect();
        let mut card_counts = vec![1usize; cards.len()];

        for card_number in 0..cards.len() {
            let matches = cards[card_number].matches();

            if matches == 0 {
                continue;
            }

            for i in 1..=matches {
                card_counts[card_number + i as usize] += card_counts[card_number];
            }
        }

        card_counts.iter().sum::().to_string()
    }
}

Python

Questions and feedback welcome!

import collections
import re

from .solver import Solver

class Day04(Solver):
  def __init__(self):
    super().__init__(4)
    self.cards = []

  def presolve(self, input: str):
    lines = input.rstrip().split('\n')
    self.cards = []
    for line in lines:
      left, right = re.split(r' +\| +', re.split(': +', line)[1])
      left, right = map(int, re.split(' +', left)), map(int, re.split(' +', right))
      self.cards.append((list(left), list(right)))

  def solve_first_star(self):
    points = 0
    for winning, having in self.cards:
      matches = len(set(winning) & set(having))
      if not matches:
        continue
      points += 1 << (matches - 1)
    return points

  def solve_second_star(self):
    factors = collections.defaultdict(lambda: 1)
    count = 0
    for i, (winning, having) in enumerate(self.cards):
      count += factors[i]
      matches = len(set(winning) & set(having))
      if not matches:
        continue
      for j in range(i + 1, i + 1 + matches):
        factors[j] = factors[j] + factors[i]
    return count

Ruby

!ruby@programming.dev

Somehow took way longer on the second part than the first part trying a recursive approach and then realizing that was dumb.

https://github.com/snowe2010/advent-of-code/blob/master/ruby_aoc/2023/day04/day04.rb

(python) Much easier than day 3.

import pathlib

base_dir = pathlib.Path(__file__).parent
filename = base_dir / "day4_input.txt"

with open(base_dir / filename) as f:
    lines = f.read().splitlines()

score = 0

extra_cards = [0 for _ in lines]
n_cards = [1 for _ in lines]

for i, line in enumerate(lines):
    _, numbers = line.split(":")
    winning, have = numbers.split(" | ")

    winning_numbers = {int(n) for n in winning.split()}
    have_numbers = {int(n) for n in have.split()}

    have_winning_numbers = winning_numbers & have_numbers
    n_matches = len(have_winning_numbers)

    if n_matches:
        score += 2 ** (n_matches - 1)

    j = i + 1
    for _ in range(n_matches):
        if j >= len(lines):
            break
        n_cards[j] += n_cards[i]
        j += 1

answer_p1 = score
print(f"{answer_p1=}")

answer_p2 = sum(n_cards)
print(f"{answer_p2=}")

Python

Part 1: https://github.com/porotoman99/Advent-of-Code-2023/blob/main/Day 4/part1.py

Part 2: https://github.com/porotoman99/Advent-of-Code-2023/blob/main/Day 4/part2.py

I found out about this event for the first time yesterday and was able to get caught up in time for day 4.

Dart Solution

Okay, that’s more like it. Simple parsing and a bit of recursion, and fits on one screen. Perfect for day 4 :-)

int matchCount(String line) => line
    .split(RegExp('[:|]'))
    .skip(1)
    .map((ee) => ee.trim().split(RegExp(r'\s+')).map(int.parse))
    .map((e) => e.toSet())
    .reduce((s, t) => s.intersection(t))
    .length;

late List matches;
late List totals;

int scoreFor(int ix) {
  if (totals[ix] != 0) return totals[ix];
  return totals[ix] =
      [for (var m in 0.to(matches[ix])) scoreFor(m + ix + 1) + 1].sum;
}

part1(List lines) =>
    lines.map((e) => pow(2, matchCount(e) - 1).toInt()).sum;

part2(List lines) {
  matches = [for (var e in lines) matchCount(e)];
  totals = List.filled(matches.length, 0);
  return matches.length + 0.to(matches.length).map(scoreFor).sum;
}

Factor on github (with comments and imports):

: line>cards ( line -- winning-nums player-nums )
  ":|" split rest
  [
    [ CHAR: space = ] trim
    split-words harvest [ string>number ] map
  ] map first2
;

: points ( winning-nums player-nums -- n )
  intersect length
  dup 0 > [ 1 - 2^ ] when
;

: part1 ( -- )
  "vocab:aoc-2023/day04/input.txt" utf8 file-lines
  [ line>cards points ] map-sum .
;

: follow-card ( i commons -- n )
  [ 1 ] 2dip
  2dup nth swapd
  over + (a..b]
  [ over follow-card ] map-sum
  nip +
;

: part2 ( -- )
  "vocab:aoc-2023/day04/input.txt" utf8 file-lines
  [ line>cards intersect length ] map
  dup length <iota> swap '[ _ follow-card ]
  map-sum .
;

PHP

Today was the easiest day so far IMHO. Today, I coded in PHP, a horrible language that produces even worse code. (Ok, full confession, I fed my family for about half a decade on PHP. I seemed to have gotten stuck with it, and so I earned a PhD to escape it.)

Anyway, the only trouble I had was I forgot about the explode function’s capacity to return empty strings. Once I filtered those I had the correct answer on the first one, and then 10 minutes later I had the second part. I wrote my code true to raw php’s awful idioms, though I didn’t make it web based. I read from stdin.

My code is linked on github:

• https://github.com/pngwen/advent-2023/blob/main/day-4a.php
• https://github.com/pngwen/advent-2023/blob/main/day-4b.php

Language: Python

Github

Catching up missed days.