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):
num = int(input())
a = []

for i in range(num):
    n = int(input())
    a.append(n)
    
myset = set(a)

len_list = len(frozenset(myset))

print(len_list)

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

print(len(set(n_list)))

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

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

d.sort(reverse=True)

ans = 0

x = max(d)+1
for i in range(0,N):
  
  if d[i] < x:
    ans += 1
    x = d[i]

print(ans)

Solution (Python):
n=int(input())
l=[]
for _ in range(n):
    k=int(input())
    if k not in l:l.append(k)
print(len(l))

Solution (Python):
from typing import List


def answer(n: int, d: List[int]) -> int:
    return len(set(d))

def main():
    n = int(input())
    d = list(int(input()) for _ in range(n))
    print(answer(n,d))

if __name__ == '__main__':
    main()

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

l = []
for i in range(N):
  if d[i] not in l:
    l.append(d[i])
    
print(len(l))

Solution (Python):

from math import floor, ceil, sqrt, factorial, log, gcd, log10
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement, chain
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
from copy import copy, deepcopy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)


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





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




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





def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()




def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')







def IR(n): return [I() for i in range(n)]







def LIR(n): return [LI() for i in range(n)]







def SR(n): return [S() for i in range(n)]







def LSR(n): return [LS() for i in range(n)]







def SRL(n): return [list(S()) for i in range(n)]


n = I()
d = IR(n)
print(len(set(d)))

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

dic = {}

for i in range(N):
  if d[i] in dic:
    dic[d[i]] += 1
  else:
    dic[d[i]] = 1

print(len(dic))

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

num = [0]*(max(d)+1)
for i in range(N):
  num[d[i]] +=1

res = 0

for i in range(max(d)+1):
  if num[i]:
    res += 1

print(res)

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

d.sort(reverse=True)

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

print(step)

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

original=[]
for i in d:
    if i not in original:
        original.append(i)
print(len(original))

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

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

D_num=list(set(D))
print(len(D_num))

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

for i in range(N):
   lst.append(input())

print(len(set(lst)))

Solution (Python):

n=int(input())
data=[]
for i in range(0,n):
    data.append(int(input()))
res=sorted(data)
c=1
for j in range(1,n):
    if res[j]!=res[j-1]:
        c=c+1
print(c)

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
n = I()
li = [I() for _ in range(n)]
li.sort(reverse=True)
before = ans =  0
for i in range(n):
    if before != li[i]:
        ans += 1
        before = li[i]
print(ans)

Solution (Python):


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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

print(len(set(a)))

Solution (Python):
with open(0) as f:
    N, *d = map(int, f.read().split())
d = list(set(d))
print(len(d))

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**6)

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

print(len(set(d)))

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

D_set = set(D)
ans = len(D_set)

print(ans)

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

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

Solution (Python):
n = int(input())
key = []
ans = 0
for _ in range(n):
    s = int(input())
    if s not in key:
        key.append(s)
        ans += 1
print(ans)

Solution (Python):
n = int(input())
d = [int(input()) for i in range(n)]
d = sorted(d, reverse=True)
ans = 0
last = 101
for i in d:
    if i < last:
        ans+=1
        last = i
print(ans)

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

print(len(set(d)))

Solution (Python):


"""
上のほうが餅が小さくなるように重ねる
→ 同じサイズの餅は使えない

同じサイズの餅は1つだけ使って（重複を排除して）
大きいものから重ねていけばいい

何段重ねられるか
= 何種類のサイズの餅があるか
"""

n = int(input())
mochi_set = set()
for i in range(n):
    size = int(input())
    mochi_set.add(size)

print(len(mochi_set))

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

Solution (Python):
N=int(input())
z=[]
for num in range(101):
  z.append(0)
counter=0
while counter < N:
  d=int(input())
  z[d]=1
  counter+=1
result=sum(z)
print(result)

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

Solution (Python):
i = input()

l = []

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

l = list(set(l))

print(len(l))

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

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

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

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

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

table  = []
for i in range(num):
    table.append(int(input()))

setting = set(table)
print(len(setting))

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

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

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

se=set([])
for d in D:
	se.add(d)
print(len(se))

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

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

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

set1 = set(list1)
ans = len(set1)
print(ans)

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

Solution (Python):
mycode = r'''








ctypedef long long LL

import numpy as np


import sys
readline = sys.stdin.buffer.readline
read = sys.stdin.readline 

cdef LL a_int(): return int(readline())

def ints(): return np.fromstring(readline(), sep=' ', dtype=np.int64)

cdef read_matrix(LL H,LL W):
    
    lines=[]
    cdef LL _
    for _ in range(H): 
        lines.append(read())
    lines=' '.join(lines) 
    return np.fromstring(lines, sep=' ',dtype=np.int64).reshape(H,W)


N=a_int()
D=read_matrix(N,1)[:,0]
print(len(np.unique(D)))


'''

import sys
if sys.argv[-1] == 'ONLINE_JUDGE':  
    import os
    with open('mycode.pyx', 'w') as f:
        f.write(mycode)
    os.system('cythonize -i -3 -b mycode.pyx')

