Also, it will fail even worse on any non-integer 
mudasobwa
Creator of Cure
NobbZ
The input was defined, yes. But still I consider it important to tell about the problems of this approach.
I consider crashing with an error not worse than a result that is confusing…
iex(1)> require Bitwise
Bitwise
iex(2)> [1, 2, 3, 1, 3, 10, 200, 10, 200, 200] |> Enum.reduce(0, &Bitwise.bxor/2)
202
202 was not even in the list…
2
mudasobwa
Creator of Cure
FWIW, I’d provide a bare implementation that is similar to MapSet (actually it replicates MapSet implementation, which is a bare map underneath):
[1, 2, 3, 1, 3, 10, 200, 10, 200] |> Enum.reduce(%{}, fn e, acc ->
if is_nil(Map.get(acc, e)), do: Map.put(acc, e, e), else: Map.delete(acc, e)
end) |> Map.keys() |> hd()
#⇒ 2
3
Andres
@mudasobwa All your ideas are welcome.
I really liked this implementation:
if is_nil(Map.get(acc, e)), do: Map.put(acc, e, e), else: Map.delete(acc, e)
Thanks so much!
0
peerreynders
Nobody would write it like this - but “replace conditional with pattern match”.
[1, 2, 3, 1, 3, 10, 200, 10, 200] |> List.foldl(%{}, fn e, acc ->
{_, acc} = get_and_update_in(acc, [e],
fn
:nil ->
{e, e}
_ ->
:pop
end)
acc
end) |> Map.keys() |> hd()
1
Andres
Yes! That’s what I’m looking for, new ideas to solve problems.
Now I need to study your code 
0
amnu3387
Although a bit of an overkill you can also use an ets table to use as a counter table.
list = [1, 2, 3, 1, 3, 10, 200, 10, 200, 10]
counter_table = :ets.new(:counter_table, [])
Enum.each(list, fn(x) -> :ets.update_counter(counter_table, x, 1, {x, 0}) end)
selector = fn(table, n_occurr) ->
case :ets.select(table, [{{:"$1", n_occurr}, [], [:"$1"]}]) do
[x] -> x
multiple_or_none -> {:error, multiple_or_none}
end
end
selector.(counter_table, 1)
# 2
selector.(counter_table, 2)
# {:error, [200, 1, 3]}
selector.(counter_table, 3)
# 10
selector.(counter_table, 4)
# {:error, []}
:ets.delete(counter_table)
# true
1
Andres
Super impresive. Really love it! Thanks so much for sharing!
Qqwy
TypeCheck Core Team
You could also create a histogram (which takes O(n) time), and then drop all elements from it that have a count of ‘2’. You then end up with:
- either exactly one element, and you can output it
- Something that does not match the input you expect, and you’re now able to return or raise a proper error.
I think that might be a more robust solution, if you cannot be entirely sure that the input precondition is met by the user at all times. It will also work for non-integers. (Although the binary XNOR is a marvellous idea 
)
4
Ted
I saw this and immediately thought of the frequencies function in Clojure’s standard library.
Returns a map from distinct items in coll to the number of times they appear.
I’m not sure if Elixir’s standard library has such a function, but here’s a simple implementation:
frequencies = fn(enumerable) ->
for {k, v} <- Enum.group_by(enumerable, &(&1)), into: %{}, do: {k, length(v)}
end
Example usage:
iex(4)> frequencies.(~w(a b c a c d d e e e f))
%{"a" => 2, "b" => 1, "c" => 2, "d" => 2, "e" => 3, "f" => 1}
And here’s how we can use frequencies to find the singleton(s):
iex(6)> xs = ~w(a b c a c d d e e e f)
["a", "b", "c", "a", "c", "d", "d", "e", "e", "e", "f"]
iex(7)> for {x, freq} <- frequencies.(xs), freq == 1, do: x
["b", "f"]
1