Elixir generate inverted / reversed map

Question

I would like to transform the input

elems = [a, b, c]
terms = [t1, t2]

@spec contains?(term, elem) :: boolean
def contains?(term, elem), do: #implementation

to either of

%{t1 => [a, b], t2 => [c]}

or

%{t1 => [a], t2 => [b, c]}

where

t1 |> contains?(a) #=> true
t1 |> contains?(b) #=> true
t1 |> contains?(c) #=> false

t2 |> contains?(a) #=> false
t2 |> contains?(b) #=> true
t2 |> contains?(c) #=> true

---

My current solution is as follows

defmodule Test do
  def contains?(term, elem) do
    elem in term
  end

  def test do
    elems = [1,2,3]
    terms = [[1,2], [2,3]]
  
    elems
    |> Enum.into(%{}, fn elem ->
      {elem,
       terms |> Enum.find(&contains?(&1, elem))}
    end)
    |> reverse_map()
  end

  defp reverse_map(map, reversed \\ %{})
  defp reverse_map(map, reversed) when map_size(map) == 0, do: reversed

  defp reverse_map(map, reversed) do
    [key | _] = Map.keys(map)
    {value, map} = Map.pop!(map, key)
    reversed = Map.update(reversed, value, [key], &[key | &1])
    reverse_map(map, reversed)
  end
end

With this solution I'm generating the map

%{a => t1, b => t1, c => t2}

then reversing it and collecting collisions in a list.

But I feel this intermediate map is unnecessary and a solution could exist without it.

In addition I'm not sure my implementation of reverse_map is as elegant as it could be.

Answer 1

defmodule Test do
  def contains?(term, elem) do
    elem in term
  end

  def test do
    elems = [1,2,3]
    terms = [[1,2], [2,3]]
    
    for e <- elems, reduce: %{} do
      acc ->
        key = Enum.find(terms, &contains?(&1, e))
        Map.update(acc, key, [e], &[e|&1])
    end  
    #=> %{[1, 2] => [2, 1], [2, 3] => [3]}
  end
end

Found a simple and elegant solution using a reduce comprehension.
Here, we iterate over each elem in elems, find the first term which contains it, then update our map with either term => [elem] or term => [elem|previous_elems] depending on if that key exists in the map yet.

---

Side note:
If I needed the elems in the same as order they were originally I could use & &1 ++ [e] instead of &[e|&1], but as I don't have that requirement it is more efficient to prepend the list.