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

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=}")

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 .
;

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

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;
}

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.

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()
    }
}

Language: Python

Github

Catching up missed days.

Crystal

late because I had to skip two days of aoc. Fairly easy

input =  File.read("input.txt").lines

sum = 0
winnings = Array.new(input.size) {[1, 0]}
input.each_with_index do |line, i|
	card, values = line.split(":")
	nums = values.split("|").map(&.split.map(&.to_i))

	points = 0
	nums[1].each do |num|
		if nums[0].includes?(num)
			points = points == 0 ? 1 : points * 2
			winnings[i][1] += 1
	end    end
	sum += points
end
puts sum

winnings.each_with_index do |card, i|
	next if card[1] == 0
	(1..card[1]).each do |n|
		winnings[i+n][0] += card[0]
end    end
puts winnings.sum(&.[0])