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


flag = [0] *110

for j in l:
  if flag[j] == 0:
    flag[j] = 1


num = 0
for k in flag:

  if k == 1:
    num += 1
print(num)

"""


num = 0
for k in flag:
  print(flag[k])
  if flag[k] == 1:
    num += 1
print(num)
"""

Solution (Python):
N = int(input())
b = []
for i in range(110):
    b.append(0)
for i in range(N):
    a = int(input())
    b[a] += 1
ans = 0
for i in range(110):
    if b[i] != 0:
        ans += 1
print(ans)

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

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

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

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

cnt_list = []
for i in range(N):
   if d[i] not in cnt_list:
       cnt_list.append(d[i])
print(len(cnt_list))

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

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

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

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

Solution (Python):


from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


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

    ans = 0
    pre = INF
    for d in sorted(D, reverse=True):
        if d < pre:
            ans += 1
            pre = d
    print(ans)


if __name__ == '__main__':
    main()

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

print(len(S))

Solution (Python):

n=int(input())
d=[input() for i 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())
D = []
tempD = []

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

for i in range(N):
    tempD.append(D[i])

for i in range(len(D)):
    while tempD.count(D[i]) >= 2:
        tempD.remove(D[i])

print(len(tempD))

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

print(len(set(d_list)))

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

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

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

solve()

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

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

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

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

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

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

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

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

print(len(set(c)))

Solution (Python):
a = int(input())
b = []
for i in range(a):
    b.append(int(input()))
b.sort(reverse=True)
c = 0
cnt = 0
for i in b:
    if not i == c:
        cnt += 1
    c = i
print(cnt)

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

Solution (Python):
print(len(set(list(input()for _ in[0]*int(input())))))

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

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

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

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

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

d_unique = list(set(d_list))

print(len(d_unique))

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

for i in range(N):
    if marker != d[i]:
        count += 1
        marker = d[i]
        
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_list = sorted(list(map(int, set([input() for _ in range(n)]))), reverse=True)
print(len(d_list))

Solution (Python):
N = int(input())
D = []
for i in range(N) :
    d = int(input())
    if d not in D :
        D.append(d)
D = sorted(D,reverse=True)
print(len(D))

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

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

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

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

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

Solution (Python):

n=int(input())
a=[]
count=0
for i in range(n):
  a.append(int(input()))
a.sort()
for i in range(n-1):
  if(a[i]==a[i+1]):
    count+=1
print(n-count)

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

Solution (Python):


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

if __name__ == '__main__':
    main()

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

for i in sorted(list_d, reverse=True):
    if j <= i:
        continue
    else:
        ans += 1
        j = i

print(ans)

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

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

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

Solution (Python):
N = int( input())
D = []
for i in range(N):
    D.append(int(input()))
D = sorted(D)
ans = 1
d_now = D[0]
for i in range(1,N):
    if d_now < D[i]:
        ans += 1
        d_now = D[i]
print(ans)

Solution (Python):


N = int(input())
mochi = []
for i in range(N):
    mochi.append(int(input()))
    
mochi = sorted(mochi)
ans = 1
for m,n in zip(mochi[:-1],mochi[1:]):
    if not m == n:
        ans += 1
        
print(ans)

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

print(len(ans))

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

num_list = sorted(set(num_list))
print(len(num_list))

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

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

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

Solution (Python):
N = int(input())
a = []
ans = 0
state = 1
for i in range(0,N):
	a.append(int(input()))
for i in range(0,N):
	for j in range(i+1,N):
		if a[i] == a[j]:
			state = 0
	if state:
		ans += 1
	state = 1
print(ans)

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

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

Solution (Python):
N = int(input());
list = [];
for i in range(0,N):
	list.append(int(input()));

list.sort(reverse=True);

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

print(ans);

Solution (Python):
import numpy as np
n = int(input())
print(np.unique(np.array([int(input()) for _ in range(n)])).shape[0])

Solution (Python):
N = int(input())
D = []
for i in range(N):
	D.append(int(input()))
D.sort()
d = 0
num = 0
for i in range(N):
	if d != D[i]:
		num += 1
	d = D[i]

print(num)

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

Solution (Python):



def getElementNum(N,a):    
    """ 
    >>> getElementNum(4,[2,4,6,8])
    4
    """
    b = list(set(a))
    return len(b)

def main():
    N = int(input())
    a = []
    for i in range(N):
        a.append( int( input() ) )
    result = getElementNum(N,a)
    print(result)

if __name__ == '__main__':
    main()

Solution (Python):

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

    mochi = list(set(ds))
    mochi.sort()
          
    print(len(mochi))

if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np

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

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

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

cout = 0
b = 500

for i in range(n):
	if b > max(a):
		cout += 1
		b = max(a)
	a.remove(max(a))
print(cout)

Solution (Python):
import collections

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

dic = collections.Counter(d)

print(len(dic.keys()))

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

Solution (Python):
import numpy as np

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


