If you have not ever heard the term **Arithmetic Progrossion**, refer to: 
http://www.codewars.com/kata/find-the-missing-term-in-an-arithmetic-progression/python

And here is an unordered version. Try if you can survive lists of **MASSIVE** numbers (which means time limit should be considered). :D

Note: Don't be afraid that the minimum or the maximum element in the list is missing, e.g. [4, 6, 3, 5, 2] is missing 1 or 7, but this case is excluded from the kata.

Example:

```python
find([3, 9, 1, 11, 13, 5]) # => 7
```

Difficulty: introductory

Starter code:

def find(seq):
	

Solutions:
def find(seq):
  return (min(seq)+max(seq))*(len(seq)+1)/2-sum(seq)

def find(a):
    return (max(a) + min(a)) * (len(a) + 1) / 2 - sum(a)

def find(seq):
    a,b,c = max(seq), min(seq), len(seq)
    z = list(range(b, a, (a-b)//c))
    return list(set(z)-set(seq))[0]


def find(nums):
    # hmm, quite fast to use min and max
    return (min(nums) + max(nums)) * (len(nums) + 1) / 2 - sum(nums)

def find(seq): 
    if len(seq) <= 1:
        return seq
    seq.sort()
    x = []
    t = 0
    for i in range(len(seq) - 1):
        if i == 0:
            t = seq[i + 1] - seq[i]
            x.append(t)
        else:
            t = seq[i + 1] - seq[i]
            if t != x[-1]:
                x.append(t)
                break
            else:
                x.append(t)
    
    return min(seq) + len(x) * x[0]

def find(seq):
  a, b, n = min(*seq), max(*seq), len(seq)
  m = (b - a)//n
  return m*abs(sum((x - a) // m for x in seq) - (n + 1)*(n)//2) + a

find=lambda s:(min(s)+max(s))*-~len(s)/2-sum(s)

def find(seq):
  seq.sort()
  pattern = abs(seq[0]-seq[1])
  for i in range(len(seq)-1):
    if seq[i]!=seq[i+1]-pattern:
      return seq[i]+pattern
  



def find(seq):
    seq.sort()
    first, last = seq[0], seq[-1]
    d = min(seq[1] - first, seq[2] - seq[1])
    n = (last - first) * 1.0/d + 1
    s = n / 2 * (first + last)
    s_ = sum(seq)
    return s - s_


def find(seq):
    prev = 0
    curr = 0
    seq.sort()
    
    length = len(seq)
    diff = (seq[length-1] - seq[0]) / length
    
    for i in range(1, len(seq)):
        
        
        if (seq[i]) == ((seq[curr])+diff):
            prev = curr
            curr = i

        
        else:
            return int(seq[curr]+diff)