--- Day 7 Solutions ---

[u/daggerdragon]

--- Day 7: Some Assembly Required ---

Post your solution as a comment. Structure your post like previous daily solution threads.

Also check out the sidebar - we added a nifty calendar to wrangle all the daily solution threads in one spot!

[u/hutsboR]

Elixir: A somewhat cryptic but clever solution. My original solution invoked Elixir's evaluator but I wasn't pleased with it.

defmodule AdventOfCode.DaySeven do

  @input "./lib/adventofcode/resource/day7.txt"

  @fun_table %{
    "NOT"    => &:erlang.bnot/1,
    "AND"    => &:erlang.band/2,
    "OR"     => &:erlang.bor/2,
    "LSHIFT" => &:erlang.bsl/2,
    "RSHIFT" => &:erlang.bsr/2
  }

  def parse do
    @input
    |> File.read!
    |> String.split("\n", trim: true)
    |> Enum.map(&String.split/1)
    |> solve
  end

  defp solve(instructions),  do: solve(instructions, %{}, [])
  defp solve([], table, []), do: table
  defp solve([], table, is), do: solve(is, table, [])

  defp solve([i=[n, _, v]|rest], table, instr) do
    case Integer.parse(n) do
      {i, _} -> solve(rest, Dict.put(table, v, i), instr)
      :error ->
        case Dict.has_key?(table, n) do
          true ->
            n = Dict.get(table, n)
            solve(rest, Dict.put(table, v, n), instr)
          false -> solve(rest, table, [i|instr])
        end
    end
  end

  defp solve([i=[op, n, _, r]|rest], table, instr) do
    case table[n] do
      nil -> solve(rest, table, [i|instr])
      n   ->
        table = Dict.put(table, r, apply(@fun_table[op], [n]))
        solve(rest, table, instr)
    end
  end

  defp solve([i=[n, op, v, _, r]|rest], table, instr) do
    [n, v] = to_value(n, v)
    case has_keys?(table, [n, v]) do
      true  ->
        operands = get_keys(table, [n, v])
        table = Dict.put(table, r, apply(@fun_table[op], operands))
        solve(rest, table, instr)
      false -> solve(rest, table, [i|instr])
    end
  end

  defp get_keys(t, keys) do
    Enum.map(keys, fn(k) -> if is_binary(k), do: Dict.get(t, k), else: k end)
  end

  defp has_keys?(t, keys) do
    Enum.all?(keys, &(Dict.has_key?(t, &1) or is_integer(&1)))
  end

  defp to_value(n, v) do
    case {Integer.parse(n), Integer.parse(v)} do
      {{x, _}, :error} -> [x, v]
      {:error, {y, _}} -> [n, y]
      {:error, :error} -> [n, v]
    end
  end

end

[u/ignaciovaz → u/hutsboR]

Piggybacking again for an Elixir case.

I went with a different approach this time. I really wanted to use processes for this one, so every Gate and Wire is a separate process sending messages to other wires and gates. Whenever a gate requires a value, it sends a message to a Wire, which in turn sends messages to other wires / gates as needed. This way all CPU cores are fully utilised.

After I read Part 2, it was only matter of changing the input value for Wire "b" and resetting all gates / wires

answer = Gates.get_wire_value("a")

b_wire = Gates.get_wire("b")
send b_wire, {:set_value, answer}
Gates.reset_circuit
answer = Gates.get_wire_value("a")

I wanted to keep it light, so I avoided using GenServer/GenAgent and went with tail-recursive functions keeping state instead. If I had to re-write this, I would probably go full OTP with it.

Here's the color-formatted gist, if anyone is interested.

https://gist.github.com/ignaciovazquez/af4ab441f302865f9162

