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
|
import adglent.{First, Second}
import gleam/dict
import gleam/int
import gleam/io
import gleam/list
import gleam/order
import gleam/string
fn parse(input) {
input
|> string.split("\n")
|> list.map(string.to_graphemes)
|> list.transpose()
}
fn roll_boulders(strs: List(String)) {
{
use chunks <- list.map(list.chunk(strs, fn(c) { c == "O" || c == "." }))
list.sort(chunks, order.reverse(string.compare))
}
|> list.flatten
}
fn score(matrix) {
use acc, col <- list.fold(matrix, 0)
acc
+ {
use col_acc, char, n <- list.index_fold(list.reverse(col), 0)
case char {
"O" -> col_acc + n + 1
_ -> col_acc
}
}
}
pub fn part1(input: String) {
input
|> parse
|> list.map(roll_boulders)
|> score()
|> string.inspect
}
fn rotate(matrix) {
matrix
|> list.map(list.reverse)
|> list.transpose
}
fn spin(matrix) {
use acc, _ <- list.fold(list.range(1, 4), matrix)
acc
|> list.map(roll_boulders)
|> rotate
}
fn spin_cycle(matrix) {
let cache = dict.new()
check_if_seen(matrix, cache, 1_000_000_000)
}
fn check_if_seen(matrix, cache, count) {
case dict.get(cache, matrix) {
Error(Nil) ->
check_if_seen(spin(matrix), dict.insert(cache, matrix, count), count - 1)
Ok(n) -> {
let assert Ok(extra) = int.modulo(count, n - count)
list.fold(list.range(1, extra), matrix, fn(acc, _) { spin(acc) })
|> score
}
}
}
pub fn part2(input: String) {
input
|> parse
|> spin_cycle
|> string.inspect
}
pub fn main() {
let assert Ok(part) = adglent.get_part()
let assert Ok(input) = adglent.get_input("14")
case part {
First ->
part1(input)
|> adglent.inspect
|> io.println
Second ->
part2(input)
|> adglent.inspect
|> io.println
}
}
|
