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())
X = set([int(input()) for _ in range(N)])
print(len(X))

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

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

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

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

N = i()
mochi = [i() for _ in range(N)]
mochi.sort(reverse=True)
ans = 1
for i in range(N-1):
    if mochi[i] > mochi[i+1]:
        ans += 1
print(ans)

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

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

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

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

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

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

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

Solution (Python):
r = int(input())
p = [int(input()) for i in range(r)]

newlist = sorted(p, reverse=False)

sheets = sorted(set(newlist), key=newlist.index)
print(len(sheets))

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def X(): return list(input())
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

N = i()
moti = []
for j in range(N):
    a = i()
    moti.append(a)

moti = set(moti)
print(len(moti))

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

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

Solution (Python):
from sys import stdin
data = stdin.readlines()

a = int(data[0])
b = []
num = 1
while num <= a:
    b.append(int(data[num]))
    num += 1

print(len(list(set(b))))

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

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

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

if __name__ == "__main__":
    main()

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

Solution (Python):
import heapq

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

a = set(a)

print(len(a))

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

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

    print(len(d))
    return


if __name__ == "__main__":
    main()
    sys.exit(0)

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

Solution (Python):
n = int(input())
d = []
count = 0
for i in range(n):
  temp = int(input())
  if not(temp in d):
    d.append(temp)
print(len(d))

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

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

Solution (Python):
N = int(input())
d = sorted(list((input()) for _ in range(N)))
count = 0
dum =""
for i in range(N):
    if d[i] != dum:
        dum = d[i]
        count += 1
print(count)

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


d.sort(reverse=True)

dUnique = set(d)


print(len(dUnique))

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

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

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

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

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

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

print(len(set(d)))

Solution (Python):
n = int(input())
l = []
for i in range(n):
  s0 = int(input())
  l.append(s0)
l.sort()
ans = 1
for i in range(1,n):
  if l[i] > l[i-1]:
    ans += 1
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())

data=list()

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

data.sort()

resu = list(set(data))

print(len(resu))

Solution (Python):



N = int(input())


X = list(int(input()) for i in range(N))
X = set(X)



print(len(X))

"""

for i in sys.stdin:
    X.append(int(i))

print(X)
"""

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

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

d = sorted(set(d))

print(len(d))

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


M_new = list(set(M))


print(len(M_new))

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

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

print(len(e))

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

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

Solution (Python):
from sys import stdin

N = int(input())
d = [stdin.readline().strip("\n") for a in range(N)]

d = set(d)

print(len(d))

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

print(len(set(ab)))

Solution (Python):
N = int(input())
D = sorted([int(input())for i in range(N)],reverse =True)
top = 0
count = 0
for j in range(N):
    if(D[j]!=top):
        count += 1
        top = D[j]
print(count)

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

Solution (Python):
N=int(input())
d=[int(input()) for i in range(N)]
check=sorted(d,reverse=True)
ans=1
for i in range(N-1):
  if check[i+1]<check[i]:
    ans+=1
print(ans)

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

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

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

Solution (Python):
N = int(input())
d = [int(input()) for _ in range(N)]
d_s = sorted(d, reverse=True)

ans = 0
flag = 0
temp = 0
for x in d_s:
    if flag != 0:
        if x < temp:
            ans += 1
        else:
            pass
    else:
        flag = 1
        ans += 1
    temp = x    
print(ans)

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

mochi = set()
for _ in range(n):
  mochi.add(int(input()))
print(len(mochi))

Solution (Python):


num = int(input())
s = set()
for i in range(num):
    s.add(int(input()))

print(len(s))

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

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

nums = [0] * 100

for v in d:
    nums[v - 1] += 1

res = 0
for n in nums:
    if n > 0:
        res += 1

print(res)

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

print(len(set(d)))

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

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

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

print(len(a))

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

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

lis = set(lis)

print(len(lis))

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

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

Solution (Python):

N = int(input())
a = []

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


'''
b = [] 
for i in range(len(a)):
    if( (a[i] in b) == False ):
        b.append(a[i])
    
    
'''
a=sorted(a)
b = []
last = 0
for i in range(len(a)):
    if(last != a[i]):
        b.append(a[i])
        last = a[i]



print(len(b))

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

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

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

for _ in range(N):
    d.add(input())

print(len(d))

