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

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

n = [input() for i in range(count)]

print(len(set(n)))

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

dic = {}
for i in range(count):
    dic[input()] = i
dic = sorted(dic)
print(len(dic))

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

Solution (Python):
N=int(input())
d = [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())
d = []

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

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

d = []
for i in range(N):
    tmp = int(input())
    if tmp in d:
        pass
    else:
        d.append(tmp)
        
print(len(d))

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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


def main():
    N = int(readline())
    d = list(map(int, readlines()))
    print(len(list(set(d))))


main()

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

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

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

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

Solution (Python):
if __name__ == '__main__':

	N = int(input())

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

	A = sorted(A,reverse=True)

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

	print(cnt)

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

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

d.sort()

j = 1
ans = 1

while j < N:
	if d[j-1] >= d[j]:
		j += 1
	else:
		ans += 1
		j += 1

print(ans)

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

mochi.sort(reverse=True)
ans = set(mochi)
print(len(ans))

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

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

print(len(set(dl)))

Solution (Python):


import numpy
import scipy

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


Ds = sorted(D, reverse=True)


c = 0
for i, d in enumerate(Ds):
    if i == 0:
        c += 1
    if d < Ds[i-1]:
        c += 1

print(c)

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

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

print(len(set(dd)))

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

Solution (Python):
import numpy as np

N=int(input())
D=np.zeros((N,),int)


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

print(len(np.unique(D)))

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

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

Solution (Python):
n = int(input()) 
d = [int(input()) for i in range(n)] 
k=0
c=0
for i in range(n):
  for j in range(n-i-1):
    if d[j] > d[j+1]:
      k = d[j]
      d[j] = d[j+1]
      d[j+1] = k
      
for i in range(n-1):
  if d[i]==d[i+1]:
    c=c+1
      
print(n-c)

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

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

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

sd = sorted(d)

val = None
cnt = 0
for i in range(N):
  if sd[i] != val:
    cnt += 1
    val = sd[i]

print(cnt)

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

Solution (Python):
n = int(input())
d = list(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(d))

Solution (Python):
import numpy as np

n = int(input())
d = [int(input()) for i in range(n)]
    
print(len(np.unique(d)))

Solution (Python):
import numpy as np

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

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

mochi = {int(input()) for i in range(N)}

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

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

Solution (Python):

n = int(input())

set = {}
for i in range(n):
    set[input()] = 0
    
print(len(set.keys()))

Solution (Python):
n = int(input())
l = list(int(input()) for _ in range(n))
l.sort()
nl = []
count = 0
for i in range(len(l)):
    if l[i] in nl:
        pass
    else:
        nl.append(l[i])
        count += 1

print(count)

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

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

Solution (Python):

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

ans = len(l)
print(ans)

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

Solution (Python):

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

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

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

print(len(set(d)))

Solution (Python):

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

c = [0] * (100+1)
for i in b:
    c[i] = i

d = []
for g in c:
    if g != 0:
        d.append(g)

print(len(d))

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

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

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

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

Solution (Python):
from sys import stdin
from itertools import combinations
from math import factorial
import numpy as np
import math

n = int(stdin.readline().rstrip())

li = [int(stdin.readline().rstrip()) for _ in range(n)]

li = list(set(li))

print(len(li))

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

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

Solution (Python):
def main(n: int, d: list):
    d = set(d)
    print(len(d))


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

    main(n, d)

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

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

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





print(len(Mochi))

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from bisect import bisect_left
import heapq

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

print(len(set(d)))

Solution (Python):
def examB():
    N = I()
    A = [I() for _ in range(N)]
    d = defaultdict(int)
    for i in A:
        d[i] +=1
    ans = len(d)
    print(ans)

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examB()

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

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 = set()
d_add = d.add

for i in range(N):
    d_add(int(input()))

print(len(d))

Solution (Python):
N = int(input())
L = []
for i in range(N):
    a = int(input())
    L.append(a)
L = sorted(L)
ans = 0
cnt = 0
for i in L:
    if(i > cnt):
        cnt = i
        ans += 1
print(ans)

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

ans = 0
maxd = 101

for i in range(N):
    if max(d) < maxd:
        ans += 1        
    maxd = max(d)
    d.remove(maxd)

print(ans)

Solution (Python):
def nyu():
    num1 = input()
    num1 = int(num1)
    
    return num1

