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



Sample input:
4
10
8
8
6


Sample output:
3

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
mochi = set()
for i in range(n):
    mochi.add(int(input()))

print(len(mochi))

Submission status: Accepted

Solution code:
N = int(input())
mochis = [int(input()) for _ in range(N)]
mochis.sort()
count = 0
tmp = 0
for i in range(N):
    if mochis[i] != tmp:
        count += 1
        tmp = mochis[i]
print(count)

Submission status: Accepted

Solution code:
n=int(input())
l=[]

for i in range(n):
  a=int(input())
  l.append(a)
  
l.sort(reverse=True)

ans=1
for i in range(0,n-1):
  if l[i]==l[i+1]:
    continue
  else:
    ans+=1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
mochis = []
for i in range(N):
    s = int(input())
    if not s in mochis:
        #print(s in mochis)
        mochis.append(s)
print(len(mochis))

Submission status: Accepted

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

d_list_unique = list(set(d_list))
print(len(d_list_unique))

Submission status: Accepted

Solution code:
import numpy as np

N = int(input())
D = np.array([int(input()) for _ in range(N)])
print(len(np.unique(D)))

Submission status: Accepted

Solution code:
n=int(input())
li=[input() for i in range(n)]
li.sort()
ans=1
if n==1:
  print(1)
else:
  for i in range(n-1):
    if li[i+1] > li[i]:
      ans+=1
  print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(count)

Submission status: Accepted

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

def hantei(x):
  for j in range(x):
    if d[x] == d[j]:
      return(0)
  return(1)

count = 1
for i in range(1, N):
  count = count + hantei(i)
  
print(count)

Submission status: Accepted

Solution code:
N = int(input())
max = -9999
list_mochi = []
for i in range(N):
        d = int(input())
        list_mochi.append(d)
list_mochi.sort()
n = len(list_mochi)
X_mochi = []
for j in range(n):
        if max < list_mochi[j]:
                max = list_mochi[j]
                X_mochi.append(list_mochi[j])
print(len(X_mochi))

Submission status: Accepted

Solution code:
N = int(input())

ds = [None] * N

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

ans = len(set(ds))

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007

#A
def A():
    s = input()[4:]
    print("2018"+s)
    return

#B
def B():
    n = I()
    d = IR(n)
    d = list(set(d))
    print(len(d))
    return

#C
def C():
    n,y = LI()
    for i in range(n+1):
        for j in range(n+1-i):
            k = n-i-j
            if 10000*i+5000*j+1000*k == y:
                print(i,j,k)
                quit()
    print(-1,-1,-1)

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == "__main__":
    B()

Submission status: Accepted

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

Submission status: Accepted

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

d = list(set(d))
d = sorted(d, reverse = True)

print(len(d))

Submission status: Accepted

Solution code:
#kagami mochi
n = int(input())
a = []
count = 1
for i in range(n):
    a.append(int(input()))

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

print(len(d))

Submission status: Accepted

Solution code:
n=int(input())
print(sum({input():1for i in range(n)}.values()))

Submission status: Accepted

Solution code:
n=int(input())
d={input():1for i in range(n)}
print(sum(d.values()))

Submission status: Accepted

Solution code:
N=int(input())
S=[0]*N
for i in range(N):
    S[i]=int(input())
print(len(set(S)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
li = []
for i in range(n):
    num = int(input())
    if num not in li:
        li.append(num)
print(len(li))

Submission status: Accepted

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

print(len(set(d)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#085 B
N = int(input())
D = [int(input()) for i in range(N)]
print(len(list(set(D))))

Submission status: Accepted

Solution code:
size = 1
N = int(input())
d_s = []
for _ in range(N):
  d_s.append(int(input()))
d_s.sort()
d_s.reverse()
for i in range(1,N):
  if d_s[i] < d_s[i-1]:
    size += 1
print(size)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

data.sort(reverse=True)
data_temp = []
for i in range(len(data)-1):
    data_temp.append(data[i]-data[i+1])
    
res = 0
for i in range(len(data_temp)):
    if data_temp[i] != 0:
        res += 1
print(res+1)

Submission status: Accepted

Solution code:
N = int(input())
L = [input() for _ in range(N)]
def counter(array):
    from collections import Counter
    return list(Counter(array).most_common())
print(len(counter(L)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
n = int(input())
s = set()
for _ in range(n):
    d = int(input())
    s.add(d)

print(len(s))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import collections

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)])))

Submission status: Accepted

Solution code:


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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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


gusaku()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
from random import randint
# from typing import TypeVar, Tuple, List
finput = sys.stdin.readline



# K = TypeVar("K")

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)
        # Double the capacity.
        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
        # Halve the capacity when #items is less than or equal to 
        # the capacity / SHRINKAGE_THRESHOLD.
        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)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
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))

Submission status: Accepted

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

Submission status: Accepted

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

ans = len(set(ds))

print(ans)

Submission status: Accepted

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

#print(D)
print(len(set(D)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(len(mochi_set))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(len(set(dn)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#バケット法による解
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

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

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()]))

Submission status: Accepted

Solution code:
# coding: utf-8
N = int(input())
D = [int(input()) for _ in range(N)]
print(len(set(D)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())

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

d_set = list(set(d))

d_set.sort()

print(len(d_set))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(len(d))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#ABC085B
n=int(input())
l=[]
for i in range(n):
	l.append(input())
#set型のオブジェクトはコンストラクタset()でも生成できる。
#引数としてリストやタプルのようなイテラブルオブジェクトを指定すると、重複する要素が除外されて一意な値のみが要素となるsetオブジェクトが生成される。
s_l=set(l)
#s_l=sorted(s_l)
#set to list by sorted
#print(type(s_l))
ans=len(s_l)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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