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

"""AtCoder Beginner Contest 085: B - Kagami Mochi
https://atcoder.jp/contests/abc086/tasks/abc085_b
"""

__author__ = 'bugttle <bugttle@gmail.com>'


def main():
    N = int(input())

    array = set()
    for _ in range(N):
        d = int(input())
        array.add(d)

    print(len(array))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
A = set()
for _ in range(N):
  A.add(int(input()))
print(len(A))

Solution (Python):

"""AtCoder Beginner Contest 085: B - Kagami Mochi
https://atcoder.jp/contests/abc086/tasks/abc085_b
"""

__author__ = 'bugttle <bugttle@gmail.com>'


def main():
    N = int(input())

    array = set()
    for _ in range(N):
        d = int(input())
        array.add(d)

    print(len(array))


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
mochi = set()

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

Solution (Python):
D = sorted( [int(input()) for _ in range(int(input()) )])
dMax = max(D)
ans= 0
for i in range(1, dMax+1):
    if i in D:
        ans+=1
    
print(ans)

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

Solution (Python):
import sys

if __name__ == "__main__":
    args = sys.stdin.read().split()
    ricecakes_list = list(map(int, args[1:]))
    ricecakes_set = set(ricecakes_list)
    print(len(ricecakes_set))

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

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

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

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

Solution (Python):
n=int(input())
d=[int(input()) for x in range(n)]
d.sort()
c=0
for i in range(n-1):
  if d[i]==d[i+1]:c+=1
print(n-c)

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

print(len(D))

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

print(len(d))

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

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

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


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

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

print(count + 1)

Solution (Python):
N = int(input())
D = [0]
X = 0
for i in range(N):
  D.append(int(input()))
d = sorted(D, reverse=True)
for j in range(N):
  if d[j] > d[j+1]:
    X += 1
print(X)

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

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

if __name__ == '__main__':
    main()

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

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

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

print(len(set(d)))

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

Solution (Python):


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

Solution (Python):
number=input().rstrip()
number=int(number)
mochi=[input().rstrip() for i in range(number)]
mochi=list(map(int,mochi))
mochi.sort()

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

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

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

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

d = sorted(d, reverse=True)

tmp = 0
step = 0
for x in d:
    if tmp != x:
        step += 1
        tmp = x
    else:
        tmp = x
print(step)

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

mochi = []
for i in range(N):
    if mochi.count(d[i]) == 0:
        mochi.append(d[i])

print("{}".format(len(mochi)))

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

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

s= set()
for i in range(n):
    s.add(input())

print(len(s))

Solution (Python):
N=int(input())
L=[]
n=0

for i in range(N):
    L.append(int(input()))
    Lsort=sorted(L)


for j in range(N-1):
    if Lsort[j]==Lsort[j+1]:
        n-=1

print(N+n)

Solution (Python):
import sys
from itertools import groupby

def resolve():
    input = sys.stdin.readline
    N=int(input())
    d= sorted(list(map(int, [input() for _ in range(N)])),reverse=True)
    a=[]
    for key, group in groupby(d):
        a.append(key)  
    print(len(a))
    
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """4
10
8
8
6"""
        output = """3"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """3
15
15
15"""
        output = """1"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """7
50
30
50
100
50
80
30"""
        output = """4"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

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

dic = {}
for i in range(len(D)):
    dic[D[i]] = 1
print(len(dic))

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

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

D.sort()

front = D[0]
count = 1
for i in range(len(D)-1):
    if front < D[i+1]:
        count += 1
        front = D[i+1]
print(count)

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

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

Solution (Python):

n = int(input())
mochi = []
for _ in range(n):
    mochi.append(int(input()))

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

Solution (Python):

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

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d.sort()
cnt, cur = 0, 0
for i in d:
    if(i != cur):
        cur = i
        cnt += 1
print(cnt)

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

Solution (Python):
n = int(input())
d = sorted([int(input()) for _ in range(n)], reverse=True)

cont = 1
mochi = [0]

