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

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

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

print(height)

Solution (Python):
from sys import stdin

N = int(stdin.readline().rstrip())
d_lst = []
for x in range(N):
  d_lst.append(int(stdin.readline().rstrip()))
  
d_lst = list(set(d_lst))
d_lst.sort(reverse=True)

count = 1
max_val  = d_lst[0]

for d in d_lst[1:]:
  if d < max_val:
    count += 1
    max_val = d
    
print(count)

Solution (Python):

def main():


    N = int(input())
    kagamiMochiList = {int(input()) for _ in range(N)}
    print(len(list(kagamiMochiList)))



    


if __name__== "__main__":
    main()

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

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

a = []

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

a	= sorted(a)
a.reverse()

tmp = a[0]
ans = 1

for i in range(1, n):
	if a[i] != tmp:
		ans = ans + 1
	tmp = a[i]
	
print(ans)

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

for i in range (N):
  d = int (input())
  num.append(d)
  
print(len(set(num)))

Solution (Python):
n = int(input())
loop = 0
array = []
moti = []

while loop < n :
    array.append(int(input()))
    loop += 1

for i in range(len(array)):
    if moti.count( array[i] )==0:
        moti.append(array[i])

print(len(moti))

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())
a = set([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())
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):
from collections import Counter


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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

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

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

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

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

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

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

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

l = sorted(d, reverse = True)

m = []
for i in range(len(l)):
    if i == 0:
        m.append(l[i])
    elif m[-1] > l[i]:
        m.append(l[i])

print(len(m))

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

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

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

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

l = []
for n in M:
  dup_flg = False
  for i in l:
    if n == i:
      dup_flg = True
  if not dup_flg:
    l.append(n)

print(len(l))

Solution (Python):
N = int(input())
M = {int(input()) for _ in range(N)}

print(len(M))

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

h = {}
for m in M:
  h[m] = 1

print(len(h.keys()))

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

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

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

print(len(set(mochi)))

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

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

print(len(set(List)))

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

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

Solution (Python):

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


ans = len(set(d_list))
print(ans)

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

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

print(len(d))

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

Solution (Python):
n = int(input())
d = dict()
for i in range(0,n):
    tmp = int(input())
    if tmp in d:
        continue
    else:
        d[tmp] = 1

print(len(d))

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

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

def combination(n, r):
    return factorial(n) // (factorial(n - r) * factorial(r))

sys.setrecursionlimit(10000)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



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


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

if __name__ == "__main__":
    N = int(sys.stdin.readline())
    s = set()
    for _ in range(N):
        s.add(int(sys.stdin.readline()))
    print(len(s))

Solution (Python):
N = int(input())
d = [0 for i in range(N)]
for i in range(N):
    d[i] = int(input())
    
d.sort()
ans = 0
prev = 0
for e in d:
    if e > prev:
        ans += 1
        prev = e

print(ans)

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

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

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

print( len(set(d)) )

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

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

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

Solution (Python):
N=int(input())
l=[0 for _ in range(100)]
for _ in range(N):
  l[int(input())-1]=1
print(sum(l))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
n=int(input())
dd=[]
for _ in range(n):
    dd.append(int(input()))
print(len(set(dd)))

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

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

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

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

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


    d = [0] * N

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

    set_d = set(d)

    print(len(set_d))

main()

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

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

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

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

Solution (Python):
n = int(input())
l = list()
for i in range(n):
  a = input()
  if not a in l:
    l.append(a)
  else:
    pass

print(len(l))

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

Solution (Python):
from collections import Counter

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

a = len(Counter(D))
print(a)

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

Solution (Python):
n = int(input())
d=[]
for i in range(n):
  d.append(int(input()))
s = set(d)
l = list(s)
li = sorted(l,reverse=True)
print(len(li))

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

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

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

if N==1:
    print(1)
    
else:
    making_mochi.append(mochi[0])
    for i in range(1,N):
        if mochi[i]!=max(making_mochi):
            making_mochi.append(mochi[i])
    print(len(making_mochi))

Solution (Python):
n = int(input())
d_list = {int(input()) for i in range(n)}

print(len(d_list))

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

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

