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

Solution (Python):
N=int(input())
d=[]
for i in range(N):
    diameter=int(input())
    truth=0
    for j in range(len(d)):
        if d[j]==diameter:
            truth+=1
    if truth==0:
        d.append(diameter)
        
print(len(d))

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

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

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

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

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().strip()

n = ni()
d = [ni() for _ in range(n)]
d = set(d)
d = sorted(d, reverse=True)
ans = 0
b = 110
for i in d:
    if i < b:
        ans += 1
    else:
        break
    b = i
print(ans)

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

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

for i in range(n):
 bucket[d[i]] += 1
for i in range(101):
 if bucket[i]>0: ret += 1

print(ret)

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

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

print(n-duplication)

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

print(len(d))

Solution (Python):
N = int(input())
count = 0
check = []
for i in range(N):
  work = int(input())
  if work not in check:
    count +=1
    check.append(work)
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()))

d.sort()

count = 1

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

print(count)

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

Solution (Python):





if __name__ == '__main__':
    mochi_count = int(input())
    mochi_diameters = [int(input()) for _ in range(mochi_count)]

    step_count = len(set(mochi_diameters))
    print(step_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())
S = set()
for i in range(N):
  S.add(input())
print(len(S))

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d.sort(reverse=True)
mochi = d[0]
dan = 1
for i in range(1,N):
    if d[i] < mochi:
        mochi = d[i]
        dan += 1
print(dan)

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())
x=[]
count=0
for i in range(n):
    x.append(int(input()))
x=set(x)
for i in x:
    count +=1
print(count)

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

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

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

print(count)

Solution (Python):

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

dm = 0
count = 1
for i in range(1, n):
    dm = d[i]-d[i-1]
    if dm > 0:
        count += 1
print(count)

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

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

a=sorted(a)
c=0
for j in range(n-1):
	if((a[j])<(a[j+1])):
		c+=1

print(c+1)

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

Solution (Python):


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

Solution (Python):
N=int(input())
l=[]
for _ in range(N):
    l.append(int(input()))
L=set(l)
LL=sorted(L,reverse=True)
cnt=1
for i in range(len(LL)-1):
    if LL[i]<=LL[i+1]:
        break
    cnt+=1
print(cnt)

Solution (Python):
def kagamimochi(diameters):
    return len(list(set(diameters)))

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

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

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

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

if __name__ == '__main__':
    print(main())

Solution (Python):
N = int(input())
List = [0]
count = 1
for i in range(N):
    List.append(int(input()))
List.pop(0)
List.sort()
i = 1
for j in range(N - 1):
    if List[i] != List[i - 1]: count += 1
    i += 1
print(count)

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

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

Solution (Python):
N = int(input())
list_mochi = []
for i in range(N):
    r = int(input())
    if not(r in list_mochi):
        list_mochi += [r]

print(len(list_mochi))

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

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

for i in range(n):
    if not d[i] in ans:
        ans.append(d[i])
print(len(ans))

Solution (Python):



import sys

def main():
    _ = sys.stdin.readline()
    print(len(set(map(int, sys.stdin.readlines()))))

if __name__ == '__main__':
    main()

Solution (Python):

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

Solution (Python):
n = int(input())
a = []
for i in range(0, n):
    a.append(int(input()))
a.sort(reverse=True)
temp = 101
ans = 0
for i in a:
    if temp > i:
        ans += 1
        temp = i
print(ans)

Solution (Python):
n = int(input())
a = []
for i in range(0,n):
    a.append(int(input()))
for i in range(0,n-1):
    for j in range(i+1,n):
        if a[i] == a[j]:
            a[j] = None
count = a.count(None)
print(n-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 = [int(input()) for _ in range(N)]

answer_set = set(d)

print(len(answer_set))

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

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

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


if __name__ == '__main__':
    main()

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

Solution (Python):


import sys

n = int(raw_input().split()[0])
ts = set()
for _ in xrange(0, n):
    di = raw_input().split()[0]
    ts.add(di)
ans = len(ts)
sys.stdout.write('%s\n' % (ans))
sys.stdout.flush()

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

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

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())
Dia = [0]*N
for i in range(N):
    Dia[i] = int(input())