for i in d:
    if mochi[-1] > i:
        cont += 1
    mochi.append(i)

print(cont)

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

count = 0
pre = 101
for x in d:
    if pre > x:
        count += 1
        pre = x
    continue
print(count)

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

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

print(len(sorted(set(s))))

Solution (Python):
def read_values():
    return map(int, input().split())


def read_list():
    return list(read_values())


def main():
    N = int(input())
    S = set()
    for _ in range(N):
        S.add(int(input()))

    print(len(S))


if __name__ == "__main__":
    main()

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

a = set(a)
print(len(a))

Solution (Python):


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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
d = []
for _ in range(N):
    d.append(int(input()))
from collections import Counter
c = Counter(d)
print(len(c.keys()))

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

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 x in range(N)]

d = set(d)

print(len(d))

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

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

aSorted = sorted(a,reverse=True)

stackNum = 1 
for j in range(len(aSorted)):
  if j == len(aSorted)-1:
    break
  if aSorted[j] > aSorted[j+1]:
    stackNum += 1

print(stackNum)

Solution (Python):
import sys


def solve(inp):
    N = int(inp.readline())
    D = [int(inp.readline()) for i in range(N)]

    nums = {}
    for d in D:
        if d not in nums:
            nums[d] = 0
        nums[d] += 1

    r = 0
    for n in nums:
        if n > 0:
            r += 1

    return str(r)


def main():
    result = solve(sys.stdin)
    if result:
        print(result)


if __name__ == '__main__':
    main()

Solution (Python):
import sys


def solve(inp):
    N = int(inp.readline())
    D = sorted([int(inp.readline()) for i in range(N)])

    r = 0
    prev = 0
    for d in D:
        if d != prev:
            r += 1
            prev = d

    return str(r)


def main():
    result = solve(sys.stdin)
    if result:
        print(result)


if __name__ == '__main__':
    main()

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

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

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

print(len(set(ds)))

Solution (Python):
temp=input()
d=[]
for x in range(int(temp)):
  d.append(int(input()))
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):



def main():

    cake_count = int(input())
    own_cakes = []
    for _ in range(cake_count):
        own_cakes.append(int(input()))
    own_cakes = sorted(own_cakes, reverse=True)

    kagami_cakes = [own_cakes.pop(0)]
    for i, cake in enumerate(own_cakes):
        if cake < kagami_cakes[-1]:
            kagami_cakes.append(own_cakes[i])
        else:
            continue

    print(len(kagami_cakes))

    return 0


if __name__ == '__main__':
    main()

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

Solution (Python):


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




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

Solution (Python):

 
import math
import itertools
import sys
import copy
 



N = int(input())

d = []
for _ 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())
d = [int(input()) for j in range(N)]



d.sort(reverse=True)

current_mochi = 0
next_mochi = 0
counter = 0

for i,num in enumerate(d):
    next_mochi = num
    if i == 0:
        counter+=1
        current_mochi = num
    elif i + 1 == len(d):
        if current_mochi > next_mochi:
            counter+=1
            break
        else:
            break
    elif current_mochi > next_mochi:
        counter+=1
        current_mochi = num

print(counter)

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

Solution (Python):
n=int(input())
List=[int(input()) for i in range(n)]
List.sort()
count=1
for i in range(n-1): 
  if List[i]!=List[i+1]:
    count +=1
print(count)

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

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

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

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

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

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

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

print(len(d))

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

print(len(d1))

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

print(len(d))

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

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

print(ans)

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

count = 0
num_i = [0 for i in range(100)]

for i in d_i:
    num_i[i - 1] += 1

for i in range(100):
    if num_i[i] != 0:
        count += 1

print(count)

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

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

Solution (Python):
from collections import defaultdict

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

count = defaultdict(int)

for item in D:
    count[item] += 1
print(len(count.keys()))

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

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

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

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

Solution (Python):

n=int(input())
d=[int(input()) for i in range(n)]
d_set=set(d)
ans=len(d_set)
print(ans)

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

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

