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

num = int(input())
data = [int(input()) for i in range(num)]

data.sort(reverse=True)

res = 1

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

print(res)

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

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

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

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

import numpy as np

n = np.unique(d_list)
print(len(n))

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

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

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

print(len(s))

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

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

print(len(list(set(MOCHIS))))

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

for i in range(a):
  a_list.append(int(input()))
  
a_set = set(a_list)

print(len(a_set))

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

uniq_D = list(set(D))
print(len(uniq_D))

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

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

print(len(kagami_mochi))

Solution (Python):

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

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

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

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

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

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

d = list(set(d))

print(len(d))

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

Solution (Python):
n = int(input())
x = []
ans_dict = {}
for _ in range(n):
    x.append(input())
for i in x:
    if i not in ans_dict:
        ans_dict[i] = 1
    else:
        ans_dict[i] = ans_dict[i]+1
print(len(ans_dict))

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

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

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

Solution (Python):
n = int(input())
d = []
for i in range(n):
    d.append(int(input()))
res = 0
for i in range(len(d)):
    a = 1
    some = d[i]
    if(i > 0):
        for j in range(i):
            if(some == d[j]):
                a = 0
                break
    res = res + a
print(res)

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

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

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

Solution (Python):
def resolve():
    N = int(input())
    t = dict()
    ans = 0
    for i in range(N):
        n = int(input())
        is_exists = t.get(n, False)
        if not is_exists:
            ans += 1
            t[n] = True
    print(ans)


if __name__ == "__main__":
    resolve()

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

result = 1
if N == 0:
	result = 0
else:
	for i in range(N-1):
		if Dj[i] != Dj[i+1]:
			result += 1
print(result)

Solution (Python):
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
mod=10**9+7

N=I()
d=[0]*N
for i in range(N):
    d[i]=I()
    
d.sort()
ans=N
for i in range(N-1):
    if d[i+1]==d[i]:
        ans-=1
        
print(ans)

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

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

a = 0
ans = 0

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

ans = n - a
print(ans)

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

if __name__ == '__main__':
    resolve()

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

if __name__ == '__main__':
    resolve()

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

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

Solution (Python):
def main():
    n = int(input())
    r = [int(input()) for i in range(n)]
    r.sort()
    counter = 0
    tmp = 0
    for i in range(n):
        if (r[i] > tmp):
            tmp = r[i]
            counter += 1
    print(counter)
main()

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

d = sorted(d)
cnt = 0

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

print(n - cnt)

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

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

a.sort()
res = [a[i] for i in range(1, n) if not a[i] == a[i-1]]

print(len(res) + 1)

Solution (Python):
input()
D = set()
while True:
    try:
        D.add(int(input()))
    except EOFError:
        break
print(len(D))

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

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

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

Solution (Python):

N = int(input())
a = [int(input()) for i in range(N)]
a.sort()
for k in range(N-1):
    if a[k] == a[k+1]:
        a[k] =-1

b=[a[k] for k in range(N) if a[k] != -1]
print(len(b))

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

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

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

Solution (Python):
n=int(input())
d=[list(map(int,input())) for _ in range(n)]
d.sort()
d.append(0)
ans=0
for i in range(n):
    if d[i]!=d[i+1]:
        ans+=1
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 = set([int(input()) for _ in range(n)])

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

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

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

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

di = set(map(int, [input() for i in range(n)]))

print(len(di))

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

s=set(ls)
print(len(s))

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

ls.sort(reverse=True)
k=1

for i in range (n-1):
  if ls[i]>ls[i+1]:
    k+=1
    
print(k)

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

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

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

final = list(set(nums))
print(len(final))

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

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

if __name__ == '__main__':
    main()

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

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

nums = [int(input().strip()) for _ in range(n)]



d_set = {i for i in nums}
print(len(d_set))

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

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

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

print(len(set(A)))

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

print(len(set(array)))

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

for i in range(0,N):
  lst.append(input())

print(len(set(lst)))

Solution (Python):
def solve():
    N = int(input())
    B = [int(input()) for _ in range(N)]
    return len(set(B))

print(solve())

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

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


if __name__ == '__main__':
    main()

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

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

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

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


for _ in range(N):
    d.append(input())


sortList = sorted(d, reverse=False)
count = 1

for i in range(N-1):
        
        if sortList[i+1] > sortList[i]:
                count = count + 1
        else:
                continue


print(count)

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

max_d = 101
c = 0
answer = []

while len(ds) > 0:
  max_ds = max(ds)
  c+=1
  ds = [d for d in ds if d != max_ds]

print(c)

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

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

max_d = 101
c = 0
answer = []

while len(ds) > 0:
  max_ds = max(ds)
  max_d = max_ds
  c+=1
  ds = [d for d in ds if d != max_ds]

print(c)

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