count = [0]*100
for i in Dia:
    count[i-1] += 1
print(100-count.count(0))

Solution (Python):

"""
https://beta.atcoder.jp/contests/abc085/tasks/abc085_b

"""
import sys
from sys import stdin
input = stdin.readline


def solve(mochi):
    availables = [False] * 101
    for m in mochi:
        availables[m] = True
    return availables.count(True)


def main(args):
    mochi = []
    N = int(input())
    for _ in range(N):
        mochi.append(int(input()))
    ans = solve(mochi)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):

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

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

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

Solution (Python):


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

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

last_mochi = 101
count = 0

for mochi in sorted(mochi_list, reverse=True):
    if mochi < last_mochi:
        count += 1
    last_mochi = mochi

print(count)

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

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

cnt = 0
for i in a:
    if i in b:
        pass
    else:
        b.append(i)
print(len(b))

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

Solution (Python):
import numpy as np

n=int(input())
d=np.zeros((n))
for i in range(n):
    d[i]=int(input())




ans=n
for i in range(n):
    flag=0
    for j in range(n-i-1):
        if(d[i]==d[i+j+1]):
            flag=flag+1
    if(flag!=0):
        ans=ans-1




print(ans)

Solution (Python):


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

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

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

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

Moti = list()
for k in d:
   if (k in Moti) == False:
      Moti.append(k)

print(len(Moti))

Solution (Python):
def RemoveDuplicates(x):
    y = []
    for i in x:
        if i not in y:
            y.append(i)
    return y

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

print(len(RemoveDuplicates(a)))

Solution (Python):

paper = int(input())


moti_list  = []
li_uniq    = []


for w in range(paper):
    paper = int(input())

    moti_list.append(paper)

li_uniq = list(set(moti_list))

print(len(li_uniq))

Solution (Python):

""" abc085b """

n = int(input())
mochiSet = set()
[mochiSet.add(int(input())) for i in range(n)]
print(len(mochiSet))

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

print(len(set(D)))

Solution (Python):
N = int(input())
ipts = [input() for i in range(N)]
dic = {}
for i in ipts:
    if(i not in dic):
        dic[i] =  True
print(len(dic))

Solution (Python):
import math
import numpy as np
from operator import mul










N = int(input())
D = [int(input()) for i in range(N)]
D_uniq = []
for x in D:
    if x not in D_uniq:
        D_uniq.append(x)

print(len(D_uniq))

Solution (Python):
n = int(input())
d = [int(input()) for i in range(n)]
d = list(sorted(d))
ret = 0
tmp = 0
for i in d:
    if tmp < i:
        tmp = i
        ret +=1
print(ret)

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

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

Solution (Python):
N = int(input())
i=0
L=[]
while i < N:
    L.append(int(input()))
    i+=1
Luni = list(set(L))
print(len(Luni))

Solution (Python):

from bisect import bisect_left, bisect_right, insort_left, insort_right

import numpy as np

import itertools

import math 
from collections import defaultdict as dd
def main():
    n = int(input())
    A = []
    for k in range(n):
        A.append(int(input()))

    A =  sorted(A)

    count = 0
    val = 0
    for a in A:
        if a > val:
            count += 1
            val = a

    print (count)

if __name__ == "__main__":
    
    
    main()

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

Solution (Python):



N = int(input())
childs = [list(map(int, input().split())) for _ in range(N)]

childs.sort(reverse=True)
count = 0
pre_c = 0
for c in childs:
    if not pre_c == c:
        count += 1
    pre_c = c
print(count)

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

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

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

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

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


import numpy as np
b=np.unique(a)
print(len(b))

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

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

