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:
N = int(input())
s = [int(input()) for i in range(N)]
A = list(set(s))
A.sort(reverse=True)
print(len(A))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input()) 
d = [int(input()) for i in range(n)] 
k=0
c=0
for i in range(n):
  for j in range(n-i-1):
    if d[j] > d[j+1]:
      k = d[j]
      d[j] = d[j+1]
      d[j+1] = k
      
for i in range(n-1):
  if d[i]==d[i+1]:
    c=c+1
      
print(n-c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

sd = sorted(d)

val = None
cnt = 0
for i in range(N):
  if sd[i] != val:
    cnt += 1
    val = sd[i]

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

n = int(input())
d = [int(input()) for i in range(n)]
    
print(len(np.unique(d)))

Submission status: Accepted

Solution code:
import numpy as np

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

Submission status: Accepted

Solution code:
N = int(input())

mochi = {int(input()) for i in range(N)}

print(len(mochi))

Submission status: Accepted

Solution code:
N = int(input())
d = [None] * N

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

ans = len(set(d))

print(ans)

Submission status: Accepted

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

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:
# coding: utf-8
n = int(input())

set = {}
for i in range(n):
    set[input()] = 0
    
print(len(set.keys()))

Submission status: Accepted

Solution code:
n = int(input())
l = list(int(input()) for _ in range(n))
l.sort()
nl = []
count = 0
for i in range(len(l)):
    if l[i] in nl:
        pass
    else:
        nl.append(l[i])
        count += 1

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

ans = len(l)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a = int(input())  # Nを取得
b = []  
for i in range(a):  # b1,b2...bnを取得
    b.append(input())
c = set(b)  # 重複を削除
print(len(c))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a = int(input())
b = []
for i in range(a):
    b.append(int(input()))

c = [0] * (100+1)
for i in b:
    c[i] = i

d = []
for g in c:
    if g != 0:
        d.append(g)

print(len(d))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())
a=[int(input()) for _ in range(n)]
a.sort(reverse=True)
d=[101,]
for i in a:
    if i<d[-1]:
        d.append(i)
print(len(d)-1)

Submission status: Accepted

Solution code:
from sys import stdin
from itertools import combinations
from math import factorial
import numpy as np
import math

n = int(stdin.readline().rstrip())

li = [int(stdin.readline().rstrip()) for _ in range(n)]

li = list(set(li))

print(len(li))

Submission status: Accepted

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

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:
def main(n: int, d: list):
    d = set(d)
    print(len(d))


if __name__ == "__main__":
    n = int(input())
    d = [int(input()) for _ in range(n)]

    main(n, d)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N=int(input())
Mochi=set(int(input()) for _ in range(N))
# Mochi=[]
# for i in range(N):
#     tmp=int(input())
#     if not tmp in Mochi:
#         Mochi.append(tmp)
print(len(Mochi))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from bisect import bisect_left
import heapq

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
d = [INT() for _ in range(N)]

print(len(set(d)))

Submission status: Accepted

Solution code:
def examB():
    N = I()
    A = [I() for _ in range(N)]
    d = defaultdict(int)
    for i in A:
        d[i] +=1
    ans = len(d)
    print(ans)

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examB()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
N = int(input())

d = set()
d_add = d.add

for i in range(N):
    d_add(int(input()))

print(len(d))

Submission status: Accepted

Solution code:
N = int(input())
L = []
for i in range(N):
    a = int(input())
    L.append(a)
L = sorted(L)
ans = 0
cnt = 0
for i in L:
    if(i > cnt):
        cnt = i
        ans += 1
print(ans)

Submission status: Accepted

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

ans = 0
maxd = 101

for i in range(N):
    if max(d) < maxd:
        ans += 1        
    maxd = max(d)
    d.remove(maxd)

print(ans)

Submission status: Accepted

Solution code:
def nyu():
    num1 = input()
    num1 = int(num1)
    #num2 = int(num2)
    return num1

def nyu2(n):
    tmp =[]
    for i in range(n):
        tmp.append(int(input()))
    return tmp

