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):
n=int(input())
a=set()
for i in range(n):
    b=int(input())
    if b in a:
        a.remove(b)
    else:
        a.add(b)
print(len(a))

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
a=[int(input()) for _ in range(n)]
a.sort()
h=a[0]
ans=1
for i in a[1:]:
    if i!=h:
        ans+=1
        h=i
    else:
        ans-=1
        h=pow(10,10)    
print(ans)

Solution (Python):
from collections import Counter

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

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

Solution (Python):
import collections
N=int(input())
A=collections.Counter([int(input()) for _ in range(N)])
print(sum(map(lambda x:x%2==1, A.values())))

Solution (Python):
n = int(input())
ary = [int(input()) for _ in range(n)]
s = set()
for i in ary:
    if i in s:
        s.discard(i)
    else: s.add(i)
print(len(s))

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

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

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

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

Solution (Python):
n = int(input())
li = dict()
for i in range(n):
    a = int(input())
    li.setdefault(a,0)
    if li[a] == 0:
        li[a] = 1
    else:
        li[a] = 0
ans = list(li.values())
print(ans.count(1))

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

Solution (Python):
from collections import defaultdict

N = int(input())
d = defaultdict(int)

for i in range(N):
    d[int(input())] += 1

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

print(ans)

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

for i in range(N):
    a_array.append(int(input()))

paper = set([])

for i in a_array:
    if i in paper:
        paper.remove(i)
    else:
        paper.add(i)

print(len(paper))

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

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-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 I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()


def summarize_list(l):
  sl=sorted(l)

  a=sl[0]
  c=1
  res=[]

  for x in sl[1:]:
    if x==a:
      c+=1
    else:
      res.append([a,c])
      a=x
      c=1
  res.append([a,c])

  return res

def main():
  n=I()
  l=[I() for _ in range(n)]

  ans=0
  l=summarize_list(l)

  for x in l:
    if x[1]%2!=0:
      ans+=1
  return ans


print(main())

Solution (Python):
from collections import Counter

n=int(input())
a=[int(input()) for i in range(n)]
counter=Counter(a)
cnt=0
for i in counter.values():
    if i%2==1:
        cnt+=1
print(cnt)

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

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

Solution (Python):
import sys
n = int(input())
d = set()
b = map(int,sys.stdin)
for a in b:
    if a in d:
        d.remove(a)
    else:
        d.add(a)
print(len(d))

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

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

Solution (Python):
from collections import Counter

N, *A = map(int, open(0).read().split())
a = list(Counter(A).values())
a = [i for i in a if i % 2 == 1]

print(len(a))

Solution (Python):
import collections

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

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

Solution (Python):
from collections import Counter

N = int(input())
A = [int(input()) for i in range(N)]
a = list(Counter(A).values())
a = [i for i in a if i % 2 == 1]

print(len(a))

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

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

print(len(A))

Solution (Python):
N=int(input())
A=[int(input()) for i in range(N)]
B=set(A)
C=len(B)
for i in A:
  if i not in B:
    B.add(i)
  else:
    B.remove(i)
print(C-len(B))

Solution (Python):
from collections import Counter
n = int(input())
ali = [int(input()) for _ in range(n)]

counter = Counter(ali)
count = 0
for k, v in counter.items():
    if v % 2 == 1:
        count += 1
print(count)

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

c = collections.Counter(A)
ans = 0
for t in c.values():
    if t%2 == 1: ans += 1
    
print(ans)

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


mydict = dict()
cnt = 0

for i in range(N):
    if not (A[i] in mydict):
        mydict[A[i]] = i
        
counter = [0] * N
for a in A:
    counter[mydict[a]] += 1
    
ans = 0
for c in counter:
    if c%2 == 1: ans += 1
    
print(ans)

Solution (Python):
from collections import Counter

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

cnt = Counter(A)
ans = 0
for num, val in cnt.items():
    if val % 2 != 0:
        ans += 1
print(ans)

Solution (Python):
n=int(input())
a={}
for _ in range(n):
    num=int(input())
    if num not in a:
        a[num]=1
    else:
        a[num]+=1
all_count=0
for _, count in a.items():
    if count%2==1:
        all_count+=1
print(all_count)

Solution (Python):
from collections import defaultdict