ds=sorted(d)
cnt=1
for i in range(N-1):
    if ds[i+1] > ds[i]:
        cnt +=1

print(cnt)

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


mochi = set()

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

print(len(mochi))

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


def main():
    sc = Scan()
    N = sc.intarr()[0]
    D = sc.intarr_ver(N)

    print(len(set(D)))


class Scan():

    def intarr(self):
        num_array = list(map(int, input().split()))
        return num_array

    def intarr_ver(self, n):
        return [int(input()) for _ in range(n)]

    def strarr(self):
        line = input()
        array = line.split(' ')
        array[-1] = array[-1].strip('\n')
        return array


def display(array):
    for a in range(len(array)):
        if len(array) - a != 1:
            print(array[a], end=' ')
        else:
            print(array[a])


def gcd(a, b):  
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):  
    return a * b // gcd(a, b)


main()

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

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

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

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

    mochi.append(input().strip())

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

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

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

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

new = list(set(lis))
print(len(new))

Solution (Python):
number_of_mochi = int(input())
mochies = set()

for _ in range(number_of_mochi):
    mochies.add(input())

print(len(mochies))

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

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

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

Solution (Python):
N = int(input())
A = [int(input()) for i in range(N)]
A.sort()
B = []
for i in range(N):
    B.append(i)
C = dict(zip(B,A))
if N == 1:
    x = 1
else:
    for i in range(N-1):
        if C[i] == C[i+1]:
            del C[i]
print(len(C))

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

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

num_list.sort(reverse = True)
result = 0

for i in range(N):
    if i == 0:
        result += 1
    else:
        if num_list[i] != num_list[i-1]:
            result += 1

print(result)

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

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

d_2 = sorted(d, reverse=True)
ans = 1
for i in range(1, n):
    if d_2[i] < d_2[i-1]:
        ans += 1
    else:
        continue

print(ans)

Solution (Python):
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

N = int(input())

A = [0] * N

for i in range(N):
    a = int(readline())
    A[i] = a

print(len(set(A)))

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

Solution (Python):
import sys

n, *d = map(int, sys.stdin.read().split())

def main():
    return len(set(d))

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

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

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

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

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

print(len(A))

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

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

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

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

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

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

Solution (Python):
from collections import Counter

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

print(len(Counter(L)))

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

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

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

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

x = sorted(x)
z = x[0]
y = 1
for i in x:
    if i > z:
        y += 1
        z = i
print(y)

Solution (Python):
import math

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

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

ans = 1

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

Newd = sorted(d)


for i in range(N-1):
    if Newd[i] < Newd[i+1]:
        ans = ans + 1
    elif Newd[i] == Newd[i+1]:
        ans = ans
    else:
        break

print(ans)

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

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

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

Solution (Python):

X = int(input())
d = []
cnt = 0
for _ in range(X):
    d.append(int(input()))

now_d = d.pop(d.index(max(d)))
cnt +=1
while(d):
    if now_d == max(d):
        now_d = d.pop(d.index(max(d)))
        continue
    else:
        now_d = d.pop(d.index(max(d)))
        cnt += 1
print(cnt)

Solution (Python):
N = int(input())
D = [int(input()) for i 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):
X=int(input())
d=[int(input()) for i in range(X)]
setd=set(d)
print(len(setd))

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

Solution (Python):
number_of_mochi = int(input())
mochies = set()

for _ in range(number_of_mochi):
    mochies.add(input())

print(len(mochies))

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

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

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

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

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

print(len(set(a)))

Solution (Python):
N = int(input())
num =[]
sum = 1
for i in range(N):
	num.append(int(input()))
num = sorted(num)
for i in range(1,N):
	if(num[i] > num[i-1]):
		sum+=1
print(sum)

Solution (Python):
num = int(input())
mochi_s = list()
for _ in range(num):
    mochi_s.append(int(input()))

print(len(set(mochi_s)))

Solution (Python):
n=int(input())
l=[]
for i in range(n):
  l.append(int(input()))
