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: introductory

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