def nyu2(n):
    tmp =[]
    for i in range(n):
        tmp.append(int(input()))
    return tmp

def sort(mochi):
    tmp_mochi = 0
    for i in range(n):
        for k in range(n):
            if mochi[i]>mochi[k] :
                tmp_mochi = mochi[i]
                mochi[i] = mochi[k]
                mochi[k] = tmp_mochi
    return mochi

def check(mochi):
    max =101
    cnt =0

    for i in range(n):
        if max>mochi[i]:
            max = mochi[i]
            cnt +=1
    return cnt

n=nyu()
mochi = nyu2(n)
mochi = sort(mochi)
print(check(mochi))

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

rice_cakes = sorted([int(input()) for i in range(N)], reverse=True)

counter = 0

minimum_size = rice_cakes[0] + 1

for cake in rice_cakes:
    if cake < minimum_size:
        counter += 1
        minimum_size = cake

print(counter)

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

Solution (Python):
import collections
import math
import numpy as np









N = int(input())
d = [int(input()) for i in range(N)]
print(len(collections.Counter(d)))

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

print(len(d))

Solution (Python):
count = 1
num = int(input())
l = [int(input()) for i in range(num)]
l.sort(reverse=True)
for i in range(num-1):  
  if l[i] > l[i+1]:
    count += 1
print(count)

Solution (Python):
def mochi(d):
    d.sort(reverse=True)
    before = 101
    cnt = 0
    for n in d:
        if n >= before:
            continue
        before = n
        cnt += 1
    return cnt

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

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

Solution (Python):

import sys
input = sys.stdin.readline


from collections import Counter
N = int(input())
D = [int(input()) for _ in range(N)]

print(len(Counter(D).values()))

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

kagami_mochi = set(d)

print(len(kagami_mochi))

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

Solution (Python):
N = int(input())
d = sorted(list([int(input()) for _ in range(N)]), reverse = True)

now = max(d)
ans = 1

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

print(ans)

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

Solution (Python):


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

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

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

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

print(len(d))

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


def main():
    N = int(readline())
    d = list(map(int, readlines()))
    print(len(list(set(d))))


main()

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

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

main()

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

Solution (Python):
N = int(input())
A = [int(input()) for i in range(N)]
A.sort(reverse=True)
count = 0

m = set(A)
        
print(len(m))

Solution (Python):
N = int(input())
A = [int(input()) for i in range(N)]
A.sort(reverse=True)
count = 0

for i in range(N):
    for j in range(i+1,N):
        if A[i] == A[j] and A[i]!=0:
            A[j] = 0
            count += 1
        
print(len(A)-count)

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

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

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

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

print(len(li))

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

a = sorted(a, reverse=True)
top = max(a)
ans = 1

for d in a:
    if d < top:
        top = d
        ans += 1
print(ans)

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

n = inp()
a = inpln(n)
print(len(set(a)))

Solution (Python):


N=int(input())

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

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

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

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

Solution (Python):


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

Solution (Python):

N = int(input())

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

print(len(set(d)))

Solution (Python):
import sys








def main():
    n, *d = (int(x) for x in sys.stdin.read().split())
    print(len(set(d)))


if __name__ == "__main__":
    
    main()

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

main()

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

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

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

Solution (Python):


if __name__ == '__main__':
    N = int(input())
    d = []

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

    d.sort()
    cnt = 0

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

    print(N - cnt)

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

t = set(ld)

print(len(t))

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

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

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

from collections import Counter
counter = Counter(di)
ans = len(counter)
print(ans)

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

Solution (Python):
N = int(input())
A = []
for j in range(N):
  A +=[input()]
A.sort()
k=[A[0]]
for i in range(1,N):
  if A[i]>A[i-1]:
    k += [A[i]]
print(len(k))

Solution (Python):
a = [int(input()) for _ in range(int(input()))]
set_ = set(a)
ans = len(set_)
print(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())
li = list()
for _ in range(n):
    li.append(int(input()))

li.sort()
ans = 0

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

print(ans + 1)

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

print(len(set(list_d)))

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

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

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

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

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

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

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

d_s = set(d)

print(len(d_s))

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

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

Solution (Python):
N = int(input())
d_list = list()
for _ in range(N):
  d = int(input())
  d_list.append(d)
d_list.sort(reverse=True)

count = 1

