Problem:
 Score: 200 points    Problem Statement  We have N cards. A number a_i is written on the i -th card. Alice and Bob will play a game using these cards. In this game, Alice and Bob alternately take one card. Alice goes first. The game ends when all the cards are taken by the two players, and the score of each player is the sum of the numbers written on the cards he/she has taken. When both players take the optimal strategy to maximize their scores, find Alice's score minus Bob's score.      Constraints   N is an integer between 1 and 100 (inclusive).  a_i \ (1 \leq i \leq N) is an integer between 1 and 100 (inclusive).         Input  Input is given from Standard Input in the following format:  N  a_1  a_2  a_3  ...  a_N       Output  Print Alice's score minus Bob's score when both players take the optimal strategy to maximize their scores.        Sample Input 1 2
3 1      Sample Output 1 2  First, Alice will take the card with 3 . Then, Bob will take the card with 1 .
The difference of their scores will be 3 - 1 = 2 .       Sample Input 2 3
2 7 4      Sample Output 2 5  First, Alice will take the card with 7 . Then, Bob will take the card with 4 . Lastly, Alice will take the card with 2 . The difference of their scores will be 7 - 4 + 2 = 5 . The difference of their scores will be 3 - 1 = 2 .       Sample Input 3 4
20 18 2 18      Sample Output 3 18

Solution (Python):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''

import numpy as np
def main2():
    stdin = open('/dev/stdin')
    N = int(stdin.readline())
    a = np.empty(N, dtype=np.int64)
    for i, c in enumerate(map(int, stdin.readline().split())):
        a[i] = c
    a = np.sort(a)
    if N & 1:
        print(a[::2].sum() - a[1::2].sum())
    else:
        print(a[1::2].sum() - a[::2].sum())
