Problem:
 Score : 300 points    Problem Statement You are playing the following game with Joisino.   Initially, you have a blank sheet of paper.  Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.  Then, you are asked a question: How many numbers are written on the sheet now?   The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?      Constraints  1≤N≤100000  1≤A_i≤1000000000(=10^9)  All input values are integers.         Input Input is given from Standard Input in the following format:  N  A_1  :  A_N       Output Print how many numbers will be written on the sheet at the end of the game.        Sample Input 1 3
6
2
6      Sample Output 1 1  The game proceeds as follows:    6 is not written on the sheet, so write 6 .    2 is not written on the sheet, so write 2 .    6 is written on the sheet, so erase 6 .    Thus, the sheet contains only 2 in the end. The answer is 1 .       Sample Input 2 4
2
5
5
2      Sample Output 2 0  It is possible that no number is written on the sheet in the end.       Sample Input 3 6
12
22
16
22
18
12      Sample Output 3 2

Solution (Python):
d = {}
for i in range(input()):
  a = input()
  try:
    d[a] += 1
  except KeyError:
    d[a] = 1

print len(filter(lambda x: x % 2, map(lambda x: d[x], d)))

Solution (Python):
n=int(input())
buff=[]
ans=1
for i in range(n):
    buff.append(input())

a=sorted(buff)

for i in range(1,n):
    if a[i] == a[i-1]:
        a[i-1]= -1
        a[i]= -1
        if ans>0:
            ans -= 1
    else:
        ans += 1

print(ans)

Solution (Python):
n = input()
d = {}
for i in range(n):
  a = input()
  try:
    d[a] += 1
  except KeyError:
    d[a] = 1

cnt = 0
for k in d:
  if d[k] % 2 == 1:
    cnt += 1

print cnt

Solution (Python):
n = int(input())
ans = set()
for i in range(n):
    a = input()
    if a in ans:
        ans.remove(a)
    else:
        ans.add(a)
 
print(len(ans))

Solution (Python):
N = int(input())
ans = set()
for i in range(N):
    num = int(input())
    if num in ans:
        ans.remove(num)
    else:
        ans.add(num)
print(len(ans))

Solution (Python):
n = int(input())
card = set()

for i in range(n):
    num = int(input())
    if num in card:
        card.remove(num)
    else:
        card.add(num)
print(len(card))

Solution (Python):
a=input()
b=[]
for i in range(a):
    b.append(input())
b.sort()
c=[]
pre=0
time=0
for i in b:
    if pre==i:
        time+=1
    else:
        if time%2==1:
            c.append(pre)
        pre=i
        time=1
if time%2!=0 and pre!=0:
    c.append(pre)
print len(c)

Solution (Python):
N=int(input())
A=set()
for i in range(N):
    a=int(input())
    if a not in A:
        A.add(a)
    else:
        A.remove(a)
print(len(A))

Solution (Python):

N = int(input())
x = [int(input()) for i in range(N)]

x.sort()
i=0
while i < N-1:
    if x[i]==x[i+1]:
        del x[i+1]
        del x[i]
        N-=2
        continue
    i+=1
print(len(x))

Solution (Python):
import sys
from collections import Counter




def read_int_list():
    return list(map(int, input().split()))


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


def main():
    n = read_int()
    c = Counter()
    for i in range(n):
        a = read_int()
        c[a] += 1

    res = 0
    for j in c:
        if c[j] % 2 != 0:
            res += 1
    print(res)


main()

Solution (Python):
n = int(input())
arr = set()
for i in range(n):
    num = int(input())
    if num in arr:
        arr.remove(num)
    else:
        arr.add(num)
print(len(arr))

Solution (Python):
n = input()

dic = {}

for i in range(n):
    a = input()
    if a not in dic:
        dic[a] = 1
    elif dic[a] == 0:
        dic[a] = 1
    else:
        dic[a] = 0

keys = dic.keys()
ct = 0
for i in keys:
    if dic[i] > 0:
        ct += 1

print ct

