game_of_life_solution_01

% Enter your code here. Read input from STDIN. Print output to STDOUT
% Your class should be named solution

-module(solution).
-export([main/0]).

parse_node([$.|Txt]) -> {{leaf,$.}, Txt};
parse_node([$X|Txt]) -> {{leaf,$X}, Txt};
parse_node([$(|Txt]) ->
    {Left, Txt1} = parse_node(Txt),
    {Node, Txt2} = parse_node(Txt1),
    {Right, [$)|Txt3]} = parse_node(Txt2),
    {{branch,Left, Node, Right}, Txt3}.

parse_tree(Txt) ->
    {Tree, []} = parse_node(Txt),
    Tree.

input_tree()->
    Txt0 = io:get_line(""),
    Txt = lists:filter(fun(E) -> ((E =/= 10) and (E =/= 13) and (E =/= 32)) end, Txt0),
%    Txt = string:strip(string:strip(Txt0, both, 13), both, 10),
    parse_tree(Txt).

rules_results(_, 16, Acc) -> Acc;
rules_results(X, N, Acc) ->
    NAcc = case X rem 2 of
        1 -> Acc ++ [$X];
        0 -> Acc ++ [$.]
    end,
    rules_results(X div 2, N + 1, NAcc).

val(XD) -> case XD =:= $X of true -> 1; false -> 0 end.
evolve(P, L, N, R, Rules) ->
    Idx = val(P) * 8 + val(L) *4 + val(N) * 2 + val(R),
    lists:nth(Idx + 1, Rules).


node_state({leaf, S}) -> S;
node_state({branch, _, {leaf, S}, _}) -> S.



evolve_node(PS, {leaf, S}, Rules) -> {leaf, evolve(PS, $., S, $., Rules)};
evolve_node(PS, {branch, Left, {leaf, S}, Right}, Rules) ->
    NLeft = evolve_node(S, Left, Rules),
    NRight = evolve_node(S, Right, Rules),
    NS = evolve(PS, node_state(Left), S, node_state(Right), Rules),
    {branch, NLeft, {leaf, NS}, NRight}.

evolve_tree(T, Rules) ->
    evolve_node($., T, Rules).

%print_tree({leaf, S}) -> io:format("~c ",[S]);
%print_tree({branch, Left, Node, Right}) ->
%    io:format("( ",[]),
%    print_tree(Left),
%    print_tree(Node),
%    print_tree(Right),
%    io:format(") ",[]).

print_value_path(Tree, Path) ->
    SPath = lists:filter(fun(C) -> ((C =/= $[) and (C =/= $])) end, Path),
    Node = lists:foldl(fun(D, {branch, Left, _, Right}) ->
                        case D =:= $> of
                            true -> Right;
                            false -> Left
                        end
                      end, Tree, SPath),
    io:format("~c~n", [node_state(Node)]).

process_query(Trees, Rules) ->
    {ok, [Step, Path]} = io:fread("","~d ~s"),
    [Tree|_] = NTrees = case Step >= 0 of
        true ->
            lists:foldl(fun(_, AccTrees) ->
                            [T|_] = AccTrees,
                            [evolve_tree(T, Rules)|AccTrees]
                            end, Trees, lists:seq(1, Step));
        false ->
            lists:foldl(fun(_, AccTrees) ->
                           [_|RTrees] = AccTrees,
                           RTrees
                           end, Trees, lists:seq(Step, -1))
     end,
     print_value_path(Tree, Path),
     NTrees.


process_queries(NQ, Tree0, Rules) ->
    lists:foldl(fun(_, Trees) ->
               process_query(Trees, Rules)
               end, [Tree0], lists:seq(1, NQ)).

main() ->
	{ok, [RuleIndex]} = io:fread("", "~d"),
    Rules = rules_results(RuleIndex, 0, []),
    Tree0 = input_tree(),
    {ok, [NQ]} = io:fread("", "~d"),
    process_queries(NQ, Tree0, Rules).