-
Notifications
You must be signed in to change notification settings - Fork 0
/
task2.eg
55 lines (42 loc) · 2.14 KB
/
task2.eg
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
# Advent of Code (AoC) - day 13, task 2
import "prelude.eg"
import "os.ego"
import "regex.ego"
import "dictionary.eg"
import "generator.eg"
using System
using OS
using List
def input = let L = read_line stdin in if eof stdin then nil else cons L input
val number = Regex::compile "[0-9]+"
val foldx = Regex::compile "fold along x"
val foldy = Regex::compile "fold along y"
data fold_x, fold_y
def parse_line =
[ L ->
if Regex::look_at number L then let {X,Y} = map to_int (Regex::matches number L) in (X,Y)
else if Regex::look_at foldx L then let {X} = map to_int (Regex::matches number L) in fold_x X
else if Regex::look_at foldy L then let {Y} = map to_int (Regex::matches number L) in fold_y Y
else none ]
def coords = filter [(X,Y) -> true | _ -> false ]
def folds = filter [(fold_x X) -> true | (fold_y Y) -> true | _ -> false ]
def size = foldl [(X0,Y0) (X1,Y1) -> (max X0 X1, max Y0 Y1)] (0,0)
def board = [(X,Y) -> (Dict::from_list . map [C -> (C, '.') ] . flatten . Gen::to_lists) (Gen::take_2d (Y+1) (X+1) Gen::space) ]
def marked_board = [CC -> foldl [B (X,Y) -> Dict::set B (Y,X) '#'] ((board . size) CC) CC]
def print_board =
[ B -> let KK = Dict::keys B in
foldl [(X0,Y0) (X1,Y1) -> (if not (X0 == X1) then print "\n" else none);
print (Dict::get B (X1, Y1)); (X1,Y1) ] (head KK) KK; print "\n" ]
def fold_along_x =
[ B X -> foldl [B ((Y0,X0),'#') -> if X0 < X then Dict::set B (Y0,X0) '#' else Dict::set B (Y0, X - (X0 - X)) '#' | B _ -> B ]
(board (([(X,Y) -> ((Y/2) - 1, X)] . size . Dict::keys) B)) (Dict::to_list B) ]
def fold_along_y =
[ B Y -> foldl [B ((Y0,X0),'#') -> if Y0 < Y then Dict::set B (Y0,X0) '#' else Dict::set B (Y - (Y0 - Y), X0) '#' | B _ -> B ]
(board (([(X,Y) -> (Y, (X/2) - 1)] . size . Dict::keys) B)) (Dict::to_list B) ]
def process =
[ FF B -> foldl [B (fold_x X) -> fold_along_x B X | B (fold_y Y) -> fold_along_y B Y] B FF ]
def count =
[ B -> foldl [N (C,'#') -> N + 1 | N _ -> N] 0 (Dict::to_list B) ]
def main =
let LL = map parse_line input in
print_board (process ((folds LL)) (marked_board (coords LL)))