Solution (Python):
n = int(input())
d = dict()
for i in range(n):
    a = int(input())
    if a in d:
        if d[a] == 0:
            d[a] = 1
        else:
            d[a] = 0
    else:
        d[a] = 1

print(sum(d.values()))

Solution (Python):
time = int(input())
ans = []
n = 0
for i in range(time):
    ans.append(input())
ans.sort(key=int)
while n+1 < len(ans):
    if ans[n] == ans[int(n + 1)]:
        ans.pop(n)
        ans.pop(n)
    else:
        n += 1
print(len(ans))

Solution (Python):
n = int(input())
a = {}
for i in range(n):
    b = int(input())
    if b in a.keys():
        a[b] += 1
    else:
        a[b] = 1
ans = 0
for i in a.keys():
    if a[i]%2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
A = [int(input()) for i in range(n)]

b = set()
lenB = 0
for a in A:
    b.add(a)
    lenB += 1
    if len(b) != lenB:
        b.remove(a)
        lenB -= 2
print(len(b))

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

array = []
for i in range(n):
	a = int(input())
	array.append(a)

array.sort()
last = -1
count = 0
ans = 0

for i in range(len(array)):
	if last != array[i]:
		if count % 2 == 1:
			ans += 1
		
		count = 1
	else:
		count += 1
		
	last = array[i]

if count % 2 == 1:
	ans += 1

print(ans)

Solution (Python):
from sys import stdin
n = int(stdin.readline())
di = {}
for i in xrange(n):
 m = int(stdin.readline())
 di[m] = di.get(m,0)^1
ans = 0
for i in di:
 ans += di[i]
print ans

Solution (Python):
N = int(raw_input())
A = map(int, [raw_input() for _ in xrange(N)])

s = set()
for x in A:
    if x in s:
        s.remove(x)
    else:
        s.add(x)
print len(s)

Solution (Python):
A={-1:False}
n=int(input())
count=0
for i in range(n):
    num=int(input())
    try:
        
        if(A[num]==True):
            count-=1
            A[num]=False
        else:
            count+=1
            A[num]=True
    except:
        
        A[num]=True
        count+=1
print(count)

Solution (Python):
N = int(input())
A = [int(input()) for n in range(N)]
A = sorted(A)

res = []
tmp = A[0]
count = 1
for i in range(1,N):
    if A[i] == tmp:
        count += 1
    else:
        res.append(count%2 != 0)
        count = 1
    tmp = A[i]
res.append(count%2 != 0)

print(sum(res))

Solution (Python):


n=int(input())
ans_dict={}
for i in range(0, n):
    a=input()
    if not a in ans_dict:
        ans_dict[a]=1
    else:
        ans_dict[a]+=1
sum=0
for thing in ans_dict:
    if ans_dict[thing]%2:
        sum+=1
print(sum)

Solution (Python):
as_ = set()
for _ in range(int(input())):
    a = int(input())
    if a in as_:
        as_.remove(a)
    else:
        as_.add(a)
 
print(len(as_))

Solution (Python):
N = int(input())
A = []

s = set()

for _ in range(N):
    inp = input()
    if inp in s:
        s.remove(inp)
    else:
        s.add(inp)

print(len(s))

Solution (Python):
import collections
N = int(input())
answer = 0
flag = collections.defaultdict(int)

for i in range(N):
  a = int(input())
  flag[a] = (flag[a]+1)%2

list = list(flag.values())

for i in range(len(list)):
  if list[i] == 1:
    answer+=1

print(answer)

Solution (Python):
import numpy as np
hoge = input()
N = int(hoge)
paper ={}
for i in range(N):
    hoge = input()
    hoge = hoge.strip()
    if hoge in paper:
        paper.pop(hoge)
    else:
        paper[hoge] = 1
    
print(len(paper))

Solution (Python):

def solve():  
    N = int(input())
    joisino_list = {}
    cnt = 0

    for _ in range(N):
        a = int(input())

        if a in joisino_list:
            joisino_list[a] += 1
        else:
            joisino_list[a] = 1

    for i in joisino_list.values():
        if i % 2:
            cnt += 1

    print(cnt)
    
  
