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
99
100
101
102
103
104
105
106
107
108
109
110
111
|
import gleam/io
import gleam/list
import gleam/bool
import gleam/string as str
import gleam/dict.{type Dict}
import ext/listx
import ext/resultx as resx
import util/input_util
import util/parser as p
type Rule {
Literal(String)
Reference(List(List(Int)))
}
type Ruleset =
Dict(Int, Rule)
fn parse_input(input: String) -> #(Ruleset, List(String)) {
let rule_parser =
p.int()
|> p.skip(p.literal(": "))
|> p.then(
p.literal("\"")
|> p.proceed(with: p.any_gc())
|> p.skip(p.literal("\""))
|> p.map(with: Literal)
|> p.or(
otherwise: p.int()
|> p.sep1(by: p.literal(" "))
|> p.sep1(by: p.literal(" | "))
|> p.map(with: Reference),
),
)
|> p.labeled(with: "rule")
let input_parser =
rule_parser
|> p.sep1(by: p.nl())
|> p.map(with: dict.from_list)
|> p.skip(p.nlnl())
|> p.then(
p.str1_until_ws()
|> p.sep1(by: p.nl()),
)
|> p.skip_ws()
input
|> p.parse_entire(with: input_parser)
|> resx.assert_unwrap
}
fn matches(
gc_queue: List(String),
rule_queue: List(Int),
ruleset: Ruleset,
) -> Bool {
case #(gc_queue, rule_queue) {
#([gc, ..rest], [rule_id, ..rule_queue]) -> {
let assert Ok(rule) = dict.get(ruleset, rule_id)
case rule {
Literal(expected) -> {
use <- bool.guard(when: gc != expected, return: False)
matches(rest, rule_queue, ruleset)
}
Reference(alternatives) ->
alternatives
|> list.any(satisfying: fn(expanded) {
matches(gc_queue, list.append(expanded, rule_queue), ruleset)
})
}
}
#([], []) -> True
_ -> False
}
}
fn solve(for messages: List(String), under ruleset: Ruleset) -> Int {
messages
|> listx.count(satisfying: fn(message) {
matches(str.to_graphemes(message), [0], ruleset)
})
}
fn part1(input: String) -> Int {
let #(ruleset, messages) = parse_input(input)
solve(for: messages, under: ruleset)
}
fn part2(input: String) -> Int {
let #(ruleset, messages) = parse_input(input)
let ruleset =
ruleset
|> dict.insert(for: 8, insert: Reference([[42], [42, 8]]))
|> dict.insert(for: 11, insert: Reference([[42, 31], [42, 11, 31]]))
solve(for: messages, under: ruleset)
}
pub fn main() -> Nil {
let testing = input_util.read_text("test19")
let assert 3 = part1(testing)
let assert 12 = part2(testing)
let input = input_util.read_text("day19")
io.debug(part1(input))
io.debug(part2(input))
Nil
}
|