sort = np.sort(j)
z = [sort[0]]
for i in range(len(j)-1):
    if (sort[i]<sort[i+1]):
        z = np.append(z,sort[i+1])
print(len(z))

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

d.sort()
d.append(0)
e.append(d[1])
for i in range(len(d)-1):
    if int(d[i])<int(d[i+1]):
        e.append(d[i+1])
print(len(e))

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

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

Solution (Python):
N = int(input())
f = [False]*101
c = 0
for i in range(N):
    d = int(input())
    if f[d]:
        continue
    f[d] = True
    c +=1

print(c)

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

unique = []

for i in a:
  if i not in unique:
    unique.append(i)

print(len(unique))

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

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

print (len(set(li)))

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

l_unique = list(set(d))

print(len(l_unique))

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

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

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

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

Solution (Python):
from collections import defaultdict
n=int(input())
dd=defaultdict(int)
for _ in range(n):
    dd[input()]+=1
print(len(dd.keys()))

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

print(len(set(d)))

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

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

print(len(d))

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

out=[]
for i in numbers:
  if i not in out:
    out.append(i)
print(len(out))

Solution (Python):

"""
Created on Tue Jun 19 03:01:30 2018

@author: ashida
"""

N = int(input())

ans = []

for i in range(N):
    d = int(input())
    if d in ans:
        tmp = 1
    else:
        ans.append(d)
        
print(len(ans))

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

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

print(len(set(d)))

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

Solution (Python):
d = []
a = input()
a = int(a)
for i in range(a):
    i = input()
    i = int(i)
    d.append(int(i))
d.sort()
pre_i = -1
cnt = 0
for i in d:
    if(pre_i!=i):
        cnt = cnt + 1
    pre_i = i

print(cnt)

Solution (Python):


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

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

Solution (Python):
print(len(sorted(set([int(input()) for _ in [0]*int(input())]))))

Solution (Python):


cnt = int(input())
mochi_list = []
for i in range(cnt):
    mochi_list.append(int(input()))

res_list = list(set(mochi_list))

print(len(res_list))

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

print(len(set(d)))

Solution (Python):
N = int(input())
mochis = sorted([int(input()) for _ in range(N)], reverse=True)
res = 1
for idx in range(1, N):
  if mochis[idx] < mochis[idx - 1]:
    res += 1

print(res)

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

Solution (Python):
import numpy
import re
import math

def main():
	"""
	テストコード実行
	:return:
	"""
	n = int(input())
	print(len(set(list(map(int, [input() for i in range(n)])))))


if __name__ == '__main__':
	main()

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

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

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

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

print(len(a))

Solution (Python):
print(len({input()for _ in[0]*int(input())}))

Solution (Python):
num = int(input())
InA = [int(input()) for i in range(num)]

ans = set(InA)

print (len(ans))

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



size_syurui_uniq = set(size_syurui)

print(len(size_syurui_uniq))

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

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

Solution (Python):

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

list.sort(reverse = True)

j = 0
cnt = 1
temp = list[0]

for j in range(N):
    if(temp > list[j]):
        temp = list[j]
        cnt = cnt + 1

print(cnt)

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

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

print(len(S))

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


if __name__ == '__main__':
    main()

Solution (Python):
input_lines = int(input())
num_list = []
for i in range(input_lines):
    s = input()
    num_list.append(s)



set_num = set(num_list)


set_length = len(set_num)
print(set_length)

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

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

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

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

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

mochi.sort()

count = N
for i in range(1,N):
    if(mochi[i-1] == mochi[i]):
        count = count - 1
print(count)

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

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    mochi = []
    for i in range(n):
        mochi.append(int(input()))

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

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

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

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

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

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

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

D.sort()
for num in range(len(D)-1):
    if D[num] == D[num+1]:
        N -= 1
print(N)

Solution (Python):
n = int(input())
mlst = list()
for i in range(n):
  mochi = int(input())
  if not mochi in mlst:
    mlst.append(mochi)
print(len(mlst))

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

Solution (Python):
N = int(input())
mochi = [0]*(101)
for _ in range(N):
    mochi[int(input())]=1
print(sum(mochi))

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

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

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

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

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

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

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

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

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

Solution (Python):
print(len({input()for _ in[0]*int(input())}))

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

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())
dan = list()

for i in range(n):
    dan.append(int(input()))
    
print(len(set(dan)))

Solution (Python):
N = int(input())
d_list = [int(input()) for i in range(N)]
result = {}
for i in d_list:
    result.setdefault(i, 0)
    result[i] += 1
print(len(result.keys()))

Solution (Python):
import os
import sys


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

print(len(set(a)))

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

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

print(len(d_list))

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

a = set(int(input()) for i in range(n))
print(len(a))

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

Solution (Python):

n = int(input())
a = set(float(input()) for i in range(n))


print(len(a))

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

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

for i in range(n):
    size.add(input())
print(len(size))

Solution (Python):
import heapq

N = int(input())

mochis = []

for i in range(N):
  mochis.append(int(input()))