solve()

Solution (Python):
l=int(input())
 
dic={}
for i in range(l):
    a=input()
    dic[a]=dic.get(a, 0) + 1
n=0
for x in dic.values():
    if x%2==1:
        n+=1

print(n)

Solution (Python):
from collections import defaultdict 

N = int(raw_input())
d = defaultdict(int)
for i in xrange(N):
    A = int(raw_input())
    d[A] = (d[A] + 1) % 2
ans = 0
for v in d.values():
    ans += v
print ans

Solution (Python):
num = int(input())
ary = []
ans = 0
for a in range(num):
    ary.append(int(input()))
ary.sort()
ikkomae = ary[0]
count = 1
for a in range(num):
    ind = a + 1
    if ind == num:
        break
    imano = ary[ind]
    if ikkomae == imano:
        count+=1
    else:
        if(count%2==1):
            ans+=1
        count = 1
    ikkomae = imano
if(count%2==1):
    ans+=1
print(ans)

Solution (Python):
N=input()
d={}
r=0
for i in range(N):
    a=input()
    d[a]=d.get(a,0)+1
    r+=1
    if d[a]%2==0:
        r-=2
print r

Solution (Python):
from collections import Counter
n=int(input())
a=[int(input()) for i in range(n)]
ans=0
for k,v in Counter(a).items():
    if v%2!=0:
        ans+=1
print(ans)

Solution (Python):
from collections import Counter
def main():
    N=int(input())
    l=[]
    for i in range(N):
        l.append(int(input()))
    c=Counter(l)
    ans=0
    for i in c:
        if c[i]%2==1:
            ans+=1
    print(ans)

if __name__=='__main__':
    main()

Solution (Python):


n = int(input())
pool = {}
for i in range(n):
    a = int(input())
    if a not in pool:
        pool[a] = True
    else:
       del pool[a]
print(len(pool))

Solution (Python):
import functools
import collections
n = int(input())
print(sum(
    map(
        lambda x: x % 2,
        functools.reduce(
            lambda d, v: d.update({v: d[v]+1}) or d,
            [int(input()) for i in range(n)],
            collections.defaultdict(lambda: 0),
        ).values(),
    )
))

Solution (Python):
import collections

N = int(input())

def mod2(n):
    a = n % 2
    return a

lis = []
for i in range(N):
    a = int(input())
    lis.append(a)

count = collections.Counter(lis)

print(sum(map(mod2, count.values())))

Solution (Python):
from collections import Counter
def read_line(*types): return [f(a) for a, f in zip(input().split(), types)]

n, = read_line(int)

counter = Counter()
for _ in range(n):
    a, = read_line(int)
    counter[a] += 1

count = 0
for n in counter.values():
    if n % 2 != 0:
        count += 1

print(count)

Solution (Python):
import numpy as np
N = int(input())
ans = set()
for i in range(N):
    A = int(input())
    if A in ans:
        ans.remove(A)
    else:
        ans.add(A)
        
print(len(ans))

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

A=[int(input()) for i in range(N)]
A.sort()
ans=N

flag=False

for i in range(N-1):
	if flag==True:
		flag=False
		continue
	elif A[i]==A[i+1]:
		ans-=2
		flag=True

print(ans)

Solution (Python):
def C_WriteandErase(N, A):
    import collections
    count_dict = collections.Counter(A)  
    ans = 0
    for k, v in count_dict.items():  
        if v % 2 == 0:  
            pass
        else:
            ans += 1  
    return ans

N = int(input())
A = [int(input()) for i in range(N)]
print(C_WriteandErase(N, A))

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

num={}
for i in range(N):
    a=int(raw_input())
    if a in num:
        num[a]^=1
    else:
        num[a]=1

c=0
for k in num:
    if num[k]==1:
        c+=1
print c

Solution (Python):
from collections import Counter
n = int(input())
numbers = [input() for i in range(n)]
counter = Counter(numbers)
how = []
for w, c in counter.most_common():
    if int(c) % 2 == 1:
        how.append(w)