def sort(mochi):
    tmp_mochi = 0
    for i in range(n):
        for k in range(n):
            if mochi[i]>mochi[k] :
                tmp_mochi = mochi[i]
                mochi[i] = mochi[k]
                mochi[k] = tmp_mochi
    return mochi

def check(mochi):
    max =101
    cnt =0

    for i in range(n):
        if max>mochi[i]:
            max = mochi[i]
            cnt +=1
    return cnt

n=nyu()
mochi = nyu2(n)
mochi = sort(mochi)
print(check(mochi))

Submission status: Accepted

Solution code:
N = int(input())

rice_cakes = sorted([int(input()) for i in range(N)], reverse=True)

counter = 0

minimum_size = rice_cakes[0] + 1

for cake in rice_cakes:
    if cake < minimum_size:
        counter += 1
        minimum_size = cake

print(counter)

Submission status: Accepted

Solution code:
import collections
import math
import numpy as np

# A = input()
# A = int(input())
# A = map(int, input().split())
# A = list(map(int, input().split()))
# A = [int(input()) for i in range(N)]
#
# c = collections.Counter()

N = int(input())
d = [int(input()) for i in range(N)]
print(len(collections.Counter(d)))

Submission status: Accepted

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

print(len(d))

Submission status: Accepted

Solution code:
count = 1
num = int(input())
l = [int(input()) for i in range(num)]
l.sort(reverse=True)
for i in range(num-1):  
  if l[i] > l[i+1]:
    count += 1
print(count)

Submission status: Accepted

Solution code:
def mochi(d):
    d.sort(reverse=True)
    before = 101
    cnt = 0
    for n in d:
        if n >= before:
            continue
        before = n
        cnt += 1
    return cnt

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# python3 (3.4.3)
import sys
input = sys.stdin.readline

# main
from collections import Counter
N = int(input())
D = [int(input()) for _ in range(N)]

print(len(Counter(D).values()))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# ABC 085: B – Kagami Mochi
n = int(input())
d = [int(input()) for _ in range(n)]

kagami_mochi = set(d)

print(len(kagami_mochi))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
d = sorted(list([int(input()) for _ in range(N)]), reverse = True)

now = max(d)
ans = 1

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
n=int(input())
d=[]
for i in range(n):
    d.append(int(input()))
d.sort(reverse=True)
e=set(d)
print(len(e))

Submission status: Accepted

Solution code:
N = int(input())

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

print(len(d))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

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

main()

Submission status: Accepted

Solution code:
N = int(input())
A = [int(input()) for i in range(N)]
A.sort(reverse=True)
count = 0

m = set(A)
        
print(len(m))

Submission status: Accepted

Solution code:
N = int(input())
A = [int(input()) for i in range(N)]
A.sort(reverse=True)
count = 0

for i in range(N):
    for j in range(i+1,N):
        if A[i] == A[j] and A[i]!=0:
            A[j] = 0
            count += 1
        
print(len(A)-count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())

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

print(len(li))

Submission status: Accepted

Solution code:
n = int(input())
a = []
for i in range(1, n+1):
    a.append(int(input()))

a = sorted(a, reverse=True)
top = max(a)
ans = 1

for d in a:
    if d < top:
        top = d
        ans += 1
print(ans)

Submission status: Accepted

Solution code:
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