Solution (Python):
N = int(input())
d = []
mochi = 101
ans = 0

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

d.sort(reverse=True)

for i in range(N):
    if mochi > d[i]:
        mochi = d[i]
        ans += 1
    else:
        pass

print(ans)

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

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

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

Solution (Python):
import sys
from itertools import combinations
import math


def I(): return int(sys.stdin.readline().rstrip())


def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))


def S(): return sys.stdin.readline().rstrip()


def LS(): return list(sys.stdin.readline().rstrip().split())


N = I()
mochi = []
for _ in range(N):
    mochi.append(I())
s_mochi = set(mochi)
print(len(s_mochi))

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

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

Solution (Python):



import os
import sys







def main():
    n = int(input())
    ans = 0
    arr = []
    for i in range(n):
        arr.append(int(input()))
    print(len(set(arr)))
    return


if __name__ == '__main__':
    main()

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

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

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


unique_list = set(input_list)

print(unique_list.__len__())

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

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

sorted_list = sorted(input_list)

unique_list = set(sorted_list)

print(unique_list.__len__())

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

print(len(D))

Solution (Python):
N=int(input())
d=[input() for i in range(N)]
sum=1
d.sort(reverse=True)
for i in range(1,N):
    if d[i-1]>d[i]:
        sum+=1
print(sum)

Solution (Python):
import collections

N=int(input())
A=[]
for i in range(N):
  A.append(int(input()))
A.sort()
c=collections.Counter(A)
cc=c.most_common()[::-1]

print(len(c))

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

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

def main():
    n = int(input())
    d = set(input() for _ in range(n))
    print(len(d))

if __name__ == '__main__':
    main()

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

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

i = 1
c = 1
list.sort(d,reverse = True) 
j = d[0]

for i in range(len(d)):
    if j > d[i]:
        c += 1
        j = d[i]

print(c)

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

a.sort(reverse=True)
num = 1

for i in range(len(a)):
  if a[i-1] > a[i]:
    num += 1

print(num)

Solution (Python):
N=int(input())
d=[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(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())
dlist = []
for i in range(n):
    dlist.append(int(input()))
print(len(sorted(set(dlist))))

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 = [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):
num = int(input())
ans = []
flag = True
for i in range(num):
  mochi = int(input())
  for j in range(len(ans)):
    if ans[j] == mochi:
      flag = False
      break
 
  if flag == True:
    ans.append(mochi)
  flag = True

print(len(ans))

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

for i in range(N):
    a=int(input())
    for k in d_list:
        if a==k:
            break
    else:
        d_list.append(a)

print(len(d_list))

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

bucket = [0] * 100
for x in d:
  bucket[x - 1] += 1

count = 0
for i in range(100):
  if (bucket[i] > 0):
    count += 1
print(count)

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

E = []
for i in range(len(D)):
  if D[i] not in E:
    E.append(D[i])
    
print(len(E))

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



a=set(list1)
print(len(a))

Solution (Python):

N = int(input())
ls = []
for _ in range(N):
    ls.append(int(input()))

print(len(list(set(ls))))

Solution (Python):
import sys

input = sys.stdin.readline
N = int(input())
d_list = set(int(input()) for _ in range(N))

print(len(d_list))

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

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

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

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

Solution (Python):
def resolve():
    n=int(input())
    l=[int(input()) for i in range(n)]
    l.sort()
    cnt=1
    for i in range(n-1):
        if l[i]<l[i+1]:
            cnt+=1
    print(cnt)
resolve()

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

Solution (Python):
n = int(input())
D = []
for i in range(n):
    d = int(input())
    D.append(d)
D.sort(reverse=True)
for j in range(n):
    if j == 0:
        x = D[j]
        ans = 1
    else:
        if D[j] < x:
            x = D[j]
            ans += 1
print(ans)

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

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

d.sort()
now = 0
ans = 0
for di in d:
  if di > now:
    ans += 1
    now = di
    
print(ans)

Solution (Python):


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

Solution (Python):
def main():
    mochi = int(input())
    list = []
    dic = {}
    for i in range(mochi):
        list.append(input())
    list.sort()
    list.reverse()
    for j in range(len(list)):
        if list[j] not in dic:
            dic[list[j]] = 'mochi' + list[j] + 'cm'
    print(len(dic))
main()

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

print(len(list(set(d_list))))

Solution (Python):
n,*d=map(int,open(0).read().split());print(len(set(d)))

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

d = {int(input()) for i in range(n)}

print(len(d))

Solution (Python):
n=int(input())
a=[]
a.append(int(input()))
for i in range(1,n):
  dumy=int(input())
  for j in a:
    if j==dumy:
      break
  else:
    a.append(dumy)
    
print(len(a))

Solution (Python):
n=int(input())
a=[]
a.append(int(input()))
for i in range(1,n):
  dumy=int(input())
  for j in range(len(a)):
    if a[j]==dumy:
      break
  else:
    a.append(dumy)
    
print(len(a))

Solution (Python):
n = int(input())
a=[]
ans=1
for _ in range(n):
  a.append(int(input()))
 
a = sorted(a, reverse=True)
 
for i in range(n-1):
  if a[i]<a[i+1]:
    break
  elif a[i]==a[i+1]:
    continue
  else:
    ans+=1
 
print(ans)

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

Solution (Python):

def func():
	n = int(input(""))
	bruh = []
	for i in range(n):
		var = input("")
		bruh.append(var)
	bruh = list(dict.fromkeys(bruh))
	return len(bruh)
print(func())

Solution (Python):




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

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

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())
ds = [input() for _ in range(n)]
print(len(set(ds)))

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

