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

import sys
input = sys.stdin.readline










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

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

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

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

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

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

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

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




print(len(list(set(num_list))))

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

answer = len(set(d_list))
print(answer)

Solution (Python):




"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
 

 


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

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

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

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

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

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

print(len(set(A)))

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

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

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

Solution (Python):


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

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

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

INF = float('inf')

"""
S = input()
N = int(input())
N, A, B = map(int, input().split())
A = list(map(int, input().split()))
D = [input() for _ in range(N)]
"""

def main():
    N = int(input())
    D = [int(input()) for _ in range(N)]
    D = sorted(list(set(D)), reverse=True)

    print(len(D))


if __name__ == '__main__':
    main()

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
D = []
for i in range(n):
    D.append(ii())
print(len(set(D)))

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


print(len(set(s)))

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

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

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

print(len(set(arr)))

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

print(len(new))

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

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

Solution (Python):
N = int(input())
dlist = []
for i in range(N):
  d = int(input())
  dlist.append(d)
  
ans = list(set(dlist))
ans.sort(reverse=True)

print(len(ans))

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

print(len(set(d)))

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

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

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

Solution (Python):
n = int(input())
d_list = []
for i in range(n):
    val = int(input())
    if val:
        d_list.append(val)
for j in range(n):
    for k in range(n):
        if j == k:
            pass
        else:
            if d_list[j] == d_list[k]:
                d_list[k] = 0
print(len([a for a in d_list if a > 0]))

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

moti_list = list(set(d))

print(len(moti_list))

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

for i in range(n):
    if A[i] not in list:
        ans = ans + 1
        list[i] = A[i]

print(ans)

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

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

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

Solution (Python):
n = int(input())
d = {}
for i in range(n):
    t = int(input())
    d[t] = d.get(t, 0) + 1

print(len(d))

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

d = []

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

d.sort(reverse=True)

cnt = 1

for s in range(0, len(d)-1):
  if (d[s] > d[s+1]):
    cnt = cnt + 1





print(cnt)

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

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

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

d.sort(reverse=True)


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

print(int(n)-dupe)

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

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())
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()))
print(len(list(set(d))))

Solution (Python):
if __name__ == '__main__':
    t = int(input())
    s = []
    for i in range(t):
        s.append(int(input()))
    print(len(set(s)))

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 i in range(N)]


d_set = set(d_list)
print(len(d_set))

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.array([int(input()) for _ in range(N)])
c = np.bincount(D)
ans = np.count_nonzero(c)
print(ans)

Solution (Python):
import sys
from math import sqrt
from collections import Counter

input = sys.stdin.readline


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    n = I()
    d = LIN(n)

    print(len(set(d)))
    pass


if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):
class KagamiMochi:
    def __init__(self):
        self.counter =1
    def count_mochi(self, mochi_num, mochi_list):
        new_list = list(set(mochi_list))
        new_list_int = [int(s) for s in new_list]
        sort_mochi_list = sorted(new_list_int, reverse=True)
        latest_mochi = sort_mochi_list[0]
        for m in sort_mochi_list:
            if int(m) < int(latest_mochi):
                latest_mochi = int(m)
                self.counter += 1
        return self.counter
            


if __name__ == "__main__":
    N = int(input())
    S = [input() for _ in range(N)]
    km = KagamiMochi()
    result = km.count_mochi(N, S)
    print(str(result))

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

print(len(set(D)))

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

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

print(len(set(a)))

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

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

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

bucket_sort = [0] * 101

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

  if bucket_sort[d] != 1:
    bucket_sort[d] = 1

ans = 0


for k in bucket_sort:
  ans +=  k

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

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

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

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

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

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

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

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

    ds = set(ds)
    ans = len(ds)
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):

import math
import itertools
import statistics
import collections

n = int(input())

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

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

Solution (Python):
import collections

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

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

Solution (Python):

n = int(input())
d = [0] * n
for i in range(n):
    d[i] = int(input())
    