max_d = 101
c = 0
answer = []

while len(ds) > 0:
  max_ds = max(ds)
  
  max_d = max_ds
  c+=1
  ds = [d for d in ds if d != max_ds]

print(c)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
n = int(input())
dList = [int(input()) for _ in range(n)]
num = [0 for _ in range(101)]
for i in dList:
    num[i] += 1
count = 0
for i in num:
    if i:
        count += 1
print(count)

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

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

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

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

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

ans = len(set_)
print(ans)

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

cnt = 0
pre_diameter = 101

while len(D) != 0:
    diameter = max(D)
    if diameter < pre_diameter:
        cnt += 1

    D.remove(diameter)
    pre_diameter = diameter

print(cnt)

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

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

Solution (Python):




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


if __name__ == "__main__":
    main()

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

Dia_mochi=list(set(Dia_mochi))
print(len(Dia_mochi))

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

Solution (Python):

N = int(input())
list_A = [0 for i in range(0,N)]
for i in range(0,N) :
    list_A[i] = int(input())

set_A = set(list_A)
print(len(set_A))

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

Solution (Python):
def main(n,d):
    
    d.sort()
    
    count = 0
    for i in range(1, len(d)):
        if d[i-1] == d[i]:
            count += 1
    return n - count

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

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

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

count = N
same = 0

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


d_new = sorted(d, reverse = True)
while j < N - 1:
	if d_new[j] == d_new[j + 1]:
		same += 1
	j += 1
ans = count - same
print(str(ans))

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

bucket = [0 for i in range(110)]
for i in range(N):
  bucket[d[i]] += 1

count = 0
for i in range(110):
  if bucket[i] != 0:
    count += 1

print(count)

Solution (Python):
N = int(input())
d = list(map(int, [input() for i in range(N)]))
d.sort()
count = 1

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

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

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

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

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

d.sort()
c = 1

for j in range(n-1):
    if d[j] == d[j+1]:
        pass
    elif d[j] < d[j+1]:
        c += 1
    else:
        pass

print(c)

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 [0] * n]
print(len(set(sorted(d))))

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

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

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

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

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

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

print(len(d))

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

Solution (Python):
print(len(set(list(map(int,open(0).read().split()))[1:])))

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

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

    print(len(D))


if __name__ == "__main__":
    main()

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

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

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

d=sorted(d)[::-1]
count=1
for p in range(N-1):
  if d[p]>d[p+1]:
    count+=1
    
print(count)

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

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

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

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

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

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n=INT()
    s=set()
    for i in range(n):
        s.add(INT())
    print(len(s))
if __name__ == '__main__':
    do()

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

x = dict()
ans = 0
for i in range(N):
    if d[i] in x:
        x[d[i]] += 1
    else:
        x[d[i]] = 1

for idx in x:
    ans += 1
print(ans)

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

num = set(d)

print(len(num))

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

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]
l.sort(reverse=True)
count = 1
left = l[0]
for i in l:
  if i < left:
    count += 1
    left = i
print(count)

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

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

num = [False]*110
for i in range(N):
    num[d[i]] = True

answer = 0
for i in range(100+1):
    if num[i]:
        answer += 1
print(answer)

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

d.sort()
first = d[0]

for i in range(1, n):
  if first < d[i]:
    res += 1
  first = d[i]
  
print(res)

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

Solution (Python):
import sys

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

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

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

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


dn_list = list(set(dn_list))

print(len(dn_list))

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

Solution (Python):
import math




n = int(input())


a = [""]*n
for i in range(n):
  a[i] = int(input())


a.sort(reverse=True)
count = 0
for i in range(n-1):
  if(a[i] == a[i+1]):
    a[i] = 0

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

Solution (Python):
n = int(input())
data = []
for i in range(n):
  d = int(input())
  data.append(d)
Data = sorted(data)
cnt = 0
tmp = -1
for i in Data:
  if(tmp < i):
    cnt += 1
    tmp = i
print(cnt)

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

d.sort()

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

print(answer)

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

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

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

Solution (Python):
_,*s = open(0)
print(len(set(s)))

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

Solution (Python):

n = int(input())
dl = [int(input()) for _ in range(n)]
dl.sort(reverse=True)

cnt = 1
d = dl[0]
for i in range(1,n):
    if d>dl[i]:
        cnt += 1
        d = dl[i]

print(cnt)

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

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

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

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

pre = a[0]
ans = 1
for i in range(1,n):
  if pre < a[i]:
    ans += 1
  pre = a[i]
print(ans)

Solution (Python):


import sys
import collections
input = sys.stdin.readline

"""
H = int(input())
h = [int(ele) for ele in input().split()]
h = [0] + h
"""


def main():
    N = int(input())
    d = [0] * (N)
    for i in range(N):
        d[i] = int(input().rstrip())

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


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
dat = {}
for _ in range(n):
    dat[int(input())] = True