print(len(how))

Solution (Python):
from collections import Counter

N = int(input())
a = [int(input()) for i in range(N)]

counter = Counter(a)

ans = 0
for num in counter:
	if counter[num] % 2 == 1:
		ans += 1

        
print(ans)

Solution (Python):
n = int(input())
a = []
for i in range(n):
    a.append(int(input()))
a.sort()
ans = 0
t = 1
for i in range(1,n):
    if a[i]!=a[i-1]:
        if t%2 == 1:
            ans += 1
        t = 1
    else :
        t += 1
if t%2 == 1:
    ans += 1
print(ans)

Solution (Python):
n=int(raw_input())
li={}
while n !=0:
    a = raw_input()
    if a in li:
        del li[a]
    else:
        li[a]=a
    n-=1
print(len(li))

Solution (Python):
import sys

written = set()

N = int(sys.stdin.readline())

for i in range(N):
    tmp = int(sys.stdin.readline())
    if tmp in written:
        written.remove(tmp)
    else:
        written.add(tmp)
print(len(written))

Solution (Python):
N = int(input())
ans = set()
for i in range(N):
    A = int(input())
    if A in ans:
        ans.remove(A)
    else:
        ans.add(A)
        
print(len(ans))

Solution (Python):
N = int(input())
A = [int(input()) for _ in range(N)]
A.sort()


def customCount(idx):
    target = A[idx]
    cnt = 1
    idx += 1
    while True:
        if idx == N or A[idx] != target:
            return cnt
        else:
            idx += 1
            cnt += 1


index = 0
result = 0
while True:
    num = customCount(index)
    index += num
    if (num % 2) == 1:
        result += 1
    if N <= index:
        break
print(result)

Solution (Python):
from collections import defaultdict

def main():
    d = defaultdict(lambda: 0)
    n = int(input())
    for _ in range(n):
        x = int(input())
        d[x] += 1

    cnt = 0
    for key, value in sorted(d.items(), key=lambda x: x[1], reverse=True):
        if value%2 == 1:
            cnt += 1
    print(cnt)
    

if __name__ == "__main__":
    main()

Solution (Python):
num=int(raw_input())
tmp={}
for i in range(num):
    a=int(raw_input())
    if a in tmp:
        tmp[a]+=1
    else:
        tmp[a]=1

output=0
for i in tmp:
    if tmp[i]%2 ==1:
        output+=1
print output

Solution (Python):
a = int(input())
s = set()
t = 0
for i in range(a):
   nb = int(input())
   if nb in s:
      s.remove(nb)
      t -= 1
   else:
      s.add(nb)
      t += 1
print(t)

Solution (Python):
from collections import Counter

if __name__ == '__main__':
    N = int(input())
    A = []
    for i in range(N):
        A.append(int(input()))

    counter_a = Counter(A)

    ans = 0
    for count in counter_a.values():
        if count % 2 != 0:
            ans += 1
    
    print(ans)

Solution (Python):
n = int(input())
a = [0] * n
d = {}
for i in range(n):
    a[i] = int(input())
    d[a[i]] = 0

for i in a:
    d[i] += 1

ans = 0
for k, i in d.items():
    if i % 2 == 1:
        ans += 1

print(ans)

Solution (Python):


N = int(input())
A = []
for i in range(N):
    A.append(int(input()))
    
import collections
c = collections.Counter(A)

cnt = 0
for i in c.values():
    cnt += i%2
print(cnt)

Solution (Python):
n = int(input())
a = [int(input()) for i in range(n)]

a.sort()

for i in range(n-1):
    if a[i] == a[i+1]:
        a[i] = 0
        a[i+1] = 0

print(len(a)-a.count(0))

Solution (Python):
N = input()
num = {}
for _ in xrange(N):
    a = raw_input().strip()
    if a in num: 
        num[a] += 1
    else:
        num[a] = 1
c = 0
for key in num:
    if(num[key]%2 == 1): c += 1
print c

Solution (Python):
N = int(input())
s = set()
for i in range(N):
  a = int(input())
  if a in s:
    s.remove(a)
  else:
    s.add(a)

