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_list = []

n = int(input())

for i in range(n):
    s = input()
    num_list.append(int(s))

sorted_num_list = sorted(list(set(num_list)), reverse=True)


print(len(sorted_num_list))
num_list.clear()

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

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)]
import collections
table=collections.defaultdict(int)
for i in range(N):
  table[d[i]]+=1
print(len(table.values()))

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

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

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

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

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

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

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

print(len(set(d)))

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

Solution (Python):

import sys


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



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)]  
    solve(N, d)

if __name__ == '__main__':
    main()

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

Solution (Python):

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

Solution (Python):
N = int(input())
ls = []
mochi = 1
for i in range(N):
  ls.append(int(input()))
ls = sorted(ls)
for i in range(N-1):
  if ls[i]<ls[i+1]:
    mochi += 1
print(mochi)

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

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

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

print(len(d))

Solution (Python):
import sys
from functools import reduce
import copy
import math
from pprint import pprint


sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def int_inputs(num_of_input):
    ins = [int(input()) for i in range(num_of_input)]
    return ins


def solve(inputs):
    mochis = list(map(int, inputs))
    mochis.sort(reverse=True)
    count = 0
    prev_mochi = -1
    for m in mochis:
        if prev_mochi == -1 or prev_mochi > m:
            count += 1
        prev_mochi = m
    return count


def string_to_int(string):
    return list(map(int, string.split()))


if __name__ == "__main__":
    N = int(input())
    ret = solve(inputs(N))
    print(ret)

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

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n = int(input().rstrip('\n'))
    d = [int(input().rstrip('\n')) for _ in range(n)]
    d.sort(reverse=True)
    l = 10 ** 10
    cnt = 0
    for i in range(n):
        if d[i] < l:
            cnt += 1
            l = d[i]
    print(cnt)


if __name__ == '__main__':
    slove()

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

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

l=sorted(l, reverse=True)
c=1
for r in range(len(l)-1):
    if l[r]>l[r+1]:
        c+=1
print(c)

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 _ in range(N)]
A = [D[0]]
for d in D:
  if d not in A:
    A.append(d)
print(len(A))

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

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

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

print(len(set(d)))

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

Solution (Python):

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

print(len(d))

Solution (Python):
def bb085():
    n = int(input())
    dn = set()
    for i in range(0, n):
        dn.add(int(input()))
    print(len(dn))

bb085()

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

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

num = [0]*100
for d in D:
    num[d-1]+=1
ans=0
for n in num:
    if n>0:
        ans+=1
print(ans)

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

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

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):
  d = int(input())
  l.append(d)
print(len(set(l)))

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

Solution (Python):
n=int(input())
b=[0]*100
for i in range(n):
  b[int(input())-1]+=1
c=0
for i in b:
  if i:
    c+=1
print(c)

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

se=set()
for i in d:
    se.add(i)
    
print(len(se))

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

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

print(len(set(d)))

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

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

print(len(set(li)))

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 i in range(N)]
a = 0
b = 0
e = sorted(d)

while b == 0:
    for l in range(N):
        if e[l-1] < e[l]:
            a += 1
        else:
            b += 1

print(a+1)

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

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

a_L = []
for val in range(n):
    a_L.append(int(input()))

a_L = list(set(a_L))
print(len(a_L))

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

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

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

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

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

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

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

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

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

arr = []

for i in range(n):
    k = int(input())
    
    if not k in arr:
        arr.append(k)

print(len(arr))

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

print(len(d))

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

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

print(len(D))

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

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

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

sorted(d_list)
print(len(list(set(sorted(d_list)))))

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

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

S = []
for _ in range(n):
    S.append(int(input()))  


S.sort()


print(len(set(S)))

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

out = 0
last = 0
for i in d:
  if last is not i:
    out += 1
  last = i

print(out)

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

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

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

Solution (Python):
i = int(input())
S = []
for _ in range(0, i):
    S.append(int(input()))
S.sort(reverse=True)

output = 0
for key, value in enumerate(S):
    if key == 0:
        output += 1
    elif value != S[key-1]:
        output += 1
print(output)

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

Solution (Python):
n = int(input())
candidate = []
for _ in range(n):
  x = int(input())
  candidate.append(x)
candidate.sort(reverse=True)
standard = max(candidate)
Answer_list = [standard]
for item in candidate:
  if item < standard:
    Answer_list.append(item)
    standard = item

print(len(Answer_list))

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

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

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

result_set = set()
for i in range(n):
    result_set.add(int(input()))

print(len(result_set))

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

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

m = 0

ans = 0

count = 0

for i in range(N):
    A[i] =  int(input())
A.sort()
for i in range(N):
    if(m<A[i]):
        m =A[i]
    elif(m == A[i]):
        count +=1
ans = N - count
print(ans)

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

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

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

Solution (Python):

n = int(input())

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

print(len(set(d_list)))

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

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

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

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

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

