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())
a = list(set(map(int, [input() for i in range(n)])))
print(len(a))

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)]
d = set(sorted(d))
print(len(d))

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

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop

import collections

n = int(input())
d = [int(input()) for i in range(n)]
d.sort(reverse= True)
cnt = 1
for i in range(n-1):
    if d[i+1] < d[i]:
        cnt+=1
print(cnt)

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

print(len(set(d)))

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

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

d.sort()

for i in d:
    if i > ref:
        ans += 1
        ref = i

print(ans)

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]
d = {}
for c in l:
    if c not in d:
        d[c] = 0
    d[c] += 1
print(len(d))

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

l = list(set([int(input()) for x in range(n)]))
l.sort(reverse=True)
print(len(l))

Solution (Python):
n = int(input())
moti = [int(input()) for i in range(n)]
import collections
moti = collections.Counter(moti)
moti = list(moti.values())
print(len(moti))

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

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

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

mochi_set = set(mochi)

print(len(mochi_set))

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

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

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

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

d = set(d)

print(len(d))

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

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

Solution (Python):



N=int(input())


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



print(len(set(d)))

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 = [int(input()) for _ in range(N)]
dict = {}
for i in range(N):
    if D[i] not in dict:
        dict[D[i]] = 1
print(len(dict))

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

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

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


d=sorted(d,reverse=True)

count=0
nowd=101

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

print(count)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

print(len(set(d)))

Solution (Python):
N = int(input())
d = [int(input()) for _ in range(N)]
d.sort()
print(1 + sum(d[i] != d[i + 1] for i in range(N - 1)))

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

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())
s = []
for i in range(N):
    s.append(int(input()))
s.sort(reverse=True)
s=set(s)
print(len(s))

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

Solution (Python):


def main():
    
    N = int(input())
    ls = []
    for i in range(N):
        ls.append(int(input()))

    ls.sort()
    cnt = 0
    tmp_size = 0
    for size in ls:
        if size > tmp_size:
            cnt += 1
            tmp_size = size

    print(cnt)


main()

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

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

Solution (Python):
n= int(input())
lst = [0] * (100 + 1)

for i in range(n):
    lst[int(input())] = 1

ans = 0
for j in lst:
    ans += j
print(ans)

Solution (Python):
n = int(input())
d_list = list()
for _ in range(n):
    d_list.append(int(input()))
print(len(set(d_list)))

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

print(len(d_unique))

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

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

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

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

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

cake=[]
for i in range(n):
    if not(rice[i] in cake):
        cake.append(rice[i])

print(len(cake))

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

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

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

print(len(set(b)))

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

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

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

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

Solution (Python):
import sys
import numpy as np

read = sys.stdin.read

n = int(input())
d = np.array(read().split(), np.int64)

ans = len(np.unique(d))
print(ans)

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

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

Solution (Python):
N = int(input())
k = []
o = 0

for j in range(N): k.append(int(input()))
l = sorted(k[:])
m = list(set(l))

print(len(m))

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

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

Solution (Python):
i = int(input())
List = []
for j in range(i):
    List.append(int(input()))
print(len(set(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())
li = []
for _ in range(N):
    li.append(int(input()))
mochi = list(set(li))
mochi.sort()
ans = 1
for i in range(len(mochi)):
    if mochi[i-1]<mochi[i]:
        ans += 1
print(ans)

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


count=0
now=101

for i in range(N):
    temp=max(d)
    if temp<now:
        count+=1
        now=temp
    d[d.index(max(d))]=0

print(count)

Solution (Python):
N = int(input())
d = {int(input()) for i in range(N)}

print(len(d))

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

Solution (Python):
n = int(input())
d = []
for _ in range(n):
    d.append(int(input()))
count_0 = 1
d = sorted(d)
for i in range(n):
    if i == n-1: break
    if d[i] == d[i+1]: continue
    count_0 += 1

d = sorted(d,reverse=True)
count_1 = 1
for i in range(n):
    if i == n-1: break
    if d[i] == d[i+1]: continue
    count_1 += 1
print(max(count_0,count_1))

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

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

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

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

print(len(set(dList)))

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

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

print(len(set(l)))

Solution (Python):
import sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
MD2 = lambda d1,d2: [[INIT_VAL]*d2 for _ in range(d1)]
MD3 = lambda d1,d2,d3: [MD2(d2,d3) for _ in range(d1)]

DIVC = lambda x,y: -(-x//y)
DIVF = lambda x,y: x//y

def main():
    n = II()
    dd = [II() for _ in range(n)]
    print(len(set(dd)))

if __name__ == '__main__':
    main()

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

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

print(len(set(a)))

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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

if __name__ == '__main__':
    main()

Solution (Python):
N,*D=open(0);print(len(set(D)))

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

i = set(d)

print(len(i))

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

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

print(len(answer_set))

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

Solution (Python):

from collections import Counter

N = int(input())
dlist = []
for i in range(1,N+1):
  dlist.append(input())

ddict = Counter(dlist)
print(len(ddict))

Solution (Python):
from collections import Counter

N = int(input())
dlist = []
for i in range(1, N + 1):
    dlist.append(input())

ddict = Counter(dlist)
print(len(ddict))

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

for i in range(n):
    a = int(input())
    seta.add(a)

print(len(seta))

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(0, N)]
print(len(set(d)))

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

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

Solution (Python):
n=int(input())
c=[]
count = 0
for i in range(n):
  Ci=int(input())
  if len([1 for x in c if x==Ci]) == 0:
    count = count + 1
    c.append(Ci)
print(count)

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.sort(reverse=True)
count = 1
for i in range(N-1):
    if d[i] > d[i+1]:
        count += 1
print(count)

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

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
data=[]
for i in range(0, n):
    data.append(int(stdin.readline().rstrip()))

print(len(set(data)))

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

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

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)]
sorted_D = sorted(D, reverse=True)