class Node:
    def __init__(self, data):
        self.data = data
        self.right = None
        self.left = None

class BST:
    def __init__(self, number_list):
        self.root = None
        for data in number_list:
            self.insert(data)
    
    def insert(self, data):
        n = self.root
        if n == None:
            self.root = Node(data)
            return
        else:
            while True:
                entry = n.data
                if entry > data:
                    if n.left is None:
                        n.left = Node(data)
                        return
                    n = n.left
                elif entry < data:
                    if n.right is None:
                        n.right = Node(data)
                        return
                    n = n.right
                else:
                    n.data = data
                    return

    
    def inorder(self,node,ll):
        if node is not None:
            self.inorder(node.left,ll)
            ll.append(node.data)
            self.inorder(node.right,ll)
        return ll

bst = BST(d)
ll = []
print(len(bst.inorder(bst.root,ll)))

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

print(len(d))

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

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

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

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

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

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

print(len(d))

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

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

d.sort(reverse=True)
  
res = 0
cur_diameter = max(d) + 1
for i in range(N):
  if d[i] < cur_diameter:
    res += 1
    cur_diameter = d[i]

print(res)

Solution (Python):
import collections
N = int(input())
D = [int(input()) for i in range(N)]
ans = 0          
DD = collections.Counter(D)
for k in DD.values():
    ans += 1
print(ans)

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

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

print(len(set(d)))

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

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

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

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

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(1,N+1)]
d=sorted(d)
moti=0
x=[]
for i in d:
  if i>moti:
    x.append(i)
    moti=i
print(len(x))

Solution (Python):
N=int(input())
d_dict={}
for n in range(N):
    d = int(input())
    if d in d_dict.keys():
        continue
    d_dict[d]=0
else:
    print(len(d_dict))

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

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

Solution (Python):
N = int(input())
num = [0]*N

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

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

data = [input() for _ in range(n)]

data = list(set(data))

print(len(data))

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

Solution (Python):
n=int(input())
d={}
for _ in range(n):
  s=input().strip()
  d[s]=1

print(len(d.keys()))

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


print(len(set(d)))

Solution (Python):
import sys
input = sys.stdin.readline
 
n = int(input())
d = [int(input()) for i in range(n)]
d.sort()
 

now = d.pop() 
ans = 1 

while len(d) != 0:
    next = d.pop()
    
    if now > next:
        ans += 1
        now = next
 
print(ans)

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

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

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 x in range(0,N)]

print(len(set(d)))

Solution (Python):
N=int(input())
d=[int(input()) for x in range(0,N)]
d.sort(reverse=True)
c=1

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7

n = INT()
d = [INT() for _ in range(n)]
print(len(list(set(d))))

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

print(len(d))

Solution (Python):
def main():
    N = int(input())
    ans = set()
    for _ in range(N):
        ans.add(input())
    print(len(ans))
if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
d = sorted([int(input()) for _ in range(n)])[::-1]
ans = 1
mx = d[0]
for i in d[1:]:
    if i < mx:
        ans += 1
        mx = i
print(ans)

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

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


print(len(list(set(mochi_cm))))

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

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

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

N_set = set()


for id in range(N):
    N_set.add(int(input()))


print(len(N_set))

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

print(len(set(d)))

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

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

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

print(len(set(d)))

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

Solution (Python):


n = int(input().rstrip())

print(len(set([int(input()) for i in range(n)])))

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 = []
for n in range(N):
    d += [int(input())]

d.sort()

ret = 0
dmin = 0
for i in range(N):
    if dmin<d[i]:
        ret += 1
        dmin = d[i]
print(ret)

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

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

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

Solution (Python):
input_count = int(input())
mochis = { int(input()) for x in range(input_count) }
print(len(mochis))

Solution (Python):

def main():
    n = int(input())
    s = set(map(int, [input() for i in range(n)]))
    print(len(s))

if __name__ == '__main__' :
    main()

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

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

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

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

