In this Kata, you will be given an array of integers whose elements have both a negative and a positive value, except for one integer that is either only negative or only positive. Your task will be to find that integer. 

Examples:

`[1, -1, 2, -2, 3] => 3`

`3` has no matching negative appearance

`[-3, 1, 2, 3, -1, -4, -2] => -4`

`-4` has no matching positive appearance

`[1, -1, 2, -2, 3, 3] => 3`

(the only-positive or only-negative integer may appear more than once)

Good luck!

Difficulty: introductory

Starter code:

def solve(arr):
	

Solutions:
def solve(arr): return sum(set(arr))


def solve(arr):
    for a in arr:
        if -a not in arr:
            return a


def solve(a):
    return sum(set(a))

def solve(arr):
    return [i for i in arr if -i not in arr][0]


def solve(arr):
    for n in arr:
        if -n not in arr: return n


def solve(arr):
    for x in arr:
        if x and -x not in arr:
            return x

def solve(arr):
    for number in arr:
        if number*-1 in arr:
            pass
        else:
            return number

def solve(arr):
    special_set = set(arr)
    n = 0
    for i in list(special_set):
        n += i
    return n

def solve(arr):
    summa = 0
    dic = {}
    res = 0
    for i in arr:
        dic[i] = 0
        if -i in arr:
            dic[i] += 1
        else:
            dic[i] = 0
    for key, value in dic.items():
        if value == 0:
            res = key
    return res

def solve(arr):
    for i in arr:
        if -1*i not in arr:
            return i

def solve(arr):
    result =0
    for a in arr: 
        if -a not in arr :
            return a;

def solve(arr):
    return [x for x in arr if not(-x in arr)][0]

def solve(arr):
    return sum(list(set(arr)))


def solve(lst):
    return sum(set(lst))

def solve(lst):
    for num in lst:
        if -num not in lst:
            return num

def solve(arr):
    for num in arr:
        if not -num in arr:
            return num

def solve(arr: list) -> int:
    """ This function returns one integer that is either only negative or only positive. """
    for i in range(len(arr)):
        if -arr[i] not in arr:
            return arr[i]

def solve(arr):
    nums = []
    unique = 0

    for i in arr:
        if -i in arr:
            nums.append(i)
        else:
            unique = i

    return unique

def solve(arr):
    arr = set(arr)
    lst = list(map(abs,arr))
    one = 0
    for i in range(len(lst)):
        if lst.count(lst[i]) == 1:
            one = lst[i]

    if one in arr:
        return one
    else:
        a = "-"+str(one)
        return int(a)

def solve(arr):
    result = []
    for i in arr:
        if arr.count(i) != arr.count(-i):
            result.append(i)
    return result[0]        

def solve(arr):
    ls = [arr[0]]
    for n in arr[1:]:
        if -(n) in ls:
            ls.pop(ls.index(-(n)))
        else:
            ls.append(n)
    return ls[0]

def solve(arr):
    arr = sorted(arr)
    for i in range(len(arr) - 1):
        if arr[i] == arr[i + 1]:
            return arr[i]
    return sum(arr)    


def solve(arr):
    return [el for el in arr if -el not in arr ][0]

def solve(arr):
    positive = sorted([x for x in arr if x>=0])
    negative = sorted([x for x in arr if x<0], reverse=True)
    longer_index = len(positive) <= len(negative)
    longer = [positive, negative][longer_index]
    for i in [positive, negative][not longer_index]:
        longer.remove(-i)
    return longer[0]

def solve(arr):
    rev = set(-x for x in arr)
    return [x for x in arr if abs(x) not in set(arr) or x not in rev][0]

def solve(arr):
    for i in arr:
        reverse = -i
        if reverse not in arr:
            return i

def solve(arr):
    for num in arr:
        if -num in arr:
            pass
        else:
            return num


def solve(arr):
    
    a = [i for i in arr if arr.count(i) != arr.count(-i)]
    
    return a[0]

def solve(arr):
    item = arr.pop()
    while(-item in arr):
        arr.remove(-item)
        item = arr.pop()
    return item

def solve(arr):
    for index, value in enumerate(arr):
        if value * -1 in arr:
            continue
        else:
            return value

def solve(arr):
    for num in arr:
        if arr.count(num * (-1)) == 0:
            return num

def solve(arr):
    values = set()
    removed_values = set()
    
    for value in arr:
        if value in removed_values:
            continue
        
        opposite = value*-1
        
        if (opposite) in values:
            values.remove(opposite)
            removed_values.add(value)
            removed_values.add(opposite)
        else:
            values.add(value)
            
    return list(values)[0]            
        
            


def solve(arr):
    result = arr[0]
    for i in range(len(arr)):
        pair = False
        for j in range(len(arr)):
            if arr[i] == -arr[j]:
                pair = True
        if (not pair):
            result = arr[i]
            
    return result

def solve(arr):
    positive_set = set()
    negative_set = set()
    for num in arr:
        if num > 0:
            positive_set.add(num)
        else:
            negative_set.add(-num)
    number = positive_set.symmetric_difference(negative_set)
    popped_number = number.pop()
    return popped_number if popped_number in arr else -popped_number

