Problem:
 Score : 200 points    Problem Statement An X -layered kagami mochi  (X ≥ 1) is a pile of X round mochi (rice cake) stacked vertically where each mochi (except the bottom one) has a smaller diameter than that of the mochi directly below it. For example, if you stack three mochi with diameters of 10 , 8 and 6 centimeters from bottom to top in this order, you have a 3 -layered kagami mochi; if you put just one mochi, you have a 1 -layered kagami mochi.  Lunlun the dachshund has N round mochi, and the diameter of the i -th mochi is d_i centimeters. When we make a kagami mochi using some or all of them, at most how many layers can our kagami mochi have?      Constraints  1 ≤ N ≤ 100  1 ≤ d_i ≤ 100  All input values are integers.         Input Input is given from Standard Input in the following format:  N  d_1  :  d_N       Output Print the maximum number of layers in a kagami mochi that can be made.        Sample Input 1 4
10
8
8
6      Sample Output 1 3  If we stack the mochi with diameters of 10 , 8 and 6 centimeters from bottom to top in this order, we have a 3 -layered kagami mochi, which is the maximum number of layers.       Sample Input 2 3
15
15
15      Sample Output 2 1  When all the mochi have the same diameter, we can only have a 1 -layered kagami mochi.       Sample Input 3 7
50
30
50
100
50
80
30      Sample Output 3 4

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

D=[]

for i in range(n):
  d=int(input())
  D.append(d)

c=set(D)

  
print(len(c))

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

Solution (Python):
N = int(input())
D = set([int(input()) for _ in range(N)])
print(len(D))

Solution (Python):
n = int(input())
*a,= [int(input()) for _ in range(n)]
print(len(set(a)))

Solution (Python):
N = int(input())
d = []
for i in range(N):
    d.append(int(input()))
print(len(set(d)))

Solution (Python):
n=int(input())
d=[0]*n
for i in range(n):
  d[i]=int(input())
print(len(set(d)))

Solution (Python):
N = int(input())
D = [int(input()) for _ in range(N)]
print(len(set(D)))

Solution (Python):
N = int(input())
d = {}

for i in range(N):
    tmp = int(input())
    d.setdefault(tmp, 0)
    d[tmp] += 1

print(len(d))

Solution (Python):
N = int(input())
d_list = []
for _ in range(N):
  d_list.append(int(input()))
  
print(len(set(d_list)))

Solution (Python):



n = int(input())
m = []

for i in range(n):
    x = int(input())
    if x not in m:
        m.append(x)
print(len(m))

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

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    n = f()[0]
    a = []
    for i in range(n):
        a.append(f()[0])
    
    a = list(set(a))

    print(len(a))

solve()

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

Solution (Python):
N = int(input())
l = set()
for i in range(N):
  l.add(int(input()))
print(len(l))

Solution (Python):
n=int(input())
d=list(int(input()) for i in range(n))
print(len(set(d)))

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

Solution (Python):
n=int(input())
d=list(int(input()) for i in range(n))
print(len(set(d)))

Solution (Python):


n = int(input())
d = [input() for i in range(n)]
new_list = list(dict.fromkeys(d))
print(len(new_list))

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

Solution (Python):
N = int(input())
A = [int(input()) for i in range(N)]
    
A_sorted = sorted(A, reverse=True)

previous_moti_diameter = 0
count = 0

for i in A_sorted:
    
    if previous_moti_diameter == i:
        
        pass
    else:
        previous_moti_diameter = i
        count += 1
        
print(count)

Solution (Python):
N = int(input())
D = set(map(int, [input() for i in range(N)]))
print(len(D))

Solution (Python):
def main():
  array = []
  
  size = int(input())
  for i in range(size):
    array.append(int(input()))
    
  array.sort(reverse=True)
  
  result = 1
  for i in range(len(array)-1):
    if array[i] != array[i+1]:
      result+=1
  
  print(result)
    
    
main()

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

data = [int(input()) for i in range(times)] 

N = data[0]

cards = data[0:]


for i in range(0, len(cards), 1):
  
  for j in range(i + 1, len(cards), 1):
    
    if cards[i] < cards[j]:
      tmp1 = cards[i]
      tmp2 = cards[j]
      
      cards[i] = tmp2
      cards[j] = tmp1
      


print(len(set([str(x) for x in cards])))

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
dd = list(set(d))

print(len(dd))

Solution (Python):


a = int(input())
b = set (input() for i in range(a))

