Problem:
 Score : 200 points    Problem Statement An X -layered kagami mochi  (X ≥ 1) is a pile of X round mochi (rice cake) stacked vertically where each mochi (except the bottom one) has a smaller diameter than that of the mochi directly below it. For example, if you stack three mochi with diameters of 10 , 8 and 6 centimeters from bottom to top in this order, you have a 3 -layered kagami mochi; if you put just one mochi, you have a 1 -layered kagami mochi.  Lunlun the dachshund has N round mochi, and the diameter of the i -th mochi is d_i centimeters. When we make a kagami mochi using some or all of them, at most how many layers can our kagami mochi have?      Constraints  1 ≤ N ≤ 100  1 ≤ d_i ≤ 100  All input values are integers.         Input Input is given from Standard Input in the following format:  N  d_1  :  d_N       Output Print the maximum number of layers in a kagami mochi that can be made.        Sample Input 1 4
10
8
8
6      Sample Output 1 3  If we stack the mochi with diameters of 10 , 8 and 6 centimeters from bottom to top in this order, we have a 3 -layered kagami mochi, which is the maximum number of layers.       Sample Input 2 3
15
15
15      Sample Output 2 1  When all the mochi have the same diameter, we can only have a 1 -layered kagami mochi.       Sample Input 3 7
50
30
50
100
50
80
30      Sample Output 3 4

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

Solution (Python):
n = int(input())
a = list(range(n))
for i in range(n):
    a[i] = int(input())
a.sort()
a.reverse()
cnt = 1
for i in range(1, n):
    if(a[i-1]>a[i]):
       cnt += 1
print(cnt)

Solution (Python):

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

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

cs = [False] * 100
for d in dn:
    cs[d-1] = True

print(sum(c for c in cs if c))

Solution (Python):

import collections

N = int(input())
mochiList = []
for n in range(N):
    mochiList.append(int(input()))

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

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

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

Solution (Python):
def solve(string):
    n, *d = map(int, string.split())
    return str(len(set(d)))


if __name__ == '__main__':
    n = int(input())
    print(solve('{}\n'.format(n) + '\n'.join([input() for _ in range(n)])))

Solution (Python):


n = int(input())

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

li.sort()

ans = 1
for i in range(1,n):
    if li[i-1] < li[i]:
        ans += 1

print(ans)

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

Solution (Python):
def sortex(X):
  b=sorted(X)
  b.append("null")
  a=[]
  for i in range(len(X)):
    if b[i]!=b[i+1]:a.append(b[i])
  return a
n=int(input());a=[int(input())for i in range(n)];a=sortex(a);print(len(a))

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

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

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

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

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

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


gusaku()

Solution (Python):
import numpy as np
N = int(input())
d = np.array([int(input()) for _ in range(N)])
print(len(set(d)))

Solution (Python):
import sys
from random import randint

finput = sys.stdin.readline





class ListNode:
    def __init__(self, key, next_=None):
        self.key, self.next = key, next_


class HashSetLinkedList:
    def __init__(self):
        self.__head = ListNode(None)
        self.__tail = self.__head
    
    def __repr__(self):
        keys = [str(key) if type(key) != str else "'" + key + "'" for key in self]
        return "->" + " -> ".join(keys)

    def find(self, key):
        cur_node = self.__head.next
        while cur_node:
            if cur_node.key == key:
                return True
            cur_node = cur_node.next
        return False

    def insert(self, key):
        if not self.find(key):
            self.__tail.next = ListNode(key)
            self.__tail = self.__tail.next
            return 1
        return 0

    def delete(self, key):
        cur_node = self.__head
        while cur_node.next:
            if cur_node.next.key == key:
                cur_node.next = cur_node.next.next
                return
            cur_node = cur_node.next

    def __iter__(self):
        self._cur_node = self.__head.next
        return self

    def __next__(self):
        if not self._cur_node:
            raise StopIteration()
        key = self._cur_node.key
        self._cur_node = self._cur_node.next
        return key


