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

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

S.sort()

T=N
for i in range(N-1):
    if S[i] == S[i+1]:
        T-=1

print(T)

Solution (Python):
N=int(input())
d={}
for i in range(N):
    di=input()
    if not di in d:
        d[di]=0
    else:
        pass
print(len(d))

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

Solution (Python):

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

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

length = len(list(set(D)))

print(length)

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

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

Solution (Python):

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

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

mochi.sort(reverse=True)

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

print(ret)

Solution (Python):
import numpy as np

N = int(input())

arr = np.zeros((N,))

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

print(np.unique(arr).size)

Solution (Python):
n = int(input())
d = []
for i in range(n):
  d += [int(input())]
d.sort(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)]

print(len(set(d)))

Solution (Python):

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

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

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

for i in range(N):
	di=int(input())
	s.add(di)

print(len(s))

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

Solution (Python):
amount = int(input())
diameter_list = []
for i in range(amount):
    diameter_list.append(int(input()))
number = 0
checked_list = []
for i in diameter_list:
    if i in checked_list:
        pass
    else:
        checked_list.append(i)
        number = number + 1
print(number)

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

Solution (Python):
N = int(input())
dic = [0]*105
for i in range(0,N):
	dic[int(input())]=1
temp = 0
for i in dic:
    temp += i
print(temp)

Solution (Python):
n=int(input());
d=[int(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):
import sys,collections
sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

n = I()
d = []
for i in range(n):
    d.append(I())
s = set(d)
print(len(s))

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

Solution (Python):
y = [int(input()) for i in range(int(input()))]
y = sorted(set(y))
c = 1
max_c = 1
for i,j in enumerate(y):
    try:
        if j < y[i+1]:
            c += 1
            if max_c < c:
                max_c = c
        else:
            c = 1
    except:
        pass
print(max_c)

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

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

Solution (Python):
from pprint import pprint as pp

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

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

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

arr.sort()
answer = 1
for i in range(1, n):
    if(arr[i-1] < arr[i]):
        answer += 1
print(answer)

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

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

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

print(len(set(ds)))

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

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

print(len(s))

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

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

length_list = []
for count in range(0, max_count):
    data = int(input())
    if not data in length_list:
        length_list.append(data)

print(len(length_list))

Solution (Python):
import numpy as np
n = int(input())
d = []
for i in range(n):
    d.append(input())
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 = [input() for i in range(N)]
a_s = set(sorted(a))

print(len(a_s))

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

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

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

Solution (Python):
l = []
for _ in xrange(int(raw_input())):
    l.append(int(raw_input()))
print len(set(l))

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

hh = [0]*101
for i in range(N):
    hh[alist[i]] = max(1,hh[alist[i]])

ss = sum(hh)
print(ss)

Solution (Python):
from collections import Counter

numData = int(raw_input())
radiusData = []
for _ in xrange(numData):
    radiusData.append(int(raw_input()))

counterR = Counter(radiusData)

print len(counterR)

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

for i in range(n):
    v = int(input())
    if v in d:
        pass
    else:
        d.append(v)

print(len(d))

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

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

print(len(d))

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

num = set()

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

print(len(num))

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

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

N = ni()
li = []

for i in range(N):
  li.append(ni())

li = list(set(li))
print(len(li))

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

for count in range(0,N):
    inputList.append(int(input()))

inputList.sort()

count = 1
for i in range(0,N-1):
    if inputList[i] < inputList[i+1]:
        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())
mochi = []
ans = 1

for _ in range(N):
    mochi.append(int(input()))
mochi.sort(reverse=True)

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

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

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

Solution (Python):


import sys

def main(argv):
    line = sys.stdin.readline()
    while line:
        D = {}
        N = int(line.rstrip("\n"))
        for i in xrange(N):
            d = int(sys.stdin.readline().rstrip("\n"))
            D[d] = 1
        print len(D.keys())

        line = sys.stdin.readline()

if __name__ == "__main__":
    main(sys.argv)

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

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

radius =[int(input()) for _ in range(N)]
radius.sort()

pile = 0
count = 0

for i in radius:
    if pile < i:
        pile = i
        count += 1

print(count)

Solution (Python):
def main():
    N = int(input())
    D = {int(input()) for _ in [0] * N}
    print(len(D))

main()

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

Solution (Python):
N = int(input())
d = []
for i in range(N):
    d.append(int(input()))
ans = 1
d.sort(reverse=True)
for j in range(len(d)-1):
    if d[j] > d[j+1]:
        ans += 1
    else:
        pass
print(ans)

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

a=set(d)

print(len(a))

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

Solution (Python):
N = int(input())
lis = []
for i in range(N):
    lis.append(int(input()))
lis.sort()
c = 1;a = lis[0]
for s in lis:
    if a!=s:
        c +=1
    a = s
print(c)

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

print(len(set(D)))

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

if __name__ == "__main__":
    main()

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

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

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

print(len(set(b)))

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

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

    s = set(D)
    ans = len(s)

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import sys

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

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

ans = 1
for i in range(len(d_l)-1):
    if d_l[i] < d_l[i+1]: ans += 1

print(ans)

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

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

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

a.sort(reverse=True)

ans = 0
tmp = 200

for ai in a:
    if (ai == tmp):
        continue
    tmp = ai
    ans += 1

print(ans)

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

Solution (Python):
def main():
    N = int(input())
    l = []
    for i in range(N):
        l.append(int(input()))
    print(len(set(l)))
if __name__=="__main__":
    main()

Solution (Python):


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

Solution (Python):
N = int(input())
d = []
cnt = 0
for i in range(N):
    d.append(int(input()))
for i in range(101):
    if d.count(i) > 0:
        cnt += 1
print(cnt)

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

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

Solution (Python):


N = int(input())
mochi = []
for n in range(N):
    mochi.append(int(input()))

print(len(set(mochi)))

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

Solution (Python):

N = int(input())
L = []
for n in range(N):
    L.append(int(input()))

def solve():
    L.sort()

    pre = -1
    count = 0
    for l in L:
        if pre != l:
            count += 1
        pre = l

    print(count)


if __name__ == "__main__":
    solve()

Solution (Python):

from collections import Counter

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

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

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

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

Solution (Python):



import sys

n = int(sys.stdin.readline().strip())
d = []
for _ in range(n):
    d.append(int(sys.stdin.readline().strip()))
print(len(set(d)))

Solution (Python):

import sys

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

if __name__ == '__main__':
	main()

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

Solution (Python):
import sys

N = int(sys.stdin.readline().strip())

d = [int(sys.stdin.readline().strip()) for i in range(N)]

print(len(set(d)))

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

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

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

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

print(len(rec))

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

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

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

print(len(mochi))

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

print(len(set(d)))

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

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

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

Solution (Python):
n = int(input())
data = []
for i in range(n):
  v = int(input())
  data += [v]
data = sorted(data)
last = 0
ans = 0
for v in data:
  if v > last:
    last = v
    ans += 1
print(ans)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**15
mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    n = I()
    a = [I() for _ in range(n)]
    t = set(a)

    return len(t)

print(main())

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

Solution (Python):
from collections import Counter

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

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

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

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

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

Solution (Python):


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

Solution (Python):
N = int(raw_input())
A = [int(raw_input()) for _ in xrange(N)]
print len(set(A))

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