Day 4: Scratchcards

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

typedef struct {
    uint8_t no;
    // the list is zero terminated, this assume input has no zero
    uint8_t winning[10];
    uint8_t have[25];
} card_t;

// Read a card_t. The caller is responsible for freeing card_t
// May return NULL if read fail
card_t* read_card() {
    int err;
    // calloc zero fill the output
    card_t* out = calloc(sizeof(card_t), 1);
    err = scanf("Card %u: ", &out->no);
    if (err != 1) {
        return NULL;
    }
    for (int i = 0; i < sizeof(out->winning); i++) {
        err = scanf("%d ", &out->winning[i]);
        if (err != 1) {
            break;
        }
    }
    scanf(" | ");
    for (int i = 0; i < sizeof(out->have); i++) {
        err = scanf("%d ", &out->have[i]);
        if (err != 1) {
            break;
        }
    }

    return out;
}

// Return number of winnings
int winnings(card_t* card) {
    int combo = 0;
    for (int i = 0; i < sizeof(card->have); i++) {
        int have = card->have[i];
        if (have == 0) {
            break;
        }
        for (int j = 0; j < sizeof(card->winning); j++) {
            int winning = card->winning[j];
            if (winning == 0) {
                break;
            }
            if (have == card->winning[j]) {
                combo++;
                break;
            }
        }
    }
    return combo;
}

int solve(card_t* card) {
    int out = winnings(card);
    if (out == 0) {
        return 0;
    }
    // 2^(n-1)
    return 1 << (out-1);
}

int main() {
    /*/
    // Part 1
    int worth_sum = 0;
    for (;;) {
        card_t* card = read_card();
        if (card == NULL) {
            break;
        }
        int worth = solve(card);
        worth_sum += worth;
        free(card);
    }
    printf("%d", worth_sum);
    /**/

    /**/
    // Part 2
#define MAX_GAMES 193
    card_t *games[MAX_GAMES] = {NULL};
    int cardCopies[MAX_GAMES] = {0};
    for(int i = 0; i < MAX_GAMES; i++) {
        games[i] = read_card();
        if(games[i] == NULL) {
            break;
        }
        cardCopies[i] = 1;
    }
    for(int i = 0; i < MAX_GAMES; i++) {
        if(games[i] == NULL) {
            break;
        }
        int winning = winnings(games[i]);
        while(winning > 0) {
            cardCopies[i + winning] += cardCopies[i];
            winning--;
        }
    }
    int totalCard = 0;
    for(int i = 0; i < MAX_GAMES; i++) {
        totalCard += cardCopies[i];
    }
    printf("%d\n", totalCard);
    /**/

    return 0;
}

I thought parsing would be complicated, but turns out scanf works pretty well since the problem has fixed input size (although different between example and real inputs). Initially the winnings and solve function was the same function, but I had to refactor that to reuse it for part 2.

Two tricks in my code:

• /*/ ... /**/ is a good way to make commented out block of code. Just add another * to make the first block /**/ to uncomment the entire block.
• 1<<n is the same as 2^n

# Advent of Code 2023
# Day 4: Scratchcards

point_sum = 0
copy_amounts = {}

with open("inputs/day_4.txt") as file:
    for i, line in enumerate(file):
        halves = line.split(": ")[1].split("|")
        winning_nums = [int(num) for num in halves[0].split()]

        points = 0
        winning_amount = 0

        for num in [int(num) for num in halves[1].split()]:
            if num in winning_nums:
                if points == 0:
                    points = 1
                else:
                    points *= 2

                winning_amount += 1

        point_sum += points
        copy_amounts[i] = winning_amount

print(f"Part 1: {point_sum}")

amounts = {card: 1 for card in copy_amounts}

for card in amounts:
    for i in range(copy_amounts[card]):
        amounts[card + i + 1] += amounts[card]

print(f"Part 2: {sum(amounts.values())}")

#!/usr/bin/env pypy3

total = 0
for line in open(0):
    winning, mine = (set(map(int, part)) for part in
                     map(str.split, line.strip().split(':')[1].split('|')))
    nmatches = len(winning & mine)
    total += int(2 ** (nmatches - 1))