heapq.heapify(mochis)

step = 0
pre_m = 1000
for i in range(N):
  m = heapq.heappop(mochis)
  if m == pre_m:
    continue
  step += 1
  pre_m = m

print(step)

Solution (Python):
N = int(input())
listD = list()
count =0 
for i in range(N):
    d = int(input())
    if d not in listD:
        listD.append(d)
        count +=1

print(count)

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

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

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

print(len(set(d)))

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

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

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

s = set()

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

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

Solution (Python):
length = int(input())
sizes = [int(input()) for x in range(length)]

sizes = list(set(sizes))

print(len(sizes))

Solution (Python):
n = int(input())
d = [i for i in range(n)]
for i in range(n):
    d[i] = int(input())
d = set(d)
print(len(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()))
d.sort()
max = -1
cnt = 0
for i in d:
    if i > max:
        cnt += 1
        max = i
print(cnt)

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

for i in range(n):
    if a[i] in b:
        continue
    else:
        b.append(a[i])
print(len(b))

Solution (Python):

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

sort_input_list = sorted(set(input_list), reverse=True)
print(len(sort_input_list))

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

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

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

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

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

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

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

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

s = 1

a.sort()

for i in range(N-1):
    if a[i] < a[i+1]:
        s = s+1
    else:
        s = s

print(s)

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

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

a.sort()
z = 1
for j in range(n-1):
    if a[j] < a[j+1]:
        z += 1
    elif a[j] == a[j+1]:
        z += 0

print(z)

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

d=[]

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

k=0


for i in range(n-1):

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

    if j == n-1:
        k += 1
k += 1

print(k)

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

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

d.sort()

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

print(t)

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

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

Solution (Python):
import sys

s_args = sys.stdin.read().splitlines()


d = [int(s_d) for s_d in s_args[1:]]

print(len(set(d)))

Solution (Python):
n = int(raw_input())
inpt = []
for i in range(0, n):
	inpt.append(int(raw_input()))

inpt.sort()
tmp = -1
cnt = 0

for i in range(0, n):
	if inpt[i] != tmp:
		cnt = cnt + 1
		tmp = inpt[i]

print cnt

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

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

print(len(s))

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

print(len(set(d)))

Solution (Python):
N,ans,x=int(input()),0,0
s=sorted([int(input()) for i in range(N)])
for i in range(N):
    if s[i]>x:
        ans+=1
        x=s[i]
print(ans)

Solution (Python):
from collections import defaultdict


if __name__ == '__main__':
    n = int(input())

    d_mochi = dict()
    for _ in range(n):
        d = int(input())
        if d in d_mochi.keys():
            continue
        else:
            d_mochi[d] = True

    print(len(d_mochi))

Solution (Python):


n = int(input())
nums = []
for i in range(n):
    nums.append(int(input()))
nums.sort()
nums.reverse()
count = len(nums)
for j in range(len(nums) - 1):
    if nums[j] == nums[j+1]:
        count -= 1
print(count)

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

print(len(moti))

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

Solution (Python):
n = int(input())
d = list(int(input()) for _ in range(n))
for i in range(n-1):
    for j in range(i+1,n):
        if d[i]>d[j]:
            
            buf = d[i]
            d[i] = d[j]
            d[j] = buf
cnt = 1

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

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

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

l = list(set(l))

print(len(l))

Solution (Python):
import math
import sys

def getinputdata():

    
    array_result = []
    
    data = input()

    
    array_result.append(data.split(" "))

    flg = 1

    try:


        while flg:

            data = input()

            array_temp = []

            if(data != ""):
                
                array_result.append(data.split(" "))

                flg = 1

            else:

                flg = 0
    finally:


        return array_result





arr_data = getinputdata()


n = int(arr_data[0][0])

set01=set()

for v in range(1,1+n):
    
    set01.add(arr_data[v][0])


print(len(set01))

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

Solution (Python):


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

di = sorted(di, reverse=True)

res = 1
top = di[0]
for i in range(1, n):
    if di[i] < top:
        top = di[i]
        res += 1

print(res)

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

ans = 0
dicts = {} 

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

    if not(d in dicts):
        dicts[d] = True
        ans += 1

print(ans)

Solution (Python):


def main():
    n = int(input())
    a = [ int(input()) for b in range(n)]

    print(len(set(a)))

if __name__ == '__main__':
    main()

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

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

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

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

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

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

sd = set(d)

print(len(sd))

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

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

Solution (Python):

N=int(input())

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

d.sort()

for i in range(N):
    if i!=0:
        if d[i-1]!=d[i]:
            num=d[i]
            out.append(num)
    else:
        out.append(d[0])

print(len(out))

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

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

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

print(len(s))

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

Solution (Python):
n = int(input())
d = sorted([int(input()) for i in range(n)])
stage = 0
pre = 0
for i in d:
    if i > pre:
        stage += 1
        pre = i
print(stage)

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

d_uniq = set(d)
print(len(d_uniq))

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

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