l=sorted(l)
ans=1
for i in range(1,n):
  if l[i-1]<l[i]:
    ans+=1
print(ans)

Solution (Python):

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

Solution (Python):
N, *d = map(int, open(0).read().split())
d = sorted(set(d), reverse=True)
print(len(d))

Solution (Python):
n=int(input())
a = sorted(list(map(int,[input() for i in range(n)])))
ans=0
for i in range(len(a)):
    if i==0: 
        ans+=1
    else : 
        if a[i]-a[i-1]>0:
            ans+=1
print(ans)

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

for i in range(1, N+1):
  d_dic[int(input())] = 0

print(len(d_dic))

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

Solution (Python):
N = int(input())
list_d = [0] * N

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

list_d.sort()

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

print(result_cnt)

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

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

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

Solution (Python):
N = int(input())
d = [int(input()) for i in range(N)]
d = sorted(d,reverse=True)
start = d[0]
ans=0
cnt=1
for i in range(1, N):
    x = d[i]
    if start<=x:
        continue
    else:
        cnt+=1
    start = x
ans=cnt
print(ans)

Solution (Python):

N = int(input())
Mochi = [int(input()) for _ in range(N)]
Mochi.sort()
K = 1
for i in range(N-1):
    if Mochi[i] < Mochi[i+1]:
        K += 1
print(K)

Solution (Python):
N = int(input())
li = [int(input()) for x in range(N)]
tmp = None
ans_li = list()
for i in sorted(li):
    if i != tmp:
        ans_li.append(i)
    tmp = i
print(len(ans_li))

Solution (Python):
n = int(input())
input_list = list(sorted([int(input()) for _ in range(n)]))

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

print(count)

Solution (Python):

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

Solution (Python):

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

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

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 = [int(input()) for _ in range(n)]
d.sort(reverse=True)
d = list(set(d))
print(len(d))

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

num = [0]*101
for i in range(n):
    num[d[i]] += 1

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

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

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

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

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

print(len(li))

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

Solution (Python):

import sys


def solve(N: int, d: "List[int]"):
    a = set(d)
    print(len(a))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    d = [int(next(tokens)) for _ in range(N)]  
    solve(N, d)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
n = int(input())
a = [0]*n
for i in range(n):
    a[i] = int(input())
a.sort(reverse = True)

s = set(a)
a_list = list(s)
print(len(a_list))

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

Solution (Python):




n = int(input())

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

li.sort()

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

print(cnt)

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

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

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

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

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

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

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

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

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

list.sort(reverse=True)

ans = 1

for j in range(n-1):

    if list[j] > list[j+1]:
        ans += 1

print(ans)

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

Solution (Python):


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


d_set = set(d)

print(len(d_set))

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

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

d = set(d)

ans = len(d)
print(ans)

Solution (Python):
from collections import Counter
N=int(input())
lists=set(int(input())for i in range (N))
m=str(len(lists))
print(m)

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):
print(len(set(input() for _ in range(int(input())))))

Solution (Python):


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

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

print(len(d))

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

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

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

ans = 1
ls = sorted(ls_d)

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

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

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

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

Solution (Python):
dbflag=""

def debug(*args):
	if ""!=dbflag: print(*args)

if ""!=dbflag: _INDATA=open(dbflag)

def readline():
	if ""!=dbflag:return _INDATA.readline()
	else: return input()


result = -1

N = int(readline())

bag = set()

for i in range(0,N):
	d = int(readline())
	bag.add(d)

result = len(bag)

print(result)

Solution (Python):

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

d.sort(reverse=True)
ret = 0
prev = 101
for i in range(len(d)):
  if (d[i] < prev):
    ret += 1
    prev = d[i]

print(ret)

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

Solution (Python):
import itertools

n = int(input())
D = []
for _ in range(n):
    D.append(int(input()))

D_set = set(D)
ans = len(D_set)
print(ans)

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

nums = []
for i in range(0,for_num):
  num = int(input())
  nums.append(num)
nums = set(nums)
print(len(nums))