uniqueList = []
for i in range(N):
    if d[i] in uniqueList:
        continue
    else:
        uniqueList.append(d[i])
        
print(len(uniqueList))

Solution (Python):

n = int(input())
xs = {int(input()) for i in range(n)}
print(len(xs))

Solution (Python):
n = int(input())
list = []
i = 0
for k in range(n):
    d = int(input())
    if d in list:
        pass
    else:
        list.append(d)
print(len(list))

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

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

for v in range(n):
    num = int(input())
    li.append(num)

ans = []

for i in li:
    if i not in ans:
        ans.append(i)       

print(len(ans))

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

a.sort()
a.reverse()

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

Solution (Python):

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

print(len(set(d)))

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

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

Solution (Python):



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

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

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

count = 0
while len(d) != 0:
    mini = min(d)
    while mini in d:
        d.remove(mini)
    count += 1

print(count)

Solution (Python):
def solve():
    n = int(input())
    mochi_size_list = []
    for i in range(n):
        d_i = int(input())
        if d_i not in mochi_size_list:
            mochi_size_list.append(d_i)
    print(len(mochi_size_list))

solve()

Solution (Python):
print(len({input() for x in [0]*int(input())}))

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

Solution (Python):



n = raw_input()
n = int(n)
d = []
ans = 0
for i in range(n):
    nyu = raw_input()
    if not nyu in d:
        ans += 1
    d.append(nyu)
print ans

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

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

mochis = []
for i in range(num):
    size = int(input())
    if size not in mochis:
        mochis.append(size)

print(len(mochis))

Solution (Python):
def main():
	n_set = set([int(input()) for _ in range(int(input()))])
	print(len(n_set))
	
if __name__ == '__main__':
	main()

Solution (Python):
import numpy as np
import pdb

def main():
    N = int(raw_input())
    dslist = []
    for k in range(N):
        kthvalue = int(raw_input())
        dslist += [kthvalue]
    dslist = np.array(dslist)
    print tallestKagami(dslist)

def tallestKagami(ds):
    N = len(ds)
    ds = np.sort(ds)[::-1]
    stacksize = 0
    while(len(ds) > 0):
        largest = ds[0]
        ds = np.delete(ds, np.where(ds == largest)[0])
        stacksize += 1

    return stacksize


if __name__ == '__main__':
    main()

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

Solution (Python):


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

print(len(set(d)))

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

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

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

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

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

Solution (Python):
import sys
s_ls = sys.stdin.read().split("\n")[1:]
if "" in s_ls:
    s_ls.remove("")
s_ls = sorted(list(map(int, set(s_ls))))
print(len(s_ls))

Solution (Python):

'''
X 段重ねの鏡餅 (X≥1) とは、X 枚の円形の餅を縦に積み重ねたものであって、
どの餅もその真下の餅より直径が小さい（一番下の餅を除く）もののことです。
例えば、直径 10、8、6 センチメートルの餅をこの順に下から積み重ねると 3 段重ねの鏡餅になり、
餅を一枚だけ置くと 1 段重ねの鏡餅になります。

ダックスフンドのルンルンは N 枚の円形の餅を持っていて、
そのうち i 枚目の餅の直径は di センチメートルです。
これらの餅のうち一部または全部を使って鏡餅を作るとき、
最大で何段重ねの鏡餅を作ることができるでしょうか。
'''

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


diameter_list.sort(reverse = True)


a = []
for i in diameter_list:
    if (i not in a):
        a.append(i)

print(len(a))

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

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

print(len(set(d)))

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

print(len(set(a)))

Solution (Python):
if __name__ == "__main__":
    n = int(input())
    ds = []
    for _ in range(n):
        d = int(input())
        ds.append(d)
    ds = list(set(ds))
    print(len(ds))

Solution (Python):


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

for i in range(n):
    K.append(input())
    
k = []
for x in K:
    if x not in k:
        k.append(x)

print(len(k))

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

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

d = []

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

d.sort()

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

