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):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''

import numpy as np
def main2():
    stdin = open('/dev/stdin')
    N = int(stdin.readline())
    d = np.empty(N, dtype=np.int64)
    for i in range(N):
        d[i] = int(stdin.readline())
    print(len(np.unique(np.sort(d))))
'''

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

a = [input() for x in range(N)]

b = set(a)

print(len(b))

Solution (Python):


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





print(len(d))

Solution (Python):


N=int(input())
l=[]

for i in range(N):
    l.append(int(input()))
    
l=set(l)

print(len(l))

Solution (Python):
a = int(input())
b = list(int(input()) for i in range(a))

c = len(set(b))

print(c)

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

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

for i in d:
    if i not in res:
        res[i] = True

print(len(res))

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

Solution (Python):
import collections
N = int(input())
D = [input() for _ in range(N)]
print(len(collections.Counter(D)))

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

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

Solution (Python):
N = int(input())
L = [int(input()) for i in range(N)]
L.sort()
c = 0
for a in range(N):
    if a == 0 or L[a] > L[a - 1]:
        c = c + 1
    else:
        pass
print(c)

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

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

a.sort()

sum = 1
now = a[0]
for i in range(1,N):
    if now < a[i]:
        sum += 1
        now = a[i]

    elif now == a[i]:
        now = a[i]

    else:
        break

print(sum)

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

Solution (Python):
n = int(input())
d = sorted([int(input()) for _ in range(n)])
cnt = 1
for a, b in zip(d[1:], d):
    if a > b:
        cnt += 1
print(cnt)

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

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

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

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

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


if __name__ == "__main__":
    resolve()

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

print(len(nums))

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

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

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

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

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

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

print(len(set(D)))

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

Solution (Python):
import sys
N = int(sys.stdin.readline().rstrip())
d = [sys.stdin.readline().rstrip() for _ in range(N)]
print(len(set(d)))

Solution (Python):
from collections import defaultdict, Counter
from heapq import heapify, heappop, heappush
from sys import stdin

def main():
    n = int(input())
    A = []
    for _ in range(n):
        A.append(int(input()))
    A.sort(reverse=True)

    ans = 0
    now = 1000
    for i in range(n):
        if now > A[i]:
            ans += 1
            now = A[i]
    print(ans)

input = lambda: stdin.readline().rstrip()
main()

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

ans = len(Dset)

print(ans)

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

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

Solution (Python):
n = int(input())
nums = sorted([int(input()) for _ in range(n)])
count = 1
prev = nums[0]
for i in range(1, n):
    if nums[i] > prev:
        count += 1
        prev = nums[i]
print(count)

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

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

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

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

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

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

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

Solution (Python):
import math
import numpy as np













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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def main():
    N = int(input())
    d = set()
    for _ in range(N):
        d.add(int(input()))
    d = sorted(list(d))
    return len(d)
    

if __name__ == '__main__':
    print(main())

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

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

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

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

Solution (Python):
n = int(input())
li = []
for i in range(n):
    li.append(int(input()))
li.sort(reverse=True)
dan = 0
mae = 101
for l in li:
    if l < mae:
        mae = l
        dan += 1
print(dan)

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

Solution (Python):
n=int(input())
c=0
prev=0
r=sorted([int(input()) for i in range(n)])
for m in r:
    if prev!=m:
        c +=1
    prev=m
print(c)

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

ds.sort()
ans=1
for i in range(len(ds)-1):
  if ds[i]<ds[i+1]:
    ans+=1
    
print(ans)

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

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

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

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

d=sorted(d)
ans=1

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

print(ans)

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

num_dict = {}

for i in d_list:
    if i in num_dict:
        num_dict[i] += 1
    else:
        num_dict[i] = 1

print(len(num_dict))

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

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

Solution (Python):
n = int(input())
array = []
cnt = 0
for i in range(n):
    array.append(int(input()))
for i in range(n):
    if not array[i] in array[:i]:
        cnt += 1
print(cnt)

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

values = {}

for i in range(rows):
    values[input()] = 1

print(len(values))

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

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

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

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

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

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

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

d_sort = sorted(d, reverse=True)
d_uq = sorted(set(d), reverse=True)


print(len(d_uq))

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

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

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

Solution (Python):

n = int(input ())



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


d2 = sorted(d)


count=1
for i in range(n-1):
    if( d2[i] < d2[i+1] ):
        count += 1
        
print(count)

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

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

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

Solution (Python):



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

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


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

print(len(set(d)))

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

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

Solution (Python):
n,*d=list(map(int,open(0).read().split()))
print(len(set(d)))

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

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

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

list = []
count = 0

for i in range(n):
    if not(d[i] in list):
        count += 1
        list.append(d[i])

print(str(count))

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

print(len(set(a)))

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

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

Solution (Python):
import sys
from fractions import gcd
import bisect
 
stdin = sys.stdin
 
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
s = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

n = ni()
d = [ni() for _ in range(n)]

print(len(set(d)))

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

Solution (Python):
Num = int(input())
Num_Array = []
count = 0
result = 0

for i in range(Num):
    Num_Array.append(int(input()))
Num_Array.sort()

while count < Num:

    if Num_Array.count(Num_Array[count]) == 1:
        result += 1
    else:
        Num_Array.pop(count)
        count -= 1
        Num -= 1
    count += 1

print(result)

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

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 = list()
for n in range(N):
    d.append(int(input()))

print(len(set(d)))

Solution (Python):
N = int(input())
d = list()
for n in range(N):
    d.append(int(input()))
d = sorted(d, reverse=True)
ans = 1
for i, n in enumerate(d):
    if i == len(d) - 1:
        break
    if n > d[i + 1]:
        ans += 1
print(ans)

Solution (Python):

N = int(input())
d = [int(input()) for i in range(N)]
import numpy as np
size = np.zeros(101)
for i in range(N):
    size[d[i]] += 1
cnt = 0
for n in range(101):
    if size[n]:
        cnt += 1

print(cnt)

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

print(len(e))

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

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

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

num = list()
for i in range(N):
  num.append(int(input()))
  
num = set(num)

print(len(num))

Solution (Python):
n = int(input())
d = [int(input()) for _ in range(n)]
d = sorted(d, reverse=True)
cnt = 0
last = 10 ** 9
for i in d:
    if i < last:
        last = i
        cnt += 1
print(cnt)

Solution (Python):
N = int(input())
li = [int(input()) for i in range(N)]
box = [0] * 101
count = 0
for i in li:
  box[i] += 1
for i in box:
  if i > 0:
    count += 1
print(count)

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

Solution (Python):
_, *d = open(0).read().split()
print(len(set(d)))

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

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

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

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

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