class HashSet:
    SCALE_FACTOR = 2
    SHRINKAGE_THRESHOLD = 4
    PRIME_NUMBER = (1 << 31) - 1
    def __init__(self, capacity=16):
        self.__arr = [HashSetLinkedList() for _ in range(capacity)]
        self.__capacity = capacity
        self.__num_items = 0
        self.__param1, self.__param2 = randint(0, self.PRIME_NUMBER - 1), randint(0,self.PRIME_NUMBER - 1)
    
    def __repr__(self):
        return "{" + ", ".join((str(key) if type(key) != str else "'" + key + "'") \
            for linked_list in self.__arr for key in linked_list) + "}"

    def __len__(self):
        return self.__num_items

    def _range_hash(self, prehashed_key):
        return (self.__param1 * prehashed_key + self.__param2) % self.__capacity

    def _resize(self, enlarge=True):
        if enlarge:
            self.__capacity *= self.SCALE_FACTOR
        else:
            self.__capacity //= self.SCALE_FACTOR
        new_arr = [HashSetLinkedList() for _ in range(self.__capacity)]
        for linked_list in self.__arr:
            for key in linked_list:
                new_idx = self._range_hash(hash(key))
                new_arr[new_idx].insert(key)
        self.__arr = new_arr

    def add(self, key):
        idx = self._range_hash(hash(key))
        self.__num_items += self.__arr[idx].insert(key)
        
        if self.__num_items == self.__capacity:
            self._resize(enlarge=True)

    def find(self, key):
        idx = self._range_hash(hash(key))
        return self.__arr[idx].find(key)

    def __contains__(self, key):
        return self.find(key)

    def discard(self, key):
        idx = self._range_hash(hash(key))
        self.__arr[idx].delete(key)
        self.__num_items -= 1
        
        
        if self.__num_items * self.SHRINKAGE_THRESHOLD <= self.__capacity:
            self._resize(enlarge=False)


N = int(finput())
d_list = [int(finput()) for _ in range(N)]

d_set = HashSet()
for d in d_list:
    d_set.add(d)


print(len(d_set))

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

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 += [int(input())]
d.sort()
count=1
for i in range(n-1):
    if d[i]<d[i+1]:
        count += 1
print(count)

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

Solution (Python):

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

L=list(set(L))
print(len(L))

Solution (Python):
N=int(input())
S=0
M=0
L=[]
for i in range(N) :
  L.append(int(input()))
L.sort()
for i in range(N) :
  if L[i]>M :
    S=S+1
    M=L[i]
print(S)

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

ans = len(set(ds))

print(ans)

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


print(len(set(D)))

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

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

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

Solution (Python):
N = int(input())
a_list = [input() for i in range(N)]
count = 0
for i in range(101):
  if str(i) in a_list:
    count += 1
print(count)

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

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

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

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(list(set([int(input()) for i in range(N)]))))

Solution (Python):
n=int(input())
d=[]
for i in range(n):
  d.append(int(input()))
d.sort(reverse=True)
cnt=1
for i in range(1,n):
  if d[i]<d[i-1]:
    cnt+=1
print(cnt)

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

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

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

D.sort(reverse=True)

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

print(ans)

Solution (Python):

n=int(raw_input())

ar=[]
mp={}

for i in range(n):
	k=int(raw_input())
	if k not in mp:
		ar.append(k)
		mp[k]=1

print(len(ar))