print(count)

Solution (Python):
x=[0]*105
N=input()
for i in range(int(N)):
    x[int(input())]=1
print(sum(x))

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
sum = 0
maxd = 1
while maxd>0:
    maxd = max(d)
    for j in range(N):
        if maxd == d[j]:
            d[j] = 0
    sum += 1
print(sum-1)

Solution (Python):
import sys
input(), print(len(set(sys.stdin.read().strip().split())))

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

Solution (Python):
N = int(input())
moti = []
for n in range(N):
    moti.append(int(input()))
counter = 0

while True:
    max_moti = max(moti)
    number_moti = moti.count(max_moti) 
    
    for i in range(number_moti): 
        index = moti.index(max_moti)
        del moti[index]
    counter += 1
    if not moti:
        break

print(counter)

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

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

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

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

print(len(S))

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

c = set()

for _ in range(n):
    d = int(input())
    if d in c:
        continue
    c.add(d)

print(len(c))

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

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 = []
ans = 1
for i in range(n):
    d.append(int(input()))
d.sort()
d.reverse()
tmp = d[0]
for i in d:
    if tmp > i:
        ans += 1
    tmp = i
print(ans)

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

print(len(s))

Solution (Python):

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

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

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

l = []
for i in range(count):
    l.append(int(input()))
l.sort()

min = l[0]
ans = 1
for elem in l:
    if min < elem:
        ans += 1
        min = elem
print(ans)

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

ans=set(a)

print(len(ans))

Solution (Python):
import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache, reduce
from operator import xor
from heapq import heappush, heappop
INF = float("inf")
sys.setrecursionlimit(10**7)


dy4, dx4 = [0, -1, 0, 1], [1, 0, -1, 0]


def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def ceil(a, b):return (a + b - 1) // b


def solve(N, d_list):
    ans = 0
    now = INF
    for d in sorted(d_list, reverse=True):
        if now > d:
            now = d
            ans += 1
    return ans


def main():
    N = int(input())
    d_list = [int(input()) for _ in range(N)]
    print(solve(N, d_list))


if __name__ == '__main__':
    main()

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

res = set()
for i in range(N):
	res.add(d[i])

print(len(res))

Solution (Python):



import sys

d = list(map(lambda x: int(x.strip()), sys.stdin.readlines()))
print(len(set(d[1:])))

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

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


array = []
for i in range(num):
    array.append(int(input()))
sort = reversed(sorted(array))

res = 0
tmp = float("inf")

for i in sort:
    if i < tmp:
        res += 1
        tmp = i
print(res)

Solution (Python):


n=int(raw_input())
d=[]
for  i in xrange(n):
 d.append(int(raw_input()))
s=set(d)
print len(s)

Solution (Python):
T=int(input())
a=[]
for i in range(T):
	b=int(input())
	if b not in a:
		a.append(b)
	else:
		pass
a.sort(reverse=True)
print(len(a))

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

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

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

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    d = [int(input()) for _ in range(N)]
    ans = len(set(d))
    print(ans)

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

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

Solution (Python):
n=int(raw_input())
N=[]
for i in range(n):
	N.append(int(raw_input()))
N.sort()
ans=1
for i in range(1,n):
	if N[i]!=N[i-1]:
		ans+=1
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 = set()
for i in range(n):
  d.add(int(input()))

print(len(d))

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq 
from itertools import *
import math
import random
import re
import string

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

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

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

size = 0
max = 9999999999

for m in mochi:
    
    if m < max:
        size += 1
        max = m

print(size)

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

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

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

array = []

for i in range(N):
    num = int(raw_input())
    array.append(num)

array.sort()

d = 1
pre_r = array.pop(0)

while len(array) > 0:
    tmp_r = array.pop(0)
    if pre_r < tmp_r:
        d = d +1
        pre_r = tmp_r

print d