print(len(s))

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

left=set()
for _ in range(n):
    i=input()
    if i in left:
        left.remove(i)
    else:
        left.add(i)
print(len(left))

Solution (Python):
import collections

N = int(input())
que = [int(input()) for i in range(N)]
count = 0
count_dict = collections.Counter(que)
for k, v in count_dict.items():
    if v % 2 == 1:
        count += 1
print(count)

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

a = [int(input()) for i in range(N)]

a = sorted(a)

t = 0
b = False
ans = 0
for i in range(N):
    if not a[i] == t:
        if b:
            ans += 1
        t = a[i]
        b = True
    else:
        if b:
            b = False
        else:
            b = True
if b:
    ans += 1


print(ans)

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

for i in range(N):
    new_num = input()
    if new_num in number_set:
        number_set.remove(new_num)
    else:
        number_set.add(new_num)

print(len(number_set))

Solution (Python):
from collections import defaultdict

n = int(input())
l = defaultdict(int)
for _ in range(n):
    a = input()
    l[a] += 1
ans = 0
for i in l.values():
    if i % 2 == 1:
        ans += 1
    else:
        pass
print(ans)

Solution (Python):


import os
import sys
import math
import numpy as np


N = int(input())
A = np.array([int(input()) for i in range(N)])

counter = {}

for a in A:
    if a in counter.keys():
        counter[a] = abs(counter[a] - 1)
    else:
        counter[a] = 1

print(sum(counter.values()))

Solution (Python):
N = int(input())
s = set()
for i in range(N):
    a = int(input())
    s.remove(a) if a in s else s.add(a)

print(len(s))

Solution (Python):
from collections import Counter
n = int(input())
a = []
for _ in range(n):
  i = int(input())
  a.append(i)
col = Counter(a)
ans = 0
for c in col.values():
	if c % 2 == 1: ans += 1
print(ans)

Solution (Python):
import collections as col


n = int(input())
ary = []
for _ in range(n):
    ary.append(input())

ary = col.Counter(ary)

print(len([v for v in ary.values() if v%2 != 0]))

Solution (Python):


import sys

def main(argv):
    line = sys.stdin.readline()
    while line:
        N = int(line)
        sheet = set()
        for i in xrange(N):
            a = sys.stdin.readline()
            if a in sheet:
                sheet.remove(a)
            else:
                sheet.add(a)
        print(len(sheet))
        line = sys.stdin.readline()
        

if __name__ == "__main__":
    main(sys.argv)

Solution (Python):
from collections import Counter
n = int(input())
data = []
for _ in range(n):
    data.append(input())
counter = Counter(data)
ans = 0
for _,count in counter.most_common():
    if count%2 != 0:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
writing = set()
for n in range(N):
    A = int(input())
    if A in writing:
        writing.remove(A)
    else:
        writing.add(A)
print(len(writing))

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

p = set()
for i in range(N):
    A = input()
    p ^= {A}

print(len(p))

Solution (Python):
from collections import Counter


def main():
    N = int(input())
    counter = Counter(
        int(input())
        for _ in range(N)
    )
    answer = sum(
        1
        for v in counter.values()
        if v % 2 != 0
    )
    print(answer)

if __name__ == '__main__':
    main()

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

a = {}

for _ in range(n):
    b = int(input())
    if b in a:
        del a[b]
    else:
        a[b] = True

print(len(a.keys()))

Solution (Python):

"""
"""


Memo = []
def solve(data):
    global Memo
    for d in data:
        if d in Memo:
            Memo.remove(d)
        else:
            Memo.append(d)
    return len(Memo)


def solve2(data):
    from collections import Counter
    c = Counter(data).most_common()
    remaining = [x for x in c if x[1]%2==1]
    return len(remaining)


def main():
    N = int(input())
    data = [int(input()) for _ in range(N)]
    result = solve2(data)
    print(result)


if __name__ == '__main__':
    main()

Solution (Python):
N = input()
a = [input() for i in range(N)]


dict={}