Solution (Python):
N = int(input())
print(len(set(map(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 = [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()))
ans = set(d)
print(len(ans))

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

Solution (Python):
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
d = [I() for i in range(N)]

print(len(set(d)))

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

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

for i in range(n):
	a.append(int(input())) 
           
while len(a) != 1:
	for i in range(a.count(max(a))):
		a.remove(max(a)) 
	c += 1
  
print(c)

Solution (Python):
N = int(input())
d = []
for i in range(0, N):
    d.append(int(input()))
l = list(set(d))
print("{}".format(len(l)))

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

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

Solution (Python):
import collections
n = int(input())
l = collections.Counter()
for i in range(n):
  a = int(input())
  l[a] += 1
l = list(l.most_common())
l.sort()
print(len(l))

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

Solution (Python):
T = int(input())
S = {0}
for i in range(1, T + 1):
    S.add(int(input()))
print(len(S)-1)

Solution (Python):
N = int(input())
Dn = []
for i in range(N):
    Dn.append(int(input()))
Dn.sort(reverse=True)
count_mochi = 1
for q in range (N-1):
    if Dn[q] != Dn[q+1]:
        count_mochi += 1

print(count_mochi)

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

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

Solution (Python):
def kagami_mochi(N: int, D: list)->int:
    return len(set(D))


if __name__ == "__main__":
    N = int(input())
    D = [int(input()) for _ in range(N)]
    ans = kagami_mochi(N, D)
    print(ans)

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

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

print(len(mochi_set))

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

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

print(len(list_set))

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

print(len(set(d)))

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

Solution (Python):

import sys

def main():
	N = int(input())
	
	mochi = []
	for i in range(N):
		tmp = int(input())
		mochi.append(tmp)
	
	new = list(set(mochi))
	new.sort()
	
	print(len(new))
	
		
if __name__ == "__main__":
	main()

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

Solution (Python):
n=int(input())
hoge=[]
for i in range(n):
  m=int(input())
  if(hoge.count(m)==0):
    hoge.append(m)
    
print(len(hoge))

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

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

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

mochi.sort(reverse=True)

for i in range(N-1):
    if i == 0:
        tmp = mochi[0]

    if tmp != mochi[i+1]:
        count += 1
        tmp = mochi[i+1]

print(count)

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

set_li = set(li)
print(len(set_li))

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

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

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

print(len(set(dn)))

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline()
def read(): return int(input())
def reads(): return [int(i) for i in input().split()]

N = read()
d = set([int(input()) for _ in range(N)])

print(len(d))

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

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

Solution (Python):

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

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    N = int(input())
    D = set()
    for _ in range(N):
        d = int(input())
        D.add(d)
    print(len(D))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
n = int(input())
l = [int(input()) for i in range(n)]
l.sort(reverse = True)
count = 1
for i in range(n-1):
    currMochi = l[i]
    if currMochi == l[i+1]:
        continue
    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())
dlist = []
for i in range(N):
    dlist.append(int(input()))
dbacket = [0]*101
for d in dlist:
    dbacket[d] += 1
answer = 0
for db in dbacket:
    if db > 0:
        answer += 1
print(answer)

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

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

N = int(input())
A = [int(input()) for _ in range(N)]
print(len(set(A)))

Solution (Python):
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())
array = []
for i in range(n):
    array.append(int(input()))
array = sorted(array)
under_mochi = array[-1]

cnt = 1
array_mochi = reversed(array[:-1])
for j in array_mochi:

    if under_mochi > j:
        cnt += 1
        under_mochi = j
print(cnt)

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

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

for i in range(N):
  d = int(input())
  D.append(d)
D = set(D)
D = list(D)
D.sort()
print(len(D))

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

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

cnt = 0
esc = 0
for i in input_list:
	if esc < i:
		cnt += 1
	esc = i
print(cnt)

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

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

cnt = 0
esc = 0
for i in input_list:
	if esc < i:
		cnt += 1
	esc = i
print(cnt)

Solution (Python):
N = input()

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

cnt = {s:(a.count(s)-1) for s in a}

print(int(N)-sum([int(j) for j in cnt.values()]))

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

d = list(set(d))

print(len(d))

Solution (Python):

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

Solution (Python):
from sys import stdin
n = int(stdin.readline().rstrip())
a = list(map(int, [stdin.readline().rstrip() for _ in range(n)]))

print(len(list(set(a))))

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

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

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

Solution (Python):
from sys import stdin
n = int(stdin.readline().rstrip())
data = [stdin.readline().rstrip() for _ in range(n)]
data = set([int(l) for l in data])
print(len(data))

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

d_set = list(set(d))

d_set.sort()

print(len(d_set))

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

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

Solution (Python):
n = int(input())
d = []
for i in range(n):
    d.append(int(input()))
d.sort()
buf = 0
count = 0
for i in range(n):
    if d[i] == buf:
        continue
    buf = d[i]
    count += 1
print(count)

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

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

s = np.array(a)
print(len(np.unique(s)))

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

print(len(d))

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

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

chk = 101
ret = 0
for i in range(len(d)):
    if d[i] < chk:
        chk = d[i]
        ret += 1
    elif d[i] > chk:
        break

print(ret)

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

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

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

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

Solution (Python):

"""
Created on Wed Feb 27 22:08:13 2019

@author: yuta
"""

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

def main(d):
    d_uniq = list(set(d))
    print(len(d_uniq))

main(d)

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

Solution (Python):
N = int(input())
d = sorted([input() for i in range(N)], reverse=True)
stages = 0
diameter = d[0]
for i in range(N):
    if i > 0:
        if diameter > d[i]:
            stages += 1
            diameter = d[i]
    else:
        stages += 1
print(stages)

Solution (Python):
print(len(set(open(0).readlines()[1:])))

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

ans = n
for i in range(n-1) :
    if D[i+1] == D[i] :
        ans -= 1
print(ans)

Solution (Python):
import numpy as np

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

print(len(np.unique(a)))

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

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

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

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

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

Solution (Python):
print(len(set(open(0).readlines()[1:])))

Solution (Python):
print(len(set(open(0).readlines()[1:])))

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

Solution (Python):

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


s_l=set(l)



ans=len(s_l)
print(ans)

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

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

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

Solution (Python):
n = int(input())
list = [int(input()) for i in range(n)]
check = 101
count = 0

list.sort(reverse=True)

for k in list:
    if k < check:
        count += 1
        check = k

print(count)

Solution (Python):
n = int(input())
list_original = [int(input()) for i in range(n)]
check = 101
count = 0

list = sorted(list_original, reverse=True)

for k in list:
    if k < check:
        count += 1
        check = k

print(count)

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

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

print( ans )

Solution (Python):
n = int(input())
list_original = [int(input()) for i in range(n)]
check = 101
count = 0

list_mid = sorted(list_original)
list = []

for j in range(1, n+1):
    list.append(list_mid[-j])

for k in list:
    if k < check:
        count += 1
        check = k

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

Solution (Python):
n = int(input())
m = [int(input()) for i in range(n)]
mso = sorted(m)
count = 0
for s in range(1,n):
  if mso[s] == mso[s-1]:
    count += 1
print(n-count)

Solution (Python):
N=int(input())
D=[int(input()) for _ in range(N)]
ans=0
dict={}
for d in D:
  dict[d]=1

for d in dict:
  ans+=1

print(ans)

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

X=0

for i in range(N):
    s=0
    for j in range(i):
       if d[i]==d[j]:
           s=1
    if s==0:
        X+=1

print(X)

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

arr.sort()
t=0
new=[]
for ii in arr:
    if t==0:
        new.append(ii)
        t+=1
        continue
    if arr[t-1]==ii:
        t+=1
        continue
    else:
        new.append(ii)
    t+=1
print(len(new))

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

L = set(L)

print(len(L))

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

Solution (Python):
n=int(input())
d=[]
for i in range(n):
    d.append(int(input()))
ans=0
for i in range(n):
    m=max(d)
    for _ in range(d.count(m)):
        d.remove(m)
    ans+=1
    if(len(d)==0):
        break
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 = [int(input()) for _ in range(N)]
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())
a = [input() for i in range(n)]
print(len(set(a)))

