102 lines
3.2 KiB
Plaintext
102 lines
3.2 KiB
Plaintext
-- introducing: let expressions!!!
|
||
-- i implemented them yesterday because this was just too annoying otherwise
|
||
|
||
load "list.quox"
|
||
load "string.quox"
|
||
load "io.quox"
|
||
|
||
|
||
def0 Line : ★ = List ℕ × List ℕ
|
||
|
||
|
||
-- i still don't have char literals. quox has no idea what "a char" is
|
||
def colon = char.from-ℕ 0x3A
|
||
def bar = char.from-ℕ 0x7C
|
||
|
||
def split-line : ω.String → Line =
|
||
λ line ⇒
|
||
letω line = snd (string.break (char.eq colon) line);
|
||
pair = string.break (char.eq bar) line;
|
||
got = fst pair; want = snd pair;
|
||
got = list.filter String string.not-null (string.split char.ws? got);
|
||
want = list.filter String string.not-null (string.split char.ws? want);
|
||
got = list.tail-or-nil String got;
|
||
want = list.tail-or-nil String want;
|
||
to-ℕs = list.map String ℕ
|
||
(λ s ⇒ maybe.fold ℕ ℕ 0 (λ n ⇒ n) (string.to-ℕ s)) in
|
||
(to-ℕs got, to-ℕs want)
|
||
|
||
def mem : ω.ℕ → ω.(List ℕ) → Bool =
|
||
λ n ⇒ list.foldlω ℕ Bool 'false (λ b n' ⇒ bool.or b (nat.eq n n'))
|
||
|
||
def all-members : ω.Line → List ℕ =
|
||
λ ln ⇒ list.filter ℕ (λ n ⇒ mem n (snd ln)) (fst ln)
|
||
|
||
def score-from-len : ω.(List ℕ) → ℕ =
|
||
λ xs ⇒
|
||
maybe.foldω (ℕ × List ℕ) ℕ 0
|
||
(λ xxs ⇒ list.foldlω ℕ ℕ 1 (λ c _ ⇒ nat.times 2 c) (snd xxs))
|
||
(list.uncons ℕ xs)
|
||
|
||
def score : ω.Line → ℕ =
|
||
λ ln ⇒ score-from-len (all-members ln)
|
||
|
||
def total-score : ω.(List Line) → ℕ =
|
||
list.foldlω Line ℕ 0 (λ n l ⇒ nat.plus n (score l))
|
||
|
||
def part1 =
|
||
io.bindω String True
|
||
(io.read-fileω "in/day4")
|
||
(λ s ⇒ io.dump (List Line)
|
||
(letω lines = string.split (char.eq char.newline) s;
|
||
lines = list.mapω String Line split-line lines in
|
||
lines))
|
||
|
||
|
||
def0 Copies : ★ = List ℕ
|
||
|
||
def CNil = list.Nil ℕ
|
||
def CCons = list.Cons ℕ
|
||
|
||
def decr-copies : Copies → ℕ × Copies =
|
||
let0 Ret : ★ = ℕ × Copies in
|
||
list.foldr ℕ Ret (1, CNil)
|
||
(λ cur nrest ⇒
|
||
case nrest return Ret of { (n, rest) ⇒
|
||
case cur return Ret of {
|
||
0 ⇒ (n, rest);
|
||
succ cur ⇒ (succ n, CCons cur rest)
|
||
}})
|
||
|
||
def new-copies : ℕ → ω.ℕ → Copies → Copies =
|
||
λ count value cs ⇒
|
||
case count return Copies of {
|
||
0 ⇒ cs;
|
||
succ _, cs' ⇒ CCons value cs'
|
||
}
|
||
|
||
def total-cards : ω.(List Line) → ℕ =
|
||
λ lines ⇒
|
||
let 0.State : ★ = ℕ × Copies;
|
||
ω.start : State = (0, CNil);
|
||
ω.next : ω.State → ω.Line → State =
|
||
λ st ln ⇒
|
||
letω total = fst st;
|
||
nc = decr-copies (snd st);
|
||
copies-this = fst nc;
|
||
copies-rest = snd nc;
|
||
score1 = list.length ℕ (all-members ln);
|
||
copies-out = new-copies copies-this score1 copies-rest;
|
||
total' = nat.plus total copies-this in
|
||
(total', copies-out) in
|
||
fst (list.foldlω Line State start next lines)
|
||
|
||
#[main]
|
||
def part2 =
|
||
io.bindω String True
|
||
(io.read-fileω "in/day4")
|
||
(λ s ⇒ io.dump ℕ
|
||
(letω lines = string.split (char.eq char.newline) s;
|
||
lines = list.mapω String Line split-line lines in
|
||
total-cards lines))
|