In this Kata, we will calculate the **minumum positive number that is not a possible sum** from a list of positive integers. 

```
solve([1,2,8,7]) = 4 => we can get 1, 2, 3 (from 1+2), but we cannot get 4. 4 is the minimum number not possible from the list. 
solve([4,1,2,3,12]) = 11. We can get 1, 2, 3, 4, 4+1=5, 4+2=6,4+3=7,4+3+1=8,4+3+2=9,4+3+2+1=10. But not 11. 
solve([2,3,2,3,4,2,12,3]) = 1. We cannot get 1.
```
More examples in test cases. 

Good luck!

Difficulty: EASY
Starter code: def solve(arr):
	

Solutions:
def solve(xs):
	m = 0
	for x in sorted(xs):
		if x > m + 1:
			break
		m += x
	return m + 1


from itertools import accumulate

def solve(arr):
	arr = sorted(arr)
	return next((x + 1 for (x, i) in zip(accumulate([0] + arr), arr + [0]) if i > x + 1), sum(arr) + 1)


def solve(r):
	ǂ = 1
	for x in sorted(r):
		if x > ǂ:
			break
		else:
			ǂ += x
	return ǂ


def solve(arr):
	arr.sort()
	res = 1
	for i in range(len(arr)):
		if arr[i] <= res:
			res += arr[i]
	return res


def solve(arr):
	(arr, res, n, i) = (sorted(arr), 1, len(arr), 0)
	while i < n and res >= arr[i]:
		(res, i) = (res + arr[i], i + 1)
	return res


def solve(a):
	a.sort()
	(i, j) = (1, 0)
	while j < len(a):
		j += 1
		if a[j - 1] <= i:
			i += a[j - 1]
		else:
			break
	return i


def solve(arr):
	miss = 1
	for a in sorted(arr):
		if a > miss:
			break
		miss += a
	return miss


solve = s = lambda a, x=1: a and s(a, x | x << a.pop()) or len(bin(~x & x + 1)) - 3


def solve(arr):
	arr.sort()
	print(arr)
	for x in range(1, sum(arr) + 1):
		working_arr = []
		if x in arr:
			continue
		for (idx_y, y) in enumerate(arr):
			if x < y:
				working_arr = arr[:idx_y]
				if sum(working_arr) < x:
					return x
	return sum(arr) + 1


def solve(arr):
	arr = sorted(arr)
	l = len(arr)
	x = 1
	for i in range(l):
		if arr[i] <= x:
			x += arr[i]
		else:
			break
	return x