import mycode

Solution (Python):
n = int(input())
a = sorted([input() for i in range(n)])
c = 1
for i in range(n - 1):
    if a[i] < a[i + 1]:
        c += 1
print(c)

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

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

moti_list.sort(reverse=True)
tower = 1
for j in range(N - 1):
    if moti_list[j] > moti_list[j + 1]:
        tower += 1

print(tower)

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

moti_list.sort(reverse=True)
tower = 1
for j in range(N - 1):
    if moti_list[j] > moti_list[j + 1]:
        tower += 1

print(tower)

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

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

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

d.sort(reverse = True)
cnt = 0

pre = d[0]

for i in d:
    if cnt != 0 and pre == i:
        continue
    cnt += 1
    pre = i

print(cnt)

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

while ds:
    tmp = max(ds)
    ds = [j for j in ds if j < tmp]
    mochidan += 1

print(mochidan)

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

Solution (Python):
import sys

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

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

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

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

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

print(len(set(List)))

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

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

print(len(List))

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

Solution (Python):
N = int(input())
d_list = []
Height = 0
for i in range(N):
    d_list.append(int(input()))
while d_list != []:
    MAX_Value = max(d_list)
    while MAX_Value == max(d_list):
        d_list.remove(MAX_Value)
        if d_list == [] :
            break
    Height +=1
print(Height)

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 = []

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

print(len(set(d)))

Solution (Python):

import sys
from typing import List


def fast_input():
    return sys.stdin.readline()[:-1]


def solve(mochi_list: List[int]) -> int:
    sorted_mochi_list = sorted(mochi_list)
    kagamimochi = set(sorted_mochi_list)
    return len(kagamimochi)


def main():
    n = int(fast_input())
    d = []
    for i in range(n):
        d.append(int(fast_input()))
    result = solve(d)
    print(result)


main()

Solution (Python):
from sys import stdin
n = int(stdin.readline().rstrip())
a = [0]*n
for x in range(n):
   a[x] = int(stdin.readline().rstrip())

a.sort(reverse = True)

sum = 1

for x in range(n-1):
   if a[x] > a[x+1]:
      sum += 1
print(sum)

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

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

print(len(seen))

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

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

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

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 _ in range(N)]
d.sort()

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    N = int(readline())
    d = [int(readline()) 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)]

print(len(set(d)))

Solution (Python):
N = int(input())
D = sorted([int(input()) for _ in range(N)], reverse=True)
cnt = 1
for i in range(len(D)-1):
    if D[i] <= D[i+1]:
        pass
    else:
        cnt += 1
print(cnt)

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

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

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

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

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

Solution (Python):



def main():
    n = int(input())
    li = [0] * 102
    for i in range(n):
        d = int(input())
        li[d] = 1
    ans = 0
    for i in range(102):
        if li[i] == 1:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):



def main():
    n = int(input())
    li = []
    for i in range(n):
        li.append(int(input()))
    li.sort(reverse=True)
    ans = 1
    for i in range(1, n):
        if li[i - 1] > li[i]:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

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

d = sorted(d)

cnt = 0
max = 0
for i in range(len(d)):
    if max < d[i]:
        max = d[i]
        cnt += 1
print(cnt)

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


N = I()
s = set()
for _ in range(N):
    s.add(I())

print(len(s))

Solution (Python):
print(len(set(open(0).read().split()[1:])))

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

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

Solution (Python):
import sys

input = sys.stdin.readline
N = int(input())
D = set()
for _ in range(N):
    D.add(int(input()))

print(len(D))

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

print(len(set(D)))

Solution (Python):
from collections import Counter

N, *D = map(int, open(0).read().split())

print(len(Counter(D).most_common()))

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

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

d=sorted(d)

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

Solution (Python):
from collections import Counter
N = int(input())
d = [int(input()) for i in range(N)]
d = Counter(d)
print(len(d))

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
a = [inp() for _ in range(n)]
print(len(set(a)))

Solution (Python):
def main():
    N = int(input())
    d = [int(input()) for _ in range(N)]
    d_set = set(d)
    ans = len(d_set)
    return ans

print(main())

Solution (Python):
N = int(input())
D = sorted([int(input()) for _ in range(N)])
cnt = 1
d = D[0]
for i in range(1,N):
    if D[i]>d:
        cnt += 1
        d = D[i]
print(cnt)

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

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

print(len(Counter(d)))

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

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


N = I()
s = set()
for i in range(N):
    s.add(I())

print(len(s))

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

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

print(len(ds))

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

Solution (Python):
N = int(input())
num = [0 for _ in range(110)]

for i in range(N):
    d = int(input())
    num[d] = 1 
print(sum(num))

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

Solution (Python):
N = input()
d = []
try :
  while True:
    a = input()
    if a :
      d.append(a)
    else :
      break
except EOFError:
  pass
c = 0
import copy
e = copy.copy(d)
for i in e :
  x = d.pop(0)
  if x not in d: 
    c += 1
