180 lines
4.8 KiB
Erlang
180 lines
4.8 KiB
Erlang
%% to compile: erlc day3A.erl
|
|
%% to run: erl -noshell -s day5 solve
|
|
%%
|
|
-module(day16).
|
|
|
|
-compile(export_all).
|
|
|
|
-export ([solve/0, solve/1, solve/2]).
|
|
-export ([read_input/0]).
|
|
|
|
solve() ->
|
|
solve(['1']),
|
|
solve(['2']),
|
|
init:stop().
|
|
|
|
solve(A) ->
|
|
solve(A, read_input()).
|
|
|
|
solve(['1'], D) ->
|
|
io:format("The solution to ~p puzzle1 is: ~p~n", [?MODULE, solve(1, D)]);
|
|
solve(1, D) ->
|
|
solution1(D);
|
|
solve(['2'], D) ->
|
|
io:format("The solution to ~p puzzle2 is: ~p~n", [?MODULE, solve(2, D)]);
|
|
solve(2, D) ->
|
|
solution2(D).
|
|
|
|
read_input() ->
|
|
{ok, IO} = file:open("input.txt", 'read'),
|
|
{ok, Line} = file:read_line(IO),
|
|
file:close(IO),
|
|
hexstr_to_bin(string:strip(Line, 'both', $\n)).
|
|
|
|
hexstr_to_bin(S) ->
|
|
hexstr_to_bin(S, []).
|
|
hexstr_to_bin([], Acc) ->
|
|
list_to_binary(lists:reverse(Acc));
|
|
hexstr_to_bin([X,Y|T], Acc) ->
|
|
{ok, [V], []} = io_lib:fread("~16u", [X,Y]),
|
|
hexstr_to_bin(T, [V | Acc]);
|
|
hexstr_to_bin([X|T], Acc) ->
|
|
{ok, [V], []} = io_lib:fread("~16u", lists:flatten([X,"0"])),
|
|
hexstr_to_bin(T, [V | Acc]).
|
|
|
|
bin_to_hexstr(Bin) ->
|
|
lists:flatten([io_lib:format("~2.16.0B", [X]) ||
|
|
X <- binary_to_list(Bin)]).
|
|
|
|
solution1(Input) ->
|
|
D = unpack(Input, [], not is_zero_bitstring(Input)),
|
|
io:format("Pkt: ~p~n", [D]),
|
|
count_versions(D, 0).
|
|
|
|
solution2(Input) ->
|
|
D = unpack(Input, [], not is_zero_bitstring(Input)),
|
|
io:format("Pkt: ~p~n", [D]),
|
|
calc(D).
|
|
|
|
calc({_,literal, V}) ->
|
|
V;
|
|
calc({_,Op, V}) ->
|
|
?MODULE:Op(V);
|
|
calc([{_,Op, V}]) ->
|
|
?MODULE:Op(V).
|
|
|
|
sum(Args) ->
|
|
io:format("sum: ~p~n", [Args]),
|
|
lists:foldl(fun(X, Acc) -> calc(X) + Acc end, 0, Args).
|
|
|
|
product(Args) ->
|
|
io:format("product: ~p~n", [Args]),
|
|
lists:foldl(fun(X, Acc) -> calc(X) * Acc end, 1, Args).
|
|
|
|
min(Args) ->
|
|
io:format("min: ~p~n", [Args]),
|
|
lists:min([calc(X) || X <- Args]).
|
|
|
|
max(Args) ->
|
|
io:format("max: ~p~n", [Args]),
|
|
lists:max([calc(X) || X <- Args]).
|
|
|
|
lt([A,B] = Args) ->
|
|
io:format("lt: ~p~n", [Args]),
|
|
case calc(A) < calc(B) of
|
|
'true' -> 1;
|
|
'false' -> 0
|
|
end.
|
|
|
|
gt([A,B] = Args) ->
|
|
io:format("gt: ~p~n", [Args]),
|
|
case calc(A) > calc(B) of
|
|
'true' -> 1;
|
|
'false' -> 0
|
|
end.
|
|
|
|
eq([A,B] = Args) ->
|
|
io:format("eq: ~p~n", [Args]),
|
|
case calc(A) == calc(B) of
|
|
'true' -> 1;
|
|
'false' -> 0
|
|
end.
|
|
|
|
count_versions([{Ver, Type, Rest}|T], Acc) ->
|
|
count_versions(T, count_versions(Rest, Acc) + Ver);
|
|
count_versions(_, Acc) ->
|
|
Acc.
|
|
|
|
is_zero_bitstring(BitString) ->
|
|
Size = erlang:bit_size(BitString),
|
|
<<0:Size>> =:= BitString.
|
|
|
|
unpack(Data, [], 'false') ->
|
|
Data;
|
|
unpack(Input, Acc, 'false') ->
|
|
Acc;
|
|
|
|
unpack(Input, Acc, 'true') ->
|
|
{{Ver, Type, Data}, Rest} = unpack(Input),
|
|
io:format("unpacking data: ~p~n", [Data]),
|
|
lists:reverse(unpack(Rest, Acc ++ [{Ver, Type, unpack(Data, [], is_bitstring(Data) andalso not is_zero_bitstring(Data))}], not is_zero_bitstring(Rest))).
|
|
|
|
%% Literal
|
|
unpack(<<V:3, 4:3, Rest/bitstring>>) ->
|
|
io:format("V:~p, T:literal~n", [V]),
|
|
unpack_literal(V, Rest);
|
|
|
|
%% Operator length type id 0
|
|
unpack(<<V:3, T:3, 0:1, Rest/bitstring>>) ->
|
|
io:format("V:~p, T:operator I:0~n", [V]),
|
|
unpack_operator_0(V, T, Rest);
|
|
|
|
%% Operator length type id 1
|
|
unpack(<<V:3, T:3, 1:1, Rest/bitstring>>) ->
|
|
io:format("V:~p, T:operator I:1~n", [V]),
|
|
unpack_operator_1(V, T, Rest).
|
|
|
|
unpack_literal(V, Pkt) ->
|
|
unpack_literal(V, Pkt, <<>>, 0).
|
|
|
|
unpack_literal(V, <<1:1, Value:4, Rest/bitstring>>, Acc, Count) ->
|
|
unpack_literal(V, Rest, <<Acc/bitstring, Value:4>>, Count + 1);
|
|
unpack_literal(V, <<0:1, Value:4, Rest/bitstring>>, Acc, Count) ->
|
|
L = <<Acc/bitstring, Value:4>>,
|
|
Size = (Count + 1) * 4,
|
|
io:format("unpack_literal value: ~p size:~p rest:~p~n", [Value, Size, Rest]),
|
|
<<X:(Size)>> = L,
|
|
{{V, literal, X}, Rest}.
|
|
|
|
unpack_operator_0(V, T, <<Length:15, Rest0/bitstring>>) ->
|
|
io:format("operator0 length:~p~n", [Length]),
|
|
<<Pkt:(Length)/bitstring, Rest/bitstring>> = Rest0,
|
|
{Rest1, Decoded} = unpack_len(Length, Rest0, []),
|
|
{{V, operator_type(T), Decoded}, Rest1}.
|
|
|
|
unpack_operator_1(V, T, <<Num:11, Rest/bitstring>>) ->
|
|
{Rest1, Decoded} = unpack_count(Num, Rest, []),
|
|
io:format("operator1 num of packets:~p Decoded:~p, Rest:~p~n", [Num,Decoded,Rest1]),
|
|
{{V, operator_type(T), Decoded}, Rest1}.
|
|
|
|
unpack_len(0, Pkt, Acc) ->
|
|
{Pkt, Acc};
|
|
unpack_len(Length, Pkt, Acc) ->
|
|
{L, R} = unpack(Pkt),
|
|
io:format("unpack_len: length:before ~p after: ~p~n", [Length, Length - bit_size(Pkt) + bit_size(R)]),
|
|
unpack_len(Length - bit_size(Pkt) + bit_size(R), R, Acc ++ [L]).
|
|
|
|
unpack_count(0, Pkt, Acc) ->
|
|
{Pkt, Acc};
|
|
unpack_count(Num, Pkt, Acc) ->
|
|
{L, R} = unpack(Pkt),
|
|
unpack_count(Num - 1, R, Acc ++ [L]).
|
|
|
|
operator_type(0) -> 'sum';
|
|
operator_type(1) -> 'product';
|
|
operator_type(2) -> 'min';
|
|
operator_type(3) -> 'max';
|
|
operator_type(5) -> 'gt';
|
|
operator_type(6) -> 'lt';
|
|
operator_type(7) -> 'eq'.
|