158 lines
3.6 KiB
Prolog
158 lines
3.6 KiB
Prolog
parse_line(S, [A, B, C, D]) :-
|
|
split_string(S, " ->", "", [X, _, _, _, Y]),
|
|
split_string(X, ",", "", [A0, B0]),
|
|
split_string(Y, ",", "", [C0, D0]),
|
|
number_string(A, A0),
|
|
number_string(B, B0),
|
|
number_string(C, C0),
|
|
number_string(D, D0).
|
|
|
|
read_file(Stream, []) :-
|
|
at_end_of_stream(Stream).
|
|
read_file(Stream, [X|L]) :-
|
|
\+ at_end_of_stream(Stream),
|
|
read_line_to_codes(Stream, C),
|
|
string_chars(S, C),
|
|
parse_line(S, X),
|
|
read_file(Stream, L).
|
|
|
|
main :-
|
|
open('../input/05', read, Stream),
|
|
%open('05', read, Stream),
|
|
read_file(Stream, Lines), !,
|
|
close(Stream),
|
|
minmax_seq(Lines, X0, X1, Y0, Y1),
|
|
C = [X0 - 10, X1 + 10, Y0 - 10, Y1 + 10],
|
|
filter_hor_vert(Lines, L0),
|
|
convert_coords(L0, C, L1),
|
|
create_grid(C, G),
|
|
mark_lines(G, L1, G1),
|
|
count_ge2(G1, W),
|
|
print(W).
|
|
|
|
filter_hor_vert([], []).
|
|
filter_hor_vert([A|As], [A|Bs]) :-
|
|
(horizontal(A); vertical(A)),
|
|
filter_hor_vert(As, Bs).
|
|
filter_hor_vert([A|As], B) :-
|
|
\+ horizontal(A),
|
|
\+ vertical(A),
|
|
filter_hor_vert(As, B).
|
|
|
|
convert_coords([], _, []).
|
|
convert_coords([[A0,A1,A2,A3]|As], [X0, X1, Y0, Y1], [[B0,B1,B2,B3]|Bs]) :-
|
|
C0 is A0 - X0,
|
|
C1 is A1 - Y0,
|
|
C2 is A2 - X0,
|
|
C3 is A3 - Y0,
|
|
B0 is min(C0, C2),
|
|
B2 is max(C0, C2),
|
|
B1 is min(C1, C3),
|
|
B3 is max(C1, C3),
|
|
convert_coords(As, [X0, X1, Y0, Y1], Bs).
|
|
|
|
create_row(0, []).
|
|
create_row(X, [0|As]) :-
|
|
X > 0,
|
|
X1 is X - 1,
|
|
create_row(X1, As).
|
|
create_grid([X0, X1, Y0, Y1], A) :-
|
|
create_grid(X1 - X0 + 1, Y1 - Y0 + 1, A).
|
|
create_grid(_, 0, []).
|
|
create_grid(X, Y, [A|As]) :-
|
|
Y > 0,
|
|
Y1 is Y - 1,
|
|
create_row(X, A),
|
|
create_grid(X, Y1, As).
|
|
|
|
minmax([A, B, C, D], X0, X1, Y0, Y1) :-
|
|
X0 is min(A, C),
|
|
X1 is max(A, C),
|
|
Y0 is min(B, D),
|
|
Y1 is max(B, D).
|
|
|
|
minmax_seq([A], X0, X1, Y0, Y1) :-
|
|
minmax(A, X0, X1, Y0, Y1).
|
|
minmax_seq([A|As], X0, X1, Y0, Y1) :-
|
|
minmax_seq(As, X00, X01, Y00, Y01),
|
|
minmax(A, X10, X11, Y10, Y11),
|
|
X0 is min(X00, X10),
|
|
X1 is max(X01, X11),
|
|
Y0 is min(Y00, Y10),
|
|
Y1 is max(Y01, Y11).
|
|
|
|
vertical([A, _, A, _]).
|
|
horizontal([_, A, _, A]).
|
|
|
|
applicable(A) :-
|
|
(vertical(A); horizontal(A)).
|
|
|
|
prefix_n(0, _, []).
|
|
prefix_n(X, [A|As], [A|Ps]) :-
|
|
X > 0,
|
|
X1 is X - 1,
|
|
prefix_n(X1, As, Ps).
|
|
|
|
suffix_n(N, A, S) :-
|
|
reverse(A, B),
|
|
prefix_n(N, B, P),
|
|
reverse(P, S).
|
|
|
|
add_one([], []).
|
|
add_one([A|As], [B|Bs]) :-
|
|
B is A + 1,
|
|
add_one(As, Bs).
|
|
|
|
mark_in_row(X, [A, B], Y) :-
|
|
length(X, L),
|
|
L1 is L - B - 1,
|
|
prefix_n(A, X, Pfx),
|
|
suffix_n(L1, X, Sfx),
|
|
append([Pfx, Q, Sfx], X),
|
|
add_one(Q, W),
|
|
append([Pfx, W, Sfx], Y).
|
|
|
|
mark_row(X, [A, B, C, B], Y) :-
|
|
length(X, L),
|
|
L1 is L - B - 1,
|
|
prefix_n(B, X, Pfx),
|
|
suffix_n(L1, X, Sfx),
|
|
nth0(B, X, Row0),
|
|
mark_in_row(Row0, [A, C], Row1),
|
|
append([Pfx, [Row1], Sfx], Y).
|
|
|
|
mark_cols([], _, []).
|
|
mark_cols([X|Xs], A, [Y|Ys]) :-
|
|
mark_in_row(X, [A, A], Y),
|
|
mark_cols(Xs, A, Ys).
|
|
mark_col(X, [A, B, A, D], Y) :-
|
|
length(X, L),
|
|
L1 is L - D - 1,
|
|
prefix_n(B, X, Pfx),
|
|
suffix_n(L1, X, Sfx),
|
|
append([Pfx, Q, Sfx], X),
|
|
mark_cols(Q, A, W),
|
|
append([Pfx, W, Sfx], Y).
|
|
|
|
mark_line(X, Z, Y) :-
|
|
mark_col(X, Z, Y); mark_row(X, Z, Y).
|
|
|
|
mark_lines(X, [], X).
|
|
mark_lines(X, [Z|Zs], Y) :-
|
|
mark_line(X, Z, Y0), !,
|
|
mark_lines(Y0, Zs, Y).
|
|
|
|
count_ge2_row([], 0).
|
|
count_ge2_row([A|As], C) :-
|
|
A >= 2,
|
|
count_ge2_row(As, C1),
|
|
C is C1 + 1.
|
|
count_ge2_row([A|As], C) :-
|
|
A < 2,
|
|
count_ge2_row(As, C).
|
|
count_ge2([], 0).
|
|
count_ge2([X|Xs], Y) :-
|
|
count_ge2(Xs, Y0),
|
|
count_ge2_row(X, Y1),
|
|
Y is Y0 + Y1.
|