'''

Solution (Python):
N = int(input())
A = [int(n) for n in input().split()]
a = 0
b = 0
for i in range(N):
  n = A.pop(A.index(max(A)))
  if (i % 2):
    b += n
  else:
    a += n
print(a-b)

Solution (Python):
N=int(input())
li=list(map(int,input().split()))
lis=sorted(li,reverse=True)
lisalice=lis[0::2]
lisbob=lis[1::2]
print(sum(lisalice)-sum(lisbob))

Solution (Python):
N = int(input())
a = map(int, input().split(' '))

a=sorted(a, reverse=True)

alice =0
bob   =0

count=0

for i in a:
    if count%2 == 0 :
       alice += i  
    else:
       bob += i
    count+=1

print(alice - bob)

Solution (Python):
N = int(input())
cards = list(map(int, input().split()))
cards.sort()
alice, bob = 0, 0
while True:
    alice += cards.pop()
    if not cards:
        break
    bob += cards.pop()
    if not cards:
        break
print(alice - bob)

Solution (Python):
N = int(input())

a = sorted(map(int,input().split()))

a.reverse()

A = []
B = []

for x in range(0,N,2):
    A.append(a[x])
    
        
for y in range(1,N,2):
    B.append(a[y])
    
print(sum(A)-sum(B))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
A.sort(reverse = True)
Alice = sum(A[::2])
Bob = sum(A)-Alice
print(Alice-Bob)

Solution (Python):
N = int(input())
list = list(map(int,input().split()))
list_alice = []
list_bob = []
list.sort(reverse=True)
for i in range(N):
    if i % 2 ==0:
        list_alice.append(list[i])
    else:
        list_bob.append(list[i])
print(sum(list_alice) - sum(list_bob))

Solution (Python):
n = int(input())
As = sorted(list(map(int, input().split())))
if n % 2 == 1:
    As = [0] + As
print(sum(As[1::2]) - sum(As[::2]))

Solution (Python):
N = int(input())
number = list(map(int, input().split()))

Alice = 0
Bob = 0

number.sort(reverse=True)

for i in range(N):
    if (i % 2) == 0:
        Alice += number[i]
    else:
        Bob   += number[i]

print(Alice - Bob)

Solution (Python):
n = int(input())
nums = sorted([int(tok) for tok in input().split()], reverse = True)

alice = sum([nums[i] for i in range(0, n, 2)])
bob = sum([nums[i] for i in range(1, n, 2)])

print(alice - bob)

Solution (Python):
n=int(input())
li=map(int,input().split())
li=sorted(li)[::-1]
A=0
B=0
for k in range(n//2):
  A += li[2*k]
  B += li[2*k+1]
if n % 2 ==1:
  A += li[n-1]
print(A-B)

Solution (Python):
N = int(input())
arr = list(map(lambda a: int(a), input().split()))
ordered_arr = sorted(arr)
total_a, total_b = 0, 0

for n in range(N):
    if n%2 == 0:
        total_a += ordered_arr[n]
    else:
        total_b += ordered_arr[n]

print(abs(total_a-total_b))

Solution (Python):
n=int(input())
li=sorted(list(map(int,input().split())),reverse=True)
a=0
b=0

for i in range(n):
  if i%2==0:
    a+=li[i]
  else:
    b+=li[i]
print(a-b)

Solution (Python):
N = int(input())
a = [int(i) for i in input().split()]
a.sort(reverse=True)

Alice = 0
Bob = 0
for i in range(N):
    if i%2 == 0:
        Alice += a[i]
    else:
        Bob += a[i]

print(Alice-Bob)

Solution (Python):
n = int(input())
a = sorted([int(x) for x in input().split()], reverse = True)
alice = 0
bob = 0
for x in range(n):
    if x % 2 == 0:
        alice += a[x]
    else:
        bob += a[x]

print(alice - bob)

Solution (Python):
input()
A=sorted(list(map(int,input().split())),reverse=True)
print(sum(A[::2])-sum(A[1::2]))

Solution (Python):
N = int(input())
a = list(map(int,input().split()))
Alice = 0
Bob = 0

for i in range(N):
    for j in range(N-1,i,-1):
        if a[j] < a[j-1]:
            a[j], a[j-1] = a[j-1], a[j]

if N % 2 == 0:
    for k in range(N//2):
        Alice += a[(2*k)+1]
        Bob += a[2*k]
        

else:
    for k in range(N//2):
        Alice += a[2*k]
        Bob += a[2*k+1]
    Alice += a[N-1]

print(Alice-Bob)

Solution (Python):
N = int(input())
nums = sorted(map(int,input().split()),reverse=True)
count = 0

for i in range(N):
    if i%2==0:
        count += nums[i]
    else:
        count -= nums[i]
        
print(count)

Solution (Python):
_ = int(input())
a = sorted(list(map(int, input().split())))[::-1]
print(sum(a[::2]) - sum(a[1::2]))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)

alice = sum(a[::2])
bob = sum(a[1::2])

print(alice - bob)

Solution (Python):
n = list(map(int , input().split()))
a = list(map(int , input().split()))

a = sorted(a, reverse=True)
al = 0
bo = 0
for i, aa in enumerate(a):
    if i %2 == 0:
        al += aa
    else:
        bo += aa
print(al -bo)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a = sorted(a, reverse=True)
alice = sum(a[::2])
bob = sum(a[1::2])
print(alice - bob)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
Alice = 0
Bob = 0
for i in range(N):
  if i%2 == 0:
    Alice += A[i]
  else:
    Bob += A[i]
ans = Alice - Bob
print(ans)

Solution (Python):
N=int(input())
a=list(map(int,input().split()))
a.sort()
a=a[::-1]

for i in range(1,N,2):
  a[i] *= -1
print(sum(a))

Solution (Python):
n=int(input())
As=list(map(int,input().split()))
As.sort(reverse=True)

alice,bob=0,0
for i in range(len(As)):
  if i%2==0:
    alice+=As[i]
  else:
    bob+=As[i]

print(alice-bob)

Solution (Python):
N = int(input())
a = list(map(int,input().split()))
a_sort = sorted(a,reverse=True)
ans = sum(a_sort[::2]) - sum(a_sort[1::2])
print(ans)

Solution (Python):
def test():
    n = int(input())
    a = list(map(int,input().split()))
    flag = 0
    alice = 0; bob = 0
    for i in range(n):
        if flag == 0:
            alice += max(a)
            a.remove(max(a))
            flag = 1
        elif flag == 1:
            bob += max(a)
            a.remove(max(a))
            flag = 0
    print(alice-bob)


if __name__ == "__main__":
    test()

Solution (Python):
def resolve():
    n = int(input())
    a = sorted(list(map(int, input().split())), reverse=True)
    print(sum(a[::2]) - sum(a[1::2]))


if __name__ == "__main__":
    resolve()

Solution (Python):
import sys
N = int(sys.stdin.readline().rstrip())
p = list(map(int, sys.stdin.readline().rstrip().split()))
p = sorted(p, reverse = True)
A = 0
B = 0
for i in range(N):
    if i%2 == 0:
        A += p[i]
    else:
        B += p[i]
print(A - B)

Solution (Python):
from collections import defaultdict, Counter
from heapq import heapify, heappop, heappush
from sys import stdin

def main():
    n = int(input())
    A = [int(x) for x in input().split()]
    A.sort(reverse=True)
    is_alice_turn = True
    ans = 0
    for i in range(n):
        if is_alice_turn:
            ans += A[i]
        else:
            ans -= A[i]
        is_alice_turn = not is_alice_turn
    print(ans)

input = lambda: stdin.readline().rstrip()
main()

Solution (Python):
N=int(input())

b=list(map(int,input().split()))

b.sort(reverse=True)

alice=[]
bob=[]

for i in range(N):
    if i==0:
        alice.append(b[i])
    elif i%2==0:
        alice.append(b[i])
    else :
        bob.append(b[i])

print(sum(alice)-sum(bob))

Solution (Python):
n = int(input())
nums = sorted(map(int, input().split()), reverse=True)
a = sum(nums[::2])
b = sum(nums[1::2])
print(a - b)

Solution (Python):
n = int(input())
nums = sorted(list(map(int, input().split())), key=lambda x: -x)
alice = 0
bob = 0
for i, num in enumerate(nums):
    if i % 2 == 0:
        alice += num
    else:
        bob += num
print(alice - bob)

Solution (Python):



n = int(input().split()[0])
a_list = list(map(int, input().split()))

a_list = sorted(a_list, reverse=True)
p_alice = sum(a_list[::2])
p_bob = sum(a_list[1::2])
ans = p_alice - p_bob
print(ans)

Solution (Python):
input()
lst = sorted(list(map(int, input().split())))[::-1]
print(sum(lst[::2]) - sum(lst[1::2]))

Solution (Python):
input()
l=sorted(map(int,input().split()))[::-1]
print(sum(l[::2])-sum(l[1::2]))

Solution (Python):
n=int(input())
a=sorted(list(map(int,input().split())),reverse=True)
print(sum(a[0::2])-sum(a[1::2]))

Solution (Python):
import math
import numpy as np










n = input()
a = list(map(int, input().split()))
a = sorted(a,reverse = True)
print(sum(a[::2]) - sum(a[1::2]))

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
A = sorted(a,reverse=True)
alice = []
bob = []
if n%2==0:
    for i in range(n//2):
        alice.append(A[0])
        A.pop(0)
        bob.append(A[0])
        A.pop(0)
    print(sum(alice)-sum(bob))
else:
    for i in range(n//2):
        alice.append(A[0])
        A.pop(0)
        bob.append(A[0])
        A.pop(0)
    alice.append(A[0])
    print(sum(alice)-sum(bob))

Solution (Python):
n = int(input())
l = sorted(list(map(int, input().split())), reverse = True)
ali = 0
bob = 0
if n % 2 == 1:
    ali = l[n-1]
for i in range(n//2):
    ali += l[i*2]
    bob += l[i*2+1]
print(ali - bob)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse = True)

Alice = 0
Bob = 0
for x in range(n):
    if x % 2 == 0:
        Alice += a[x]
    else:
        Bob += a[x]

print(Alice-Bob)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))

A = []
B = []

while N > 0:
    A.append(max(a))
    a.remove(max(a))
    N -= 1
    if N != 0:
        B.append(max(a))
        a.remove(max(a))
        N -= 1

print(sum(A) - sum(B))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))

a.sort()
a.reverse()

print(sum(a[::2])-sum(a[1::2]))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))

a.sort()
a.reverse()

alice,bob=0,0

if n%2 == 0:
    for i in range(int(n/2)):
        alice += a[2*i]
        bob += a[2*i+1]
else:
    for i in range(int((n+1)/2)):
            alice += a[2*i]
            bob += a[2*i+1] if 2*i+1<len(a) else 0

print(alice-bob)

Solution (Python):
n = int(input())
src = list(map(int, input().split()))
a = 0
b = 0
srt = sorted(src, reverse=True)
for i,s in enumerate(srt):
    if i%2 == 0:
        a += s
    else:
        b += s
print(a-b)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
a.sort()
A_score = 0
B_score = 0
counter = 0
while len(a)>0:
  if counter % 2 == 0:
    A_score += a.pop()
  else:
    B_score += a.pop()
  counter += 1

print(A_score - B_score)