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):
import collections
N = int(input())
A = collections.Counter([int(input()) for _ in range(N)])
A = A.values()
ans = [x for x in A if x&1]
print(len(ans))

Solution (Python):
import collections

N = int(input())
A = list([int(input()) for _ in range(N)])
A = collections.Counter(A).values()

ans = [x for x in A if x&1]
print(len(ans))

Solution (Python):
import sys
import collections

input = sys.stdin.readline


def main():
    N = int(input())
    C = collections.Counter()
    for _ in range(N):
        C[int(input())] += 1

    ans = 0
    for k in C.keys():
        if C[k] & 1:
            ans += 1

    print(ans)




    

if __name__ == '__main__':
    main()

Solution (Python):


def main():
    n = int(input())
    m = {}
    for i in range(n):
        a = int(input())
        m.setdefault(a,0)
        m[a] = (m[a] + 1) % 2
    print(sum(m.values()))

if __name__ == '__main__':
    main()

Solution (Python):
import collections
N = int(input())
A = [] 
for _ in range(N):
    A.append(int(input()))
answer = 0
numbers = collections.Counter(A)

for i in numbers.values():
    answer += i % 2

print(answer)

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

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

A.sort()
A.append(0)

start=A[0]
cnt=1
anscnt=0

for i in range(1,len(A)):

    if A[i]==start:
        cnt+=1
    elif A[i]!=start:
        if cnt%2==0:
            anscnt+=cnt
        elif cnt%2!=0:
            anscnt+=cnt-1    
        cnt=1
        start=A[i]


print(N-anscnt)

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

paper = {}

for a in A:
    paper.setdefault(a - 1, 0)
    paper[a - 1] += 1

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

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

from collections import defaultdict

m = defaultdict(int)

n = ni()
for i in range(n):
    a = ni()
    if m[a] == 0:
        m[a] = 1
    else:
        m[a] = 0

print(sum(m.values()))

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

Solution (Python):

 
import math
import itertools
import sys
import copy
 






N = int(input())
T = {}
for _ in range(N) :
  a = int(input())
  if a not in T :
    T[a] = ""
  else :
    T.pop(a)
    
print(len(T))

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

ans=1
k=1
for i in range(N-1):
    if s[i]==s[i+1]:
        k=k*(-1)
    else:k=1
    ans+=k
        
print(ans)

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

y = a[0]
c = 1
ans = 0
for i in range(1, n):
   if (a[i] == y):
      c += 1
   else:
      if (c % 2 == 1):
         ans += 1
      y = a[i]
      c = 1

if (c % 2 == 1):
   ans += 1

print(ans)

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

Solution (Python):
counter = {}
for i in range(int(input())):
    a = int(input())
    if a not in counter:
        counter[a] = 0

    if counter[a] == 0:
        counter[a] = 1
    else:
        counter[a] = 0

print(sum(counter.values()))

Solution (Python):
n = int(input())
dic = {}
for _ in range(n):
  a = int(input())
  if a in dic:
    dic[a] += 1
  else:
    dic[a] = 1

ans = 0
for i in dic:
  if dic[i]%2 == 1:
    ans += 1
    
print(ans)

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

Solution (Python):
N = int(input())
A={}
for _ in range(N):
    a = int(input())
    if a in A:
        A.pop(a)
    else:
        A[a]=1
print(len(A))

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())
s=[int(input())for i in range(n)]
s.sort()
def groupby(a):
    a2=[[a[0],1]]
    for i in range(1,len(a)):
        if a2[-1][0]==a[i]:
            a2[-1][1]+=1
        else:
            a2.append([a[i],1])
    return a2
s=groupby(s)
l=len(s)
cnt=0
for i in range(l):
    cnt+=s[i][1]%2
print(cnt)

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


import numpy as np