print(len(b))

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

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

Solution (Python):
n = int(input())
b = []
for u in range(n):
    b.append(input())
a = []
r = 0
for i in b:
    if i not in a:
        a.append(i)
    
print(len(a))

Solution (Python):
N=int(input())
D=[input() for i in range(N)]
D=sorted(D)
count=1
for i in range(N-1):
    if D[i]!=D[i+1]:
        count+=1
print(count)

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

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

Solution (Python):
N = int(input())
D = list(set(int(input()) for _ in range(N)))

print(len(D))

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

a = list(set(a))

print(len(a))

Solution (Python):
print(len(set([int(input()) for _ in range(int(input()))])))

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

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

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

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

d = set(d)

print(len(d))

Solution (Python):


N = int(input())


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


l = set(list)


print(len(l))

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

print(len(set(nums)))

Solution (Python):
n = int(input())
D = list(input() for i in range(n))
D = set(map(int,D))
print(len(D))

Solution (Python):




n = int(input())
d = list()
for i in range(n):
    d.append(int(input()))

d.sort()


cnt = 0
sav_val = -1
for i in range(n):
    if d[i] != sav_val:
        cnt += 1
        sav_val = d[i]


print(cnt)

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

Solution (Python):
n = int(input())
lst = []
cnt = 0

for i in range(n):
    lst.append(int(input()))

lst.sort()

for i in range(len(lst)-1):
    if lst[i] != lst[i+1]:
        cnt += 1
    else:
        pass

print(cnt+1)

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

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

print(len(set(mochi)))

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

print(len(set(a)))

Solution (Python):
def main():
    N = int(input())
    d = [int(input()) for i in range(N)]
    ans = 0
    print(len(set(d)))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
cnt=1
mochi=[]
import sys
X=int(input())
for i in sys.stdin.readlines():
  mochi.append(int(i.rstrip()))
mochi=sorted(mochi,reverse=True)

cnter=mochi[0]
for j in mochi:
  if cnter!=j:
    cnt+=1
    cnter=j
print(cnt)

Solution (Python):
n = int(input())
inputs= []
for i in range(n):
  inputs.append(int(input()))
mochis = sorted(set(inputs))
print(len(mochis))

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

Solution (Python):
n,*d,=map(int,open(0).read().split())
num=[0]*101
for i in range(n):
    num[d[i]]+=1
ans=0
for j in range(len(num)):
    if num[j]>0:
        ans+=1
print(ans)

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

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

Solution (Python):
N = int(input())
D = len(set([int(input()) for _ in range(N)]))
print(D)

Solution (Python):
N = int(input())
print(len(set(map(int, [input() for i in range(N)]))))

Solution (Python):

import sys
input = sys.stdin.readline

n = int(input())
lst = list(map(int, [input().rstrip() for _ in range(n)]))
print(len(set(lst)))

Solution (Python):
print(len(set((input() for _ in range(int(input()))))))

Solution (Python):
N = int(input())
D = [int(input()) for i in range(N)]
S = set(D)
print(len(S))

Solution (Python):
n = int(input())
D = set()
for i in range(n):
	D.add(int(input()))

print(len(D))

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

bucket = {}
for i in range(1, 101):
    bucket[i] = 0
for i in range(n):
    bucket[int(num_list[i])] += 1
res = 0
for i in range(1, 101):
    if bucket[i] > 0:
        res += 1

print(res)

Solution (Python):
n = int(input())
d_list = [input() for i in range(n)]
unique_list = list(set(d_list))
print(len(unique_list))

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

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

unique_num_dict = {}
for i in range(n):
    if d_list[i] in unique_num_dict.keys():
        unique_num_dict[d_list[i]] += 1
    else:
        unique_num_dict[d_list[i]] = 1

print(len(unique_num_dict))

Solution (Python):
N = int(input())
d = [int(input()) for n in range(N)]
d2 =  sorted(d, reverse=True)
cnt = 1
i = 0
for i in range(N-1):
    if(d2[i] > d2[i+1]):
        cnt += 1
        i += 1
print(cnt)

Solution (Python):
import sys
print(len(set(sys.stdin.read().split("\n")[1:-1])))

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

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

print(len(set(a)))

Solution (Python):
N = int(input())
km= []
for i in range(0,N):
    a = int(input())
    km.append(a)
km.sort()
km.reverse()
k=1
for j in range(0,N-1):
    if km[j]>km[j+1]:
        k=k+1