set_S = set(S)

print(len(set_S))

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

Solution (Python):
N = int(input())
x = [int(input()) for i in range(N)]
cnt = 1
x.sort()
for i in range(N):
    if(i > 0 and x[i-1] < x[i]):
        cnt += 1
print(cnt)

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


if __name__ == '__main__':
    solve()

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

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

L = []
for _ in range(N):
    d = int(input())
    if not d in L:
        L.append(d)

print(len(L))

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


resolve()

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

set_d = set([])

for _ in range(N):
    set_d.add(int(input()))

print(len(set_d))

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

for i in range(1,101):
    if i in num_list:
        count += 1
    

print(count)

Solution (Python):
n = int(input())
d = [None] * n
for i in range(n):
    d[i] = int(input())
d.sort(reverse=True)
previous = d[0]
cnt = 1
for i in range(1, n):
    if d[i] < previous:
        cnt += 1
        previous = d[i]
print(cnt)

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

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

l = set(l)
l = sorted(l)
print(len(l))

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

d = set(d)
print(len(d))

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import numpy as np

rl = sys.stdin.readline
n = int(rl())
s = set()
for _ in range(n):
  s.add(int(rl()))
print(len(s))

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

new_list = set(d)
print(len(new_list))

Solution (Python):
n = int(input())               
d = {}
for i in range(n):             
    m = int(input())           
    d[str(m)] = "hoge"         

print (len(d.keys()))

Solution (Python):
num = int(input())
line = []
line2 = []
for i in range(num):
  line.append(int(input()))
line.sort()

line2.append(line[0])
for size in line:
  if size > line2[0]:
    line2.insert(0, size)
print(len(line2))

Solution (Python):
def ABC_85_B():
    N=int(input())
    d = [0 for _ in range(N)]
    c=1
    for i in range(N):
        d[i]=int(input())

    d.sort(reverse=True)

    for i in range(N-1):

        if d[i] > d[i+1]:
            c+=1
        elif d[i] == d[i+1]:
            c=c
        else:
            break

    print(c)



if __name__ == '__main__':

    ABC_85_B()

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

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

Solution (Python):
from sys import stdin
def I(): return int(stdin.readline().rstrip())

n = I()
sd = set()
for _ in range(n):
    sd.add(I())

print(len(sd))

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

Solution (Python):


num = int(input())
mochi = set()
for i in range(num):
    line = int(input())
    mochi.add(line)
    
print(len(mochi))

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

Solution (Python):




import sys
from fractions import gcd
import math
from math import ceil,floor
import collections











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



print(len(set(D)))

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]




N = ii()
D = [ii() for _ in range(N)]

D = sorted(D)

cnt = 1
for i in range(1, N):
    if D[i] > D[i-1]:
        cnt += 1
print(cnt)

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

print(len(set(d)))

Solution (Python):
num = int(input())
alist = []
n = 0
while n < num:
    alist.append(int(input()))
    n += 1