n=int(input())
a=np.array([int(input()) for i in range(n)])
a=np.sort(a)
ans=0
i=0
while(i<=n-1):
    c=1
    while(i<=n-2 and a[i]==a[i+1]):
        i+=1
        c+=1
    if(c%2==1):ans+=1
    
    i+=1
print(ans)

Solution (Python):
n=int(input())
d={}
ans=0
for i in range(n):
    a=int(input())
    try:
        if d[a]%2==0:
            ans+=1
            d[a]+=1
        else:
            ans-=1
            d[a]+=1
    except:
        d[a]=1
        ans+=1
print(ans)

Solution (Python):
N=int(input())
A=[int(input()) for _ in range(N)]
d=dict()
for a in list(set(A)):
  d[a]=0
for a in A:
  d[a]+=1
ans=0
for a in list(d.keys()):
  if d[a]%2==1:
    ans+=1
print(ans)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from bisect import bisect

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
A = [INT() for _ in range(N)]

dic = defaultdict(int)

for x in A:
	dic[x] += 1

print(len([1 for x in dic if dic[x]%2 == 1]))

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

for i in range(N):
    a=int(input())
    if a in B:
        B.remove(a)
    else:
        B.add(a)
print(len(B))

Solution (Python):
from collections import Counter

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



c = Counter(a)
ans = 0

for _a in list(set(a)):
    if c[_a]%2 != 0:
        ans += 1

print(ans)

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

for n in range(N):
  a = int(input())
  
  if a in sets:
    sets.remove(a)
  else:
    sets.add(a)

print(len(sets))

Solution (Python):

import collections
N = int(input())
a = [int(input()) for i in range(N)]
c = collections.Counter(a)
ans = 0


val = list(c.values())
for j in range(len(val)):
    if val[j] % 2 == 0:
        pass
    else:
        ans += 1

print(ans)

Solution (Python):
A = set()
for i in range(int(input())):
    A ^= set([int(input())])
print(len(A))

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

from collections import Counter
ans = 0
for (key, value) in Counter(A).items():
  if value % 2 == 1:
    ans += 1

print(ans)

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

Solution (Python):
import sys
import collections

input = sys.stdin.readline
n = int(input())
A = collections.Counter([int(input()) for _ in range(n)])

keys, cnts = zip(*A.most_common())
ans =0
for cnt in cnts:
    if cnt % 2 != 0:
        ans += 1

print(ans)

Solution (Python):







n = int(input())
s = set()

for i in range(n):
  s ^= {input()}

print(len(s))

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

Solution (Python):
import collections

n = int(input())
ls = [int(input()) for _ in range(n)]

c = collections.Counter(ls)
ls_s =c.most_common()

ans = 0

for i in range(len(ls_s)):
    if ls_s[i][1] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):
n = int(input())
a = sorted([int(input()) for _ in range(n)])
ans = 0
tmp = 1
for i in range(n-1):
    if a[i] == a[i+1]:
        tmp += 1
    else:
        if tmp % 2 == 1:
            ans += 1
        tmp = 1
if tmp % 2 == 1:
    ans += 1
print(ans)

Solution (Python):
n=int(input())
dic={}
for i in range(n):
    v=int(input())
    dic[v]=dic.get(v,0)+1
count=0

for k in dic.keys():
    if dic[k]%2!=0:
        count+=1
print(count)

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

dic={}
count=0

for i in range(n):
    dic[al[i]]=dic.get(al[i],0)+1

for k in dic.keys():
    if dic[k]%2!=0:
        count+=1
print(count)

Solution (Python):
n=int(input())
a=sorted([int(input()) for i in range(n)])
tmp = a[0]
rank= 1
ans = 0
for i in a[1:]:
    if i == tmp:
       rank += 1
    else:
        tmp = i
        ans += rank%2
        rank = 1
ans += rank%2
print(ans)

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

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


cnt = Counter(memo)

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

print(ans)

