got subpackets by bits and count going, mostly

Author: maco

2021/elixir/lib/advent_of_code/day_16.ex

@@ -1,52 +1,114 @@
 defmodule AdventOfCode.Day16 do
   def part1(args) do
     bitlist = Base.decode16!(args)
-    decode_packet(bitlist)
+    {data, _} = decode_packet(bitlist)
+    total_versions(data)
   end
 
-  def decode_packet(bitlist) do
-    <<v::3, t::3, rest::bits>> = bitlist
+  def decode_packet(<<v::3, 4::3, rest::bits>>) do
+    IO.puts("decode")
+    IO.puts("going to literal")
+    {payload, remainder} = literal_value(rest)
+    {%{version: v, type: 4, payload: payload},remainder}
+  end
 
-    case t do
-      4 -> literal_value(rest)
-      _ -> operator(rest)
-    end
+  def decode_packet(<<v::3, t::3, rest::bits>>) do
+    IO.puts("decode")
+    IO.inspect({bits_to_integer(<<v>>),bits_to_integer(<<t>>)}, label: "{v, t}")
+    IO.puts("going to operator")
+    {payload, remainder} = operator(rest)
+    {%{version: v, type: t, payload: payload}, remainder}
   end
 
-  # TODO
   @doc """
       iex> AdventOfCode.Day16.literal_value(<<191, 138, 0::size(2)>>)
-      2021
+      {2021, <<0::3>>}
   """
   def literal_value(bitlist) do
-    <<a::1, b::size(4), rest::bits>> = bitlist
-    IO.inspect({a, b}, label: "a and b")
-    if match?(<<^a::1>>, <<0::1>>) do
-      IO.puts("base case")
-      <<b::4>>
-    else
-      IO.puts("else")
-      n = literal_value(rest)
-      IO.inspect(is_bitstring(<<b::4>>), label: "b is bitstring")
-      IO.inspect(is_bitstring(n), label: "n is bitstring")
-      << <<b::4>>, n >>
-    end
-  end
-
-  def operator(bitlist) do
+    IO.puts("entering literal")
+    {v, remainder} = do_literal_value(bitlist)
+
+    size = bit_size(v)
+    <<int::size(size)>> = v
+    int
+
+    {int, remainder}
+  end
+
+  defp do_literal_value(<<0::1, b::4, rest::bits>>) do
+    IO.puts("literal base")
+    {<<b::4>>, rest}
+  end
+
+  defp do_literal_value(<<_::1, b::4, rest::bits>>) do
+    IO.puts("literal recursion")
+    {n, remainder} = do_literal_value(rest)
+    m = <<b::4>>
+    IO.inspect(is_bitstring(m), label: "m is bitstring")
+    IO.inspect(bit_size(m), label: "m bit size")
+    IO.inspect(bit_size(<< m::bits , n::bits >>), label: "full bit size")
+    {<< m::bits , n::bits >>, remainder}
+  end
+
+  def operator(<<0::1, len::15, rest::bits>> = bitlist) do
+    IO.puts("operator")
+    IO.puts("by length")
+    len = bits_to_integer(<<len>>)
+    <<subpackets::size(len)-bits, remainder::bits>> = rest
+    {subpackets_by_bits(subpackets), <<>>} # remainder should be junk?
+  end
+
+  def operator(<<1::1, subpackets::11, rest::bits>> = bitlist) do
     IO.puts("operator")
-    <<mode::1, rest::bits>> = bitlist
-    case mode do
-      0 ->
-        IO.puts("by length")
-        <<len::15, rest2::bits>> = bitlist
-        <<subpackets::size(len)>> = rest2
-        decode_packet(subpackets)
-      1 ->
-        IO.puts("by number of packets")
-        <<subpackets::11, rest2::bits>> = bitlist
-        decode_packet(rest2)
-    end
+    IO.puts("by number of packets")
+    IO.inspect(subpackets, label: "count")
+    subpackets = subpackets_by_count(rest, subpackets)
+    {subpackets, rest} |> IO.inspect(label: "operator return")
+  end
+
+  def subpackets_by_count(remainder, 0), do: []
+
+  def subpackets_by_count(bitlist, count) do
+    IO.inspect(count, label: "subpacket")
+    {data, remainder} = decode_packet(bitlist)
+    IO.inspect(data, label: "data in subpacket")
+    [ data | subpackets_by_count(remainder, count - 1)]
+  end
+
+  def subpackets_by_bits(<<>>) do
+    IO.puts("ran out of bits")
+     []
+  end
+
+  def subpackets_by_bits(bitlist) do
+    IO.puts("inspecting a subpacket")
+    {data, remainder} = decode_packet(bitlist)
+    IO.inspect(data)
+    [ data | subpackets_by_bits(remainder)] |> IO.inspect
+  end
+
+  @doc """
+      iex> packet = %{payload: [
+      ...> %{payload: 10, type: 4, version: 6},
+      ...> %{payload: 20, type: 4, version: 2}
+      ...>],
+      ...>type: 6,
+      ...>version: 1}
+      iex> AdventOfCode.Day16.total_versions(packet)
+      9
+  """
+  def total_versions(%{version: v, payload: x } = packet) when is_integer(x), do: v
+
+  def total_versions(%{version: v, payload: payload} = packet) do
+    Enum.reduce(payload, v, fn subpacket, acc ->
+      acc + total_versions(subpacket)
+    end)
+  end
+
+  defp bits_to_integer(bs) do
+    size = bit_size(bs)
+    <<int::size(size)>> = bs
+    int
   end
 
   def part2(args) do

2021/elixir/test/advent_of_code/day_16_test.exs

@@ -4,18 +4,55 @@ defmodule AdventOfCode.Day16Test do
 
   import AdventOfCode.Day16
 
-  @tag :skip
+  # @tag :skip
   test "literal number packet" do
     input = "D2FE28"
-    result = part1(input)
+    {result, _} = Base.decode16!(input) |> decode_packet()
 
-    assert result
+    assert result[:version] == 6
+    assert result[:type] == 4
   end
 
-  @tag :skip
-  test "operator packet" do
+  # @tag :skip
+  test "operator packet with length" do
     input = "38006F45291200"
+    {result, _} = Base.decode16!(input) |> decode_packet()
+
+    assert result[:version] == 1
+    assert result[:type] == 6
+  end
+
+  # @tag :skip
+  test "operator packet with count" do
+    input = "EE00D40C823060"
+    {result, _} = Base.decode16!(input) |> decode_packet()
+
+    assert result[:version] == 7
+    assert result[:type] == 3
+  end
+
+  test "example 1" do
+    input = "8A004A801A8002F478"
+    result = part1(input)
+    assert result == 16
+  end
+
+  test "example 2" do
+    input = "620080001611562C8802118E34"
+    result = part1(input)
+    assert result == 12
+  end
+
+  test "example 3" do
+    input = "C0015000016115A2E0802F182340"
+    result = part1(input)
+    assert result == 23
+  end
+
+  test "example 4" do
+    input = "A0016C880162017C3686B18A3D4780"
     result = part1(input)
+    assert result == 31
   end
 
   @tag :skip