Solution (Python):
N = input('')
d = []
temp = input('')
d.append(temp)
for i in range(1, N):
    flag = 0
    temp = input('')
    for j in range(0, len(d)):
        if temp == d[j]:
            flag = 1
    if flag == 0:
        d.append(temp)
        
print len(d)

Solution (Python):
i = int(raw_input())
a = []
s = set()
for x in range(i):
	a.append(int(raw_input()))
for x in a:
	s.add(x)
print(len(s))

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

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

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

i = 1
j = 1
while i < N:
    if a[i-1] != a[i]:
        j += 1
    i += 1
    
print(j)

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

Solution (Python):
s = '0'
l = []
ans = 0
temp = -1
n = int(raw_input())
for i in range(0, n):
    s = raw_input()
    if (s != ''):
        l += [int(s)]
l.sort()
for i in range(0, len(l)):
    if(l[i] != temp):
        ans += 1
        temp = l[i]

print(ans)

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

Solution (Python):
n = int(input())
ls = []
ans = 0
for i in range(n) :
    x = int(input())
    if x in ls :
        continue
    ls.append(x)
    ans += 1
print(ans)

Solution (Python):
l = int(raw_input())
arr = []
for i in range(l):
    s = raw_input()
    arr.append(s)
arr = sorted(arr, reverse=True)
counter = 1
for s in range(1,len(arr)):
    if arr[s] < arr[s-1]:
        counter+=1

print counter

Solution (Python):
N=int(input())
X=[]
Y=[]
S=0
for I in range(N):
	X.append(int(input()))
while X!=[] and S<len(X):
	if X[S] not in Y:
		Y.append(X.pop(S))
	else:
		S+=1
print(len(Y))

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

mochies = []

for i in range(0, n):
    input_mochi = int(input())
    if input_mochi in mochies:
        continue
    else:
        mochies.append(input_mochi)

print(len(mochies))

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


print(len(set(m)))

Solution (Python):
n = int(input())
d = sorted([int(input()) for k in range(n)], reverse=True)
dp = [0 for _ in range(n)]

for i in range(n):
	found = False
	for j in reversed(range(i)):
		if d[j] > d[i]:
			dp[i] = dp[j] + 1
			found = True
			break
	if not found:
		dp[i] = 1
print(max(dp))

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

s = set()
for _ in range(0, n):
  e = int(input())
  s.add(e)

print(len(s))

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

print(len(mochi))

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

Solution (Python):
n = input()
n = int(n)
s = set([])

for i in range(1, n+1):
    a = input()
    a = int(a)
    s.add(a)

print(len(s))

Solution (Python):



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


print(len(set(li)))

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

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

Solution (Python):

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


d.sort()
count = 0
pre = 0

for ele in d:
    if ele > pre:
        count += 1
    
    pre = ele

print(count)

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

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

for i in range(0,n):
    f = int(input())
    s.add(f)

print(len(s))

Solution (Python):


if __name__ == '__main__':
    N = int(input())
    d = [int(input()) for i in range(N)]

    ans = list(set(d))

    print(len(ans))

Solution (Python):


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

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

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

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

list_input=[]
list_uniq=[]
for i in range(N):
    a=input()
    a=int(a)
    list_input.append(a)
    
for x in list_input:
    if x not in list_uniq:
        list_uniq.append(x)
        
print(len(list_uniq))

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

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

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

    d_set = set(d)
    print(len(d_set))
solve()

Solution (Python):
import math

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

ans = 1
temp = d[0]
for i in range(1,len(d)):
    if d[i] < temp:
        ans += 1
        temp = d[i]

print(ans)

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

Solution (Python):
import numpy as np
N = int(input())
d = np.array([int(input()) for i in range(N)])
c = 0
while len(d)>0:
    m = np.max(d)
    d = d[d<m]
    c += 1
print(c)

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

Solution (Python):
N=input()
nlist=[]
for i in xrange(N):
    n=input()
    if n in nlist:
        continue
    else:
        nlist.append(n)
print len(nlist)