for i in range(N):
	if a[i] in dict:
		dict[ a[i] ]+=1 
	else:
		dict[ a[i] ]=1



cnt=0
for key,value in dict.items():			
	cnt+=value%2

print cnt

Solution (Python):
from collections import Counter
N = int(input())

ans = []
for i in range(N): 
    a = int(input())
    ans.append(a)

count = Counter(ans)

anser = 0
for _ in count.values():
    if _ % 2 == 1:
        anser += 1

print(anser)

Solution (Python):



n = raw_input()
n = int(n)

al = []

for i in range(n):
    a = raw_input()
    a = int(a)
    al.append(a)

al.sort()

num = 0

i = 0
while i < n:
    if i == n-1:
        num += 1
        break
    if al[i] == al[i+1]:
        i += 2
    else:
        num += 1
        i += 1

print num

Solution (Python):
N = int(input())
s = set()
res = 0
for _ in range(N):
    x = int(input())
    if x in s:
        s.remove(x)
        res -= 1
    else:
        s.add(x)
        res += 1
print(res)

Solution (Python):
import collections

N = int(input())
A = [int(input()) for _ in range(N)]

d = collections.Counter(A)
print(sum([1 for k, v in d.items() if v % 2] ))

Solution (Python):
def solution():
	n = int(input())
	l = []
	for i in range(n):
		x = int(input())
		l.append(x)

	l.sort()

	i = 0
	ans = 0
	while i<(n-1):
		if l[i]==l[i+1]:
			i+=2
		else:
			i+=1
			ans+=1
	if i==n-1:
		ans+=1
			

	print(ans)

solution()

Solution (Python):
def main():
    N = int(input())
    A = tuple(int(input()) for _ in range(N))

    num = dict()
    for n in A:
        num[n] = num.get(n, 0) + 1

    ans = 0
    for v in num.values():
        ans += v % 2

    print(ans)

main()

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

a = {}
for i in range(N):
    a_i = int(input())
    if a_i in a:
        del a[a_i]
    else:
        a[a_i] = 1

print(len(a))

Solution (Python):
from collections import defaultdict

N = int(input())

a = defaultdict(lambda: 0)

for _ in range(N):
    x = int(input())
    if a[x]:
        a[x] -= 1
    else:
        a[x] += 1

print(sum(a.values()))

Solution (Python):

N = int(input())
ans = 0
array = []
d = {}
for tmp in range(N):
    a = int(input())
    array.append(a)
    if a not in d:
        d[a] = 1
    else:
        d[a] += 1
array = list(set(array))
for tmp in range(len(array)):
    if d[array[tmp]]%2 == 1:
        ans += 1
    else:
        pass
print(ans)

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

moji = set()
for i in range(n):
    a = int(input())
    if a in moji:
        moji.remove(a)
    else:
        moji.add(a)
        
    
print(len(moji))

Solution (Python):
N = int(input()) 
l = [int(input()) for i in range(N)] 

l.sort()


a=0
ans=0
for i in l:
	if i==a:
		ans -= 1
		a=0
	else:
		ans += 1
		a=i

print(ans)

Solution (Python):
N = int(input())
s = set()
for i in range(N):
    A = input()
    if A in s:
        s.remove(A)
    else:
        s.add(A)
print(len(s))

Solution (Python):


import sys


def main():
    _ = sys.stdin.readline()
    arr = set()
    for line in sys.stdin:
        num = line.rstrip()
        if num in arr:
            arr.remove(num)
        else:
            arr.add(num)
    print(len(arr))


if __name__ == "__main__":
    main()

Solution (Python):
n = int(raw_input())
s = {1,5}
s.remove(1)
s.remove(5)
for _ in xrange(n):
	a = int(raw_input())
	if a in s:
		s.remove(a)
	else:
		s.add(a)
print(len(s))

Solution (Python):
n=int(input())
a=[]
for i in [0]*n:
    a.append(input())
from collections import Counter
c=Counter(a)
ans=0
for i in c:
    if c[i]%2==1:
        ans+=1
print(ans)

Solution (Python):