top = sorted_D[0]
result = 1

for mochi in sorted_D:
    if top > mochi:
        top = mochi
        result += 1

print(result)

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

print(len(list(set(l))))

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

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

Solution (Python):
import collections

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

c = collections.Counter(l)

print(len(c))

Solution (Python):
n=int(input())
b=[0]*105
for _ in range(n):
    v=int(input())
    b[v]+=1

cnt=0
for i in range(105):
    if b[i]>0:
        cnt+=1

print(cnt)

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

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
















import collections
N = int(input())
d = [int(input()) for _ in range(N)]
c = collections.Counter(d)
print(len(c))

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

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

n=0
d.sort(reverse=True)
dd=[]
dd.append(d[0])
for i in range(N):
    if d[i]<min(dd):
        dd.append(d[i])

n=len(dd)
print(n)

Solution (Python):
import sys, math
sys.setrecursionlimit(10 ** 6)
from collections import deque, defaultdict, Counter
from operator import itemgetter

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


if __name__ == '__main__':
    main()

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

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

print(len(set(d)))

Solution (Python):
N = int(input())
l = list()
for n in range(N):
    l.append(int(input()))
d = {}
for i in l:
    d[i] = 1
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())
l = list()
for n in range(N):
    l.append(int(input()))
l.sort(reverse=True)
total = 0
res = 101
for i in l:
    if res > i:
        total += 1
        res = i
print(total)

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

print(len(set(n_list)))

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

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

print(len(set(n_list)))

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

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

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

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

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

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

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

Solution (Python):


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

print(len(set(d)))

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

dest_list = list(set(in_list))
print(len(dest_list))

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

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=sorted(d,reverse=True)
ans=1
for i in range(n-1):
  if (d[i]>d[i+1]):
    ans+=1
print(ans)

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

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

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

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

ans = 0
com = 0
l.sort(reverse=True)
for j in l:
    if j < com:
        ans += 1
        com = j
    elif j > com:
        ans = 1
        com = j
    

print(ans)

Solution (Python):

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

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

Solution (Python):

import io

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

Solution (Python):
import numpy as np

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


print(len(np.unique(d)))

Solution (Python):

import sys


def solve(N: int, d: "List[int]"):
    return



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



if __name__ == '__main__':
    main()

Solution (Python):

import sys


def solve(N: int, d: "List[int]"):
    return



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



if __name__ == '__main__':
    main()

Solution (Python):
len_d = int(input())
ans=0
al=[]
for _ in range(len_d):
  ll=int(input())
  al.append(ll)

al.sort()

print(len(set(al)))

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

s = set(d)

print(len(s))

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


if '__main__' == __name__:
    resolve()

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

mochi_list = []

for i in range(n):
  d_i = int(input())
  mochi_list.append(d_i)

mochi_set = set(mochi_list)

stacked_num = len(mochi_set)

print(stacked_num)

Solution (Python):
def main():
    N = int(input())
    M = [int(input()) for _ in range(N)]
    M.sort()
    h = 0
    top = 1000
    for i in range(N):
        m = M.pop()
        if m < top :
            top = m
            h += 1
    print(h)
main()

Solution (Python):
n = int(input())
bucket = [0]*(101)

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

for i in range(n):
    bucket[d[i]] += 1

counter = 0

for num in bucket:
    if num > 0:
        counter+=1

print(counter)

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

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

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

Solution (Python):

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

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

d = sorted(d, reverse=True)

dan = 1
current_size = d[0]

for i in range(1, N):
    if d[i] < current_size:
        dan += 1
        current_size = d[i]
print(dan)

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

Solution (Python):
n = int(input())
c = 0
record = []
for i in range(n):
    val = int(input())
    if not val in record:
        record.append(val)
        c += 1
print(c)