print(len(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())
mochis = []
for _ in range(N):
	mochis.append(int(input()))

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

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

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

Solution (Python):
import sys, math, itertools, bisect, copy, re
from collections import Counter, deque, defaultdict






INF = float('inf')
MOD = 10 ** 9 + 7
EPS = 10 ** -7
sys.setrecursionlimit(1000000)









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

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

d.sort()
counter = 0
for i in range(N):
    if i==0: counter += 1
    else :
        if d[i]>d[i-1]: counter += 1
print(counter)

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

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

n = int(input())
d = []
for _ in range(0, n):
    d += [int(input())]

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

print(len(dN))

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




D.sort()
mochi = [D[0]]
for d in D[1:]:
    if mochi[-1] < d:
        mochi.append(d)

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

Solution (Python):
n = int( input() )
dic = {}
for i in range(n):
  diameter = input()
  
  dic[diameter] = int( diameter )
  


print( len(dic) )

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

print(len(d))

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

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

lista=set(lista)

print(len(lista))

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

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

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

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

d_removed = sorted(set(d), key=d.index)

print(len(d_removed))

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

b = set(a)



print(len(b))

Solution (Python):
n = int(input())
hoge = {}
for _ in range(n):
  x = int(input())
  hoge[x] = 1
print(len(hoge))

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

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

m = list(set(m))
ans = len(m)
print(ans)

Solution (Python):
n = int(input())
d_list = [int(input()) for i in range(n)]
d_list.sort(reverse = True)
count = 1

for i in range(1, n):
    if d_list[i] < d_list[i-1]:
        count += 1
print(count)

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

d.sort()
d_tmp = d[0]
count = 1

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

print(count)

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    d = [None]*N
    for n in range(N):
        d[n] = int(input())
    d = list(set(d))
    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 = sorted([input() for _ in range(N)])

print(len(set(l)))

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

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

Solution (Python):
*a,=map(int,open(0))
print(len(set(a[1:])))

Solution (Python):
N = int(input())
cake_count = 1
cake_list = []

while cake_count <= N:
    cake_list.append(int(input()))
    cake_count += 1

cake_diameters = list(set(cake_list))
layer = len(cake_diameters)

print(layer)

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

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

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

i=0
inputNumbers=[]
while i<n:
  inputNumbers.append(int(input()))
  i=i+1

print(len(set(inputNumbers)))

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 = int(input())
  if not a in A:
    A.append(a)
print(len(A))

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

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

Solution (Python):
import sys

lines = sys.stdin.read().splitlines()
mochis = set(map(int, lines[1:]))
print(len(mochis))

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

count = 0
store = {}
for _ in range(n):
    d = input()
    if store.get(d) is None:
        store[d] = True
        count += 1

print(count)

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

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

Solution (Python):
def solve():
    a = read()
    result = think(a)
    write(result)


def read():
    n = read_int(1)[0]
    a = []
    for i in range(n):
        a.append(read_int(1)[0])
    return a


def read_int(n):
    return list(map(int, read_line().split()[:n]))


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


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


def write(result):
    print(result)


if __name__ == '__main__':
    solve()

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

for i in range(n):
  getn = int(input())
  a.append(getn)
  
b = set(a)

print(len(b))

Solution (Python):



if __name__ == '__main__':
    n = int(input())
    d = list([int(input()) for _ in range(n)])
    print(len(set(d)))

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

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

print(len(D))

Solution (Python):
N = int(input())
dL = [0]*N
for n in range(N):
  dL[n] = int(input())
print(len(list(set(dL))))

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

Solution (Python):
n = int(input())
s = set()
for _ in [0]*n:
  s.add(int(input()))
print(len(s))

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

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

Solution (Python):
nN = int(input())
 
nList = []
 
nTmp = int(input())
nList.append(nTmp)
nAns = 1
 
if (nN > 1):  
  for i in range(nN - 1):
    nTmp = int(input())
      
    if nTmp not in nList:
      nList.append(nTmp)
      nAns += 1
    
print(nAns)

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

s = set(li)
print(len(s))

Solution (Python):

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

print(len(set(D)))

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

print(len(set(d)))

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

Solution (Python):
N = int(input())
d = [int(input()) for _ in range(N)]
d.sort()
count = 0
for i in range(N):
    if 0<i and d[i] == d[i-1]:
        continue
    else:
        count += 1
if count == 0:
    count += 1
print(count)

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

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

Solution (Python):
from numpy import unique

n = int(input())
num_list = []
for i in range(n):
    num = int(input())
    num_list.append(num)
print(len(unique(num_list)))

Solution (Python):
N = int(input())
number_list = sorted([input() for i in range(N)])
before = 0
count = 0
for i in range(N):
    if(before==number_list[i]):
        continue
    else:
        count += 1
    before = number_list[i]
print(count)

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

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

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

Solution (Python):
MOCHI_NUM = int(input())
MOCHIS = list()
for i in range(MOCHI_NUM):
    MOCHIS.append(int(input()))

print(len(set(MOCHIS)))

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

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

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

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

greatmochis=list(set(mochis))

print(len(greatmochis))

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

if N ==1:
    print(1)
    exit()

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

num =[0]*101

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

c = 0

for i in range(101):
    if num[i] !=0:
        c +=1
print(c)

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

if N ==1:
    print(1)
    exit()

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


d.sort()

c = 1

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

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

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

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

print(len(set(a)))

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())
list = sorted(int(input()) for _ in range(n))
cnt = 0
for i in range(n-1):
  if list[i] < list[i+1]:
  	cnt += 1
  else:
    pass