Solution (Python):
N=int(input())
A=[int(input()) for _ in range(N)]
import collections
A_=collections.Counter(A)
ans=0
for v in A_.values():
    if v%2!=0:
        ans+=1
print(ans)

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

Solution (Python):
dic = {}
N = int(input())
for _ in range(N):
  A = int(input())
  if A not in dic:
    dic[A] = 1
  elif dic[A] != 0:
    dic[A] -= 1
  else:
    dic[A] += 1
print(sum(dic.values()))

Solution (Python):
n = int(input())
ans = {}
for _ in range(n):
    a = int(input())
    if a not in ans:
        ans[a] = 0
    ans[a] += 1

print(len([k for k,v in ans.items() if v % 2]))

Solution (Python):
N = int(input())
A = [int(input()) for i in range(N)]
dicta = {}
for i in A:
    if i not in dicta:
        dicta[i] = 1
    else:
        dicta[i] += 1
ans = 0
for v in dicta.values():
    if v%2 == 1:
        ans += 1
print(ans)

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

paper=set()
for i in range(n):
    if a[i] not in paper:
        paper.add(a[i])
        continue
    if a[i] in paper:
        paper.discard(a[i])
        continue

print(len(paper))

Solution (Python):
import collections

N=int(input())

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

c = collections.Counter(A)

values, counts = zip(*c.most_common())
print(len([i for i in counts if i %2!= 0]))

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

a.sort()
cnt = 1
ans = 0
for i in range(1,n):
    if a[i] == a[i-1]:
        cnt += 1
    else:
        if cnt%2 != 0:
            ans += 1
        cnt = 1
else:
    if cnt%2 != 0:
        ans += 1

print(ans)

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

d = {}
for i in range(n):
    if a[i] not in d:
        d[a[i]] = 0
    else:
        del d[a[i]]

print(len(d))

Solution (Python):
dic = {}
N = int(input())
for _ in range(N):
  x = int(input())
  if x in dic:
    dic[x] += 1
  else:
    dic[x] = 1
counter = 0
for i in dic.keys():
  if dic[i] %2 == 1:
    counter +=1
print(counter)

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

s=set()

for i in range(n):
    if a[i] not in s:
        s.add(a[i])
    else:
        s.discard(a[i])
print(len(s))

Solution (Python):
from collections import Counter
n = int(input())
l = [0] * n
ans =0
for i in range(n):
  l[i] = int(input())
print( sum(s%2 for s in Counter(l).values()))

Solution (Python):
from collections import Counter
def main():
    n=int(input())
    L=[0]*n
    for i in range(n):
        L[i] = int(input())
    print(sum(s%2 for s in Counter(L).values()))
main()

Solution (Python):
import sys
input = sys.stdin.readline

N = int(input())



ans_set = set()

for i in range(N):
    A = int(input())
    if A in ans_set:
        ans_set.remove(A)
    else:
        ans_set.add(A)

print(len(ans_set))

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

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

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

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()
    d = collections.defaultdict(int)
    for _ in range(N):
        c = S()
        d[c] += 1
    cnt = 0
    for key, val in d.items():
        if val % 2 == 1:
            cnt += 1
    print(cnt)
main()

Solution (Python):
N=int(input())
paper={}
for i in range(N):
  a=input()
  if a in paper:
    paper[a]+=1
  else:
    paper[a]=1
counter=0
for key in paper.keys():
  if int(paper[key])%2==1:
    counter+=1
print(counter)

Solution (Python):
import collections
n = int (input())
ln = []
ln2 = []
for _ in range(n):
    ln.append( int (input()))

C = collections.Counter(ln)
 
ans = 0
for k, v in C.items():
    if (v%2 != 0):
        ans += 1

print(ans)

Solution (Python):
import collections

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

C = collections.Counter(A)

ans = 0
for k,v in C.items():
    if (v%2 != 0):
        ans += 1

print(ans)

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)
ans=list(s)
print(len(ans))