n = int(input())
a = defaultdict(int)
for _ in range(n):
    a[int(input())] += 1
print(len([1 for v in a.values() if v % 2]))

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

Solution (Python):
from collections import Counter

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

c = Counter(As)
c = sorted(c.items(), key=lambda x:x[0])
A_unique, A_counts = zip(*c)

ans = 0
for a in A_counts:
    if a%2!=0:
        ans += 1
print(ans)

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

print(len([1 for n in d.values() if n % 2 == 1]))

Solution (Python):
from collections import Counter as co
n=int(input())
l=[int(input()) for _ in range(n)]
print(len([1 for (a,d) in co(l).items() if d%2]))

Solution (Python):
from collections import defaultdict


def resolve():
    n = int(input())
    a = list(int(input()) for _ in range(n))
    d = defaultdict(int)
    for ai in a:
        d[ai] += 1
    ans = 0
    for v in d.values():
        ans += v % 2
    print(ans)


if __name__ == "__main__":
    resolve()

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

a = sorted(a)
d = {}
for i in a:
  if i not in d.keys():
    d[i] = 1
  else:
    d[i] += 1

print(len([i for i in d.values() if i % 2 == 1]))

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

print(len(s))

Solution (Python):
import collections

n = int(input())
counter = collections.Counter()
for _ in range(n):
    counter[int(input())] += 1
res = 0
for k, v in counter.items():
    if v % 2 == 1:
        res += 1
print(res)

Solution (Python):
from collections import Counter
N = int(input())
arr = [int(input()) for _ in range(N)]
c = Counter(arr)
count = 0
for k, v in c.items():
    if v % 2 != 0:
        count += 1
print(count)

Solution (Python):
import sys
import math
from fractions import gcd

from collections import Counter



def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

big_prime = 1000000007

