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: EASY
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):
	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)