print(int(cnt) + 1)

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 _ in range(N):
	d.append(int(input()))

d.sort()

ans = 0

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

print(ans)

Solution (Python):
n = int(input())
d = [int(input()) for i in range(n)]
d.sort()
counter = 0
for i in range(n):
  if i+1< n:
    if d[i] < d[i+1]:
      counter += 1
  else:
      print(counter+1)

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

dLst.sort()
tmp = dLst[0]
ansCnt = 1
for i in range(1, N):
    if tmp < dLst[i]:
        ansCnt += 1
    tmp = dLst[i]

print(ansCnt)

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
count = 1
for i in range(1,N):
    flag = 0
    for k in range(i):
        if d[i] == d[k]:
            flag = 1
    if flag == 0:
        count += 1

print(count)

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

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

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

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

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

Solution (Python):


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

print(len(l))

Solution (Python):

import sys
import math
from collections import defaultdict


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


mod = 10**9 + 7


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



N = I()
d = set()
for i in range(N):
  d.add(I())
print(len(d))

Solution (Python):
import math

n = int(input())






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

print(len(ls))

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

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

Solution (Python):
def main33():
    num = int(input())
    tumi = []
    tumi.append(0)
    result = 0
    for i in range(num):
        moti = int(input())
        hantei = True
        for j in tumi:
            if j == moti:
                hantei = False
                break
        if hantei:
            result = result + 1
            tumi.append(moti)
    print(result)

if __name__ == "__main__":
    main33()

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

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

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

Solution (Python):
n=int(input())
d=[]
for _ in range(n):
  d.append(int(input()))
m=d.sort()
t=list(set(d))
print(len(t))

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

while n > 0:
    d.append(int(input()))
    n -= 1

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

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

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

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

print(len(d_list))

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

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

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

Solution (Python):
N=int(input())
d=[int(input()) for i in range(N)]
d=sorted(d)
counter=0
for i in range (N):
  if i==0:
    counter+=1
  else:
    if  d[i]>d[i-1]:
      counter+=1
print(counter)

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d.sort()
j = 0
k = 0
for i in range(N):
    if(j < d[i]):
        k += 1
        j = d[i]
print(k)

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

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

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

li = [int(input()) for i in range(n)]
sl = set(li)

print(len(sl))

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

print(len(set(l)))

Solution (Python):
import sys
n = int(input())
print(len(set(map(int,sys.stdin))))

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

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(list(set(d))))

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

print(len(set(l)))

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

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

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

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

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

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

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

num = []
while(len(a) > 0):
    
    num.append(max(a))
    index = max(a)
    for i in range(0,n):
        if(len(a) > 0 and index in a):
            a.remove(index)
            
print(len(num))

Solution (Python):
n = int(input())
binary = [0 for i in range(110)]
for  i in range(n):
    tmp = int(input())
    binary[tmp] += 1
    
ans = 0
for i in binary:
    if i > 0:
        ans += 1
print(ans)

Solution (Python):
import sys

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

if __name__ == "__main__":
    n = int(input())
    dl = [int(input()) for i in range(n)]

    print(len(set(dl)))

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

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

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d_sorted = sorted(d)
size = 0
count = 0
for i in range(N):
    if(size < d_sorted[i]):
        count += 1
        size = d_sorted[i]
print(count)

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

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

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

print(len(set(d)))

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

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

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

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

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

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

Solution (Python):
n=int(input())
li=[int(input()) for k in range(n)]

lis=[0]*110
a=0

for i in range(0,n):
   lis[li[i]]+=1
for j in range(0,101):
    if lis[j]>0:
        a+=1

print(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 i in range(n)]

d = set(d)

print(len(d))

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

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

d_list.sort(reverse=True)
bottom = d_list[0]
count = 1
for d in d_list[1:]:
    if bottom > d:
        bottom = d
        count += 1

print(count)

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

Solution (Python):


import sys

def input(): 
    return sys.stdin.readline().strip()

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

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

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

Solution (Python):
size = int(input())
mochi = [0]*size

for i in range(0, size):
    mochi[i] = int(input())
    
mochi = list(set(mochi))
mochi.sort()

print(len(mochi))

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

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

Solution (Python):


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

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

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

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

Solution (Python):

def kagamiMochi():
	N = int(input())
	d = []
	for _ in range(0, N):
		d.append(int(input()))

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

	count = 0
	for j in num:
		if j:
			count += 1
	print(count)

kagamiMochi()

Solution (Python):
def kagamiMochi():
	N = int(input())
	d = []
	for _ in range(0, N):
		d.append(int(input()))
	d.sort()
	count = 1
	for j in range(1, N):
		if d[j] != d[j-1]:
			count += 1
	print(count)

kagamiMochi()