s=[]
for i in range(n):
    list.append(s,int(input()))

ct = 0
m_ini=0 
while max(s)>0:
    m_ini = max(s)
    for i in range(n):
        if s[i]== m_ini:
            s[i]=0
        else:
            pass
    ct = ct+1
print(ct)

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 i in range(N))
D.sort(reverse = True)

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

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

print(len(set(D)))

Solution (Python):


import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

N = ni()
D = nin(N)
D.sort()

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)]
print(len(set(d)))

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

a.sort(reverse=True)

c = 1
b_i = a[0]
for i in a[1:]:
    if i >= b_i:
        continue
    c = c + 1
    b_i = i

print(c)

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

d.sort(reverse=True)

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

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

Solution (Python):
import numpy
f=[]
for i in range(int(input())):f.append(int(input()))
print(len(numpy.unique(f)))

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

Solution (Python):
firstint = int(input())
inputary = [int(input()) for i in range(firstint)]
inputary.sort(reverse=True)
counter = 1
Comparisoner = inputary[0]
for elm in inputary:
    if Comparisoner > elm:
        counter +=1
    elif Comparisoner is elm:
        continue
    else:
        break
    Comparisoner = elm

print(counter)

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

print(len(D))

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

dan = len(set(d))

print(dan)

Solution (Python):



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

d_list = set(d_list)
ans = len(d_list)
print(ans)

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

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

Solution (Python):
def main():
    N = int(input())
    d = [0] * 100
    for i in range(N):
        d[int(input()) - 1] = 1
    print(sum(d))


if __name__ == '__main__':
    main()

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

Solution (Python):


N = int(input())


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


d.sort()

for n in range(0,N):
    if d[n-1] == d[n]:
        count -=1

if count == 0:
    count= 1

print(count)

Solution (Python):
n = int(input())
flag = [0] * 101

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

result = 0
for i in range(101):
    result += flag[i]

print(result)

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

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

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)]
A=[]
d.sort(reverse=True)
for j, n in enumerate(d):
    if j==0:
        A.append(n)
    else:
        if A[-1]>n:
            A.append(n)
        else:
            pass
print(len(A))

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

Solution (Python):








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

    print(len(set(d)))

resolve()

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

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

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

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)]
y = set(x)
print (len(y))

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

Solution (Python):
nums = [int(input()) for _ in range(int(input()))]
nums_dict = dict()
for i in nums:
    nums_dict[i] = True
print(len(nums_dict.keys()))

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

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

Solution (Python):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = int(sys.stdin.readline().rstrip())
    lines = [int(sys.stdin.readline().rstrip()) for _ in range(N)]
    print(len(set(lines)))


if __name__ == '__main__':
    main()

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

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

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

resolve()

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

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

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

Solution (Python):

from collections import Counter

def main():
    n = int(input())

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

    item = Counter(d)
    print(len(item))

main()

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

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

print(len(set(d)))

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

print(len(set(di)))

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

    print(len(d))
if __name__ == '__main__':
    solve()

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

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

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

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

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

Solution (Python):
N = int(input())
d = {}
for i in range(N):
    a = int(input())
    if d.get(a) is None:
        d[a] = 1
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())
l=[int(input()) for _ in range(n)]
print(len(set(l)))

Solution (Python):

def Kagami_Mochi(n , dl):

    ans = len(set(dl))

    return ans

def main():
    n = int(input())
    dl = [str(input()) for i in range(n)]
    print(Kagami_Mochi(n , dl))

if __name__ == '__main__':
    main()

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

print(len(set(l)))

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

Solution (Python):

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

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



b = [] 
for i in range(len(a)):
    if( (a[i] in b) == False ):
        b.append(a[i])
    
    

print(len(b))

Solution (Python):

import numpy as np

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

d = np.array(d)
ans = len(np.unique(d))
print(int(ans))

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

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

s = list(set(d))

print(len(s))

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

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

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