# Task
After a long night (work, play, study) you find yourself sleeping on a bench in a park. As you wake up and try to figure out what happened you start counting trees.

You notice there are different tree sizes but there's always one size which is unbalanced. For example there are 2 size 2, 2 size 1 and 1 size 3. (then the size 3 is unbalanced)

Given an array representing different tree sizes. Which one is the unbalanced size.

Notes:
```
There can be any number of sizes but one is always unbalanced
The unbalanced size is always one less than the other sizes
The array is not ordered (nor the trees)```

# Examples

For `trees = [1,1,2,2,3]`, the result should be `3`.

For `trees = [2,2,2,56,56,56,8,8]`, the result should be `8`.

For `trees = [34,76,12,99,64,99,76,12,34]`, the result should be `64`.

# Input/Output


- `[input]` integer array `trees`

Array representing different tree sizes


- `[output]` an integer

The size of the missing tree.

Difficulty: introductory

Starter code:

def find_the_missing_tree(trees):
	

Solutions:
def find_the_missing_tree(trees):
  return sorted(trees, key=trees.count)[0]

from collections import Counter
def find_the_missing_tree(trees):
    return Counter(trees).most_common()[-1][0]    

def find_the_missing_tree(trees):
    return min(trees, key = lambda n: trees.count(n))

def find_the_missing_tree(trees):
    return -sum(trees) % sum(set(trees))

def find_the_missing_tree(trees):
    sum_of_all_trees = sum(trees)
    sum_of_unique_trees = sum(set(trees))
    count = sum_of_all_trees // sum_of_unique_trees + 1
    return count * sum_of_unique_trees - sum_of_all_trees

from collections import Counter

def find_the_missing_tree(trees):
    counter = Counter(trees)
    return min(counter.keys(), key=counter.get)

from collections import Counter

def find_the_missing_tree(trees):
    return min(Counter(trees).most_common(), key=lambda x: x[1])[0]

from collections import Counter
def find_the_missing_tree(trees):
    a = Counter(trees)
    a = str(a)
    #create list of counter 
    a_s = (a.split())
    l_a = len(a_s)
    dd_a = str(a_s[l_a - 2])
    res_str = dd_a.translate({ord(i): None for i in ':'})
    res_int = int(res_str)
    return res_int

from collections import Counter
def find_the_missing_tree(trees):
    c=Counter(trees)
    odd=[k for k,v in c.items() if v%2]
    even=[k for k,v in c.items() if v%2==0]
    return even[0] if len(even)==1 else odd[0]

import collections

def find_the_missing_tree(trees):
    count = collections.Counter( trees )
    return min( count, key = count.get )