n = inp()
a = inpln(n)
print(len(set(a)))

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
N=int(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import Counter
N = int(input())
dlist = Counter([int(input()) for _ in range(N)])
print(len(dlist.items()))

Submission status: Accepted

Solution code:
# coding: utf-8

n = int(input())
d = list(set([input().rstrip() for i in range(n)]))
print(len(d))

Submission status: Accepted

Solution code:

N = int(input())
#入力された文字をN回読み込む
d = [input() for i in  range(N)]
#リストを集合（重複なし）に変換
print(len(set(d)))

Submission status: Accepted

Solution code:
import sys
# import collections
# import math
# import string
# import bisect
# import re
# import itertools
# import statistics

def main():
    n, *d = (int(x) for x in sys.stdin.read().split())
    print(len(set(d)))


if __name__ == "__main__":
    # execute only if run as a script
    main()

Submission status: Accepted

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

main()

Submission status: Accepted

Solution code:
N =int(input())
d = sorted([int(input()) for i in range(N)], reverse=True)
C =0
for i in range(1, N):
    if d[i] < d[i-1]:
        C +=1
print(C+1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding=utf-8

if __name__ == '__main__':
    N = int(input())
    d = []

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

    d.sort()
    cnt = 0

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

    print(N - cnt)

Submission status: Accepted

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

t = set(ld)

print(len(t))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
di = list(int(input()) for i in range(n))

from collections import Counter
counter = Counter(di)
ans = len(counter)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
A = []
for j in range(N):
  A +=[input()]
A.sort()
k=[A[0]]
for i in range(1,N):
  if A[i]>A[i-1]:
    k += [A[i]]
print(len(k))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
li = list()
for _ in range(n):
    li.append(int(input()))

li.sort()
ans = 0

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

print(ans + 1)

Submission status: Accepted

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

print(len(set(list_d)))

Submission status: Accepted

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

Submission status: Accepted

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

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

d_s = set(d)

print(len(d_s))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
d_list = list()
for _ in range(N):
  d = int(input())
  d_list.append(d)
d_list.sort(reverse=True)

count = 1

for i, num in enumerate(d_list):
  target = i + 1
  if target == len(d_list):
    break
  if num > d_list[target]:
    count += 1
print(count)

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())
d = sorted([int(input()) for i in range(N)],reverse = 1)
count = 1
for i in range(len(d)-1):
    if d[i] > d[i+1]:
        count += 1
print(count)

Submission status: Accepted

Solution code:
n = int(input())
a = [int(input()) for i in range(n)]
a = sorted(a, reverse=True)
ans =1
for i in range(n - 1):
    if a[i] != a[i+1]:
        ans += 1
print(ans)

Submission status: Accepted

Solution code:
n = int(input())

a = [int(input()) for i in range(n)]
a = sorted(a,reverse=True)

ans=1

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

print(ans)

Submission status: Accepted

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

print(len(set(d)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
x = int(input())
y = [int(input()) for i in range(x)]

y.sort(reverse=True)

def fun(y):
  tmp = y[0]
  ans = 1
  for i in y[1:]:
    if tmp > i:
      ans += 1
      tmp = i
    else:
      pass
  return ans
    
print(fun(y))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
d_list = []

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

d_list.sort()
tmp_d = -1
mochi_count = 0
for i in range(N):
    if tmp_d == d_list[i]:
        continue
    else:
        tmp_d = d_list[i]
        mochi_count += 1

print(mochi_count)

Submission status: Accepted

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

# num[i] は iの出現回数を示す。配列numを初期化
num = [0] * 101
# 最大の段数をカウント
count = 0

for i in range(N):
    num[d[i]] += 1

for i in range(101):
    if num[i] > 0:
        count += 1

print(count)

Submission status: Accepted

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

# dを降順にソート
d.sort(reverse=True)

# 段数をカウント(1段からスタート)
count = 1

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

print(count)

Submission status: Accepted

Solution code:
N = int(input())
motis = []
for i in range(N):
    motis.append(int(input()))
motis.sort(reverse=True)

count = []
for i in range(N):
    tmp = motis[i]
    if tmp not in count:
        count.append(tmp)
print(len(count))

Submission status: Accepted

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

print(len(set(d)))

Submission status: Accepted

Solution code:
N = int(input())
D = [int(input()) for i 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(input())
D = [int(input()) for _ in range(N)]

from collections import Counter
C = list(Counter(D).most_common())
print(len(C))

Submission status: Accepted

Solution code:
n, *d = map(int, open(0).read().split())

d.sort()

ans = 0
scale = 0
for i in d:
    if scale < i:
        ans += 1
    scale = i

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

#chexk
#print(d)

#sorting
for i in range(N-1):
  for j in range(N-1-i): #昇順にしたい
    if (d[j] > d[j+1]): #要素i が 要素i+1 より大きい ので入れ替え
      temp = d[j]
      d[j] = d[j+1]
      d[j+1] = temp
  #check
  #print(d)

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

#b = int(input())
#N,A,B = map(int,input().split())
#judge
 
print(count)
#print('result')
#print('Count = '+str(count))
#print('Bob = '+str(Bob))
#print('Alice-Bob = '+str(Alice-Bob))
#print(Alice-Bob)
#output

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
bkt = []
for _ in range(n):
  s = int(input())
  if s not in bkt:
    bkt.append(s)
print(len(bkt))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import bisect
n = int(input())
ls = []
for i in range(n):
  bisect.insort(ls, int(input()))

layer = 1
current = ls[0]
for i in range(n):
  if current != ls[i]:
    layer += 1
    current = ls[i]
  
print(layer)

Submission status: Accepted

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

ls.sort()
layer = 1
current = ls[0]
for i in range(n):
  if current != ls[i]:
    layer += 1
    current = ls[i]
  
print(layer)

Submission status: Accepted

Solution code:
n = int(input())

print(len({input() for i in range(n)}))

Submission status: Accepted

Solution code:
n=int(input())
dic={}
for i in range(n):
    d=int(input())
    dic[d]=True
print(len(dic))

Submission status: Accepted

Solution code:
n=int(input())
d=sorted(list(map(int,[input() for i in range(n)])),reverse=True)
ans=1
for j in range(len(d)-1):
    if d[j+1] < d[j]:
        ans +=1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())
d=list(int(input()) for i in range(n))
d.sort()
count=1
for i in range(1,len(d)):
  if d[i-1]!=d[i]:
    count+=1
print(count)

Submission status: Accepted

Solution code:
n = int(input())

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

deduplicate = set(d)

print(len(deduplicate))

Submission status: Accepted

Solution code:
n=int(input())
k=sorted({input() for i in range(n)})
print(len(k))

Submission status: Accepted

Solution code:
N = int(input())
Set = set()
for i in range(N):
    x = int(input())
    Set.add(x)

print(len(Set))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

for i in range(n):
    d.append(int(input()))
count = 0
d.sort()
temp = -1
for index, item in enumerate(d):
    if temp != item:
        count += 1
    temp = item
print(count)

Submission status: Accepted

Solution code:
N = int(input())
ret = {}
for n in range(N):
    d = int(input())
    if not d in ret:
        ret[d] = d
print(len(ret))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
d = tuple(int(input()) for _ in range(n))
print(len(set(d)))

Submission status: Accepted

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

moti_list.sort(reverse=True)

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

print(count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

ans = 1
D.sort()
temp = D[0]
for i in range(1, N):
    if D[i] > temp:
        ans += 1
        temp = D[i]
        
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
d_list=[]

for i in range(N):
  d_list.append(int(input()))
  
set_d = set(d_list)
print(len(set_d))

Submission status: Accepted

Solution code:
n=int(input())
list1=[]
for i in range(n):
  i=int(input())
  list1.append(i)
#int(input()) for _ in range(n)
set1=set(list1)
len1=len(set1)
print(len1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(len(ds))

Submission status: Accepted

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

cnt = 0
j = 0
for i in d:
  if j==i:
    cnt += 1
  j = i
  
print(n-cnt)

Submission status: Accepted

Solution code:
N=int(input())
d=[]
for n in range(N):
  x=int(input())
  d.append(x)
ans=sorted(set(d), key=d.index)
print(len(ans))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

print(len(set(d)))

Submission status: Accepted

Solution code:
n = int(input())
d = [0]*n
for i in range(n):
  d[i] = int(input())
d.sort(reverse = True)
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())
a = sorted(map(int, [input() for i in range(N)]), reverse=True)

dan = 1

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

print(dan)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

if N == 1:
	print(1)
	sys.exit()
A = sorted(A, reverse = True)

t = A[0]
cnt = 1
for i in range(1,N):
	if A[i] < t:
		cnt += 1
		t = A[i]
	
print(cnt)

Submission status: Accepted

Solution code:
n = int(input())

s = [int(input()) for _ in range(n)]
s = list(set(s))

print(len(s))

Submission status: Accepted

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

for i in range(N):
    D += [input()]

print(len(set(D)))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
num_list = []

n = int(input())

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

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


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N=int(input())
d=[int(input()) for i in range(N)]
import collections
table=collections.defaultdict(int)
for i in range(N):
  table[d[i]]+=1
print(len(table.values()))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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