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

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

print(len(set(d)))

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

d = list(set(d_input))
d.sort(reverse=True)
kagamimochi = len(d)

print(kagamimochi)

Solution (Python):
N = int(input())
d_list = [int(input()) for i in range(N)]
d_list = sorted(list(set(d_list)), reverse=True)

print(len(d_list))

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

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

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

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

    D_set = set(D)
    print(len(D_set))


if __name__ == '__main__':
    main()

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

n = int(readline())
d = [int(readline()) for _ in range(n)]
ans = len(set(d))
print(ans)

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

d = set(d)

print(len(d))

Solution (Python):
X = len(set(map(int, (input() for _ in range(int(input()))))))
print(X)

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

Solution (Python):



import sys



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def solver(riceCakesList):
    result = 0
    
    
    result = len(set(riceCakesList))
    return result
if __name__ == "__main__":
    N = II()
    DI = list()
    for _ in range(N):
        DI.append(II())
    print("{}".format(solver(DI)))

Solution (Python):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N = int(readline())
s = set()

for _ in range(N):
    d = int(readline())
    s.add(d)

print(len(s))

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

print(len(set(D)))

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def Yes(): print("Yes"); return
def No(): print("No"); return


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0: 
        cnt+=1 
        temp //= i
      arr.append([i, cnt])
  if temp!=1:
    arr.append([temp, 1])
  if arr==[]:
    arr.append([n, 1])
  return arr


def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


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


def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count


def Base_10_to_n(X, n):
  if X//n:
    return Base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def Base_n_to_10(X, n):
  return sum(int(str(X)[-i])*n**i for i in range(len(str(X))))


def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count





N = inputI()
d = inputILs(N)

print(len(set(d)))

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

print(len(A))

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

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

tin=lambda : map(int, input().split())
lin=lambda : list(IN())
mod=1000000007



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

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

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

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

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

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

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

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

mochi=set(mochis)


print(len(mochi))

Solution (Python):
n = int(input())
steps = list()
for pivot in range(n):
  steps.append(int(input()))

steps = set(steps)

print(len(steps))

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

r = []
cnt = 0
for i in d:
  if cnt == 0:
    r.append(i)
    cnt += 1
  else:
    if r[-1] == i:
      continue
    else:
      r.append(i)
      cnt += 1
print(cnt)

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

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

Solution (Python):

import sys


def solve(N: int, d: "List[int]"):
    d = set(sorted(d)) 
    return(len(d))
    


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    d = [int(next(tokens)) for _ in range(N)]  
    print(solve(N, d))

if __name__ == '__main__':
    main()

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

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

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

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

prev = 0
ans = 0
for i in d_list:
  if prev < i:
    ans += 1
  prev = i
  
print(ans)

Solution (Python):
n = int(input())
d = []
for d_i in range(n):
  d.append(int(input()))
  
count = 0
pre_max = -1
max = -1

for i in range(n): 
  for j in d:
    if j > max:
      max = j
      
  d[d.index(max)] = 0
      
  if pre_max == -1:
    count += 1
    
  elif max < pre_max:
    count += 1
    
  pre_max = max
  max = -1
  
print(count)

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

d.sort(reverse=True)
cnt = 0
for i in range(N):
    if i==0:
        cnt += 1
        continue
    elif d[i]==d[i-1]:
        continue
    else:
        cnt += 1

print(cnt)

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

sort_d = list(set(d))
max_number = max(sort_d)

count = 0
for i in sort_d:
  if max_number > i:
    count+=1
print(count+1)

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

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

Solution (Python):
n = int(input())
lists = [0]*100
for i in range(n):
    num = int(input()) - 1
    lists[num] += 1
count = 0
for i in lists:
    if i > 0:
        count += 1
print(count)

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

result = 0
maxMochi = 0
for tmp in range(num):
    if max(mochi) == maxMochi:
        mochi.pop(mochi.index(max(mochi)))
        continue

    maxMochi = max(mochi)
    result += 1
    mochi.pop(mochi.index(max(mochi)))

print(result)

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

Solution (Python):
mochis = int(input())
mochi_diameter = [int(input()) for i in range(mochis)]
mochi_fixed = list(set(mochi_diameter))
ans = len(mochi_fixed)

print(ans)

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

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

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

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

count = 0
for i in range(N):
  if i==0:
    count += 1
  elif A[i] != A[i-1]:
    count += 1
  else:
    count += 0
 
print(count)

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

Solution (Python):
import numpy as np
n = int(input())
d_list = []
for i in range(n):
    d = int(input())
    d_list.append(d)
d_array = np.array(d_list)
d_array_sort = np.sort(d_array)[::-1]
count = 0
maximum = 0
for i, d in enumerate(d_array_sort):
    if i == 0:
        maximum = d
        count += 1
    elif d < maximum:
        maximum = d
        count += 1