def solve(arr):
    duplicates = [x for x in arr if arr.count(x) > 1]
    return duplicates[0] if duplicates else sum(arr)

def solve(numbers):
    for x in numbers:
        if not -x in numbers:
            return x

def solve(arr):
    while 1:
        number = arr[0]
        opposite_number = number * (-1)
        if opposite_number in arr:
            arr.remove(number)
            arr.remove(opposite_number)
        else:
            return arr[0]

def solve(arr):

    for n in arr:
        if n < 0 and abs(n) not in arr:
            return n
        elif n > 0 and -n not in arr:
            return n


def solve(arr):
    end = 0
    x = 0
    while end == 0:
        k = 1
        i = arr[x]
        for j in arr:
            if i == j*-1:
                k = 0
        if k == 1:
            ans = i
            end = 1
        x = x + 1
    return ans

def solve(arr):
    for a in arr:
        if -a in arr:
            continue
        if -a not in arr:
            return a

def solve(arr):
    
    pos = [ a for a in arr if a >= 0]
    neg = [ a for a in arr if a < 0]
    
    neg = list(map(abs, neg))
    
    print(pos, neg)
    for element in arr:
        if not(abs(element) in pos and abs(element) in neg):
            return element

def solve(arr):
    a = set(arr)
    return sum(a)


def match(vale,g):
    va=False
    for val in g:
             if val==-vale:
                 va=True
    return(va)
        
def solve(g):
    m=[]
    for val in g :
         if match(val,g)==False:
             m.append(val)
    
    return m[0]  


def solve(arr):
    cleaned = list(set(arr))
    for i in cleaned:
        if not -i in cleaned:
            return i


def solve(a):
    for n in a:
        if -n in a:
            continue
        else:
            return n

def solve(arr):
    arr2 = set(arr)
    return sum(arr2)


def solve(arr):
    return list(set(filter(lambda x: arr.count(x) != arr.count(-x), arr)))[0]

def solve(arr):
    for i in range(0,len(arr)):
        if (-arr[i]) not in arr:
            return arr[i]

def solve(arr):
    
    for i in range(len(arr)):
        if -1*arr[i] not in arr[0:i] + arr[i+1:]:
            return arr[i]

def solve(arr):
    arr.sort()
    l=len(arr)
    neg=[]
    pos=[]
    for i in arr:
        if i <0:
            neg.append(i)
        else:
            pos.append(i)

    if(len(neg)>len(pos)):
        for i in neg:
            if abs(i) not in pos:
                return i
    else:
        for i in pos:
            if -i not in neg:
                return i
    
    
            
       
            
    


def solve(arr):
    return [value for value in arr if -value not in arr][0]
    


def solve(arr):
    arr = set(arr)
    return next(filter(lambda i :not (sum(arr) - i) ,arr))

def solve(arr):
    arr = set(arr)
    for item in arr:
        if not (sum(arr) - item):
            return item

def solve(arr):
    return list(set(x for x in arr if x * -1 not in arr))[0]

def solve(arr):
    new_arr = [val for val in arr if not arr.count(-val)]
    return new_arr[0]

def solve(arr):
    arr = set(arr)
    sum = 0
    for i in arr:
        sum+=i
    return sum

def solve(arr):
    for i in arr:
        if i and -i not in arr:
            return i

def solve(arr):
    for i in arr:
        if -1*i in arr:
            continue
        else:
            return i

def solve(arr):
    a = 1
    for i in arr:
        if arr.count(i) > 1:
            a = arr.count(i)  
    return sum(arr) / a

def solve(arr):
    arr.sort()
    
    while len(arr) >= 1:
        if arr[0] < 0 and abs(arr[0]) in arr:
            x = abs(arr[0])
            arr.remove(arr[0])
            arr.remove(x)
        else:
            return arr[0]

from collections import defaultdict

def solve(arr):
    d = defaultdict(int)
    for x in arr:
        d[abs(x)] += x
    return next(k if k in arr else -k for k,v in d.items() if v != 0)

def solve(arr):
    sing = sum(set(arr))
    return sing

def solve(ar):
    x = len(ar)
    i = 0
    temp = 0
    while i < x:
        c = 0
        char = ar[i]
        while c <= (x - 1):
            if char == (-(ar[c])):
                i += 1
                break
            c += 1
        else:
            temp = char
            return temp

    return temp

def solve(arr):
    for num in arr:
        if arr.count(-num) == 0: return num
    return 


def solve(arr):
    
    for i in arr:
        if -i not in arr:
            return i
    return


def solve(arr):
    return list(set([x for x in arr if -x not in arr]))[0]

def solve(ar):
    
    for item in ar:
        if -item not in ar:
            return item

def solve(arr):
    pos = set([x for x in arr if x>0])
    neg = set([abs(x) for x in list([x for x in arr if x<0])])
    if pos.issubset(neg):return (neg-pos).pop()*(-1)
    else:return (pos-neg).pop()




def solve(arr):
    for idx, num in enumerate(arr):
        if num in (arr[:idx] + arr[idx+1:]):
            return arr[idx]
    return sum(arr)