print(k)

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

A.sort()

t=0

for j in range(N-1):
    if A[j]<A[j+1]:
        t=t+1
t=t+1
print(t)

Solution (Python):
n = int(input())
d = list(map(int, [input() for i in range(n)]))

d_unique = list(set(d))
print(len(d_unique))

Solution (Python):
n = int(input())
d = set(map(int,[input() for _ in [0]*n]))
print(len(d))

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

for d in D:
  if not d in ans:
    ans.append(d)

print(len(ans))

Solution (Python):
import sys

def main():
    n = int(input())
    a = [int(input()) for _ in range(n)]
    print(counter(a))

def counter(a):
    return len(set(a))

if __name__ == '__main__':
    main()

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

d=[]
for i in range(n):
    temp=int(input())
    d.append(temp)
print(len(set(d)))

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

Solution (Python):
N = int(input())
d = [int(input()) for _ in range(N)]
print(len(list(set(d))))

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

b=list(set(a))
print(len(b))

Solution (Python):
n=int(input())
s_len=set( [int(input()) for _ in range(n)] )
print(len(s_len))

Solution (Python):
n=int(input())
c=0
a=list()
while c<n:
    a.append(int(input()))
    c=c+1
k=list(set(a))
print(len(k))

Solution (Python):
N = int(input())
d = [int(input()) for _ in range(N)]
d.sort()
pre = d[0]
cnt = 1
for i in d:
    if(i!=pre):
        cnt += 1
    pre = i
print(cnt)

Solution (Python):
N = int(input())
d = []
count = 1

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

d.sort(reverse=True)

for i in range(N):
    if d[i-1] - d[i] > 0:
        count += 1

print(count)

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

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

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

for i in range(N):
    mochi.append(int(input()))
    
mochi = set(mochi)

print(len(mochi))

Solution (Python):
N = int(input())
li = []
for i in range(N):
    li.append(input())
    
list_unique = list(set(li))
print(len(list_unique))

Solution (Python):
N = int(input())
d_list = [int(input()) for _ in range(N)]
d_set = set(d_list)
print(len(d_set))

Solution (Python):
n = int(input())
d = list(map(int, [input() for i in range(n)]))
ans = len(set(d))
print(ans)

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

ans = 1
for i in range(N-1):
    if m[i+1] > m[i]:
        ans += 1
print(ans)

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

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

Solution (Python):
n = int(input())
a = map(int, [input() for i in range(n)])
b = set(a) 
print(len(b))

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

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

d.sort()
ans = 1

for i in range(n-1):
    if d[i] < d[i+1]:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
a = set(map(int, [input() for i in range(n)]))
print(len(a))

Solution (Python):
N=int(input())
n=[]
for i in range(N):
  n.append(int(input()))
list.sort(n,reverse=True)

num=1
for j in range(N-1):
  if n[j] > n[j+1]:
    num +=1
print(num)

Solution (Python):
N = int(input())
num_list = [int(input()) for i in range(N)]
num_list_unique = list(set(num_list))
print(len(num_list_unique))

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

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

d = list(set(d))

print(len(d))

Solution (Python):
N = int(input())
d = [0]*N
for i in range(N):
    d[i] = int(input())
d.sort(reverse=True)
bef = d[0]
ans = 1
for j in range(1, N):
    if bef > d[j]:
        ans += 1
        bef = d[j]
print(ans)

Solution (Python):
N=int(input())
d_list=map(int, list(input() for i in range (N)))

d_unique=list(set(d_list))

print(len(d_unique))

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

Solution (Python):
N = int(input())
*D, = [int(input()) for _ in range(N)]
print(len(set(D)))

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

Solution (Python):
N = int(input())
count = [False]*1000

for i in range(N):
    d = int(input())
    count[d] = True

print(count.count(True))

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


set = set(d)

print(str(len(set)))

Solution (Python):
N = int(input())
d = map(int, [input() for _ in range(N)])
print(len(set(d)))

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

print(len(set(d)))

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

lst = []
for i in range(N):
  lst.append(int(input()))
print(len(set(lst)))

Solution (Python):
n = int(input())
d = list(map(int, [input() for i in range(n)]))
ans = len(set(d))
print(ans)

Solution (Python):
N=int(input())
d=[0]*N
for i in range(N):
    d[i]=int(input())
print(len(set(d)))

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

Solution (Python):
print(len(set([input() for _ in range(int(input()))])))

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