Solution (Python):
n=int(input())
a=[]
while n>0:
    b=int(input())
    a.append(b)
    n-=1
print(len(set(a)))

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

Solution (Python):

N = int(input())
d = list(int(input()) for i in range(N))

print(len(set(d)))

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

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

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

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

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

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()))
ans = [0] * 100
for i in range(N):
   ans[d[i]-1] = 1
print(sum(ans))

Solution (Python):
N,*D =map(int,open(0).read().split())
D =set(D)
print(len(D))

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

s = set(d)

print(len(s))

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

Solution (Python):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import permutations,combinations
from pprint import pprint

def myinput():
    return map(int,input().split())

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col):
    data.sort(key=lambda x:x[col],reverse=False)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

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

print(len(set(d)))

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

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

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

mochi = 1
for i in range(n):
    if i != 0:
        if array[i-1] > array[i]:
            mochi += 1

print(mochi)

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

ans = 0
sub = 101
d.sort(reverse=True)
for i in range(n):
    if sub > d[i]:
        ans += 1
        sub = d[i]

print(ans)

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d = list(set(d))
d = sorted(d)
m = max(d)
print(str(d.index(m) + 1))

Solution (Python):
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    m = [ii() for _ in range(ii())]
    print(len(set(m)))


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
l = []
ans = []
for i in range(N):
  l.append(int(input()))
l.sort()
ans.append(l[0])
for i in range(1,N):
  if ans[-1] != l[i]:
    ans.append(l[i])
print(len(ans))

Solution (Python):

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

dict1 = {}    
for i in range(N):
    dict1[input()] = 1
    
list1 = list(dict1.values())
print(len(list1))

Solution (Python):








N = int(input())
flag = [0 for i in range(101)] 
num = [0 for i in range(N)]    

for i in range(N):
    num[i] = int(input())
    
for i in range(N):
    flag[num[i]] = 1

print(sum(flag))

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

Solution (Python):
N = int(input())
D = [int(input()) for x 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())
print(len(set(map(int, [input() for i in range(n)]))))

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

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

Solution (Python):
import numpy as np
if __name__ == "__main__":
    
    
    
    
    
    
    N = int(input())
    d = []
    for i in range(N):
        d_i = int(input())
        d.append(d_i)
    
    
    print(len(set(d)))

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

Solution (Python):


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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
N = int(input())
moti =[]
for i in range(N):
    moti.append(int(input()))
ans=1
moti.sort()
for i in range(len(moti)-1):
    if moti[i] < moti[i+1]:
        ans += 1
    else:
        continue
print(ans)

Solution (Python):
from collections import defaultdict

n = int(input())
dic = defaultdict(int)

for i in range(n):
    dic[int(input())] += 1

print(len(dic))

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 = [int(input()) for i in range(n)]
s = set(d)
print(len(s))

Solution (Python):

import sys
try:
    from typing import List
except ImportError:
    pass


def solve(N: int, d: "List[int]"):
    print(len(set(d)))


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    d = [int(next(tokens)) for _ in range(N)]  
    solve(N, 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())
d = [int(input()) for _ in range(n)]
d.sort()
d_set = set(d)
print(len(d_set))

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

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

for i in range(N):
  d[i] = int(input())
d = sorted(d, reverse=True)

ans = 0
for i in range(N):
  if len(stack) == 0:
    stack.append(d[i])
  elif stack[-1] == d[i]:
    continue
  elif stack[-1] > d[i]:
    stack.append(d[i])
  else:
    ans = max(ans, len(stack))
    stack = [d[i]]

ans = max(ans, len(stack))
print(ans)

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

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

d = dict()

for i in range(n):
    x = int(input())
    if x not in d:
        d[x] = x
    else:
        continue

print(len(d))

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

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

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

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

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

Solution (Python):
n = int(input())
d_list = [0] * n
count = 0
check = False

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

for i in range(110):
  for j in range(n):
    if d_list[j] == i:
      check = True
  if check == True:
    count += 1
    check = False

print(count)

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

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

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

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

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

d = sorted(d)

count = 0

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

print(count + 1)

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

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

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

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

D = set(D)

print(len(D))

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

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

D = {}
for i in d:
  D[i] = 0



print(len(D))

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

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

Solution (Python):
n = int(input()) 
d = []
for i in range(n):
    d.append(int(input()))
    
d=list(set(d))
d.sort()
before=0
ans=0
for i in d:
    if i > before:
        ans += 1
    else:
        break
    before = i
    
print(ans)

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

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

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



print(len(set(a)))

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

for _ in range(n):
  d.append(int(input()))
  
d_new = sorted(set(d))
  
print(len(d_new))

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

Solution (Python):
n = int(input())
a = []
for i in range(n):
    a.append(int(input()))
dic = {}
for i in a:
    if i not in dic:
        dic[i] = 1
    else:
        dic[i] += 1
print(len(dic))