Solution (Python):
import sys
from collections import Counter
n = int(input())
a_ls = []
for i in range(n):
    a = int(sys.stdin.readline().strip())
    a_ls.append(a)
ct = Counter(a_ls)
print(sum([i % 2 for i in ct.values()]))

Solution (Python):
N = int(input())
from collections import defaultdict
dic = defaultdict(int)
for n in range(N):
    a = int(input())
    dic[a] += 1
ans = 0
for key, value in dic.items():
    if value % 2 != 0:
        ans += 1
print(ans)

Solution (Python):
import collections
N=int(input())
A=[]
answer=0
for i in range(N):
  A+=[int(input())]
C=collections.Counter(A)
P=list(C.values())
for x in P:
  answer +=x%2
print(answer)

Solution (Python):
from collections import Counter
n = int(input())
a = [int(input()) for _ in range(n)]
x = Counter(a)
cnt = 0
for i in x.values():
    cnt += i % 2
print(cnt)

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
A = []
for _ in range(N):
    A.append(int(input()))
import collections
import numpy as np
c = collections.Counter(A)
d = np.array(list(c.values()))
print(np.count_nonzero(d % 2 == 1))

Solution (Python):
import sys
from collections import Counter

n, *a = map(int, sys.stdin.read().split())

def main():
    res = 0
    for c in Counter(a).values():
        res += c & 1

    return res

if __name__ == '__main__':
    ans = main()
    print(ans)

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

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

print(ans)

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

A = []
for i in range(n):
	A.append(int(input()))
	
s = set()

for a in A:
	if a in s:
		s.discard(a)
	else:
		s.add(a)

print(len(s))

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

Solution (Python):
n = int(input())
f = {}
for _ in range(n):
	x = int(input())
	if x not in f:
		f[x] = 0
	f[x] = f[x] ^ 1
ans = 0
for [x, y] in f.items():
	ans = ans + y
print(ans)

Solution (Python):
D = {}
N = int(input())
for i in range(N):
  A = int(input())
  if A in D:
    if D[A] == 1:
      D[A] -= 1
    else:
      D[A] += 1
  else:
    D[A] = 1
print(sum(D[i] for i in D))

Solution (Python):
n = int(input())
a = []
for _ in range(n):
    a.append(int(input()))
a.sort()

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

Solution (Python):
N = int(input())
nums = [int(input()) for i in range(N)]
idxs = set(nums)
ans = {idxs.pop() : 0 for i in range(len(idxs))}
count = 0

for num in nums:
    ans[num] += 1

for i in ans.keys():
    ans[i] = (ans[i] % 2)

print(sum(ans.values()))

Solution (Python):
n=int(input()) 
a=[input() for i in range(n)]
from collections import Counter
S=Counter(a)
cnt=0
for i in S.values():
  if i%2!=0:
    cnt+=1
print(cnt)

Solution (Python):
import sys
n = int(input())
a = [int(i) for i in sys.stdin]
a.sort()
dict = {}
for i in range(n):
  if a[i] in dict:
    del dict[a[i]]
  else: 
  	dict[a[i]]=0
print(len(dict))

Solution (Python):
n=int(input())
A=[]
ans=set()
for i in range(n):
    A.append(int(input()))
for a in A:
    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):
    a=int(input())
    if(a not in ans):
        ans.add(a)
    else:
        ans.remove(a)
print(len(ans))

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

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

Solution (Python):
from collections import Counter

def main()->None:
    N = int(input())
    range_N = range(N)
    A = [int(input()) for _ in range_N]

    count_A = Counter(A)

    res = []
    for a in count_A.keys():
        count = count_A[a]
        if count % 2 == 1:
            res.append(a)
    print(len(res))








if __name__ == "__main__":
    main()

Solution (Python):
import collections
n = int(input())
a = [int(input()) for i in range(n)]
b = collections.Counter(a)
cnt = 0
for i in b.keys():
	if b[i] % 2 != 0:
		cnt += 1