print(total)

#!/usr/bin/env pypy3

from collections import defaultdict

copies = defaultdict(lambda: 1)
for i, line in enumerate(open(0), start=1):
    copies[i]   # defaultdict hack
    winning, mine = (set(map(int, part)) for part in
                     map(str.split, line.strip().split(':')[1].split('|')))
    nmatches = len(winning & mine)
    for j in range(i + 1, i + nmatches + 1):
        copies[j] += copies[i]

print(sum(copies.values()))

=ARRAYFORMULA(
  SUM(
   MAP(
    A:A,
    LAMBDA(
     x,
     LET(
      d,SPLIT(
         TOCOL(
          SPLIT(
           REGEXEXTRACT(x,": (.*)"),
           "|"),
          3),
         " "),
      t,SUM(COUNTIF(INDEX(d,2),INDEX(d,1)))-1,
      IF(t=-1,0,2^t))))))

import kotlin.math.pow

object Day4 {
    data class Card(val id: Int, val winners: Set<Int>, val havers: Set<Int>)

    private fun parse(line: String) = let {
        fun numsOf(s: String) = Regex("""\d+""").findAll(s).map { it.value.toInt() }.toSet()
        fun idOf(s: String) = Regex("""\d+""").find(s)!!.value.toInt()
        line.split(":").let {
            val (winners0, havers0) = it[1].split("|")
            Card(idOf(it[0]), numsOf(winners0), numsOf(havers0))
        }
    }

    fun part1(lines: List<String>) = lines.sumOf { line ->
        val (_, winners, havers) = parse(line)
        val inter = winners.intersect(havers)
        if (inter.isNotEmpty()) 2.0.pow(inter.size - 1).toInt() else 0
    }

    fun part2(lines: List<String>) = let {
        val cards = lines.map { parse(it) }
        val counts = Array<Int>(cards.size + 1) { if (it == 0) 0 else 1 }
        cards.forEach { (id, winners, havers) ->
            ((id + 1)..(id + winners.intersect(havers).size)).forEach { counts[it] += counts[id] }
        }
        counts.sum()
    }

    val input = javaClass.getResourceAsStream("${javaClass.name}.txt")!!.reader().readLines()
}

fun main() {
    with(Day4) {
        println(part1(input))
        println(part2(input))
    }
}

fn main() {
    println!("Part 1: {}", part1(include_str!("../input.txt")));
    println!("Part 2: {}", part2(include_str!("../input.txt")));
}

#[derive(Debug)]
struct Card {
    id: usize,
    winning_numbers: Vec<usize>,
    numbers_you_have: Vec<usize>,
}

impl Card {
    fn num_matches(&self) -> usize {
        let mut count = 0;

        for number in self.numbers_you_have.iter() {
            if self.winning_numbers.contains(number) {
                count += 1;
            }
        }

        count
    }

    fn score(&self) -> usize {
        let count = self.num_matches();

        if count == 0 {
            return 0;
        }

        2usize.pow((count - 1) as u32)
    }
}

impl From<&str> for Card {
    fn from(value: &str) -> Self {
        let split = value.split(": ").collect::<Vec<_>>();
        let id = split[0]
            .split(' ')
            .last()
            .unwrap()
            .parse::<usize>()
            .unwrap();
        let numbers = split[1].split(" | ").collect::<Vec<_>>();

        let winning_numbers = numbers[0]
            .trim()
            .split(' ')
            .filter(|n| !n.is_empty())
            .map(|n| n.parse::<usize>().unwrap())
            .collect::<Vec<_>>();

        let numbers_you_have = numbers[1]
            .trim()
            .split(' ')
            .filter(|n| !n.is_empty())
            .map(|n| n.parse::<usize>().unwrap())
            .collect::<Vec<_>>();

        Card {
            id,
            winning_numbers,
            numbers_you_have,
        }
    }
}

fn parse_cards(input: &str) -> Vec<Card> {
    input.lines().map(Card::from).collect()
}