N = int(raw_input().rstrip())
A = {}
for i in range(N):
    a = int(raw_input())
    if a in A:
        if A[a] == 1:
            A[a] = 0
        else:
            A[a] = 1
    else:
        A[a] = 1
print sum(A.values())

Solution (Python):
from collections import defaultdict
lst= defaultdict(bool)
for i in range(int(input())):
    t = input()
    lst[t] = not lst[t]

print(len([x for x in lst if lst[x]]))

Solution (Python):
n = int(input())
m = set()
while n:
    x = int(input())
    if x in m:
        m.remove(x)
    else:
        m.add(x)
    n -= 1
print(len(m))

Solution (Python):
N = int(input())
d = {}
for i in range(N):
    a = int(input())
    if a in d:
        d[a] = 1 - d[a]
    else:
        d[a] = 1
print(sum(d.values()))

Solution (Python):
def c():
    from collections import Counter
    n = int(input())
    a = [int(input()) for _ in range(n)]
    c = dict(Counter(a))
    total = 0
    for v in c.values():
        total += v % 2
    print(total)

c()

Solution (Python):
N = input()
S = set()
for _ in range(N):
    A = input()
    if A in S:
        S.remove(A)
    else:
        S.add(A)
print len(S)

Solution (Python):


N = int(input())
nums = set()

for i in range(N):
    A = int(input())

    if A in nums:
        nums.remove(A)
    else:
        nums.add(A)
print(len(nums))

Solution (Python):
from collections import Counter
N = int(input())
numbers = [int(input()) for i in range(N)]

num_cnt = Counter(numbers)

ans_box = list(filter(lambda x:x%2==1 , num_cnt.values()))
print(len(ans_box))

Solution (Python):
N = int(input())
from collections import Counter
c = []
for i in range(N):
    c.append(int(input()))

c=Counter(c)
print(sum([1 for k, v in c.items() if v % 2 != 0]))

Solution (Python):


N=int(input())
a=[]
for i in range(N):
    a.append(int(input()))

chk={}

for sa in a:
    if sa in chk:
        if chk[sa]==1:
            chk[sa]=0
        else:
            chk[sa]=1
    else:
        chk[sa]=1


print(sum(chk.values()))

Solution (Python):
N = int(input())
A = {}
for i in range(N):
    a = int(input())
    if a not in A:
        A[a] = 0
    A[a] = A[a] + 1
num = 0
for k, v in A.items():
    if v % 2 == 1:
        num = num + 1
print(num)

Solution (Python):
s = set()
n = int(input())
for _ in range(n):
    x = int(input())
    if x in s:
        s.remove(x)
    else:
        s.add(x)

print(len(s))

Solution (Python):





def main():
    N = int(input())

    nums = set()
    for _ in range(N):
        a = int(input())
        if a in nums:
            nums.remove(a)
        else:
            nums.add(a)

    print(len(nums))

if __name__ == "__main__": main()

Solution (Python):
def i1():
 return int(input())
def i2():
 return [int(i) for i in input().split()]
from collections import defaultdict
d = defaultdict(int)
n=i1()
a=0
for i in range(n):
    d[i1()]+=1
for i in d.values():
    if i%2==1:
      a+=1
print(a)

Solution (Python):
N = int(input())
s = set()
for i in range(N):
    j = int(input())
    if j in s:
        s.remove(j)
    else:
         s.add(j)

print(len(s))

Solution (Python):
from collections import Counter

n = int(input())
values = Counter([int(input()) for _ in range(n)])
ans = 0
for number in values.keys():
    if values[number] % 2 != 0:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
A = set()
for _ in range(N):
  a = int(input())
  if a in A:
    A.remove(a)
  else:
    A.add(a)
print(len(A))

Solution (Python):

import heapq
import math

N = int(input())
A = []
for i in range(N):
    A.append(int(input()))
A = sorted(A)
num = 0
bef = None
count = 0
for a in A:
    if bef is None:
        bef = a
    if bef == a:
        count += 1
    else:
        if count % 2 == 1:
            num += 1
        count = 1
    bef = a