print(count)

Solution (Python):
i=int(input())
import sys
ans=[i.rstrip() for i in sys.stdin.readlines()]
print(len(set(ans)))

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)]
D.sort(reverse=True)
current = 101
count = 0
for d in D:
  if current > d:
    current = d
    count += 1
print(count)

Solution (Python):
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

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

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

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

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

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

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

dic = {}

for i in num_list:
    dic[i] = 1

print(len(dic.keys()))

Solution (Python):


import sys



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def solver(cakeTotal, riseSet):
    RISE_MAXSIZE = 100
    result = 0
    
    bucketList = [0] * RISE_MAXSIZE
    for p in range(0,cakeTotal, +1): 
        weigh = riseSet[p]
        bucketList[weigh-1] = bucketList[weigh-1] + 1
    for p in range(RISE_MAXSIZE):
        if 0 < bucketList[p]:
            result = result + 1
    return result
if __name__ == "__main__":
    N = II()
    DI = list()
    for _ in range(0, N):
        DI.append(II())
    print("{}".format(solver(N, DI)))

Solution (Python):
N = int(input())
d = sorted([int(input()) for i in range(N)])
c = 1
for i in range(N - 1):
    if d[i] < d[i + 1]:
        c += 1
print(c)

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

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

Solution (Python):
import numpy as np

n = int(input())
d = [int(input()) for _ in range(n)]
i0 = 101
count = 0
d.sort()
d.reverse()
for i in range(0, n):
    
    if i0 > d[i]:
        count += 1
        i0 = d[i]

print(count)

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

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

print(len(ans))

Solution (Python):
n = int(input())
d = list()
for a in range(0, n):
    d.append(int(input()))

d.sort(reverse=True)

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

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

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

Solution (Python):
n = int(input())
d = list()
for a in range(0, n):
    d.append(int(input()))

d.sort(reverse=True)
before = d[0]
ans = 0

for a in range(1, n):
    if before > d[a]:
        ans += 1
    before = d[a]

print(ans+1)

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

Solution (Python):

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

d.sort()
cnt = 1
for i in range(1,n):
  if d[i] > d[i-1]:
    cnt += 1
print(cnt)

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

print(len(set(d_ls)))

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

print(len(set(d)))

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

print(len(set(list)))

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

ans  = 1
d.sort()
c = d[0]
for i in range(1, n):
  if c < d[i]:
    ans += 1
  c = d[i]
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(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(sorted(set(D))))

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

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

print(len(d))

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

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

print(len(list))

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

Solution (Python):
"""
蟻本2-4-2 二分探索木の例題
"""

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

d.sort()
count = 1

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

print(count)

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):
import sys
n = int(sys.stdin.readline())
dictionary = {}
for i in range(110):
    dictionary[i] = 0
for line in sys.stdin:
    num = int(line.rstrip("\n"))
    dictionary[num] += 1
mochi = 0
for i in range(110):
    if dictionary[i] > 0:
        mochi += 1
print(mochi)

Solution (Python):
import sys
n = int(sys.stdin.readline())
l = [int(line.rstrip("\n")) for line in sys.stdin]
print(len(set(l)))

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

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

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

