169 lines
4.7 KiB
Erlang
169 lines
4.7 KiB
Erlang
%% to compile: erlc day3A.erl
|
|
%% to run: erl -noshell -s day5 solve
|
|
%%
|
|
-module(day14).
|
|
|
|
-export ([solve/0, solve/1, solve/2]).
|
|
-export ([expand_pair/4, read_input/0]).
|
|
-compile ([export_all]).
|
|
|
|
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'),
|
|
Data = read_input(IO),
|
|
file:close(IO),
|
|
Data.
|
|
|
|
read_input(IO) ->
|
|
read_input(IO, []).
|
|
|
|
read_input(IO, Input) ->
|
|
case read_line(IO) of
|
|
'eof' -> make_map(Input);
|
|
Line -> read_input(IO, Input ++ [Line])
|
|
end.
|
|
|
|
read_line(IO) ->
|
|
case file:read_line(IO) of
|
|
'eof' -> 'eof';
|
|
{ok, Line} -> parse_line(Line)
|
|
end.
|
|
|
|
parse_line(Line) ->
|
|
string:tokens(Line, " ->\n").
|
|
|
|
make_map(Input) -> make_map(Input, maps:new()).
|
|
|
|
make_map([], Map) -> Map;
|
|
make_map([[P, [Res]]|Rest], Map) ->
|
|
NewMap = maps:put(P, Res, Map),
|
|
make_map(Rest, NewMap).
|
|
|
|
solution1(PolyMap) ->
|
|
Ets = ets:new(polymer, [set, public, named_table]),
|
|
Polymer = "FNFPPNKPPHSOKFFHOFOC",
|
|
init_counters(Ets, PolyMap),
|
|
io:format("~p~n", [ets:tab2list(Ets)]),
|
|
Pairs = make_pairs(Polymer, []),
|
|
io:format("expand pairs: ~p~n",[Pairs]),
|
|
count_pairs(Pairs, Ets),
|
|
[count_elems(Pair, Ets, 1) || Pair <- Pairs],
|
|
loop(Ets, PolyMap, 10),
|
|
get_max_elm(Ets) - get_min_elm(Ets).
|
|
|
|
solution2(PolyMap) ->
|
|
Ets = ets:new(polymer, [set, public, named_table]),
|
|
Polymer = "FNFPPNKPPHSOKFFHOFOC",
|
|
init_counters(Ets, PolyMap),
|
|
io:format("~p~n", [ets:tab2list(Ets)]),
|
|
Pairs = make_pairs(Polymer, []),
|
|
io:format("expand pairs: ~p~n",[Pairs]),
|
|
count_pairs(Pairs, Ets),
|
|
[count_elems(Pair, Ets, 1) || Pair <- Pairs],
|
|
loop(Ets, PolyMap, 40),
|
|
get_max_elm(Ets) - get_min_elm(Ets).
|
|
|
|
get_max_elm(Ets) ->
|
|
Ents = ets:tab2list(Ets),
|
|
{V, _} = lists:max([{V,X} || {{elem, X},V} <- Ents]),
|
|
V.
|
|
|
|
get_min_elm(Ets) ->
|
|
Ents = ets:tab2list(Ets),
|
|
{V, _} = lists:min([{V,X} || {{elem, X},V} <- Ents]),
|
|
V.
|
|
|
|
loop(Ets, _PolyMap, 0) -> ets:tab2list(Ets);
|
|
loop(Ets, PolyMap, Count) ->
|
|
Counters = get_counters(Ets),
|
|
[update_ets(Ets, PolyMap, Counter) || Counter <- Counters],
|
|
loop(Ets, PolyMap, Count - 1).
|
|
|
|
init_counters(Ets, PolyMap) ->
|
|
maps:foreach(fun([X,Y] = Key, _Value) -> ets:insert(Ets, {{elem,X},0}), ets:insert(Ets, {{elem,Y},0}), ets:insert(Ets, {{pair, Key}, 0}) end, PolyMap).
|
|
|
|
update_ets(_Ets, _PolyMap, {_Key, 0}) -> ok;
|
|
update_ets(Ets, PolyMap, {[X,Y] = Key, Value}) ->
|
|
V = maps:get(Key, PolyMap),
|
|
count_pair([X,V],Ets, Value),
|
|
count_pair([V,Y],Ets, Value),
|
|
count_pair(Key,Ets, -1 * Value),
|
|
count_elem(V, Ets, Value).
|
|
|
|
get_counters(Ets) ->
|
|
Ents = ets:tab2list(Ets),
|
|
[{X,V} || {{pair, X},V} <- Ents].
|
|
|
|
make_pairs([_], Pairs) -> Pairs;
|
|
make_pairs([X,Y|Rest], Pairs) -> make_pairs([Y|Rest], [[X,Y]|Pairs]).
|
|
|
|
count_pairs([], _Ets) -> ok;
|
|
count_pairs([P|Rest], Ets) ->
|
|
count_pair(P, Ets, 1),
|
|
count_pairs(Rest, Ets).
|
|
|
|
count_pair(P, Ets, V) ->
|
|
ets:update_counter(Ets, {pair,P}, {2,V}).
|
|
|
|
count_elems([X,Y], Ets, V) ->
|
|
count_elem(X, Ets, V),
|
|
count_elem(Y, Ets, V).
|
|
|
|
count_elem(Elem, Ets, V) ->
|
|
ets:update_counter(Ets, {elem,Elem}, {2,V}).
|
|
|
|
expand_pair(_P, _PolyMap, _Ets, 0) -> ok;
|
|
expand_pair([P1,P2], PolyMap, Ets, Count) when is_list(P1), is_list(P2) ->
|
|
expand_pair(P1,PolyMap, Ets, Count - 1);
|
|
expand_pair([X,Y] = P, PolyMap, Ets, Count) ->
|
|
[V] = maps:get(P, PolyMap),
|
|
ets:update_counter(Ets, [V], {2,1}),
|
|
[expand_pair(Pa, PolyMap, Ets, Count) || Pa <- [[X,V]] ++ [[V,Y]]].
|
|
|
|
|
|
pairs([], _PolyMap, Pairs, _Ets, 0) ->
|
|
Pairs;
|
|
pairs([], PolyMap, Pairs, Ets, Count) ->
|
|
io:format("new pairs: ~p~n", [Pairs]),
|
|
pairs(Pairs, PolyMap, [], Ets, Count - 1);
|
|
pairs([[X,Y] = P|Rest], PolyMap, Pairs, Ets, Count) ->
|
|
[V] = maps:get(P, PolyMap),
|
|
ets:update_counter(Ets, [V], {2,1}),
|
|
pairs(Rest, PolyMap, Pairs ++ [[X,V]] ++ [[V,Y]], Ets, Count).
|
|
|
|
count(Polymer) ->
|
|
Ps = lists:usort(Polymer),
|
|
[ {count_p(P, Polymer), [P]} || P <- Ps].
|
|
|
|
count_p(P, Polymer) ->
|
|
lists:foldl(fun(X, Acc) -> case X == P of 'true' -> Acc + 1; _ -> Acc end end, 0, Polymer).
|
|
|
|
steps(Polymer, _PolyMap, 0) -> Polymer;
|
|
steps(Polymer, PolyMap, Count) ->
|
|
Insert = get_insert_list(Polymer, PolyMap),
|
|
steps(lists:flatten(lists:zipwith(fun(A, B) -> [A,B] end, Polymer, Insert)), PolyMap, Count - 1).
|
|
|
|
get_insert_list(Polymer, PolyMap) ->
|
|
get_insert_list(Polymer, PolyMap, []).
|
|
|
|
get_insert_list([_], _PolyMap, InsertList) -> lists:reverse([[]|InsertList]);
|
|
get_insert_list([P1,P2|Rest], PolyMap, InsertList) ->
|
|
V = maps:get([P1,P2], PolyMap),
|
|
get_insert_list([P2|Rest], PolyMap, [V|InsertList]).
|