print (cnt)

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

def fanc(n, a):
    if n == 1: 
        print(1)
        return 0
    cnt = 0
    while len(a) > 1:
        same_cnt = 0
        j = 1
        while a[0] == a[j]:
            same_cnt += 1
            if j == len(a) - 1:
                break
            j += 1
        if same_cnt  % 2 == 0:
            cnt += 1
        del a[0:same_cnt+1]
    if len(a) == 1: cnt += 1
    print(cnt)
    return 0

fanc(n, a)

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

Solution (Python):
d={}
for _ in[0]*int(input()):
    i=input()
    d[i]=d.get(i,0)^1
print(sum(d.values()))

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

l = [int(input()) for _ in range(n)]
c = Counter(l)

ans = [i for i in c.values() if i % 2 == 1]

print(len(ans))

Solution (Python):
N = int(input())
A = [int(input()) for i in range(N)]
A = sorted(A)
ans = 0
prev = A[0]
cnt = 0
for a in A:
    if prev == a:
        cnt += 1
        prev = a
    else:
        if cnt % 2 == 1:
            ans += 1
        cnt = 1
        prev = a
if cnt % 2 == 1:
    ans += 1
print(ans)

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

def groupby(a):
    a2=[[a[0],1]]
    for i in range(1,len(a)):
        if a2[-1][0]==a[i]:
            a2[-1][1]+=1
        else:
            a2.append([a[i],1])
    return a2

y=groupby(x)
c=0
for i in y:
    if i[1]%2==1:
        c+=1
print(c)

Solution (Python):
import collections
n = int(input())
nums = collections.defaultdict(int)
ans = 0
for _ in range(n):
    num = int(input())
    nums[str(num)] += 1
for k in nums.keys():
    if nums[k] % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
nums = set([])
for _ in range(n):
    num = int(input())
    if num in nums:
        nums.remove(num)
    else:
        nums.add(num)
print(len(nums))

Solution (Python):
n=int(input())
ans=set()
for i in range(n):
    ans^=set([input()])
print(len(ans))

Solution (Python):
N=int(input())
s=set()
for i in range(N):s^={input()}
print(len(s))

Solution (Python):
N = int(input())
d = {}
for _ in range(N):
    A = int(input())
    d[A] = not d.get(A, False)

print(sum(d.values()))

Solution (Python):
n = int(input())
al = []
for _ in range(n):
    a = int(input())
    al.append(a)

al = sorted(al)
ans = 0

before = 0
for a in al:
    if before == a:
        ans -= 1
        before = 0
    else:
        ans += 1
        before = a
    
print(ans)

Solution (Python):
from collections import Counter
def ABC073C_WriteAndErase():
    N = int(input().strip())
    Ai = [int(input().strip()) for i in range(N)]


    Bi = Counter(Ai)
    count = 0
    for key, val in Bi.items():
        if val % 2 == 1:
            count += 1

    print(count)
    

def main():
    ABC073C_WriteAndErase()

if __name__ == "__main__":
    main()

Solution (Python):
from collections import Counter
def ABC073C_WriteAndErase():
    N = int(input().strip())
    Ai = [int(input().strip()) for i in range(N)]


    Bi = Counter(Ai)
    count = 0
    for key, val in Bi.items():
        if val % 2 == 1:
            count += 1

    print(count)
    

def main():
    ABC073C_WriteAndErase()

if __name__ == "__main__":
    main()

Solution (Python):
import collections

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

B = collections.Counter(A)

count = 0
for key, val in B.items():
    if val % 2 == 1:
        count += 1

print(count)

Solution (Python):
N = int(input())
A = {}
for i in range(N):
    a = int(input())
    if a in A:
        A[a] += 1
    else:
        A[a] = 1
ans = 0
for val in A.values():
    ans += val % 2
print(ans)