Solution (Python):
""" AtCoder """

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

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

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

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

s = set()

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

print(len(s))

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

N = int(input())
mochi_set = [input() for _ in range(N)]
print(len(set( mochi_set )))

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

N = int(input())
mochi_set = set()

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

print(len(mochi_set))

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

Solution (Python):
from sys import stdin
N=int(stdin.readline().rstrip())
a=[]
for i in range(N):
    a.append(int(input()))
print(len(set(a)))

Solution (Python):
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions

def j(q):
    if q==1: print("Yes")
    else:print("No")
    exit(0)


def ct(x,y):
    if (x>y):print("")
    elif (x<y): print("")
    else: print("")

def ip():
    return int(input())










n = ip()                      
a=[ip() for i in range(n)]    




print(len(set(a)))

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

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

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

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

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

Solution (Python):
N = int(input())
d = []
for _ in [0]*N:
    s = int(input())
    if s in d:
        continue
    else:
        d.append(s)
print(len(d))

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

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

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

print(len(d))

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

for i in range(N):
    D.add(input())

print(len(D))

Solution (Python):


n = int(input())

if n == 0:
    print('0')
    exit()

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


d_list.sort()
d_list.reverse()

cnt = 1
for i in range(1, len(d_list)):
    if d_list[i] != d_list[i - 1]:
       cnt += 1

print(cnt)

Solution (Python):
N = int(input())
d = {}

for _ in range(N):
    i = int(input())
    if i in d.keys():
        d[i] += 1
    else:
        d[i] = 1

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

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

l_unique = list(set(t))
print(len(l_unique))

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

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

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

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

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

    print(len(set(d)))

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

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

Solution (Python):
int_n = int(input())
int_array = []

for d in range(int_n):
    int_array.append(int(input()))

int_set = set(int_array)

print(len(int_set))

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

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

Solution (Python):


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

print(len(d_arr_omit))

Solution (Python):

N = int(input())

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

print(len(mochi))

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

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

Solution (Python):
n = int(input())
d = [0]*n
for i in range(n): d[i] = int(input())
d.sort()
d_max = 0
col = 0
for di in d:
    if d_max<di: 
        d_max = di
        col += 1
print(col)

Solution (Python):
inp = int(input())
g = []
for i in range(inp):
  m = input()
  if m in g:
    pass
  else:
    g.append(m)
print(len(g))

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

kagami = 0
while(len(mochi) is not 0):
    tmp = mochi[0]
    for i in range(len(mochi) - 1):
        if(mochi[i] < tmp):
            tmp = mochi[i]
    mochi = [i for i in mochi if i != tmp]
    kagami += 1
print(kagami)

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