I used :digraph for the first one still doing the second one (the way I found ended up counting leaves), your solution does give me a little hint so thank you.

I tried a too clever solution first… but I rolled back to this one… took some tries to get right, so it is not that polished yet

defmodule Aoc2020.Day07 do
  def part1(input) do
    rules =
      input
      |> Enum.into(%{})

    for {color, specs} <- rules, color != "shiny gold", reduce: 0 do
      sum ->
        if find(rules, specs, "shiny gold") do
          sum + 1
        else
          sum
        end
    end
  end

  def part2(input) do
    rules =
      input
      |> Enum.into(%{})

    count_bags(rules, "shiny gold") - 1
  end

  def find(rules, [], _), do: false
  def find(rules, [{_, color} | rest], color), do: true

  def find(rules, [{_, child_color} | rest], color),
    do: find(rules, rest, color) || find(rules, Map.get(rules, child_color, []), color)

  def count_bags(rules, color) do
    specs = Map.get(rules, color, [])

    for {quantity, color} <- specs, reduce: 1 do
      sum ->
        sum + quantity * count_bags(rules, color)
    end
  end

  def input_stream(path) do
    File.stream!(path)
    |> Stream.map(&parse/1)
  end

  def parse(line) do
    line
    |> String.replace(["bags", "contain", "bag"], "")
    |> String.replace(~r/\s+|\./, " ")
    |> String.trim()
    |> String.split(",")
    |> Enum.map(fn part -> String.trim(part) |> String.split(" ") end)
    |> create_rule()
  end

  def create_rule([[mod, color | rule] | rules]) do
    {"#{mod} #{color}", parse_spec([rule | rules])}
  end

  defp parse_spec([["no", "other"]]), do: []
  defp parse_spec([]), do: []

  defp parse_spec([[quantity, mod, color] | rest]) do
    [{String.to_integer(quantity), "#{mod} #{color}"} | parse_spec(rest)]
  end
end

input = Aoc2020.Day07.input_stream("input.txt")

Aoc2020.Day07.part1(input)
|> IO.inspect(label: "part1")

Aoc2020.Day07.part2(input)
|> IO.inspect(label: "part2")

Same here. But now it’s working:

Finally done with number 2. Here’s how I did it. Used :digraph for the first one.

They get uglier every day!

defmodule Day07.Fns do
  # revmap: map a bag to the list of bags that contain it
  def revmap(_container, [], bagmap), do: bagmap

  def revmap(container, [bag | bags], bagmap) do
    bag = String.replace(bag, ".", "")

    # ugly
    bagmap = Map.update(bagmap, bag, [container], fn cur -> [container | cur] end)

    revmap(container, bags, bagmap)
  end

  # map a bag to a map of bags it contains, and how many
  # %{"wavy lavender" => %{"light magenta" => 1, "striped cyan" => 2}}
  def nummap(_container, [], bagmap), do: bagmap

  def nummap(container, [bag | bags], bagmap) do
    bag = String.replace(bag, ".", "")

    [count, containedbag] =
      Regex.scan(~r/(\d+)\s(.*)/, bag, capture: :all_but_first)
      |> hd()

    # ugly
    bagmap =
      Map.update(bagmap, container, %{containedbag => String.to_integer(count)}, fn cur ->
        Map.put(cur, containedbag, String.to_integer(count))
      end)

    nummap(container, bags, bagmap)
  end

  def cancontain(_bagmap, [], mapset), do: Enum.count(mapset)

  def cancontain(bagmap, [bag | bags], mapset) do
    containers =
      Map.get(bagmap, bag, [])
      |> Enum.reject(fn nextbag -> nextbag == bag or nextbag in mapset end)

    newmapset =
      containers
      |> MapSet.new()
      |> MapSet.union(mapset)

    cancontain(bagmap, bags ++ containers, newmapset)
  end

  def totalbags(bagmap, bag) do
    contains = Map.get(bagmap, bag, %{})

    # ugly, not tail-recursive
    if contains == %{} do
      0
    else
      immediate =
        Map.values(contains)
        |> Enum.sum()

      inside =
        Enum.map(contains, fn {ibag, icount} -> icount * totalbags(bagmap, ibag) end)
        |> Enum.sum()

      immediate + inside
    end
  end
end

defmodule Day07 do
  alias Day07.Fns

  def readinput() do
    File.read!("7.input.txt")
    |> String.replace(~r/ bag(s)?/, "")
    |> String.replace(", ", ".")
    |> String.split("\n", trim: true)
    |> Enum.reject(fn s -> String.contains?(s, "no other") end)
  end

  def part1(input \\ readinput()) do
    input
    |> Enum.map(&String.replace(&1, ~r/(\d+) /, ""))
    |> Enum.map(&String.split(&1, " contain "))
    |> Enum.map(fn [container, contains] ->
      [container, String.split(contains, ".", trim: true)]
    end)
    |> Enum.reduce(%{}, fn [container | [contains | _]], acc ->
      Fns.revmap(container, contains, acc)
    end)
    |> Fns.cancontain(["shiny gold"], MapSet.new())
  end

  def part2(input \\ readinput()) do
    input
    |> Enum.map(&String.split(&1, " contain "))
    |> Enum.map(fn [container, contains] ->
      [container, String.split(contains, ".", trim: true)]
    end)
    |> Enum.reduce(%{}, fn [container | [contains | _]], acc ->
      Fns.nummap(container, contains, acc)
    end)
    |> Fns.totalbags("shiny gold")
  end
end