# Task
 A noob programmer was given two simple tasks: sum and sort the elements of the given array `arr` = [a1, a2, ..., an]. 
 
 He started with summing and did it easily, but decided to store the sum he found in some random position of the original array which was a bad idea. Now he needs to cope with the second task, sorting the original array arr, and it's giving him trouble since he modified it.

 Given the array `shuffled`, consisting of elements a1, a2, ..., an, and their sumvalue in random order, return the sorted array of original elements a1, a2, ..., an.

# Example

 For `shuffled = [1, 12, 3, 6, 2]`, the output should be `[1, 2, 3, 6]`.

 `1 + 3 + 6 + 2 = 12`, which means that 1, 3, 6 and 2 are original elements of the array.

 For `shuffled = [1, -3, -5, 7, 2]`, the output should be `[-5, -3, 2, 7]`.

# Input/Output


 - `[input]` integer array `shuffled`

    Array of at least two integers. It is guaranteed that there is an index i such that shuffled[i] = shuffled[0] + ... + shuffled[i - 1] + shuffled[i + 1] + ... + shuffled[n].

    Constraints:

    `2 ≤ shuffled.length ≤ 30,`

    `-300 ≤ shuffled[i] ≤ 300.`


 - `[output]` an integer array

    A `sorted` array of shuffled.length - 1 elements.

Difficulty: introductory

Starter code:

def shuffled_array(s):
	

Solutions:
def shuffled_array(s):
    result = sorted(s)
    result.remove(sum(result) // 2)
    return result


def shuffled_array(s):
    for i in s:
        if sum(s)-i == i: 
            s.pop(s.index(i))
            break
    return sorted(s)

def shuffled_array(s):
    s.pop(s.index(sum(s) /2))
    return sorted(s)

shuffled_array=lambda a:a.sort()or a.remove(sum(a)/2)or a

def shuffled_array(s):
    s.remove(sum(s)//2)
    s.sort()
    return s

def shuffled_array(s):
    for i in range(len(s)):
        k = s[:i] + s[i+1:]
        if sum(k) == s[i]:
            return sorted(k)

def shuffled_array(s):
    s.sort()
    for i in range(len(s)):
        if s[i] == sum(s[:i]+s[i+1:]):
            return s[:i]+s[i+1:]

def shuffled_array(a):
    a.remove(sum(a) / 2)
    return sorted(a)

shuffled_array=lambda a:a.remove(sum(a)/2)or sorted(a)

def shuffled_array(lst):
    R = lst[:]
    R.remove(sum(R) // 2)
    return sorted(R)