for i, num in enumerate(d_list):
  target = i + 1
  if target == len(d_list):
    break
  if num > d_list[target]:
    count += 1
print(count)

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

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

Solution (Python):
n = int(input())
a = [int(input()) for i in range(n)]
a = sorted(a, reverse=True)
ans =1
for i in range(n - 1):
    if a[i] != a[i+1]:
        ans += 1
print(ans)

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

a = [int(input()) for i in range(n)]
a = sorted(a,reverse=True)

ans=1

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

print(ans)

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

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

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

y.sort(reverse=True)

def fun(y):
  tmp = y[0]
  ans = 1
  for i in y[1:]:
    if tmp > i:
      ans += 1
      tmp = i
    else:
      pass
  return ans
    
print(fun(y))

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

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

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

d_list.sort()
tmp_d = -1
mochi_count = 0
for i in range(N):
    if tmp_d == d_list[i]:
        continue
    else:
        tmp_d = d_list[i]
        mochi_count += 1

print(mochi_count)

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


num = [0] * 101

count = 0

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

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

print(count)

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


d.sort(reverse=True)


count = 1

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

print(count)

Solution (Python):
N = int(input())
motis = []
for i in range(N):
    motis.append(int(input()))
motis.sort(reverse=True)

count = []
for i in range(N):
    tmp = motis[i]
    if tmp not in count:
        count.append(tmp)
print(len(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 i in range(N)]
D.sort(reverse=True)
ans = 1
for i in range(N-1):
  if D[i] > D[i+1]:
    ans += 1
print(ans)

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, *d = map(int, open(0).read().split())

d.sort()

ans = 0
scale = 0
for i in d:
    if scale < i:
        ans += 1
    scale = i

print(ans)

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

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


if __name__ == '__main__':
    main()

Solution (Python):

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





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

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




 
print(count)

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

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

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

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

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

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

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

Solution (Python):
import bisect
n = int(input())
ls = []
for i in range(n):
  bisect.insort(ls, int(input()))

layer = 1
current = ls[0]
for i in range(n):
  if current != ls[i]:
    layer += 1
    current = ls[i]
  
print(layer)

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

ls.sort()
layer = 1
current = ls[0]
for i in range(n):
  if current != ls[i]:
    layer += 1
    current = ls[i]
  
print(layer)

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

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

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

Solution (Python):
n=int(input())
d=sorted(list(map(int,[input() for i in range(n)])),reverse=True)
ans=1
for j in range(len(d)-1):
    if d[j+1] < d[j]:
        ans +=1
print(ans)

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

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

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

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

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

deduplicate = set(d)

print(len(deduplicate))

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

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

print(len(Set))

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

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

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

for i in range(n):
    d.append(int(input()))
count = 0
d.sort()
temp = -1
for index, item in enumerate(d):
    if temp != item:
        count += 1
    temp = item
print(count)

Solution (Python):
N = int(input())
ret = {}
for n in range(N):
    d = int(input())
    if not d in ret:
        ret[d] = d
print(len(ret))

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

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

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

moti_list.sort(reverse=True)

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

print(count)

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

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

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

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

ans = 1
D.sort()
temp = D[0]
for i in range(1, N):
    if D[i] > temp:
        ans += 1
        temp = D[i]
        
print(ans)

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

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

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

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

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

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

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

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

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

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

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

print(len(ds))

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

cnt = 0
j = 0
for i in d:
  if j==i:
    cnt += 1
  j = i
  
print(n-cnt)

Solution (Python):
N=int(input())
d=[]
for n in range(N):
  x=int(input())
  d.append(x)
ans=sorted(set(d), key=d.index)
print(len(ans))

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

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

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

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

print(len(set(d)))

Solution (Python):
n = int(input())
d = [0]*n
for i in range(n):
  d[i] = int(input())
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())
a = sorted(map(int, [input() for i in range(N)]), reverse=True)

dan = 1

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

print(dan)

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

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

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

if N == 1:
	print(1)
	sys.exit()
A = sorted(A, reverse = True)

t = A[0]
cnt = 1
for i in range(1,N):
	if A[i] < t:
		cnt += 1
		t = A[i]
	
print(cnt)

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

s = [int(input()) for _ in range(n)]
s = list(set(s))

print(len(s))

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

for i in range(N):
    D += [input()]

print(len(set(D)))

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

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

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

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

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