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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
import adglent.{First, Second}
import gleam/bool
import gleam/dict.{type Dict}
import gleam/int
import gleam/io
import gleam/list
import gleam/option.{None, Some}
import gleam/result
import gleam/set.{type Set}
import gleam/string
type Card {
Card(number: Int, winners: Int)
}
fn numbers_to_set(str: String) -> Set(Int) {
str
|> string.split(" ")
|> list.map(int.parse)
|> result.values()
|> set.from_list()
}
fn parse_card(card: String) -> Card {
let assert Ok(#("Card" <> n_str, rest)) = string.split_once(card, ": ")
let assert Ok(#(winning_str, has_str)) = string.split_once(rest, " | ")
let assert Ok(n) = int.parse(string.trim(n_str))
let winning = numbers_to_set(winning_str)
let has = numbers_to_set(has_str)
let winners = set.size(set.intersection(winning, has))
Card(number: n, winners: winners)
}
fn win_points(n: Int) {
bool.guard(n < 2, n, fn() { 2 * win_points(n - 1) })
}
pub fn part1(input: String) {
use acc, c <- list.fold(string.split(input, "\n"), 0)
c
|> parse_card
|> fn(c: Card) { win_points(c.winners) }
|> int.add(acc)
}
fn win_more_cards(cards: List(String), count: Dict(Int, Int)) {
case cards {
[] ->
count
|> dict.values
|> int.sum
[raw_card, ..rest] -> {
let card = parse_card(raw_card)
case card.winners {
0 -> win_more_cards(rest, count)
n -> win_more_cards(rest, update_counts(n, card, count))
}
}
}
}
fn update_counts(n: Int, card: Card, count: Dict(Int, Int)) -> Dict(Int, Int) {
let assert Ok(bonus) = dict.get(count, card.number)
use acc, n <- list.fold(list.range(card.number + 1, card.number + n), count)
use c <- dict.update(acc, n)
case c {
Some(i) -> i + bonus
None -> panic as "won a card that doesn't exist in the card pile"
}
}
pub fn part2(input: String) {
let cards = string.split(input, "\n")
let count =
list.range(1, list.length(cards))
|> list.map(fn(n) { #(n, 1) })
|> dict.from_list()
win_more_cards(cards, count)
}
pub fn main() {
let assert Ok(part) = adglent.get_part()
let assert Ok(input) = adglent.get_input("4")
case part {
First ->
part1(input)
|> adglent.inspect
|> io.println
Second ->
part2(input)
|> adglent.inspect
|> io.println
}
}
|