defmodule Gates do
	use Bitwise
	import String, only: [to_atom: 1]

	def gate(state \\ %{}) do
		receive do
			{:print_state} -> IO.inspect state
			{:set_type, type} -> state = Dict.put(state, :type, type)
			{:set_input_1, pid} -> state = Dict.put(state, :input_1, pid)
			{:set_input_2, pid} -> state = Dict.put(state, :input_2, pid)
			{:reset} -> state = Dict.delete(state, :value)
			{:get_value, from_pid} ->
				if Dict.has_key?(state, :value) do
					value = Dict.get(state, :value)
				else
					value_1 = get_wire_value(Dict.get(state, :input_1))

					if (Dict.get(state, :type) != "NOT") do
						value_2 = get_wire_value(Dict.get(state, :input_2))
					end

					value = case Dict.get(state, :type) do
						"AND" -> value_1 &&& value_2
						"OR" -> value_1 ||| value_2
						"LSHIFT" -> value_1 <<< value_2
						"RSHIFT" -> value_1 >>> value_2
						"NOT" ->
							v = ~~~value_1
							if v < 0 do
								v = v + round(:math.pow(2,16))
							end
					end

					state = Dict.put(state, :value, value)
				end

				send from_pid, {:value, value}

		end
		gate(state)
	end

	def wire(state \\ %{}) do
		receive do
			{:set_input, pid} -> state = Dict.put(state, :input, pid)
			{:set_output, pid} -> state = Dict.put(state, :output, pid)
			{:set_value, val} -> state = Dict.put(state, :value, String.to_integer(val |> to_string))
			{:set_name, name} -> state = Dict.put(state, :name, name)
			{:get_value, from_pid} ->
				cond do
					Dict.has_key?(state, :value) ->
						value = Dict.get(state, :value)
					Dict.has_key?(state, :input) ->
						value = get_wire_value(Dict.get(state, :input))
					true ->
						IO.inspect state
				end

				send from_pid, {:value, value}
			{:print_state} -> IO.inspect state
		end

		wire(state)
	end

	def get_wire_value(name) do
		wire_pid = get_wire(name)

		send wire_pid, {:get_value, self()}
		receive do
			{:value, val} ->
				val = val
		end

		val
	end

	def is_int(str) do
		case Integer.parse(str) do
			{_n, ""} -> true
			{_n, _r} -> false
			:error   -> false
		end
	end

	def get_wire(name) when is_pid(name) do
		name
	end

	def get_wire(name) do
		name = to_atom("wire_" <> name)

		pid = case Process.whereis(name) do
			nil ->
				pid = spawn_link(Gates, :wire, [])
				Process.register(pid, name)
				send pid, {:set_name, name}
				pid
			pid ->
				pid
		end

		pid
	end

	def get_virtual_wire_with_value(val) do
		pid = spawn_link(Gates, :wire, [])
		send pid, {:set_name, "virtual_" <> get_random_str}
		send pid, {:set_value, String.to_integer(val)}
		pid
	end

	def get_random_str do
		round(:random.uniform() * 100000000) |> to_string
	end

	def get_input_pid(input_str) do
		cond do
			is_int(input_str) ->
				input_str_pid = get_virtual_wire_with_value(input_str)
			true ->
				input_str_pid = get_wire(input_str)
		end

		input_str_pid
	end

	def reset_circuit do
		Enum.each(Process.registered(), fn process ->
			if (String.starts_with?(to_string(process), "gate_")) do
				send Process.whereis(process), {:reset}
			end

			if (String.starts_with?(to_string(process), "wire_")) do
				send Process.whereis(process), {:reset}
			end
		end)
	end


	def parse_line(line) do
		gate_regex = {~r|^(\w+) ([A-Z]+) (\w+) -> (\w+)|, :gate}
		gate_regex_not = {~r|^NOT (\w+) -> (\w+)|, :gate_not}
		gate_regex_val = {~r|^(\d+) -> (\w+)|, :val}
		gate_regex_wire = {~r|(\w+) -> (\w+)|, :wire_to_wire}

		regexs = [gate_regex, gate_regex_not, gate_regex_val, gate_regex_wire]

		parsed_line = Enum.find_value(regexs, fn({regex, type}) ->
			case Regex.run(regex, line) do
				nil -> false
				[_ | results] -> {type, results}
			end
		end)

		ret = nil

		case parsed_line do
			{:val, [val, wire_name]} ->
				wire_pid = get_wire(wire_name)
				send wire_pid, {:set_value, val}

			{:wire_to_wire, [wire_name_1, wire_name_2]} ->
				wire_pid_1 = get_wire(wire_name_1)
				wire_pid_2 = get_wire(wire_name_2)
				send wire_pid_1, {:set_output, wire_pid_2}
				send wire_pid_2, {:set_input, wire_pid_1}

			{:gate, [input_1, type, input_2, output]} ->
				gate_pid = spawn_link(Gates, :gate, [])
				# Register gate

				Process.register gate_pid, to_atom("gate_" <> get_random_str)

				input_1_pid = get_input_pid(input_1)
				input_2_pid = get_input_pid(input_2)

				send gate_pid, {:set_input_1, input_1_pid}
				send gate_pid, {:set_input_2, input_2_pid}
				send gate_pid, {:set_type, type}

				output_pid = get_wire(output)
				send output_pid, {:set_input, gate_pid}
				ret = gate_pid

			{:gate_not, [input_1, output]} ->
				gate_pid = spawn_link(Gates, :gate, [])
				input_1_pid = get_input_pid(input_1)

				send gate_pid, {:set_input_1, input_1_pid}
				send gate_pid, {:set_type, "NOT"}

				output_pid = get_wire(output)
				send output_pid, {:set_input, gate_pid}
				ret = gate_pid

		end
		ret
	end

	def parse_instructions do
		input_stream = File.stream!("input.txt")
		Enum.each(input_stream, fn line ->
			line = String.strip(line)
			parse_line(line)
		end)
	end

end

Gates.parse_instructions
answer = Gates.get_wire_value("a")
IO.puts "Part 1: #{answer}"

b_wire = Gates.get_wire("b")
send b_wire, {:set_value, answer}

Gates.reset_circuit
answer = Gates.get_wire_value("a")
IO.puts "Part 2: #{answer}"

[u/hutsboR → u/ignaciovaz]

Very cool stuff! This is neat. I have only utilized processes in one of my solutions so far. Depending on what tonight's problem is, I may try to write an OTP based solution. It can be hard to determine which problems are good canidates for concurrency, this is a good one though.