fn part1(input: &str) -> usize {
    parse_cards(input).iter().map(|card| card.score()).sum()
}

fn part2(input: &str) -> usize {
    let cards = parse_cards(input);
    let mut count = 0;

    let num_matches = cards
        .iter()
        .map(|card| card.num_matches())
        .collect::<Vec<_>>();

    let mut num_copies = vec![1; cards.len()];

    for i in 0..cards.len() {
        count += num_copies[i];

        if num_matches[i] == 0 {
            continue;
        }

        for j in (i + 1)..=(i + num_matches[i]) {
            num_copies[j] += num_copies[i];
        }
    }

    count
}

I did this in the most naive way I could think of, so it's kind of slow at 35ms for both parts. A set data structure would probably be much faster for finding the winning numbers, but it's fast enough, so I won't bother optimizing it right now.

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;
use std::collections::{HashSet,HashMap};

extern crate regex;
use regex::Regex;

struct Card {
    id: usize,
    winning: HashSet<usize>,
    my_numbers: HashSet<usize>,
}
impl From<&String> for Card {
    fn from(s: &String) -> Self {
        let re = Regex::new(r"Card[\s]+(\d+): ([\d\s]+) \| ([\d\s]+)").unwrap();
        let matches = re.captures(&s).unwrap();
        Self {
            id:         matches[1].parse().unwrap(),
            winning:    matches[2].split_whitespace().map(|x| x.parse::<usize>().unwrap()).collect(),
            my_numbers: matches[3].split_whitespace().map(|x| x.parse::<usize>().unwrap()).collect(),
        }
    }
}
impl Card {
    pub fn matching_numbers(&self) -> usize {
        self.winning.iter().filter(|n| self.my_numbers.contains(n)).count()
    }
    pub fn score(&self) -> usize {
        let common = self.matching_numbers() as u32;
        if common == 0 { 0 } else { usize::pow(2,common-1) }
    }
}

fn solve(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };
    let cards: Vec<_> = input.iter().map(Card::from).collect();

    // Part 1
    let part1: usize = cards.iter().map(|c| c.score()).sum();
    println!("Part 1: {part1}"); // 27454

    // Part 2
    let mut my_cards: HashMap<usize,usize> = HashMap::new();
    for card_id in 1..=cards.len() {
        my_cards.insert(card_id,1);
    }
    for card in cards {
        let count = *my_cards.get(&card.id).unwrap();
        for x in 1..=card.matching_numbers() {
            *my_cards.entry(&card.id+x).or_insert(0) += count;
        }
    }
    let part2: usize = my_cards.iter().map(|(_,v)| v).sum();
    println!("Part 2: {part2}"); // 6857330

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}

I think the thing I had the most trouble with on this one was naming, honestly.
Part 2 seemed like it would be a challenge, but turned out to be quite straightforward once I came up with sensible—if a bit verbose—labels for the two variables that describe each card: {self_copy_count, child_copy_count}.

It was nice that you could get away with not parsing any numbers for this one. It works fine just by comparing the numeric strings.
You don't even need to use the card IDs!