Solution (Python):
a = int(input())
numbers = [int(input()) for i in range(a)]
numbers = list(set(numbers))
numbers.sort(reverse=True)
count = 0
ans = len(numbers)
print(ans)

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

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

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

print(ans)

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

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

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

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

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

d_list = list(d_set)
d_list.sort()

print(len(d_list))

Solution (Python):

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

array.sort()
count = 1

for i in range(n):
    if(i > 0 and array[i] != array[i-1]):
        count += 1

print(count)

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

Solution (Python):
def main():

    N = int(input())
    D = []
    for _ in range(N):
        d = int(input())
        D.append(d)
    D = list(set(D))
    D.sort()
    count = 1
    for i in range(len(D) - 1, -1, -1):
        if D[i - 1] < D[i]:
            count += 1
        else:
            break
    print(count)


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

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

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

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

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

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

print(len(d_list))

Solution (Python):



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


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

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

    number_of_steps = 0
    previous_diameter = 0
    for i in range(N):
        if d[i] > previous_diameter:
            number_of_steps += 1
        previous_diameter = d[i]

    print(number_of_steps)

solve()

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

Solution (Python):

def main():
	list1 = []
	n = int(input())
	for i in range(n):
		list1.append(int(input()))
	set1 = set(list1)
	print(len(set1))
 
 
if __name__ == "__main__":
	main()

Solution (Python):

import sys
from collections import deque, defaultdict
import copy
import bisect

import math
import heapq
from itertools import combinations, permutations

import sys
def input():
	return sys.stdin.readline().strip()

N = int(input())
ans = 0
d = defaultdict(int)
for i in range(N):
	di = int(input())
	if d[di] == 0:
		ans += 1
		d[di] += 1
print(ans)

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

Solution (Python):
n = int(input())
d = [int(input()) for i in range(n)]
cnt = 1
d = sorted(d)
for i in range(n-1):
    if d[i+1] > d[i]:
        cnt += 1
    elif d[i+1] < d[i]:
        break
print(cnt)

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

Solution (Python):
import numpy as np

N = int(input())

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

ans = len(np.unique(bs))
print(ans)

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

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

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

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

d = []

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

res = list(set(d))

print(len(res))

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

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

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

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

c = 0
lastSize = 0
while(True):
    if(len(d) != 0):
        np = max(d)
        d.remove(np)
        if(np != lastSize):
            lastSize = np
            c += 1
    else:
        break
print(c)

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

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 i in range(n)]
d.sort()
print(len(set(d)))

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

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

Solution (Python):
N = int(input())
d_list = []
count = 0
for i in range(0, N):
    num = int(input())
    if num in d_list:
        count += 1
    else:
        d_list.append(num)
        
    
print(N -count)

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

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

Solution (Python):
n = int(input())
x = sorted([input() for i in range(n)])
l = len(x)
for i in range(0,n-1):
    if x[i] == x[i+1]:
        l -= 1
print(l)

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

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

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


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

Solution (Python):
n = int(input())
lis = [int(input()) for i in range(n)]
import collections as cl
dic = cl.Counter(lis)
print(len(dic.keys()))

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

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

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

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

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

v = 0
count = 0
for i in range(n):
    if v < d[i]:
        count += 1
        v = d[i]
print(count)

Solution (Python):
import collections

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


kind = collections.Counter(d)


print(len(kind))

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

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

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

print(len(d))

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

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

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

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

d = set(d)
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())
mochi = set()
for i in range(N):
	r = int(input())
	mochi.add(r)

print(len(mochi))

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

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

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

print(len(set(d)))

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

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

Solution (Python):
import sys
N=int(sys.stdin.readline())
print(len(set(sys.stdin.readline() for i in range(N))))

Solution (Python):
N = int(input())
ds = sorted([int(input()) for _ in range(N)], reverse=True)
prev, ans = 0, 0
for n in ds:
  if n != prev:
    ans += 1
  prev = n 
print(ans)

Solution (Python):
import sys
s=set()
N=int(sys.stdin.readline())
s = set(sys.stdin.readline() for i in range(N))
print(len(s))

Solution (Python):
import sys
s=set()
N=int(sys.stdin.readline())
s = set(sys.stdin.readline() for i in range(N))
print(len(s))

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):
from collections import Counter
n = int(input())
diameters = list(map(int,[input() for i in range(n)]))
ans = 0
ans = len(Counter(diameters))
print(ans)

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

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

st = set(d)

print(len(st))

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

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

print(len(set(l)))

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

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

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

Solution (Python):
N=int(input())
mochi=[]
for i in range(N):
    a=int(input())
    mochi.append(a)
    
mochi_1=set(mochi)
mochi_2=sorted(mochi_1)

print(len(mochi_2))

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

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

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

l=list(set(l_1))
print(len(l))

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

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

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

mochi_set = set(mochi_init)
print(len(mochi_set))