Solution (Python):
from collections import Counter
N = int(input())
D = [int(input()) for _ in range(N)]
print(len(Counter(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 = [input() for _ in range(N)]
print(len(set(D)))

Solution (Python):
n = int(input())
d = [int(input()) for i in range(n)]
d.sort(reverse = True)
m = 101
ans = 0
for i in d:
    if i < m:
        ans += 1 
        m = i  
print(ans)

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

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

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

print(len(set(D)))

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

Solution (Python):
n = int(input())
cards = list(int(input()) for i in range(n))
results = []
for card in cards:
    if card not in results:
        results.append(card)
print(len(results))

Solution (Python):
import numpy as np
n = int(input())
d = np.empty(n)
count=1
for i in range(0,n):
    d[i]=int(input())
d=sorted(d)
for i in range(1,n):
    if d[i]!=d[i-1]:
       count=count+1
print(count)

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

    d_dict = dict()
    for di in d_list:
        d_dict[str(di)] = 1


    print(len(d_dict))

if __name__ == '__main__':
    main()

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

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

tmp.sort(reverse = True)

ans = list(dict.fromkeys(tmp))

print(len(ans))

Solution (Python):

N = int(input())

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

print(len(sorted(set(d))[::-1]))

Solution (Python):
n = input()

s = [0]

for i in range(int(n)):
    t = input()
    if t not in s:
        s.append(t)
        
print(len(s)-1)

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

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

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

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

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

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

    d = sorted(d, reverse = True)
    X = 1
    for i in range(N-1):
        if d[i] > d[i+1]: X +=1 

    print(X)  

if __name__ == "__main__":
    main()

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

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

print(len(mochi_diameter_list))

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

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

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

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

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

x = len(d)

for i in range(x):
    for j in range(x - 1 - i):
        if d[j] < d[j + 1]:
            tmp = d[j]
            d[j] = d[j + 1]
            d[j + 1] = tmp
            
z = set(d)

print(len(z))

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

r = {}
for i in range(n):
  r[input()]=""

print(len(r))

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

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

r.sort(reverse=True)

dan=1
for i in range(1,r[0]):
  if i in r:
    dan +=1
  
print(dan)

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

nlist = [0] * 101
for i in range(N):
    if(nlist[dlist[i]]==0):
        nlist[dlist[i]] = 1

print(sum(nlist))

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

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

Solution (Python):
from sys import stdin


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    N = int(_in[0])  
    d_arr = []
    for i in range(N):
        _ = int(_in[i+1])  
        d_arr.append(_)
    
    cnt = len(set(d_arr))
    
    print(cnt)

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

Solution (Python):
a,*b=open(0);print(len(set(b)))

Solution (Python):
def resolve():
    
    n = int(input())
    
    
    
    D = [int(input()) for i in range(n)]
    
    
    
    

    Dsort = sorted(D)
    cnt = 1
    for i in range(1, n):
        if Dsort[i] > Dsort[i-1]:
            cnt += 1

    print(cnt)
resolve()

Solution (Python):

"""this is python work script"""
def solve(input_list):

    list_uniq = set(input_list)
    answer = len(list_uniq)

    return answer

def main():
    """main function"""
    N = int(input())
    list_input = [input().rstrip() for _ in range(N)]

    answer = solve(list_input)
    print(answer)

if __name__ == '__main__':
    main()

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

def main(n,d):
    d.sort(reverse=True)
    npre=d[0]
    ndan=1
    for i in range(1,n):
        if(d[i]<npre):
            npre=d[i]
            ndan+=1
    
    return ndan

def main2(n,d):
    
    set_d = set(d)
    return len(set_d)

if __name__=='__main__':
    n,d=readinput()
    ans=main2(n,d)
    print(ans)

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

def main(n,d):
    d.sort(reverse=True)
    npre=d[0]
    ndan=1
    for i in range(1,n):
        if(d[i]<npre):
            npre=d[i]
            ndan+=1
    
    return ndan

if __name__=='__main__':
    n,d=readinput()
    ans=main(n,d)
    print(ans)

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

    print(len(d_set))


main()

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

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

print(len(set(d)))

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,sqrt
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7


n=I()
s=[I() for i in range(n)]
print(len(list(set(s))))

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

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

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

List.sort()
List.reverse()

count = 0

for i in range(len(List)):
  if i==0:
    m = max(List)
    count += 1
    List.remove(m)
  elif m!=max(List):
    m = max(List)
    count += 1
    List.remove(m)
  else:
    List.remove(m)
    continue
    
print(count)

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

L = []
for i in range(N):
  mochi = input()
  if mochi not in L:
    L.append(mochi)
    
print(len(L))

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

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

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

disk_unique = list(set(disk))

print(len(disk_unique))

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

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

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

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

A = []

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

set1 = set(A)

print(len(set1))

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

myset = set()

for i in range(N):
    myset.add(input())
    
print(len(myset))

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

D = [0]*n
for i in range(n):
    D[i] += int(input())

ans = set(D)
print(len(ans))

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

Solution (Python):
N=int(input())
list=[int(input()) for i in range(N)]
list.sort()
m=1
for i in range(N-1):
  if list[i+1]!=list[i]:
    m+=1
print(m)

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

Solution (Python):
n = int(input())
lis = []
count = 1
for _ in range(n):
    lis.append(int(input()))
lis.sort()

for i in range(n-1):
    sa = lis[i] - lis[i+1]
    if sa !=0:
        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())
d = [input() for i in range(n)]

print(len(set(d)))

Solution (Python):
n=int(input())
lis=[]
for i in range(n):
  lis.append(int(input()))
lis.sort()
keep=0
count=0
for i in range(0,n):
  if lis[i]!=keep:
    count+=1
    keep=lis[i]
  else:
    keep=lis[i]
print(count)

Solution (Python):
cnt = int(input())
numset= set()

for x in range(cnt):
    size = int(input())
    numset.add(size)

print(len(numset))

Solution (Python):
from collections import Counter

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

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

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

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

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

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

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

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

setA=set(listA)
print(len(setA))

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

Solution (Python):
N=int(input())
d=[int(input()) for _ in range(N)]
d=list(set(d))
d.sort(reverse=True)
cnt=1
for i in range(len(d)-1):
    if d[i+1]<d[i]:
        cnt+=1
    else:
        print(cnt)
        exit()
print(cnt)

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

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

print(ans)

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

d.sort(reverse = True)

count = 0

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

print(count)