print(len(dat.items()))

Solution (Python):

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

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

Solution (Python):
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys




read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

N = int(readline())
S = set([int(readline().decode()) for _ in range(N)])

print(len(S))

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

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

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

Solution (Python):
N = int(input())
D = []
ans = 0
for _ in range(N):
    d = int(input())
    if d  not in D:
        D.append(d)
        ans += 1
print(ans)

Solution (Python):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(input())
d = [int(input()) for _ in range(n)]
print(len(list(set(d))))

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

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

print(len(set(d)))

Solution (Python):




def main():
  n = int(input())
  tmp = {}
  for i in range(n):
    x = int(input())
    if x in tmp.keys():
      tmp[x] += 1
    else:
      tmp[x] = 0
  print(len(tmp))
    
  
if __name__ == "__main__":
  main()

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

Solution (Python):



def input_one_number():
    return int(input())


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


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


def input_multiple_number_as_list_sep(N):
    ins = []
    for i in range(N):
        ins.append(input())
    return ins


def input_map():
    return [list(map(int,list(input()))) for i in range(h)]


def print_list(list):
    print(*list)
    return


def print_map(maplist):
    for i in maplist:print(*i, sep='')
    return


def generate_primenums():
    n = 100
    primes = set(range(2, n+1))
    for i in range(2, int(n**0.5+1)):
        primes.difference_update(range(i*2, n+1, i))
    primes=list(primes)
    return primes

def memo():
    a=[0]*5
    b=a  
    b2=a[:]  
    a[1]=3
    print('b:{}, b2:{}'.format(b,b2))  
    
    import copy
    a= [[0]*3 for i in range(5)] 
    b=copy.deepcopy(a)  
    
    
    odd=[i for i in range(100) if i%2==1] 

    
    import bisect
    a = [1, 2, 3, 5, 6, 7, 8, 9]
    b=bisect.bisect_left(a, 8)

    
    from itertools import permutations, combinations,combinations_with_replacement,product
    a=['a','b','C']
    print(list(permutations(a)))
    print(list(combinations(a,2)))
    print(list(combinations_with_replacement(a,3)))



def kaijo(n):
    import math
    return math.factorial(n)


def num_combination(n,r):
    import math
    return math.factorial(n) // math.factorial(n - r)



def calc_gcd(a,b):
    import fractions
    GCD=fractions.gcd(a,b)
    lcm=a*b//gcd
    return gcd,lcm


def calc_gcd_list(l):
    gcd = l[0]
    for i in range(1, N):
        gcd = fractions.gcd(gcd, l[i])
    return gcd


def sum_digit(n):
    sum = 0
    while n > 0:
        sum += n%10
        n //= 10
    return sum

N = input_one_number()
lst_d = input_multiple_number_as_list_sep(N)

lst_d.sort()

dan = len(lst_d)

before = 100000
for i in lst_d:
    if before == i:
        dan -= 1
    before = i

print(dan)

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

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

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

now = mochi.pop(0)
cnt = 1
for i in mochi:
    if i < now:
        now = i
        cnt += 1

print(cnt)

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

Solution (Python):
N = int(input())
lst = []
ans = 1

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

lst.sort()

for i in range(N):
    if i == 0:
        pass
    elif lst[i] == lst[i-1]:
        pass
    else:
        ans += 1

print(ans)

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

Solution (Python):
import numpy as np

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

dd = np.sort(np.unique(d))[::-1]





print(len(dd))

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

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

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

s=0
cnt=0
for i in d:
 if s<i:
  cnt+=1
  s=i
print(cnt)

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

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

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

print(len(set(lst)))

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

print(len(D))

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

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

print(len(a))

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

print(len(lst1))

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

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

mochis.sort(reverse=True)
cnt = 0
beforeMochies = 101
for mochi in mochis:
  if beforeMochies != mochi:
    cnt+=1
  
  beforeMochies = mochi
  
print(cnt)

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

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

    
    
print(len(d))

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

print(len(set(d)))

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

d = sorted(d, key = lambda x: -x)
count = 0
candidate = 1000
for i in d:
  if candidate > i:
    candidate = 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())
d = [input() for i in range(n)]

print(len(set(d)))

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

Solution (Python):
n = int(input())
Set = {int(input()) for i in range(n)}

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

Solution (Python):
len = int(input())
d = []
count = 1
for x in range(len):
    d.append(int(input()))

d.sort()
for x in range(len-1):
    if d[x] != d[x+1]:
        count += 1
print(count)

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

Solution (Python):
nums = [int(input()) for _ in range(int(input()))]
num_dict = dict()
for i in nums:
    num_dict[i] = True

print(len(num_dict.keys()))

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

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

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

print(len(list(set(D))))

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

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

print(len(set(d)))