So let's get started for this 6kyu kata -- I hope I'll do a 5kyu next time.

The gist of this Kata is pretty simple, we've got a list of numbers, and we have to find which one appears an odd number of times.

    FindOdd.find([20,1,-1,2,-2,3,3,5,5,1,2,4,20,4,-1,-2,5]) # 5
    FindOdd.find([1,1,2,-2,5,2,4,4,-1,-2,5]) # -1
    FindOdd.find([10]) # 10

That's pretty straight forward and when I've read it I knew I was going to use Enum.reduce, it's not the only way to achieve it obviously but that's what comes in my mind.

As usual I'll also share another solution at the end of this post.

defmodule FindOdd do
    def find([]), do: []
    def find([x]), do: x
    def find(list), do: list
end

So I've choose to use function clauses over multiples private function being called by the find one.

With these 3 clauses all cases are covered.

I want to create a Map where the key is the number in the list and the value is the number of times we encounter it, like this %{10: 1}.

Hence the Map I want to use, the shape of my data will looks like this {x, y}, and because I do not really care of the number of times at the end, it's going to be much like this {x, _}.

def find(list) do
    {x, _} = 
        list
        |> Enum.reduce(%{}, fn x, acc -> Map.update(acc, x, 1, &(&1 + 1))end)
        |> Enum.find(fn {_,y} -> rem(y, 2) == 1 end)
    x
end

Let's analyze this bit by bit.

I take the list and pass it to the Enum.reduce/3 function.
The first argument is the list itself, the second is where I want to accumulate the data and the third is the lambda.

If x is present in map with value of 1, &(&1 + 1) is invoked with argument 1 and its result is used as the new value of x in my acc which is a Map.

I could have decoupled it but for the sake of simplicity and because it's not really the topic of this post I'll keep it like this.

So once I've got my reduced Map I still need to find where it's odd, and as I said earlier, it's explicitly told that there's only one odd value.
I just need to find in my Map -- a map implements the protocol Enumerable so I can call Enum module functions on my Map -- with the help of Enum.find, which takes the Enum and a lambda.

Here I just pass y because it's the value I want to get the reminder of.
The Kernel.rem/2 or just rem function gives us back the reminder of the division, also named the modulo, and I want to it to equal to 1 when x is divided by 2.

After this, I just need to return x et voila.

It was a really simple problem, and because it is simple there's a tons of way to solve it.

My favorite is this almost one liner function.

defmodule FindOdd do
  import Bitwise
  def find(list), do: Enum.reduce(list, &Bitwise.bxor/2)
end

The usage of bitwise operators is a field where I do not really perform so well, I recall having used it for solving a problem on Codewars too in a JS kata.
It will maybe be part of a future blog post!

Thanks for reading and happy coding.