def maxlist(l,r):
    temp_list =[]
    p = 0
    q = r
    while q >= 1:
        m = max(l)
        l = [t for t in l if t != m]
        temp_list.append(m)
        q = len(l)
    size = len(temp_list)
    return size

ans = maxlist(alist,num)

print(ans)

Solution (Python):
def main():
    n = int(input())
    d = [int(input()) for i in range(n)]
    d_u = list(set(d))
    res = len(d_u)
    print(res)
if __name__ == '__main__':
    main()

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

Solution (Python):



import sys
from collections import Counter,deque


def II(): return int(sys.stdin.readline())
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 solver(riseSetQue):
    result = 0
    riseCounter = Counter(riseSetQue)
    result = len(riseCounter)
    return result
if __name__ == "__main__":
    N = II()
    riceSet = deque()
    for j in range(0, N, +1):
        riceSet.append(II())
    print("{}".format(solver(riceSet)))

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

arr = set(d)
print(len(arr))

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

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

Solution (Python):


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    n = ii()
    L = [ii() for _ in range(n)]
    print(len(list(set(L))))


if __name__ == "__main__":
    main()

Solution (Python):

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

s.sort()
ans=0
for i in range(1,n):
    if s[i-1]==s[i]:
        ans+=1
print(n-ans)

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

e = set(d)

print(len(e))

Solution (Python):
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
import cmath as cma
import copy as cp
import sys
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
    if n: return [0 for _ in range(n)]
    else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
    if n: return ["" for _ in range(n)]
    else: return sinput().split()
def barr(n): return [False for _ in range(n)]
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7; EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf

n = iinput()
d = [iinput() for i in range(n)]

s = set(d)
ans = len(s)
print(ans)

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

print(len(d))

Solution (Python):
d = {}
for i in range(int(input())):
  k = int(input())
  d[k] = 1
  
print(len(d.keys()))

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

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

Solution (Python):
arr = []

N = int(input())
for i in range(0,N):
  D = int(input())
  arr.append(D)

arr = sorted(set(arr))
print(len(arr))

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

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

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

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

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

d = set(d)
print(len(d))

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

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

print(len(set(Mochi)))

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

set_list_d = set(list_d)
print(len(set_list_d))

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

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

Solution (Python):
N = int(input())
a = list(range(N))
for i in range(N):
    a[i] = int(input())
a.sort()
p = 1
for i in range(N - 1):
    if a[i + 1] - a[i] != 0:
        p += 1
print(p)

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline

def main():
    n = int(read())
    se = set()
    for i in range(n):
        a = int(read())
        se.add(a)
    print(len(se))
if __name__ == '__main__':
    main()

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

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

d = set(d)

print(len(d))

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

Solution (Python):
N = int(input())
D = [int(input()) for i in range(N)]
D.sort(reverse=True)
ans = 0
pre_d = float('inf')
for d in D:
  if d < pre_d:
    ans += 1
    pre_d = d

print(ans)

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

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

print(len(set(d)))

Solution (Python):



def main():
    N = int(input())
    print(len(set([input() for i in range(N)])))

if __name__ == '__main__':
    main()

Solution (Python):

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

Solution (Python):
import sys


def main(lines):
    print(len(set(lines[1:])))


if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)

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

for i in range(N):
    
    c.append(int(input()))
    
print(len(set(c)))

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

Solution (Python):
num = []
n = int(input())
[num.append(int(input())) for x in range(n)]
print(len(set(num)))

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

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

mochi_kai = sorted(list(set(mochi)))

print(len(mochi_kai))

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

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

li = []
ans = 0
for i in range(n):
    tmp = input()
    if tmp in li:
        continue
    else:
        li.append(tmp)
        ans += 1

print(ans)

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

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

answer = N
s = sorted(d)

for i in range(N-1) :
    if(s[i] == s[i+1]) :
        answer = answer - 1


print(answer)

Solution (Python):


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

ans = len(set(d))
print(ans)

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

Solution (Python):

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

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

array = set(array)

print(len(array))

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

print(len(set(D)))

Solution (Python):

inf = 10 ** 15
mod = 10 ** 9 + 7

n = int(input())
d = [list(map(int, input().split())) for i in range(n)]
d.sort()
pre = 0
count= 0
for num in d:
    if pre != num:
        count+=1
    pre = num
print(count)