def solve(arr):
    pos = []
    neg = []
    for i in arr:
        if i < 0:
            neg.append(i)
        else:
            pos.append(i)
    for i in neg:
        if abs(i) not in pos:
            return i
            break
    for j in pos:
        if -j not in neg:
            return j
            break

def solve(arr):
    for i,v in enumerate(arr):
        isTrue = False
        for k,kv in enumerate(arr):
            if i == k:
                continue
            if v == arr[k] * -1:
                isTrue = True
                break
                
        if isTrue == False:
            return v

def solve(arr):
    return sum(arr) / arr.count(max(arr, key = arr.count))

def solve(arr):
    parr = []
    narr = []
    for i in arr:
        if i < 0:
            narr.append(i)
        else:
            parr.append(i)
    res = 0
    for a in narr:
        if abs(a) not in parr:
            res = a
    for b in parr:
        if b*-1 not in narr:
            res = b
    return res



def solve(arr):
  check = []
  for i in arr:
    if -i not in arr:
      return i

from collections import Counter
def solve(arr):
    return sum(arr)/Counter(arr).most_common(1)[0][1]

def solve(arr):
    abs_arr = [abs(n) for n in arr]

    for n in set(abs_arr):
        if not(n in arr and -n in arr):
            return arr[abs_arr.index(n)]

def solve(arr):
    for i in arr:
        m, s = 0, -i
        for j in arr:
            if s == j: m = 1
        if m == 0: return i

def solve(arr):
    for i in arr:
        m = 0
        s = -i
        for j in arr:
            if s == j: m = 1
        if m == 0: return i

def solve(arr):
    for num in arr:
        if num > 0 and -num not in arr:
            return num
        elif num < 0 and num-(num*2) not in arr:
            return num

def solve(arr):
    dict = {}
    for a in arr:
        if abs(a) not in dict:
            dict[abs(a)] = a
        elif dict[abs(a)] == a:
                return a
                break
        else:
            dict[abs(a)] = a + dict[abs(a)]
    for v in list(dict.values()):
        if v != 0:
            return v


def solve(arr):
    newArr = []
    for x in arr:
        if x*-1 not in arr:
            return x

def solve(arr):
    for num in arr:
        if -1 * num not in arr:
            return num

def solve(arr):
    for x in arr:
        if not(x*-1 in arr):
            return x

def solve(arr):
    negative = set([i for i in arr if i < 0])
    positive = set([i for i in arr if i > 0])
    res = None
    for i in negative:
        if i * -1 not in positive:
            res = i
    for i in positive:
        if i * -1 not in negative:
            res = i
    return res

def solve(arr):
    for i in range(len(arr)):
        count = 0
        if arr.count(arr[i]) > 1:
            return arr[i]
        for j in range(len(arr)):
            if arr[i] == (-arr[j]):
                count += 1
        if count != 1: return arr[i]

from collections import Counter
def solve(arr):
    c = Counter(arr)
    for k, v in c.items():
        if (k*-1) not in c.keys():
            return k

import collections
def solve(arr):
    count = collections.Counter(arr)
    for number in arr:
        if not count[-number]:
            return number

def solve(arr):
    for val in arr:
        if -1*val not in arr:
            return val


def solve(arr):
    for i in arr:
        if -1*i in arr:
            continue
        return i

def solve(arr):
    sum = 0
    times = 0
    ele = {}
    for i in arr:
        if i in ele:
            ele[i] = ele[i]+i
        else:
            ele[i] = i
        sum = sum + i
    for k,v in ele.items():
        if v == sum:
            if -k not in arr:
                times = sum/k
    if times > 1:
        sum = sum/times
    return sum

def solve(arr):
    for num in arr:
        if arr.count(num) > arr.count(-num):
            return num
        elif arr.count(-num) >  arr.count(num):
            return -num

def solve(arr):
    for i, el in enumerate(arr):
        if arr.count(el*-1) == 0:
            return el


def solve(arr):
    return sum(dict.fromkeys(arr))

def solve(arr):
    for i in arr:
        if i in arr and i * -1 not in arr:
            return i


def solve(arr):
    for x in arr:
        if (-x) not in arr and x in arr or x not in arr and (-x) in arr:
            return x

def solve(arr):
    for i in arr:
        n=0
        for j in arr:
            n+=1
            if i+j ==0:
                break
            if len(arr)==n and i+j !=0:
                return i

def solve(arr):
    return [i for i in arr if arr.count(-i) == 0][0]

def solve(arr):
    for i in range(len(arr)):
        if arr.count(arr[i]*-1) != 1:
            return arr[i]

def solve(arr):
    while len(set(arr)) > 1:
        for i in range(len(arr) - 1):
            if arr.count(-arr[i]):
                arr.remove(-arr[i])
                arr.remove(arr[i])
                break
    return (list(set(arr))[0])

def solve(arr):
    for i in range(0,len(arr)):
        num = arr[i]
        reversenumber = -num
        found = False
        for index in range(0, len(arr)):
            if i == index :
                continue
            if reversenumber == arr[index]:
                found = True
                break
        if found == False:
            return num