"""


 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())


 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""


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

L = [int(sys.stdin.readline()) for _ in range(N)]

Lc = Counter(L)

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

print(ans)

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

Solution (Python):
import collections
import sys

input = sys.stdin.readline


class AtCoder:
    def main(self):
        N = int(input())
        A = [int(input()) for _ in range(N)]

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



if __name__ == '__main__':
    AtCoder().main()

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

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

for i in range(N-1):
  if A[i] == A[i+1]:
    n += 1
  else:
    if n % 2:
      ans += 1
    n = 1

if n % 2:
  ans += 1

print(ans)

Solution (Python):



N = int(input())
A = list()
for _ in range(N):
    A.append(int(input()))


ans = set()
for i in range(N):
    if A[i] in ans:
        ans.remove(A[i])
    else:
        ans.add(A[i])


print(len(ans))

Solution (Python):
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N):
    read_all = [tuple(map(int, input().split())) for _ in range(N)]
    return map(list,zip(*read_all))



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

d = defaultdict(int)
for i in range(N):
    if d[A[i]]==0:
        d[A[i]] = 1
    else:
        d[A[i]] = 0

ans = 0
for k in d.keys():
    if d[k] != 0:
        ans += 1
        
print(ans)

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

Solution (Python):
N = int(input())
A = []
from collections import defaultdict
D = defaultdict(int)
for i in range(N):
    a = int(input())
    A.append(a)
    D[a] += 1

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

Solution (Python):


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

paper = set()

for num in a:
    if num in paper:
        paper.discard(num)
    else:
        paper.add(num)

ans = len(paper)
print(ans)

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

Solution (Python):
in_=int(input())
size=10001
l=[[] for i in range(size)]
for i in range(in_):
  num=int(input())
  r=num%size
  if num in l[r]:
    l[r].remove(num)
  else:
    l[r].append(num)
sum=0
for li in l:
  sum=sum+len(li)
print(sum)

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
import collections

input = sys.stdin.readline

N = int(input())

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

l = collections.Counter(L)

cnt = 0

for i in l.keys():
    if l[i]%2!=0:cnt += +1
print(cnt)

Solution (Python):
import sys
n,*A = map(int,sys.stdin)
B = set()
for a in A:
    B ^= {a}
print(len(B))

Solution (Python):
import sys
n,*A = map(int,sys.stdin)
B = set()
for a in A:
    if a in B:
        B.remove(a)
    else:
        B.add(a)
print(len(B))

Solution (Python):
import sys
n,*A = sys.stdin
B = set()
for a in A:
    if int(a) in B:
        B.remove(int(a))
    else:
        B.add(int(a))
print(len(B))

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 sys
input = sys.stdin.readline
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 sys
input = sys.stdin.readline
n = int(input())
A = set()
for _ in range(n):
    a = input().rstrip()
    if a in A:
        A.remove(a)
    else:
        A.add(a)
print(len(A))

Solution (Python):
N,*A=open(0);s=set()
for a in A:s^={int(a)}
print(len(s))

Solution (Python):
import collections as c
N = int(input())
num = c.Counter([int(input()) for _ in range(N)])

a = list(num.values())

ans = 0

for s in a:
	if s%2 == 1:
		ans += 1

print(ans)

Solution (Python):
if __name__ == "__main__":
    N = int(input())
    
    d = {}
    for i in range(N):
        Ai = int(input())
        if Ai in d.keys():
            d[Ai] = not d[Ai]
        else:
            d[Ai] = True
    
    ans = 0
    for item in d.items():
        if item[1]:
            ans += 1
    
    print(ans)

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    from collections import Counter
    c = Counter(A)
    ans = 0
    for v in c.values():
        if(v%2):
            ans += 1

    print(ans)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = [int(next(tokens)) for _ in range(N)]  
    solve(N, A)

if __name__ == '__main__':
    main()

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

Solution (Python):
import collections
from sys import stdin
N = int(stdin.readline().rstrip())
data = []
for _ in range(N):
    data.append(int(input()))
c = collections.Counter(data)
ans = 0
for i in list(c.values()):
    if i % 2 != 0:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
d = {}
for _ in range(N):
  t = int(input())
  if t in d:
    d[t] += 1
  else:
    d[t] = 1
print(sum(i % 2 for i in d.values()))

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)


N = int(input())
s = {}
for i in range(N):
    a = int(input())
    if s.get(a, False):
        s.pop(a)
    else:
        s[a] = True

print(len(s))

Solution (Python):
from collections import Counter
N = int(input().strip())
ans = 0
c = Counter([int(input().strip()) for _ in range(N)])
for k,v in c.items():
  if v%2 == 1:
    ans += 1

print(ans)

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

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

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

    a = sorted([int(input()) for i in range(N)]) + [int(1e10)]

    ans = 0
    pre = a[0]
    count = 1
    for i in range(1, N+1):
        if pre != a[i] and count&1:
            ans += 1
            count = 0
        count += 1
        pre = a[i]
    print(ans)


if __name__ == "__main__":
    main()

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

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

    dic = {}
    for i in range(N):
        a = int(input())
        if a in dic:
            dic[a] += 1
        else:
            dic[a] = 1
    
    ans = 0
    for num, count in dic.items():
        if count&1:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

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

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

    nums = []

    for i in a:
        if len(nums) > 0:
            if i <= nums[-1]:
                ind = bisect.bisect_left(nums, i)
                if nums[ind] == i:
                    nums.pop(ind)
                else:
                    nums.insert(ind, i)
            else:
                nums.append(i)
        else:
            nums.append(i)
    
    print(len(nums))


if __name__ == "__main__":
    main()

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

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

    nums = []

    for i in a:
        if len(nums) > 0:
            if i <= nums[-1]:
                ind = bisect.bisect_left(nums, i)
                if nums[ind] == i:
                    nums.pop(ind)
                else:
                    bisect.insort(nums, i)
            else:
                nums.append(i)
        else:
            nums.append(i)
    
    print(len(nums))


if __name__ == "__main__":
    main()

Solution (Python):
from collections import defaultdict

N = int(input())

d = defaultdict(int)
for i in range(N):
    a = int(input())
    if d[a]:
        d.pop(a)
    else:
        d[a] = 1

print(len(d.keys()))

Solution (Python):
import sys
input = sys.stdin.readline
from collections import Counter
n=int(input())
a=[int(input()) for i in range(n)]

count = Counter(a)
ans=0
for i in count.values():
    ans+=i%2
print(ans)

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

count = Counter(a)
ans=0
for i in count.values():
    ans+=i%2
print(ans)

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

Solution (Python):
n = int(input())
li = []
for i in range(n):
    li.append(int(input()))
import collections
a = collections.Counter(li)
a = a.most_common()
num = 0
for i in range(len(a)):
    if a[i][1]%2==1:
        num += 1
print(num)

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

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

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

Solution (Python):
n=int(input())
a=[input() for _ in range(n)]
l={}
for i in a:
    if i in l:
        del l[i]
    else:
        l[i]=0
print(len(l))

Solution (Python):
N = int(input())
d = {}
for _ in range(N):
    A = int(input())
    if A in d:
        d[A] = not d[A]
    else:
        d[A] = True

print(sum(d.values()))

Solution (Python):
n = int(input())
a = [int(input()) for _ in range(n)]
b = {}
for i in a:
    if i in b:
        del b[i]
    else: b[i] = 0
print(len(b))

Solution (Python):
N = int(input())
A = []
for _ in range(N):
    A.append(int(input()))
A.sort()
ans = 0
idx = 0
while idx < N:
    sub = 0
    while idx + sub < N and A[idx] == A[idx + sub]:
        sub = sub + 1
    if sub % 2 == 1:
        ans = ans + 1
    idx = idx + sub
print(ans)

Solution (Python):
import sys
import copy
import  math
import bisect
from collections import *
from operator import itemgetter
"""
from fractions import gcd
def lcm(x, y):
    return (x * y) // gcd(x, y)