Solution (Python):
from collections import Counter
N = int(input())
A = Counter([int(input()) for _ in range(N)])
ans = 0
for val in A.values():
    if val % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
dic = {}
for _ in range(n):
  tmp = int(input())
  if tmp in dic and dic[tmp] == 1:
    dic[tmp] = 0
  else:
    dic[tmp] = 1
print(sum(dic.values()))

Solution (Python):
N = int(input())
D = {}
for _ in range(N):
    A = int(input())
    if A not in D: D[A]=0
    D[A]+=1
print(len([v for v in D.values() if v%2==1]))

Solution (Python):

if __name__ == '__main__':
    N=int(input())
    sheet=set()
    for i in range(N):
        temp=int(input())
        if temp in sheet:
            sheet.remove(temp)
        else:
            sheet.add(temp)
    print(len(sheet))

Solution (Python):

if __name__ == '__main__':
    N=int(input())
    sheet=[]
    for i in range(N):
        temp=int(input())
        sheet.append(temp)
    sheet.sort()
    count=0
    i=0
    while i<N:
        s=sheet[i]
        j=i
        while i<N and sheet[i]==s:
            i+=1
        d=i-j
        if d%2==1:
            count+=1

    print(count)

Solution (Python):
from collections import Counter
N = int(input())
A = Counter([int(input()) for _ in range(N)])
ans = 0
for val in A.values():
    if val % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
from collections import defaultdict
D = defaultdict(int)
for i in range(N):
    D[int(input())] += 1
ans = 0
for value in D.values():
    if value % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
from collections import defaultdict
N = int(input())
A = [int(input()) for _ in range(N)]

d = defaultdict(int)

for a in A:
    d[a] ^= 1
answer = sum(d.values())
print(answer)

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

Solution (Python):
h={}
N=int(input())
for i in range(N):
    a=int(input())
    if( a in h):
        h.pop(a)
    else:
        h[a]=1

print(len(h))

Solution (Python):
from collections import defaultdict
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def main():
    n=int(input())
    cnt=defaultdict(int)
    for _ in range(n):
        a=int(input())
        cnt[a]+=1
    print(sum(v%2 for v in cnt.values()))
main()

Solution (Python):
n = int(input())
a = set()
for _ in range(n):
    a ^= {input()}
print(len(a))

Solution (Python):
N=int(input())
s=set()
for i in range(N):s^={input()}
print(len(s))

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

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

c = collections.Counter(r)
count = 0
for key, v in c.items():
  if v % 2 != 0:
    count += 1
print(count)

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

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

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

Solution (Python):
n = int(input())
m = [int(input()) for _ in range(n)]

from collections import Counter
c = Counter(m)
ans = 0
for k in c.keys():
    if c[k] % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
a = sorted([int(input()) for _ in range(n)])
ans = 0
tmp = 1
for i in range(n-1):
    if a[i] == a[i+1]:
        tmp += 1
    else:
        if tmp%2 == 1:
            ans += 1
        tmp = 1
if tmp%2 == 1:
    ans += 1
print(ans)

Solution (Python):
n = int(input())
m = [int(input()) for _ in range(n)]

from collections import Counter
c = Counter(m)
ans = 0
for k in c.keys():
    if c[k] % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
from collections import defaultdict
d = defaultdict(int)
n = int(input())
for _ in range(n):
  d[int(input())] += 1
ans = 0
for i in d.values():
  ans += i%2
print(ans)

Solution (Python):
import numpy as np
import collections
N = int(input())
a_list = [int(input()) for i in range(N)]

counter = collections.Counter(a_list)
val_array = np.array(list(counter.values()))
mod2_array = val_array % 2

ans_dict = collections.Counter(mod2_array)
ans = ans_dict[1]
print(ans)

Solution (Python):
from collections import Counter

N = int(input())
P = []
for i in range(N):
  P.append(int(input()))
  
Pc = Counter(P)