defmodule AdventOfCode.Solution.Year2023.Day04 do
  def part1(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&parse_card/1)
    |> Enum.map(&score_card/1)
    |> Enum.sum()
  end

  def part2(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.map(&parse_card/1)
    |> count_cards()
  end

  defp score_card({_, 0}), do: 0
  defp score_card({_, n}), do: Integer.pow(2, n - 1)

  defp count_cards(cards, acc \\ 0)
  defp count_cards([], acc), do: acc

  defp count_cards([{self_copy_count, 0} | children], acc) do
    count_cards(children, acc + self_copy_count)
  end

  defp count_cards([{self_copy_count, child_copy_count} | children], acc) do
    {children_to_copy, unchanged} = Enum.split(children, child_copy_count)

    new_children =
      for {sub_self_copy_count, sub_child_copy_count} <- children_to_copy do
        {sub_self_copy_count + self_copy_count, sub_child_copy_count}
      end

    count_cards(new_children ++ unchanged, acc + self_copy_count)
  end

  defp parse_card(line) do
    [_card_number, contents] = String.split(line, ": ")

    [winners_str, hand_str] = String.split(contents, " | ")
    winners = MapSet.new(String.split(winners_str))
    hand = MapSet.new(String.split(hand_str))

    {1, MapSet.size(MapSet.intersection(winners, hand))}
  end
end

def parse_card(line)
  id = line.match(/Card\s+(\d+):.+/)[1].to_i
  numbers = line.split(":")[1].split("|").map { |s| s.split(" ").map(&:to_i) }
  {id: id,
   winning: numbers.first,
   have: numbers.last}
end

def score_card(card)
  matches = card[:winning].filter { |n| card[:have].include?(n) }
  return 0 if matches.empty?
  matches[1..].reduce(1) { |score, n| score * 2 }
end

def compute_p1(input)
  input
    .lines
    .map { |l| parse_card(l) }
    .map { |c| score_card(c) }
    .sum
end

def card_matches(card)
  card[:winning].filter { |n| card[:have].include?(n) }
end

def compute_p2(input)
  cards = input
            .lines
            .map { |l| parse_card(l) }
  copies_table = {}
  cards.each { |c| copies_table[c[:id]]=1 }
  cards.each_with_index do |card,idx|
    copies_table[idx+1].times do
      matches = card_matches(card).count
      1.upto(matches) do |i|
        copies_table[idx+i+1] += 1
      end
    end
  end
  copies_table.values.sum
end

#!/usr/bin/awk -f
{
	sub(/Card[ ]*[0-9]*: /, "")
	split($0, card, "|")
	card[2] = card[2] " "
	$0 = card[1]
	num = 0

	for (i = 1; i <= NF; ++i)
		if (match(card[2], "[^0-9]+" $i "[^0-9]+"))
			num = num ? num * 2 : 1

	total += num
}

END { print total }

Due to past experience from Lanternfish and other exponential problems in the past, I decided to simply save their multipliers in a table instead of making actual copies of the cards.

#!/usr/bin/awk -f
{
	mult[NR] += 1
	sub(/Card[ ]*[0-9]*: /, "")
	split($0, card, "|")
	card[2] = card[2] " "
	$0 = card[1]
	num = 0

	for (i = 1; i <= NF; ++i)
		if (match(card[2], "[^0-9]+" $i "[^0-9]+"))
			++num

	for (i = 1; i <= num; ++i)
		mult[NR + i] += 1 * mult[NR]

	total += mult[NR]
}

END { print total }

useful corner of the stdlib I learned today: strings.Fields acts like strings.Split but automatically handles repeated whitespace for you.

package day04

import (
    "fmt"
    "math"
    "strconv"
    "strings"

    "github.com/dlclark/regexp2"
    "github.com/spf13/cobra"

    "spit-evil-olive.tips/aoc2023/common"
)

type Card struct {
    ID      int
    Winners map[int]bool
    Choices map[int]bool
}

var cardRegex = regexp2.MustCompile(`Card +(?<id>\d+): (?<winners>[\d +]+) \| (?<choices>[\d ]+)`, regexp2.None)

func parseNumbersToMap(s string) (map[int]bool, error) {
	m := make(map[int]bool)

	for _, strNumber := range strings.Fields(s) {
		number, err := strconv.Atoi(strNumber)
		if err != nil {
			return m, fmt.Errorf("failed to parse '%s'", strNumber)
		}
		m[number] = true
	}
	
	return m, nil
}

func parseInput(path string) ([]Card, error) {
    var cards []Card

    lines, err := common.ReadFileLines(path)
    if err != nil {
        return cards, err
    }

    for _, line := range lines {
        match, err := cardRegex.FindStringMatch(line)
        if err != nil {
            return cards, fmt.Errorf("failed to parse '%s': %w", line, err)
        }

        if match == nil {
            return cards, fmt.Errorf("failed to parse '%s'", line)
        }

        var card Card

        id := match.GroupByName("id").String()
        card.ID, err = strconv.Atoi(id)
        if err != nil {
            return cards, fmt.Errorf("failed to parse %s: %w", line, err)
        }

        card.Winners, err = parseNumbersToMap(match.GroupByName("winners").String())
        if err != nil {
            return cards, fmt.Errorf("failed to parse %s: %w", line, err)
        }

        card.Choices, err = parseNumbersToMap(match.GroupByName("choices").String())
        if err != nil {
            return cards, fmt.Errorf("failed to parse %s: %w", line, err)
        }

        cards = append(cards, card)
    }

    return cards, nil
}

func (c Card) Value() int {
    matches := 0

    for winner, _ := range c.Winners {
        if _, ok := c.Choices[winner]; ok {
            matches += 1
        }
    }

    if matches == 0 {
        return 0
    } else {
        return int(math.Pow(2.0, float64(matches-1)))
    }
}

var CommandA = &cobra.Command{
    Use:  "04a",
    Args: cobra.ExactArgs(1),
    RunE: func(cmd *cobra.Command, args []string) error {
        cards, err := parseInput(args[0])
        if err != nil {
            return err
        }

        sum := 0
        
        for _, card := range cards {
            sum += card.Value()
        }

        fmt.Printf("%v\n", sum)

        return nil
    },
}

I refactored my Value() function to allow MatchCount() as well:

--- day04a.go   2023-12-03 21:54:42.345171158 -0800
+++ day04b.go   2023-12-03 21:55:01.321394030 -0800
@@ -75,19 +75,24 @@
        return cards, nil
 }