"""
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

n = ni()
li = [ni() for _ in range(n)]
c = Counter(li)
ans = 0
for k, v in c.items():
    if v % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
from collections import Counter,defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
 
ans = 0
n = inp()
a = [inp() for _ in range(n)]
d = defaultdict(int)
 
for key in a:
    d[key] += 1
for i in d:
    if d[i] % 2:
        ans += 1 
print(ans)

Solution (Python):
import collections as co
N = int(input())
A = [int(input()) for i in range(N)]
c = co.Counter(A)
count = 0
for a,b in c.most_common():
    if b%2==1:
        count += 1
print(count)

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

D = {}

for i in range(n):
    try:
        D[A[i]] += 1
    except:
        D[A[i]] = 1

ans = 0
for i in D.values():
    ans += i % 2
print(ans)

Solution (Python):
import itertools
l = sorted([int(input()) for _ in range(int(input()))])
print(sum(1 for key,value in itertools.groupby(l) if len(list(value))%2))

Solution (Python):
import itertools
n = int(input())
l = sorted([int(input()) for _ in range(n)])
l = [1 for key,value in itertools.groupby(l) if len(list(value))%2]
print(len(l))

Solution (Python):
from collections import Counter,defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

ans = 0
n = inp()
a = [inp() for _ in range(n)]
d = defaultdict(int)

for key in a:
    d[key] += 1
for i in d:
    if d[i] % 2:
        ans += 1 
print(ans)

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

for i in range(N):
    a = int(input())
    if a in A.keys():
        A[a] += 1
    else:
        A[a] = 1

ans = 0

for i in A.keys():
    if A[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):
n = int(input())
l = sorted([input() for _ in range(n)])
x = l[0]
count = 0
score = 0
for s in l[1:]:
    if x==s:
        count+=1
    else:
        score+=count%2==0
        count=0
    x = s
score+=count%2==0
print(score)

Solution (Python):
n = int(input())
l = sorted([input() for _ in range(n)])
x = l[0]
count = 0
score = 0
for s in l[1:]:
    if x==s:
        count+=1
    else:
        score+=count%2==0
        count=0
    x = s
score+=count%2==0
print(score)

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

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

l = []
for i in list(count):
  if count[i] % 2 != 0:
    l.append(count[i])

print(len(l))

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

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

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

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

Solution (Python):



import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n = I()
a = [I() for _ in range(n)]
b = list(Counter(a).items())
ans = 0
for i,j in b:
    if j % 2:
        ans += 1
print(ans)

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

result = {}
for a_i in a:
    if not a_i in result or 0 == result[a_i]:
        result[a_i] = 1
    else:
        result[a_i] = 0
print(list(result.values()).count(1))

Solution (Python):
N,*A=list(map(int,open(0).read().split()))

import collections
c = collections.Counter(A)
cnt=0
for _, x in c.most_common():
  if x % 2 != 0:
    cnt+=1
print(cnt)

Solution (Python):
n = int(input())
array = {}

for i in range(n):
    a = int(input())
    if a not in array:
        array[a] = 1
    elif array[a] == 1:
        array[a] -= 1
    else:
        array[a] += 1

print(sum(array.values()))

Solution (Python):
from collections import defaultdict


def main():
    n = int(input())
    d = defaultdict(int)
    for i in range(n):
        d[int(input())] += 1

    ans = 0
    for k in d.keys():
        if d[k] % 2 == 1:
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()

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

Solution (Python):
import collections

n=int(input())
a=[int(input()) for i in range(n)]
count=0
a = collections.Counter(a)
a=a.most_common()
a=list(a)

for i in range(len(a)):
    if a[i][1]%2==1:
        count+=1
print(count)

Solution (Python):
n = int(input())
l = sorted([int(input()) for _ in [0]*n])
ans = n
for i in range(1,n):
  if l[i] == l[i-1]:
    ans -= 2
    l[i] = 0
print(ans)

Solution (Python):


import collections

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

for _ in range(n):
    a_list.append(int(input().split()[0]))

counter = collections.Counter(a_list)
no_list = [k for k, c in counter.items() if c % 2 == 1]
ans = len(no_list)
print(ans)

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

def main():
    n=int(input())
    a=[0 for _ in range(n)]
    for i in range(n):
        a[i]=int(input())
    check={}
    for i in a:
        if not (i in check):
            check[i]=1
        elif(check[i]==1):
            check[i]=0
        elif(check[i]==0):
            check[i]=1
    ans=0
    for i in check:
        if(check[i]==1):
            ans+=1
 
    print(ans)
    
    
main()

Solution (Python):
from collections import Counter
n=int(input())
a=[input() for _ in range(n)]
c=Counter(a)

ans=0
for k,v in c.items():
    ans+=v%2
print(ans)

Solution (Python):
N = int(input())
M = {}
for i in range(N):
  A = int(input())
  if not(A in M):
    M[A] = 0
  M[A] += 1
r = 0
for A in M.keys():
  if M[A]%2 == 1:
    r += 1
print(r)

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

a.sort()

ans = 0
tmp = 1

for i in range(n-1):
    if a[i] == a[i+1]:
        tmp += 1
    else:
        ans += tmp % 2
        tmp = 1

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

print(ans)

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

a.sort()

ans = 0
tmp = 1

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

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

print(ans)

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

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

Solution (Python):
import collections

n = int(input())
a = [int(input()) for _ in range(n)]
b = collections.Counter(a)

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

print(cnt)

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

Solution (Python):
from collections import defaultdict

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

mem = defaultdict(int)
for i in range(N) :
    mem[A[i]] += 1
    
ret = 0
for v in mem.values() :
    if v % 2 == 1 :
        ret += 1
print(ret)

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

    d = dict()
    for a in A:
        d[a] = d.get(a, 0) + 1
    count = 0
    for a in d:
        if d[a] % 2 == 1:
            count += 1
    return count


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

Solution (Python):
nums = int(input())
ary = list(range(nums))

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

ary.sort()
a = {}
result = 0

for i in ary :
    if i in a:
        a[i] = a[i]+1
    else:
        a[i] = 1

for i in a.keys():
    if a[i] % 2 == 1:
        result += 1

print (result)

Solution (Python):
nums = int(input())
ary = list(range(nums))
check_number = [0 for i in range(nums+2)]
for i in range(nums):
    ary[i] = int(input())

ary.sort()
check = 0
count = 0
result = 0
x = 0
for i in ary :
    if check == i:
        check_number[x] += 1
    else:
        check = i
        x += 1
        check_number[x] = 1

for i in check_number:
    if i % 2 == 1:
        result += 1
print (result)

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

Solution (Python):
n = int(input())
a = [int(input()) for i in range(n)]
a.sort()
result = 0
count = 1
for i in range(n-1):
    if a[i] == a[i+1]:
        count += 1
    else:
        if count % 2 == 1:
            result += 1
        count = 1
if count % 2 == 1:
    result += 1
print(result)

Solution (Python):
n=int(input())
As=[int(input()) for _ in range(n)]
As.sort()
As_uniq=list(set(As))

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

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

A.sort()
a=0
count=0
total=0
for i in A:
    if i==a:
        count+=1
    else:
        if count%2==1:
            total+=1
        a=i
        count=1
if count%2==1:
    total+=1
print(total)