# Scala algorithm: Find an unpaired number in an array

## Algorithm goal

If you were to group each number of an array with another one of itself, would there be any that cannot be grouped?

## Explanation

This problem firstly does not specifically have to be on numbers - it applies in fact to any type, which is why we use generic types of Scala to implement the solution.

The solution approach is to create a Set, and as soon as an item is encountered, remove it from the set if it is there, and append to the set if it is not -- then any item remaining in the set is basically the unpaired item. (this is Â© from www.scala-algorithms.com)

This provides us with the ability to be more precise because a type T cannot be accidentally mixed up with an Int.

The Scala approach we use is to run a 'foldLeft' - a 'foldLeft' is basically an iteration over all the values with a function, and a final result. See 'Concepts' below for explanation.

## Scala concepts & Hints

### foldLeft and foldRight

A 'fold' allows you to perform the equivalent of a for-loop, but with a lot less code.

### Option Type

The 'Option' type is used to describe a computation that either has a result or does not. In Scala, you can 'chain' Option processing, combine with lists and other data structures. For example, you can also turn a pattern-match into a function that return an Option, and vice-versa!

### Pattern Matching

Pattern matching in Scala lets you quickly identify what you are looking for in a data, and also extract it.

### Stack Safety

Stack safety is present where a function cannot crash due to overflowing the limit of number of recursive calls.

This function will work for n = 5, but will not work for n = 2000 (crash with java.lang.StackOverflowError) - however there is a way to fix it :-)

In Scala Algorithms, we try to write the algorithms in a stack-safe way, where possible, so that when you use the algorithms, they will not crash on large inputs. However, stack-safe implementations are often more complex, and in some cases, overly complex, for the task at hand.

## Algorithm in Scala

9 lines of Scala (version 2.13), showing how concise Scala can be!

```
def findUnpairedItem[T](a: Array[T]): Option[T] = {
a.foldLeft[Set[T]](Set.empty)({
case (set, n) if set.contains(n) =>
set - n
case (set, n) =>
set + n
})
.headOption
}
```

## Test cases in Scala

```
assert(findUnpairedItem(Array(1, 2, 1)).contains(2))
assert(findUnpairedItem(Array(1, 2, 1, 1, 1)).contains(2))
assert(findUnpairedItem(Array(1, 1, 1, 1, 1)).contains(1))
assert(findUnpairedItem(Array(1, 1, 1, 1)).isEmpty)
assert(findUnpairedItem(Array(1, 2, 3, 1, 2)).contains(3))
assert(findUnpairedItem(Array(1, 2, 3, 3, 1, 2)).isEmpty)
```