-func (c Card) Value() int {
-       matches := 0
+func (c Card) MatchCount() int {
+       count := 0

        for winner, _ := range c.winners {
                if _, ok := c.choices[winner]; ok {
-                       matches += 1
+                       count += 1
                }
        }

-       if matches == 0 {
+       return count
+}
+
+func (c Card) Value() int {
+       count := c.MatchCount()
+       if count == 0 {
                return 0
        } else {
-               return int(math.Pow(2.0, float64(matches-1)))
+               return int(math.Pow(2.0, float64(count-1)))
        }
 }

and then it's pretty simple to keep track of card counts:

var CommandB = &cobra.Command{
    Use:  "04b",
    Args: cobra.ExactArgs(1),
    RunE: func(cmd *cobra.Command, args []string) error {
        cards, err := parseInput(args[0])
        if err != nil {
            return err
        }

        cardCounts := make(map[int]int)

        for _, card := range cards {
            cardCounts[card.ID] += 1
            count := cardCounts[card.ID]

            for i := 1; i <= card.MatchCount(); i++ {
                cardCounts[card.ID+i] += count
            }
        }

        totalCount := 0
        for _, count := range cardCounts {
            totalCount += count
        }

        fmt.Printf("%v\n", totalCount)

        return nil
    },
}

$ time ./aoc2023 04a day04/04.txt > /dev/null

________________________________________________________
Executed in    3.65 millis    fish           external
   usr time    1.75 millis  306.00 micros    1.44 millis
   sys time    2.30 millis  138.00 micros    2.16 millis

> time ./aoc2023 04b day04/04.txt > /dev/null

________________________________________________________
Executed in    3.81 millis    fish           external
   usr time    0.71 millis  233.00 micros    0.47 millis
   sys time    3.90 millis  109.00 micros    3.79 millis

data Card = Card {
    cardNumber :: Int,
    winningNums :: [Int],
    yourNums :: [Int]
} deriving (Show)

parseCard :: String -> Card
parseCard s = Card cardNum winning your where
    cardNum = read $ take 4 $ drop 4 s
    winning = map read $ drop 2 $ words (takeWhile (/='|') s)
    your = map read (tail (words $ dropWhile (/='|') s))

scoreCard :: Card -> Int
scoreCard (Card _ winning yours) = length (filter (`elem` winning) yours)

solve1 :: [String] -> Int
solve1 input = sum $ map (points . scoreCard . parseCard) input where
    points n = if n == 0 then 0 else 2 ^ (n - 1)

solve2 :: [String] -> Int
solve2 input = score (map (scoreCard . parseCard) input) [1,1..] 0 where
    score [] _ acc = acc
    score (x:xs) (c:count) acc = score xs count' acc' where
        acc' = acc + c
        count' = map (+c) (take x count) ++ drop x count

Sets really came in handy for this challenge, as did recognizing that you can use powers of two to compute the points for each card. I tried using a regular expression to parse each card, but ended up just doing it manually with split :|

Numbers = set[int]
Card    = list[Numbers]

def read_cards(stream=sys.stdin) -> Iterator[Card]:
    for line in stream:
        yield [set(map(int, n.split())) for n in line.split(':')[-1].split('|')]

def main(stream=sys.stdin) -> None:
    cards  = [numbers & winning for winning, numbers in read_cards(stream)]
    points = sum(2**(len(card)-1) for card in cards if card)
    print(points)

This took me longer than I wished... I had to think about it carefully before seeing how you can just keep track of the counts of each card, and then when you get to that card, you add to its copies your current count.

def main(stream=sys.stdin) -> None:
    cards  = [numbers & winning for winning, numbers in read_cards(stream)]
    counts = defaultdict(int)

    for index, card in enumerate(cards, 1):
        counts[index] += 1
        for copy in range(index + 1, index + len(card) + 1):
            counts[copy] += counts[index]

    print(sum(counts.values()))

use regex::Regex;
use std::collections::{HashSet, VecDeque};

#[aoc(day4, part1)]
fn part1(input: &str) -> usize {
    let number_re = Regex::new("([0-9]+)").unwrap();
    input
        .lines()
        .map(|line| {
            let (_card, matches) = number_re
                .captures_iter(line)
                .skip(1)
                .map(|c| c.get(1).unwrap().as_str())
                .enumerate()
                .fold((HashSet::new(), 0), |(mut card, mut matches), (i, n)| {
                    if i < 10 {
                        card.insert(n);
                    } else if card.contains(n) {
                        matches += 1;
                    }
                    (card, matches)
                });

            if matches == 0 {
                0
            } else {
                2usize.pow(matches - 1)
            }
        })
        .sum()
}

#[aoc(day4, part2)]
fn part2(input: &str) -> usize {
    let number_re = Regex::new("([0-9]+)").unwrap();
    let card_matches: Vec<usize> = input
        .lines()
        .map(|line| {
            let (_card, matches) = number_re
                .captures_iter(line)
                .skip(1)
                .map(|c| c.get(1).unwrap().as_str())
                .enumerate()
                .fold((HashSet::new(), 0), |(mut card, mut matches), (i, n)| {
                    if i < 10 {
                        card.insert(n);
                    } else if card.contains(n) {
                        matches += 1;
                    }
                    (card, matches)
                });
            matches
        })
        .collect();

    let mut processing_cards = VecDeque::new();

    for (i, _) in card_matches.iter().enumerate() {
        processing_cards.push_back(i);
    }

    let mut total_cards = 0;
    while !processing_cards.is_empty() {
        let card_i = processing_cards.pop_front().unwrap();
        let matches = card_matches[card_i];
        for i in 0..matches {
            processing_cards.push_back(card_i + i + 1);
        }
        total_cards += 1;
    }

    total_cards
}

julia> input = readlines("Downloads/input");

julia> a = 0;

julia> for card in input
           data = split(card, ": ")[2]
           win, my = split.(split(data, " | "))
           value = 0
           for number in my
               if number ∈ win
                   if value == 0
                       value = 1
                   else
                       value *= 2
                   end
               end
           end
           a += value
       end

julia> a
20667

julia> counts = Dict(i => 1 for i in 1:length(input));

julia> for (i, card) in enumerate(input)
           data = split(card, ": ")[2]
           win, my = split.(split(data, " | "))
           value = 0
           for number in my
               if number ∈ win
                   value += 1
               end
           end
           if value > 0
               for cn in i+1:i+value
                   counts[cn] += counts[i]
               end
           end
       end

julia> counts |> values |> sum
5833065

package com.michaeleisemann.aoc23.services;

import com.michaeleisemann.aoc23.interfaces.DayInterface;
import org.springframework.stereotype.Service;

import java.util.*;

// https://adventofcode.com/2023/day/4
@Service
public class Day4Service implements DayInterface {

    private class Card {
        private record Numbers (List<Integer> numbers) {
            public Numbers(String numbers) {
                // there can be more than one space between numbers
                this(Arrays.stream(numbers.split("\\s+")).map(Integer::parseInt).toList());
            }
        }

        private final int id;

        private final Numbers winningNumbers;
        private final Numbers actualNumbers;

        public Card(int id, String winningNumbers, String actualNumbers) {
            this.id = id;
            this.winningNumbers = new Numbers(winningNumbers);
            this.actualNumbers = new Numbers(actualNumbers);
        }

        public int getId() {
            return id;
        }

        public Numbers getWinningNumbers() {
            return winningNumbers;
        }

        public Numbers getActualNumbers() {
            return actualNumbers;
        }

        /**
         * Find which actual numbers are in the winning numbers
         * @return
         */
        public List<Integer> getMatchingNumbers() {
            List<Integer> matchingNumbers = new ArrayList<>();
            for (Integer actualNumber : actualNumbers.numbers) {
                if (winningNumbers.numbers.contains(actualNumber)) {
                    matchingNumbers.add(actualNumber);
                }
            }
            return matchingNumbers;
        }

        @Override
        public String toString() {
            return "Card{" +
                    "id=" + id +
                    ", winningNumbers=" + winningNumbers +
                    ", actualNumbers=" + actualNumbers +
                    '}';
        }

    }


    public String part1(String puzzleInput) {
        List<Card> cards = parsePuzzleInput(puzzleInput);
        int total = 0;
        for (Card card : cards) {
            List<Integer> matchingNumbers = card.getMatchingNumbers();
            if (matchingNumbers.isEmpty()) {
                continue;
            }
            /* The first match makes the card worth one point and each match after the first doubles the point value of that card. */
            int points = 1;
            for (int i = 1; i < matchingNumbers.size(); i++) {
                points *= 2;
            }
            total += points;

        }
        return String.valueOf(total);
    }

    public String part2(String puzzleInput) {
        List<Card> cards = parsePuzzleInput(puzzleInput);
        HashMap<Integer, Integer> cardCopies = new HashMap<>();

        // Add all the cardIds to the map with a value of 1 (base)
        for (Card card : cards) {
            cardCopies.put(card.getId(), 1);
        }

        for (int i = 0; i < cards.size(); i++) {
            Card card = cards.get(i);
            int copies = cardCopies.get(card.getId());
            int newCards = card.getMatchingNumbers().size();
            for (int j = 1; j <= newCards && i + j < cards.size(); j++) {
                cardCopies.put(cards.get(i + j).getId(), cardCopies.getOrDefault(cards.get(i + j).getId(), 0) + copies);
            }
        }

        int totalCards = cardCopies.values().stream().mapToInt(Integer::intValue).sum();
        return String.valueOf(totalCards);
    }


    private List<Card> parsePuzzleInput(String puzzleInput) {
        List<Card> cards = new ArrayList<>();
        for (String line : puzzleInput.split("\n")) {
            // Split on the first colon
            String[] parts = line.split(":", 2);
            String id = parts[0].replaceAll("\\D+", "");
            String[] numbers = parts[1].split("\\|");
            cards.add(new Card(Integer.parseInt(id), numbers[0].trim(), numbers[1].trim()));
        }
        return cards;
    }

    private Card findCardById(List<Card> cards, int id) {
        for (Card card : cards) {
            if (card.getId() == id) {
                return card;
            }
        }
        return null;
    }
}

#[derive(Debug)]
struct Card {
    winners: usize,
}

impl Card {
    fn num_winners(&self) -> usize {
        self.winners
    }

    fn score(&self) -> u32 {
        1 << self.winners >> 1
    }
}

impl TryFrom<&str> for Card {
    type Error = Box<dyn std::error::Error>;
    fn try_from(value: &str) -> Result<Self> {
        type Res<T> = std::result::Result<Vec<T>, std::num::ParseIntError>;

        let (_, data) = value.split_once(':').ok_or("Line is missing card id")?;
        let (cards, have) = data.split_once('|').ok_or("Line is missing '|'")?;
        let cards: Vec<_> = cards
            .trim()
            .split(' ')
            .filter(|s| s.len() > 0)
            .map(|n| n.trim().parse::<u32>())
            .collect::<Res<_>>()?;
        let winners = have
            .trim()
            .split(' ')
            .filter(|s| s.len() > 0)
            .map(|n| n.trim().parse::<u32>().map(|val| cards.iter().find(|v| **v == val)))
            .try_fold(0, |acc, x| x.map(|opt| acc + opt.map(|_| 1).unwrap_or(0)))?;
        Ok(Card { winners })
    }
}

fn first() -> Result<String> {
    let summed_scores = load_input(4)?
        .lines()
        .map(Card::try_from)
        .try_fold(0, |acc, x| x.map(|card| acc + card.score()))?
        .to_string();
    Ok(summed_scores)
}

fn second() -> Result<String> {
    let cards = load_input(4)?
        .lines()
        .map(Card::try_from)
        .collect::<Result<Vec<Card>>>()?;
    let num_cards = cards.len();
    let mut copies = vec![1; num_cards];
    for (idx, card) in cards.iter().enumerate() {
        let curr_count = copies[idx];
        let num_to_boost = card.num_winners();
        for i in (idx + 1)..=(std::cmp::min(idx + num_to_boost, num_cards)) {
            copies[i] += curr_count;
        }
    }
    let total_copies = copies.iter().sum::<u32>().to_string();
    Ok(total_copies)
}

with open("input.txt", 'r', encoding="utf-8") as file:
    data = file.read().strip().split('\n')

data = [x.split(':') for x in data]
data = [x[1].split('|') for x in data]
data = [[x[0].split(), x[1].split()] for x in data]


def p1(x):
    points = 0
    for card in x:
        matches = 0 # Number of matches on this card
        for i in card[0]:
            if i in card[1]:
                matches += 1
        points += 2**(matches-1) if matches > 0 else 0
    return points

def p2(x):
    scratchies = list(range(1,202)) # We initially have one copy of each card 1-201
    current_card = 0
    for card in x:
        current_card += 1
        current_card_copies = scratchies.count(current_card) # Number of total copies of current card
        matches = 0 # Matches on this card
        for i in card[0]:
            if i in card[1]:
                matches += 1
        for j in list(range(1, matches + 1)):
            # We need to append [current_card+j] once per copy of the current card
            scratchies.extend([current_card + j] * current_card_copies)
    return len(scratchies)

print(f"{p1(data)}\n{p2(data)}")

from collections import Counter # pylint: disable=C0415

with open("input.txt", 'r', encoding="utf-8") as file:
    data = file.read().strip().split('\n')
data = [x.split(':') for x in data]
data = [x[1].split('|') for x in data]
data = [[x[0].split(), x[1].split()] for x in data]

points = 0
for card in data:
    matches = 0 # Number of matches on this card (reset to 0 each loop)
    matches = sum(1 for i in card[0] if i in card[1]) # Add 1 to matches for each # in card[0] if it's in card[1]
    points += 2**(matches-1) if matches > 0 else 0 # Add 2^(# of matches -1) points (assuming there are any matches)

scratchies = Counter(range(1,202)) # We initially have one copy of each card 1-201
current_card = 0
total_scratchies = 0
for card in data:
    current_card += 1 # Move to the next card number
    current_copies = scratchies[current_card] # Number of total copies of current card
    matches = 0 # Matches on this card
    matches = sum(1 for i in card[0] if i in card[1]) # Add 1 to matches for each # in card[0] if it's in card[1]
    for j in range(1, matches + 1): # Add claimed card numbers to the list of cards once for each copy of the current card
        scratchies[current_card + j] += current_copies
    total_scratchies += scratchies[current_card]

print(f"Part 1: {points}\nPart 2: {total_scratchies}")