ans = 0
ans = len(set(di))  
print(ans)

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

di = sorted(di, reverse=True)
ans = 0
for i in range(N):
  if i < N-1 and di[i] == di[i+1]:
    i = i + 1
    continue
  ans += 1
  
print(ans)

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

Solution (Python):
N=int(input())
a=[]
stage=0

for i in range(N):
    inp = int(input())
    if  inp not in a :
        a.append(inp)
        stage+=1
print(stage)

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

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

d.sort()

counter = 1
for i in range(N-1):
    if d[i] - d[i+1] != 0:
        counter += 1
print(counter)

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

Solution (Python):
N=int(input())
d=set()
for i in range(N):
    d.add(int(input()))
print(len(d))

Solution (Python):
import sys
unique_list = []
input_list = sys.stdin.readlines()[1:]
for i in input_list:
    if i not in unique_list:
        unique_list.append(i)
print(len(unique_list))

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

Solution (Python):
n = int(input())
d = [int(input()) for _ in range(n)]
mochi = sorted(set(d))
print(len(mochi))

Solution (Python):
print(len(set([int(input())for _ in range(int(input()))])))

Solution (Python):
N = int(input())
d = {int(input()) for _ in range(N)}
print(len(d))

Solution (Python):
n=int(input())
list=[]
count=1
for i in range(n):
  list.append(int(input()))
list.sort()
tmp=list[0]
for i in range(1,n):
  if tmp==list[i]:
    continue
  else:
    count += 1
  tmp=list[i]
print(count)

Solution (Python):

N =int(input())
mochi =[]
for i in range(N):
    mochi.append(int(input()))
print(len(set(mochi)))

Solution (Python):

N = int(input())
l = []
for i in range(N):
    l.append(int(input()))
l.sort()
l = list(set(l))
print(len(l))

Solution (Python):

N = int(input())
l = []
for i in range(N):
    l.append(int(input()))
l.sort()
l = list(set(l))
print(len(l))

Solution (Python):
n= int(input())
d =[]
for i in range(n):
    d.append(int(input()))
b = set(d)
print(len(b))

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

a = 1

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

print(a)

Solution (Python):

n = int(input())

list = []
for i in range(n):
	new = int(input())
	if new not in list:
		list.append(new)

print(len(list))

Solution (Python):
maisu = int(input())
diameter_list = []
for _ in range(0, maisu):
    diameter_list.append(int(input()))
diameter_list.sort()
before = 0
total = 0
for diameter in diameter_list:
    if diameter > before:
        total += 1
        before = diameter
print(total)

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

d.sort()
uniq = list(set(d))
print(len(uniq))

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

for i in range(N):
    D[i] = input()

print(len(list(set(D))))

Solution (Python):
n = int(input())
d = set(int(input()) for i in range(n))

print(len(d))

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

print(len(set(x)))

Solution (Python):
N=int(input())
d=[]
for i in range(N):
  d.append(int(input()))
print(len(set(d)))

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

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

Solution (Python):
import collections

N = int(input())

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

print(len(collections.Counter(x)))

Solution (Python):
N = int(input())
kagami = [0]*N
for i in range(N):
  kagami[i] = int(input())
kagami_sorted = list(set(kagami))
kagami_sorted.sort()
print(len(kagami_sorted))

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

Solution (Python):
N = int(input())
d = list(map(int, [input() for i in range(N)]))

print(len(set(d)))

Solution (Python):
n = int(input())
D = set()
for i in range(n):
    d = int(input())
    D.add(d)
print(len(D))

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

Solution (Python):
_,*s=open(0);print(len(set(s)))

Solution (Python):
n = int(input())
s = set()
for i in range(n):
    s.add(int(input()))
print(len(s))

Solution (Python):
n = int(input())
d = set(map(int, [input() for i in range (n)]))

print(len(d))

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

Solution (Python):
def main():
    N = int(input())
    ans = []
    for _ in range(N):
        ans.append(int(input()))
    print(len(set(ans)))


main()

Solution (Python):
n = int(input())
d = {int(input()) for _ in range(n)}

print(len(sorted(d, reverse=True)))

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

print(len(set(D)))

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

print(len(set(D)))

Solution (Python):
n = int(input())
d = set(int(input()) for i in range(n))
print(len(d))

Solution (Python):
N = int(input())
l = []
for n in range(N):
  l.append(int(input()))
l.sort(reverse=True)  
print(len(set(l)))