if count % 2 == 1:
    num += 1

print(num)

Solution (Python):
n = int(input())
cnt = {}
for _ in range(n):
    a = int(input())
    if a in cnt:
        cnt[a] += 1
    else:
        cnt[a] = 1
ans = 0
for v in cnt.values():
    ans += v % 2
print(ans)

Solution (Python):
import copy
import sys
import numpy as np

from math import *
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline

def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N] = [int(input_raw[0])]
    num_set = set([])
    for i in range(N):
        input_raw = read_func().strip().split()
        val = int(input_raw[0])
        if val not in num_set:
            num_set.add(val)
        else:
            num_set.remove(val)

    print len(num_set)


if __name__ == '__main__':
    main()

Solution (Python):
n=int(raw_input())
res = set([])
for i in range(n) :
    x = int(raw_input())
    if x in res :
        res.remove(x)
    else :
        res.add(x)
print len(res)

Solution (Python):
N = int(raw_input())
d = {}
for n in xrange(N):
  a = int(raw_input())
  d[a] = d.get(a, 0) + 1

answer = 0
for x in d.itervalues():
  if x % 2 == 1:
    answer += 1

print answer

Solution (Python):
from collections import Counter

n = int(input())
cnt = Counter(int(input()) for _ in range(n))
print(sum(1 for k, v in cnt.most_common() if v % 2 == 1))

Solution (Python):
from collections import Counter
N = int(input())
src = [int(input()) for i in range(N)]
counter = Counter(src)

ans = 0
for v in counter.values():
    if v%2 == 1:
        ans += 1
print(ans)

Solution (Python):

def get_ln_inputs():
    return input().split()


def get_ln_int_inputs():
    return list(map(int, get_ln_inputs()))


def main():
    N = get_ln_int_inputs()[0]
    A = list()
    for _ in range(N):
        A.append(get_ln_int_inputs()[0])

    res = {}
    for a in A:
        if not a in res:
            res[a] = 1
        else:
            del res[a]
    print(len(res))
    return


main()

Solution (Python):
n = int(input())
h = set()
for i in range(n):
    a = int(input())
    if a in h:
        h.remove(a)
    else:
        h.add(a)
print(len(h))

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

f = {}
for i in range(n):
    a = int(input())
    if not f.get(a):
        f[a] = True
    else:
        f[a] = None

print(sum(1 for i in f if f[i]))

Solution (Python):

N = int(input())
P = dict()
for _ in range(N):
    A = int(input())
    if A not in P.keys():
        P[A] = 1
    else:
        P[A] = (P[A] + 1) % 2
        
print(sum(P.values()))

Solution (Python):
import collections
n = int(input())
a = [int(input()) for i in range(n)]
cnt = collections.Counter(a)
total = 0
for c, v in cnt.items():
    if v%2 == 1:
        total += 1
print(total)

Solution (Python):
from collections import Counter

n = int(input())
c = Counter(int(input()) for _ in range(n))
print(sum(v & 1 for v in c.values()))

Solution (Python):
d = dict()
for i in range(int(input())):
  elem = int(input())
  if elem in d:
    del d[elem]
  else:
    d[elem] = i
print(len(d))

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
gosa = 1.0 / 10**10
mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    n = I()
    s = set()
    for _ in range(n):
        a = I()
        if a in s:
            s.remove(a)
        else:
            s.add(a)

    return len(s)

print(main())

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

n = ni()
s = set()
for i in range(n):
    x = ni()
    if x in s:
        s.remove(x)
    else:
        s.add(x)
print(len(s))

Solution (Python):
from collections import Counter

def main():
    n = int(input())
    c = Counter()
    for _ in range(n):
        x = int(input())
        c[x] += 1
    ans = 0
    for cc in c.values():
        if cc % 2 == 1:
            ans += 1
    print(ans)
    
if __name__ == '__main__':
    main()

Solution (Python):
N = input()
S = set()
for i in xrange(N):
    a = int(raw_input())
    if a in S:
        S.discard(a)
    else:
        S.add(a)
print len(S)