print(c)

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

Solution (Python):


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

Solution (Python):


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

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

print(len(set(a)))

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

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

Solution (Python):
import numpy as np

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

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

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

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

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

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

print(len(set(l)))

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

a_set=set(a)
print(len(a_set))

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

Solution (Python):
n = int(input())
d = []
for _ in range(n):
    d.append(int(input()))
d.sort()
a = 1
for i in range(len(d) - 1):
    if d[i] < d[i + 1]:
        a += 1
print(a)

Solution (Python):


N = int(input())

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

print(len(set(data_list)))

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


l = [0]*100
for i in range(N):
  l[d[i]-1] = 1
  
print(sum(l))

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

l = [0]*100
for i in range(N):
  l[d[i]-1] = 1
  
print(sum(l))

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

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

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

Solution (Python):
N = int(input())
List  = (int(input()) for i in range(N))

print(len(set(List)))

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):
def main():
    N = int(input())
    d = [int(input()) for _ in range(N)]

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


if __name__ == "__main__":
    main()

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()))
A=set(A)
print(len(A))

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

for i in range(n):
    l.append(input())

print(len(set(l)))

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

Solution (Python):
n=int(input())
a=set(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())
dd=[list(map(int,list(input()))) for i in range(N)]
d = sorted(dd)
c = 1
for i in range(N-1):
    if d[i] != d[i+1]:
        c += 1
print(c)

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

Solution (Python):
from collections import Counter

n = int(input())
d = (int(input()) for _ in range(n))
c = Counter(d)

print(len(c))

Solution (Python):

i=int(input())
rrr=[]
for d in range(i):
    r=[int(input())]
    rrr+=r
s=len(set(rrr))
print(s)

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

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

Solution (Python):
n=int(input())
moti=[input() for i in range(n)]
moti.sort()
count=1
for i in range(n-1):
    if moti[i]!=moti[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())
lst = []
for i in range(n):
  lst.append(int(input()))

lst = set(lst)
print(len(lst))

Solution (Python):
N=int(input())
d=[0]*N
for i in range(N) :
  d[i]=int(input())
d.sort()
count=1
for i in range(1,N) :
  if d[i-1]!=d[i] :
    count+=1
print(count)

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

lis = list(s)
lis.sort()
print(len(lis))

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

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

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

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

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

Solution (Python):
N = int(input())
D = sorted([int(input()) for _ in range(N)])
if len(D) > 1:
    i,prev = 0,None
    while i < (len(D)-1):
        if D[i] == D[i+1]: 
            D.pop(i+1)
        else:
            prev = D[i]
            i +=1
print(len(D))

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

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 _ in range(n)]
print(len(set(d)))

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

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

Solution (Python):
n = int(input())
cake = []
for i in range(n):
    cake.append(int(input()))
    
cake.sort()
kagami = [cake[0]]
num = cake[0]
for i in cake:
    if i > num:
        kagami.append(i)
        num = i
print(len(kagami))

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

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

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

dset = set(d)

print(len(dset))

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

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

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

Solution (Python):
from collections import defaultdict,deque
import math
def main():
    n = int(input())
    d = [int(input()) for i in range(n)]
    dd = defaultdict(int)
    for i in d:
        dd[i]+=1
    tmp = dd.keys()
    print(len(tmp))


if __name__ == '__main__':
    main()

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

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

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

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

print(len(set(d_i_list)))

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

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

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

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

Solution (Python):
def resolve():
    n = int(input())
    dl = list()
    for i in range(n):
        d = int(input())
        dl.append(d)
    dl = sorted(dl, reverse=True)
    pre = 110
    ans = 0
    for d in dl:
        if d < pre:
            ans += 1
        pre = d
    print(ans)
resolve()

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

dss = set(ds)
print(len(dss))

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

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

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

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

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

a.sort()
count = 0

for i, j in enumerate(a):
    try:
        if j == a[i + 1]:
            a[i] = 0
            count += 1
        else:
            pass
    except IndexError:
        pass

print(n - count)

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

x = sorted(d, reverse=True)

ans = 1
for i in range(N-1):
    if x[i] - x[i+1] >0:
        ans += 1
    else:
        continue


print(ans)

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

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

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

Solution (Python):
n = int(input())
dic = {}
for i in range(n):
    d = int(input())
    dic.setdefault(d,0)
    dic[d] += 1
print(len(dic))

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

li = set()

for i in range(N):
    li.add(int(input()))

print(len(li))

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

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

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

	num = [0] * 101

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

	ans = 0

	for i in range(101):
		if num[i] > 0:
			ans += 1

	print(ans)

  
if __name__ == "__main__":
  	main()

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

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

	print(len(d))



  
if __name__ == "__main__":
  	main()

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

d = set(sorted(d))

print(len(d))

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

Solution (Python):

n = int(input())

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

d_list = list(set(d_list))

d_list = sorted(d_list, reverse = True)

ans = len(d_list)

print(ans)

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