Solution (Python):
N = int(input())
d_dic = {}

for i in range(N):
    di = input()
    if di in d_dic.keys():
        d_dic[di] = d_dic[di] + 1
    else:
        d_dic[di] = 1

print(len(d_dic.keys()))

Solution (Python):
n = int(input())
d = list(map(int, [input() for i in range(n)]))
d = list(set(d))
print(len(d))

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

d_list.sort(reverse=True)

ex_d = d_list[0]
count = 1

for mochi_d in d_list:
    if ex_d != mochi_d:
        count += 1
    ex_d = mochi_d

print(count)

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

d_unique = list(set(d))

print(len(d_unique))

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


A = [0] * 101
for d in D:
  A[d] = 1

print(sum(A))

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

print(len(set(a)))

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

li.sort()
li.reverse()
ans = 1
k = li[0]
for j in li:
  if j < k:
    ans += 1
    k = j
            

print(ans)

Solution (Python):


N = int(input())
li = []
count = 0

for i in range(N):
    li.append(int(input()))
li.sort()
while li != []:
    val = li.pop()
    li = [i for i in li if i != val]
    count += 1
print(count)

Solution (Python):


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

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

length_list = sorted(length_list)
no_dup_list = []

for i in range(len(length_list)):
    if i == len(length_list) - 1:
         no_dup_list.append(x)
    else:
        x = length_list[i]
        next_x = length_list[i + 1]
        if x != next_x:
            no_dup_list.append(x)
        else:
            continue

print(len(no_dup_list))

Solution (Python):
n = int(input().split()[0])
length_list = []
for _ in range(n):
    x = int(input().split()[0])
    length_list.append(x)

print(len(list(set(length_list))))

Solution (Python):
N = int(input())
d = (int(input()) for _ in range(N))
d = set(d)
print(len(d))

Solution (Python):
N = int(input())
listD =[]
while True:
    try:
        listD.append(int(input()))
    except:
        break;

counter = 1

listD.sort()
for n in range(N-1):
    if listD[n]<listD[n+1]:
        counter += 1
print(counter)

Solution (Python):
N = int(input())
import sys
mochi = [int(i) for i in sys.stdin]
print(len(set(mochi)))

Solution (Python):
from sys import exit

N = int(input())
s = set()
for n in range(N):
    s.add(str(input()))
print(len(s))

Solution (Python):


n = int(input())
d = [0] * n
for i in range(n):
    d[i] = int(input())

d = set(d)
d = list(d)

print(len(d))

Solution (Python):
N = int(input())
s = [int(input()) for i in range(N)]
s = list(set(s))
print(len(s))

Solution (Python):



import sys


l = []
n = int(input())
for i in range(n):
  d = int(input())
  if d not in l:
    l.append(d)

print(len(l))

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

l = []
for i in range(n):
  d = int(input())
  l.append(d)
l = list(set(l))
print(len(l))

Solution (Python):
print(len(list(set(int(input()) for i in range(int(input()))))))

Solution (Python):
n = int(input())
mochi = set()
for i in range(n):
    mochi.add(int(input()))

print(len(mochi))

Solution (Python):
N = int(input())
mochis = [int(input()) for _ in range(N)]
mochis.sort()
count = 0
tmp = 0
for i in range(N):
    if mochis[i] != tmp:
        count += 1
        tmp = mochis[i]
print(count)

Solution (Python):
n=int(input())
l=[]

for i in range(n):
  a=int(input())
  l.append(a)
  
l.sort(reverse=True)

ans=1
for i in range(0,n-1):
  if l[i]==l[i+1]:
    continue
  else:
    ans+=1
print(ans)

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

Solution (Python):
N = int(input())
mochis = []
for i in range(N):
    s = int(input())
    if not s in mochis:
        
        mochis.append(s)
print(len(mochis))

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

d_list_unique = list(set(d_list))
print(len(d_list_unique))

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

Solution (Python):
import numpy as np

N = int(input())
D = np.array([int(input()) for _ in range(N)])
print(len(np.unique(D)))

Solution (Python):
n=int(input())
li=[input() for i in range(n)]
li.sort()
ans=1
if n==1:
  print(1)
else:
  for i in range(n-1):
    if li[i+1] > li[i]:
      ans+=1
  print(ans)

Solution (Python):
N = int(input())
s = set([])
for _ in range(N):
  s.add(int(input()))
print(len(s))

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

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d.sort()
count = 1

