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_list=list()
for _ in range(N):
    d_list.append(int(input()))

print(len(set(d_list)))

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

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

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

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

for i in range(N):
    di = int(input())
    diams.append(di)

diams.sort(reverse = True)

count = 1

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

print(count)

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

s =set(d)

print(len(s))

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

mochi_use = sorted(mochi,reverse = True)

ans = 1

for i in range(n-1):
    if mochi_use[i] > mochi_use[i+1]:
        ans += 1

print(ans)

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

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

print(len(set(d)))

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

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

    print(len(set(m)))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
sys.setrecursionlimit(100000)
import heapq
n=int(input())
data=[]
for i in range(n):
    heapq.heappush(data,int(input()))
print(len(set(data)))

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

print(len(set(li)))

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

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

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

print(count)

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

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

m = []

for i in l:
  if i not in m:
    m.append(i)
    
print(len(m))

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

Solution (Python):
n=int(input())
arr=sorted(set([int(input()) for i in range(n)]), reverse=True)
print(len(arr))

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

d = list(set(d))
d.sort(reverse=True)
print(len(d))

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

print(len(set(A)))

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

print(len(list(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 = list(int(input()) for _ in range(n))
d.sort(reverse=True)
a = 1
for i in range(n):
    if d[i] < d[i-1]:
        a += 1
print(a)

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

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

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

Solution (Python):
def inpl(): return list(map(int, input().split()))


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

Solution (Python):
from collections import Counter

def inpl(): return list(map(int, input().split()))


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

Solution (Python):
def main(N,xs):
    
    print(len(set(xs)))

if __name__ == '__main__':
    N = int(input())
    ds = list(map(lambda s: int(input()), range(N)))
    main(N,ds)

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

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

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

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

Solution (Python):
N = int(input())
D = [int(input()) for _ in range(N)]
from collections import Counter
C = list(Counter(D).most_common())
print(len(C))

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

print(len(d))

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

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

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

d=1
for i in range(a-1):
	if c[i]<c[i+1]:
		d=d+1
print(d)

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

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

Solution (Python):
import numpy as np
num = int(input())
ary = []
for _ in range(num):
    ary += [int(input())]
ary = np.array(ary)

print(len(np.unique(ary)))

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

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

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

Solution (Python):
N = int(input())
d = []
for i in range(N):
    d.append(int(input()))
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())
T = []
for i in range(N):
    T.append(int(input()))
H=list(set(T))
I=sorted(H)
print(len(I))

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

Solution (Python):
N = int(input())
d = list(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 = list(set(d))
print(len(d))

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

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

d_sort = []
d_sort = sorted(d)
count = 0

for i in range(len(d_sort)-1):
    if(d_sort[i] == d_sort[i+1]):
        count += 1

print(len(d)-count)

Solution (Python):
N = int(input())
l = []
i = 0
while i < N:
    l.append(int(input()))
    i += 1

size = 0
tmp = -1
while len(l) > 0:
    if tmp != max(l):
       size += 1
    tmp = max(l)
    l.remove(max(l))
print(size)

Solution (Python):
import sys

input = sys.stdin.readline


def ii(t: type = int):
    return t(input())


def il(t: type = int):
    return list(map(t, input().split()))


def iml(N: int, t: type = int):
    return [t(input()) for _ in range(N)]


N = ii()
D = iml(N)

print(len(set(D)))

Solution (Python):
import sys

import numpy as np

input = sys.stdin.readline


def ii(t: type = int):
    return t(input())


def il(t: type = int):
    return list(map(t, input().split()))


def iml(N: int, t: type = int):
    return [t(input()) for _ in range(N)]


N = ii()
D = iml(N)

print(np.unique(D).size)

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

ans = len(set(D))

print(ans)

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

ans = len(set(sorted(D)))

print(ans)

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

Solution (Python):
from collections import defaultdict

n = int(input())
d = defaultdict(int)
for _ in range(n):
    tmp = int(input())
    d[tmp] += 1

print(len(d.keys()))

Solution (Python):




def  motiTower(givenRange):
	distMeter = []
	for i in givenRange:
		distMeter.append(int(input().strip()))
	setKagamiMoti = set()
	for i in givenRange:
		setKagamiMoti.add(distMeter[i])
	answer = len(setKagamiMoti)
	return answer

if __name__ == '__main__':
	N=int(input())
	distRange = range(0,N,+1)
	solution=motiTower(distRange)
	print("{}".format(solution))

Solution (Python):
moti_total = int(input())
moti = []
for n in range(moti_total):
  moti.append(int(input()))
moti.sort()
tower = 1
for n in range(moti_total-1):
  if moti[n] is not moti[n+1]:
    tower += 1
print(tower)

Solution (Python):

N = int(input())

d = []
i = 0
while N>i:
    d.append(int(input()))
    i += 1


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

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

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

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

Solution (Python):



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


if __name__ == '__main__':
    main()

Solution (Python):

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

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

A = []

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

print(len(set(A)))

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

Solution (Python):


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

    s = set()
    for di in d:
        s.add(di)

    print(len(s))


if __name__ == '__main__':
    main()

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

print(len(s))

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


abc085_b()

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(map(int, [input() for i in  range(N)]))

print(len(set(d)))

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

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

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

motiarray = []

for i in range(0,N):
    if motiarray.count(le[i])==0:
        motiarray.append(le[i])


print(len(motiarray))

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

Solution (Python):
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())
dat = []
for i in range(n):
  a = int(input())
  if dat.count(a)==0:
    dat.append(a)
print(len(dat))

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

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

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

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

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

mochi = set(list(mochi))
print(len(mochi))

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

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

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

a=set(a)

print(len(a))

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

Solution (Python):
cnt = int(input())
width_list = []
for x in range(cnt):
    width = int(input())
    width_list.append(width)

width_sort = sorted(width_list)
dan = 0
now_width = 0
for x in width_sort:
    if now_width != x:
        dan += 1
    now_width = x
print(dan)

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

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

for i in range(n):
    d.append(int(input()))
d.sort()
    
count = 0
prevd = 0

for i in range(n):
    if d[i] != prevd:
        count += 1
    prevd = d[i]
print(count)

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

Solution (Python):
times = int(input())
num = list(map(int,[input() for _ in range(times)]))
print(len(set(num)))

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

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

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

print(len(list(set(ds))))

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

print(len(d_list))

Solution (Python):

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

Solution (Python):

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

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

N = int(input())

d = [] 

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

d.sort(reverse  = True )

counter = 1

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

print(counter)

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

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

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

L = set(L)

print(len(L))

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

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

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

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


l = sorted([input() for _ in range(N)])

print(len(set(l)))

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

Solution (Python):
N = int(input())
inputVal = [int(input()) for i in range(N)]
inputVal.sort()
default = 0
count = 0

for i in inputVal:
    if i != default:
        count += 1
        default = i

print(count)

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

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_set = set(list(int(input()) for i in range(n)))
print(len(d_set))

Solution (Python):


if __name__ == "__main__":
    n = int(input())
    vals = set()

    for _ in range(n):
        dum = int(input())
        vals.add(dum)

    print(len(vals))

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

Solution (Python):
N = int(input())
A = [0] * 101
for _ in range(N):
    A[int(input())] = 1
print(sum(A))

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

mochi_list.sort()
count = 0
mochi = 0

for i in range(n):
    if mochi_list[i] != mochi:
        mochi = mochi_list[i]
        count += 1

print(count)

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

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

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

a_list.sort()

d = 0
step = 0

for j in range(n):
    if a_list[j] > d:
        step += 1
        d = a_list[j]

print(step)

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

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

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

Solution (Python):
N = int(input())
d = [ int(input()) for i in range(N)]
d = sorted(set(d))[::-1]
count = 0

for j in range(len(d)):
    count += 1
    
print(count)

Solution (Python):
N = int(input())
d = [ int(input()) for i in range(N)]
d = sorted(d)[::-1]
mochi = d[0]
count = 1

for j in range(1, N):
  if( d[j] < mochi ):
    count += 1
    mochi = d[j]

  else:
    continue
    
print(count)

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

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

pre_v = 0
c = 0
for v in sorted(d):
	if v > pre_v:
		c += 1
	pre_v = v
print c

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

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

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

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

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

print(len(set(d)))

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

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

moti = set()

for _ in range(n):
    moti.add(input())
    
print(len(moti))

Solution (Python):



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

print(len(set(d)))

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

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

Solution (Python):
N=int(input())
List=[int(input()) for i in range(N)]
List.sort(key=lambda x:x)
n=1
So=[]
while n<=List[N-1]:
  if n in List:
    So.append(n)
  n+=1
print(len(So))

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

ans = len(set(l))

print(ans)

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

a = set(mochi)
a = len(a)
print(a)

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

d = [int(m) for m in d]
e = set(d)
print(len(e))

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

    return (len(list(set(li))))


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

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

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

Solution (Python):
N=int(input())
moti={int(input())for i in range(1,N+1)}
print(len(moti))

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

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_list = []
for i in range(N):
	a = int(input())
	mochi_list.append(a)

mochi_list.sort()

y = -1
num = 0
for i in mochi_list:
	if y < i:
		num += 1
		y = i
	
print(num)

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

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

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

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

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

Solution (Python):
from sys import stdin


def main() -> None:
    dic = set()
    n = int(next_str())

    for i in range(n):
        dic.add(int(input()))

    print(len(dic))


def next_str() -> str:
    result = ""
    while True:
        tmp = stdin.read(1)
        if tmp.strip() != "":
            result += tmp
        elif tmp != '\r':
            break
    return result


if __name__ == '__main__':
    main()

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

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

Solution (Python):


n = int(input())
a=[]
for i in range(0,n):
  a.append(int(input()))
b=set(a)
print(len(b))

Solution (Python):
number=int(input())
line=set(map(int,[input() for i in range(number)]))

print (len(line))

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

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

mochi = []
for i in range(N):
    a = int(input())
    if(mochi.count(a)==0):
        mochi.append(a)
print(len(mochi))

Solution (Python):

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


mochi.sort(reverse=True)
dan = 0;
low = 101;
for x in mochi:
    if x < low:
        dan += 1;
        low = x;
print(dan);

Solution (Python):

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

d.sort()
d.reverse()

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

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

d.sort()
print(len(list(set(d))))

Solution (Python):
import collections as c

N = int(input())
d = []
for _ in range(N):
    cnt = c.Counter(d)
    foo = input()
    if cnt[foo] == 0:
        d.append(foo)

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())
D = []
for i in range(N) :
    d = int(input())
    D.append(d)
D = sorted(D,reverse = True)
D = list(set(D))
print(max(len(D),1))

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

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

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

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

sys.setrecursionlimit(10**5) 
 
def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

n = ni()
ds = set()
for _ in range(n):
    ds.add(ni())
    
print(len(ds))

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

import collections
d_c=collections.Counter(d_list)
d_val, d_count=zip(*d_c.most_common())
print(len(d_val))

Solution (Python):
N = int(input())
A = [int(input()) for _ in range(N)]
A.sort()
prev = 0
cnt = 0
for a in A:
    if a > prev:
        prev = a
        cnt += 1
print(cnt)

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

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

a = list(set(a))

print(len(a))

Solution (Python):
n = int(input())
d = sorted([int(input()) for x in range(n)], reverse = True)
d2 = []
for x in d:
    if x not in d2:
        d2.append(x)
print(len(d2))

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

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

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

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

d = collections.Counter(d)
print(len(d.keys()))

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

Solution (Python):
def answer():

    N = int(input())
    d = {}

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

    print(len(d))


answer()

Solution (Python):
def answer():

    N = int(input())

    s = set()

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

    print(len(s))


answer()

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

Solution (Python):
import math as M
N=int(input())
list=[]
for i in range(N):
    n=int(input())
    if n not in list:
        list.append(n)

print(list.__len__())

Solution (Python):
import math as M
N=int(input())
list=[]
for i in range(N):
    n=int(input())
    if n not in list:
        list.append(n)

print(list.__len__())

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

count = 0
now = 0
for i in range(n):
    if now != d[i]:
        count += 1
        now = d[i]

print(count)

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

Solution (Python):
import collections

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

print(len(collections.Counter(d)))

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

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

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

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

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

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

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

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

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

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

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

for i in range(0, 101):
    d.append(0)
for i in range(0, N):
    x = int(input())
    d[x] = 1
for i in d:
    flag += i

print(flag)

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

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

d = []

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


s = set(d)

print(len(s))

Solution (Python):
n = int(input())
index=0
mochiL =[]
while index < n:
    d = int(input())
    if d in mochiL:
        pass
    else:
        mochiL.append(d)
    index+=1

print(len(mochiL))

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

print(len(set(d)))

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

Solution (Python):
n = int(input())
count = 0
ans_list = []
while count < n:
    ans_list.append(int(input()))
    count += 1
print(len(set(ans_list)))

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

print(len(ans))

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

print(len(set(d)))

Solution (Python):

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

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

arr = list(set(arr))
print(len(arr))

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

print(len(set(list)))

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

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

print(len(set(D)))

Solution (Python):
N=int(input())
D=[]
count=1
for i in range(N):
  D.append(int(input()))
x=max(D)  
D.sort()
for i in range(N):
  if D[i]==x:
    break
  elif D[i]==D[i+1]:
    continue
  elif D[i]<D[i+1]:
    count+=1
print(count)

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

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

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

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

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

print(len(set(moti)))

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

Solution (Python):
from sys import stdin

N = int(stdin.readline().rstrip())
d = [int(stdin.readline().rstrip()) for _ in range(N)]
d.sort()

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

    prev_mochi = d[i]

print(ans)

Solution (Python):

import os, sys
import math

def read_items_in_line(cast=int):
    return [cast(x) for x in sys.stdin.readline().strip(' \n').split(' ')]

N = read_items_in_line()[0]
d = []
for i in range(N):
    d += [read_items_in_line()[0]]

print(len(set(d)))

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

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