ans = 0
for k, v in Pc.items():
  if v%2 != 0:
    ans += 1
print(ans)

Solution (Python):
n=int(input())
a=[]
for i in range(n):
    a.append(int(input()))
import collections as c
d=c.Counter(a)
x=list(d.items())
cnt=0
for i in x:
    if i[1]%2==1:
        cnt+=1
print(cnt)

Solution (Python):
import collections
N = int(input())
A = [int(input()) for i in range(N)]
c = collections.Counter(A).most_common()
ans = 0
for i in range(len(c)):
    ans += c[i][1] % 2
print(ans)

Solution (Python):
from collections import Counter
n=int(input())
A=Counter([int(input()) for i in range(n)])
print(sum(1 if count%2 else 0 for count in A.values()))

Solution (Python):
from collections import Counter

n=int(input())
a=[int(input()) for _ in range(n)]

ans=0
c=Counter(a)
c_m=c.most_common()
for i in range(len(c_m)):
    if int(c_m[i][1])%2!=0:
        ans+=1
print(ans)

Solution (Python):
n = int(input())
d = dict()
for _ in range(n):
    num = int(input())
    d[num] = d.get(num, 0) + 1
ans = 0
for i in d.items():
    ans += i[1] % 2

print(ans)

Solution (Python):
N = int(input())
num_count = {}
for _ in range(N):
    num = int(input())
    if num_count.get(num):
        num_count[num] += 1
    else:
        num_count[num] = 1
        
left_num = 0
for value in num_count.values():
    left_num += value%2
    
print(left_num)

Solution (Python):
N = int(input())
A = {}
for _ in range(N):
    a = int(input())
    if a not in A:
        A[a] = 1
    else:
        A[a] += 1
count = 0
for val in A.values():
    if val % 2 == 0:
        continue
    else:
        count+= 1
print(count)

Solution (Python):
from collections import Counter

n = int(input())
aa = [int(input()) for _ in range(n)]

c=Counter(aa)
ans = 0

for i,j in c.most_common():
  ans+=j%2

print(ans)

Solution (Python):
from sys import stdin
from itertools import accumulate
from itertools import groupby

n = int(stdin.readline().rstrip())
li = [int(stdin.readline().rstrip()) for _ in range(n)]
point = 0
li.sort()

lin = []
for key, value in groupby(li):
    lin.append(len(list(value)))

for i in lin:
    if i%2 == 1:
        point += 1

print(point)

Solution (Python):
import sys
from collections import Counter

input = sys.stdin.readline

def main():
    N = int(input())
    A = Counter([int(input()) for i in range(N)])

    print(sum([1 for c in A.values() if c % 2]))


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = []
for i in range(N):
    A.append(int(input()))
cnt = 1
ans = 0
A.sort()
for i in range(N-1):
    if A[i] == A[i+1]:
        cnt += 1
    else:
        if cnt%2 == 1:
            ans += 1
        cnt = 1
if cnt%2 == 1:
    ans += 1
print(ans)

Solution (Python):

N = int(input())
d = {}
for i in range(N):
    a = int(input())
    if a not in d.keys():
        d[a] = 1
    else:
        d[a] += 1
ans = 0
for a in d.items():
    ans += a[1] % 2
print(ans)

Solution (Python):

N = int(input())
d = {}
for i in range(N):
    a = int(input())
    if a not in d.keys():
        d[a] = 1
    else:
        d[a] += 1
ans = 0
for a in d.items():
    ans += a[1] % 2
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
s = set()
for _ in range(N):
  x = int(input())
  if x in s:
    s.discard(x)
  else: s.add(x)
print(len(s))

Solution (Python):
A = set()
for i in range(int(input())):
	A ^= set([int(input())])
print(len(A))

Solution (Python):
import collections

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

counts = collections.Counter(nums)

con = 0

for i in counts.values():
  if i % 2 == 1:
    con += 1
    
print(con)

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

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

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