for i in range(1, N):
  if d[i-1] < d[i]:
    count = count + 1

print(count)

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

def hantei(x):
  for j in range(x):
    if d[x] == d[j]:
      return(0)
  return(1)

count = 1
for i in range(1, N):
  count = count + hantei(i)
  
print(count)

Solution (Python):
N = int(input())
max = -9999
list_mochi = []
for i in range(N):
        d = int(input())
        list_mochi.append(d)
list_mochi.sort()
n = len(list_mochi)
X_mochi = []
for j in range(n):
        if max < list_mochi[j]:
                max = list_mochi[j]
                X_mochi.append(list_mochi[j])
print(len(X_mochi))

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

ds = [None] * N

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

ans = len(set(ds))

print(ans)

Solution (Python):
N=int(input())
ds={int(input()) for _ in range(N)}
print(len(ds))

Solution (Python):
N = int(input())
l = [input() for _ in range(N)]
print(len(set(l)))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


def A():
    s = input()[4:]
    print("2018"+s)
    return


def B():
    n = I()
    d = IR(n)
    d = list(set(d))
    print(len(d))
    return


def C():
    n,y = LI()
    for i in range(n+1):
        for j in range(n+1-i):
            k = n-i-j
            if 10000*i+5000*j+1000*k == y:
                print(i,j,k)
                quit()
    print(-1,-1,-1)


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == "__main__":
    B()

Solution (Python):
N = int(input())
mochi = []
for i in range(N):
  mochi.append(int(input()))
print(len(list(set(mochi))))

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

d = list(set(d))
d = sorted(d, reverse = True)

print(len(d))

Solution (Python):

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

a.sort()
a.reverse()
for i in range(1, n):
    if a[i] < a[i-1]:
        count += 1
print(count)

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

Solution (Python):


n = int(input())
d = [0] * n
for i in range(n):
    d[i] = int(input())

d = set(d)
d = list(d)
d.sort()

print(len(d))

Solution (Python):
N = int(input())
d = [int(input()) for _ in range(N)]
print(len(set(d)))

Solution (Python):
n=int(input())
print(sum({input():1for i in range(n)}.values()))

Solution (Python):
n=int(input())
d={input():1for i in range(n)}
print(sum(d.values()))

Solution (Python):
N=int(input())
S=[0]*N
for i in range(N):
    S[i]=int(input())
print(len(set(S)))

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

print(len(set(d)))

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

Solution (Python):
n = int(input())
li = []
for i in range(n):
    num = int(input())
    if num not in li:
        li.append(num)
print(len(li))

Solution (Python):
N = int(input())
d = [0] * N
for i in range(N):
    d[i] = int(input())

print(len(set(d)))

Solution (Python):
import collections
n = int(input())
d = []
for _ in range(n):
    d.append(int(input()))
print(len(collections.Counter(d)))

Solution (Python):
n = int(input())
d = [0]*n
for i in range(n):
    d[i] = int(input())
print(len(set(d)))

Solution (Python):
n = int(input())
l = []
for i in range(0, n):
    l.append(int(input()))
print(len(set(l)))

Solution (Python):

N = int(input())
D = [int(input()) for i in range(N)]
print(len(list(set(D))))

Solution (Python):
size = 1
N = int(input())
d_s = []
for _ in range(N):
  d_s.append(int(input()))
d_s.sort()
d_s.reverse()
for i in range(1,N):
  if d_s[i] < d_s[i-1]:
    size += 1
print(size)

Solution (Python):
N = int(input())
a = []
for i in range(N):
  a.append(int(input()))
print(len(list(set(a))))

Solution (Python):
n=int(input())
d=[int(input()) for i in range(n)]
ld=list(set(d))
print(len(ld))

Solution (Python):
print(len({input()for _ in range(int(input()))}))

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

data.sort(reverse=True)
data_temp = []
for i in range(len(data)-1):
    data_temp.append(data[i]-data[i+1])
    
res = 0
for i in range(len(data_temp)):
    if data_temp[i] != 0:
        res += 1
print(res+1)

Solution (Python):
N = int(input())
L = [input() for _ in range(N)]
def counter(array):
    from collections import Counter
    return list(Counter(array).most_common())
print(len(counter(L)))

Solution (Python):
N = int(input())
s = set()
for _ in range(N):
  s.add(input())
print(len(s))

Solution (Python):

n = int(input())
s = set()
for _ in range(n):
    d = int(input())
    s.add(d)

print(len(s))