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

def count(list, target_index = None):
    dict = {}
    if target_index == None:
        for i in range(len(list)):
            dict[list[i]] = dict.get(list[i], 0) + 1
    if target_index != None:
        for i in range(len(list)):
            dict[list[i][target_index]] = dict.get(list[i][target_index], 0) + 1
    return dict


def input_int_list(n):
    list = [0]*n
    for i in range(n):
        list[i] = int(input())
    return list

num = int(input())
discs = input_int_list(num)

print(str(len(count(discs))))

Solution (Python):
import collections

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

ans = collections.Counter(d)
print(len(ans))

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

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

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

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

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

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

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

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

Solution (Python):
import math
N=int(input())
array = [0]*N
for i in range(N):
    array[i]=int(input())
array=sorted(array)
max=array[N-1]+1
bucket=[0]*(max+1)
for val in array:
    bucket[val]=bucket[val]+1
s=0
for i in range(max+1):
    if bucket[i]>0:
        s=s+1
print(s)

Solution (Python):









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

print(len(set(d)))

Solution (Python):









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

d.sort(reverse=True)

last = 101
ans = 0

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

print(ans)

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

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

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

Solution (Python):
n=int(input())
d=[int(input())for i in range(n)]
num=[0 for i in range(max(d)+1)]
for i in d:
    num[i]+=1
ans=len(num)-num.count(0)
print(ans)

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

n,*d=map(int,read().split())
d.sort()
print(sum(x<y for x,y in zip(d,d[1:]))+1)

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

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

for _ in range(n):
    list.append(int(input()))

print(len(set(list)))

Solution (Python):

N = int(input())

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

j = N
for i in range(1,101):
    k = dn.count(i)
    if k >= 2:
        j = j - (k - 1)
print(j)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N = int(readline())
    A = list(int(readline()) for _ in range(N))
    print(len(set(A)))


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

Solution (Python):
N=int(input())
A=[int(input()) for i in range(N)]
B=[]
while len(A)!=0:
  if A[0] not in B:
    B.append(A[0])
  A.pop(0)
print(len(B))

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

print(len(R))

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

print(len(set(a)))

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

Solution (Python):
N  = int(input())
num = list(map(int, (input() for h in range(N))))
num.sort()
count = 1

for i in range(N-1):
    if not num[i] == num[i+1]:
        count += 1
print(count)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *D = map(int, read().split())

    print(len(set(D)))

    return


if __name__ == '__main__':
    main()

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

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

size_dict = {}

for x in X:
    size_dict[x] = 1

ans = len(size_dict.keys())

print(ans)

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

Solution (Python):

N,*list1=open(0).read().split()

N=int(N)

list1=[int(i) for i in list1]





print(len(set(list1)))

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

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

Solution (Python):
L=list()
N=int(input())
for i in range(N):
  n=int(input())
  if n not in L:
    L.append(n)
print(len(L))

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

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

print(len(set(d)))

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

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

ans = len(set(d))

print(ans)

Solution (Python):
x = int(input())
D = []
for i in range(x):
    d = int(input())
    D.append(d)
k = []
count = 1
d = max(D)
k.append(d)
D.remove(d)
for j in range(x-1):
    c = max(D)
    if c < d:
        k.append(c)
        d = c
        count += 1
    D.remove(c)

print(count)

Solution (Python):
n = int(input())
d = [0] * n
ans = 1
for i in range(n):
    d[i] = int(input())
d.sort()
for i in range(1, n):
    if d[i - 1] == d[i]:
        continue
    else:
        ans += 1
print(ans)

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 i in range(N)]
num = [0]*101  
for i in range(N):
	num[a[i]] += 1

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

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

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

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

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

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

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

ans = len(set(d))

print(ans)

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

Solution (Python):
n,*aa = map(int, open(0).read().split())

aa = set(aa)

print(len(aa))

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

for _ in range(N):
  D = int(input())
  li[D] = 1
  
print(sum(li))

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

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

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

d.sort()

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

print(count)

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

Solution (Python):
N = int(input())
a=[0]*N
count=1

for i in range(N):
    a[i]=int(input())
a.sort()
for i in range(N-1):
    if a[i] != a[i+1]:
        count = count + 1
print(count)

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

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

kakagamimochi_list=list(set(mochi_list))
print(len(kakagamimochi_list))

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

print(len(set(d)))

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

d.sort(reverse=True)

ans = 0
tmp = 100000
for i in range(N):
    if d[i]<tmp:
        ans+=1
        tmp=d[i]
print(ans)

Solution (Python):
def main():
    N = int(input())
    d = []
    for i in range(N):
        d.append(int(input()))
    d.sort()
    d.reverse()
    t = 101
    cnt = 0
    for i in range(len(d)):
        if t > d[i]:
            t = d[i]
            cnt += 1
    print(cnt)
main()

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

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

for i in range(N):
    d = int(input())
    S.add(d)

print(len(S))

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

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

print(len(d_set))

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

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

mochi_unique = list(set(mochi_list))

print(len(mochi_unique))

Solution (Python):
N = int(input())
D = {}
for i in range(N):
  d = int(input())
  D[d] = 1
print(len(D))

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

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

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

Solution (Python):
N = int(input())
d = []
d.append(int(input()))
a = 1
for _ in range(N-1):
    i = int(input())
    w = True
    for j in range(a):
        if i == d[j]:
            w = False
    if w:
        d.append(i)
        a += 1
print(a)

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

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

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

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

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

print(len(set(mochies)))

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

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

print(sum([min(set(mochies)) < i for i in set(mochies)])+1)

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

print(len(set(D)))

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

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
d = []
for i in range(n):
    d.append(int(stdin.readline().rstrip()))

print (len(set(d)))

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

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

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

sets = set(lists)
print(len(sets))

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

Solution (Python):
n = int(input())
d = sorted(list(int(input()) for _ in range(n)))[::-1]
ans = [d[0]]

for i in d[1:]:
    if ans[-1] > i:
        ans.append(i)
print(len(ans))

Solution (Python):
N = int(input())
D = sorted([int(input()) for _ in range(N)],reverse=True)
d = D[0]
cnt = 1
for i in range(1,N):
    if D[i]<d:
        cnt += 1
        d = D[i]
print(cnt)

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate 

from collections import deque,defaultdict,Counter
import decimal
import re












import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
n = I()
A = [I() for i in range(n)]
print(len(list(set(A))))

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

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


def solve():

    return len(set(d))


print(solve())

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

Solution (Python):
N=int(input())
ls=[int(input()) for i in range(N)]
ls=sorted(ls,reverse=True)
A=0
i=0
while i<N-1:
  if ls[i]==ls[i+1]:
    A=A+1
  i=i+1
print(N-A)

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


def main():
    N = int(input())
    mochi = set()
    for _ in range(N):
        d = int(input())
        mochi.add(d)
    print(len(mochi))


if __name__ == "__main__":
    main()

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

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

def unique(collection):
    result = []
    return [x for x in collection if x not in result and not result.append(x)]

print(len(unique(L)), flush=True)

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


nums_unique = list(set(string_list))
print(len(nums_unique))

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

mochies = []

for i in range(n):
    p = input()
    q = int(p)
    mochies.append(q)

mochies.sort()

count = 1

for i in range(len(mochies)):
    if i + 1 == len(mochies):
        break
    if mochies[i] < mochies[i + 1]:
        count += 1
    else:
        continue
    
print(count)

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
    n = int(input())
    d = set(map(int, readlines()))
    print(len(d))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
n = int(input())
d = []
while n:
    d.append(int(input()))
    n -= 1

d.sort()
before_d = 0
count = 0
for d_temp in d:
    if before_d < d_temp:
        before_d = d_temp
        count += 1

print("{}".format(count))

Solution (Python):
N = int(input())
ans = 0
D=[]
for i in range(N):
    D.append(int(input()))
num=[0]*110
for i in range(N):
    
    num[D[i]]+= 1
    
for i in range(110):
    if num[i] > 0:
        ans += 1
print(ans)

Solution (Python):


n = int(input())

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

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

Solution (Python):
n = int(input())
d = [0] * 101
for i in range(0, n):
    inp = int(input())
    d[inp] += 1

count = 0
for i in d:
    if i > 0:
        count += 1
print(count)

Solution (Python):

import sys
sys.setrecursionlimit(10 ** 5)
input = sys.stdin.readline
mod = 1000000007
inf = float("INF")
def I(): return int(input().rstrip())
def IR(n): return [I() for _ in range(n)]
def LI(): return list(map(int, input().rstrip().split()))
def LIR(n): return [LI() for _ in range(n)]
def LI_(): return list(map(lambda x: int(x) - 1, input().rstrip().split()))
def LIR_(n): return [LI_() for _ in range(n)]
def F(): return float(input().rstrip())
def FR(n): return [F() for _ in range(n)]
def LF(): return list(map(float, input().rstrip().split()))
def LFR(n): return [LI() for _ in range(n)]
def S(): return input().rstrip()
def SR(n): return [S() for _ in range(n)]
def LS(): return list(sys.stdin.readline().rstrip().split())
def LSR(n): return [LS() for _ in range(n)]


n = I()
d = IR(n)
print(len(set(d)))

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

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

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

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

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

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

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

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

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

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

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

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

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

print(len(set(d)))

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

a.sort()
x = 0


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

Solution (Python):
N = int(input())
l = list()
for i in range(N):
    l.append(int(input()))

print(len(set(l)))

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

for i in range(n):
    input_list.append(int(input()))

sorted_list = sorted(input_list)

unique_list = set(sorted_list)

print(unique_list.__len__())

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

Solution (Python):

N = int(input())

S = set()
for i in range(N):
  d = int(input())
  S.add(d)

print(len(S))

Solution (Python):







__giturl__ = "$URL$"


from sys import stdin
input = stdin.readline


def main():
  N = int(input())
  D = [int(input()) for _ in range(N)]

  print(len(set(D)))


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

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



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

Solution (Python):
n = int(input())
d=[]
b=[]
cnt=0
for i in range(n):
    a = int(input())
    d.append(a)
for i in range(101):
    b.append(0)
for i in d:
    if b[i]==0:
        b[i]=i
        cnt+=1

print(cnt)

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

print(len(set(d)))

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

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

print(len(set(keep)))

Solution (Python):


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

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

d = set(d)

print(len(d))

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

Solution (Python):
n = int(input())
int_list = sorted([int(input()) for i in range(n)],reverse=True)
count = 1
i= 0
while i + 1 < len(int_list) :
    if int_list[i] > int_list[i + 1]:
        count += 1
    i += 1 
print(count)

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

print(len(syu))

Solution (Python):
n = int(input())
d = [int(input()) for i in range(n)]
num = [0] * 110
count = 0
for i in range(len(d)):
    num[d[i]]+= 1
for j in num:
    if j >= 1:
        count += 1
print(count)

Solution (Python):
n = int(input())
int_list = sorted([int(input()) for i in range(n)],reverse=True)
count = 1
i= 0
while i + 1 < len(int_list) :
    if int_list[i] > int_list[i + 1]:
        count += 1
    i += 1 
print(count)

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

print(len(D))

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

Solution (Python):
n=int(input())
a=sorted([int(input()) for i in range(n)])
res=1
for i in range(1,n):
    if a[i-1]<a[i]:res+=1
print(res)

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

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

Solution (Python):
n=int(input())
a=[]
e=1
for i in range(n):
  a.append(int(input()))
a.sort()
s=a.pop(0)
while a:
  k=a.pop(0)
  if s < k:
    e+=1
    s=k
print(e)

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

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

Solution (Python):


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

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

Solution (Python):

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

print(len(set(d)))

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

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

Solution (Python):
N = int(input())
d = list(set([int(input()) for n 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(input() for _ in range(n))))

Solution (Python):
def main():
    N = int(input())
    diameters = [int(input()) for x in range(N)]
    unique = list(dict.fromkeys(diameters))
    print(len(unique))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
N = int(input())
a = []
for i in range(N):
  a.append(int(input()))
a.sort()
count = 1
j = 0
while j < N-1:
  if a[j] != a[j+1]:
    count += 1
  j += 1
print(count)

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

strlist = [input() for i in range(n)]
intlist = [int(x) for x in strlist]
sortlist = sorted(intlist)

temp = 0
ans = 0

for d in sortlist:
  if int(d) > temp:
    temp = int(d)
    ans += 1

print(ans)

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

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

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

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

Solution (Python):
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt, gcd
from copy import deepcopy
from functools import reduce



def main():
    n = int(input())
    x_list = []
    for i in range(n):
        x = int(input())
        x_list.append(x)

    l = list(set(x_list))
    print(len(l))


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
d = [0]*n

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

ans = 0

i = 0
while True:
  if i == n-1:
    break
  if d[i] != d[i+1]:
    ans += 1
    i += 1
  else:
    if max(d) == d[i]:
      break
    else:
      i += 1
print(ans+1)

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

Solution (Python):

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


cnt = 0
while len(D) > 0:
    max_d = max(D)
    D = [d for d in D if d < max_d]
    cnt += 1

print(cnt)

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)}
print(len(d))

Solution (Python):
from collections import defaultdict

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

dict = defaultdict(int)
for i in d:
    dict[i] += 1
print(len(dict))

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

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

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

d_set=set(d_list)

print(len(d_set))

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

answer = len(dictionary)
print(answer)

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

print(len(l))

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

Solution (Python):
def actual(N, D):
    
    bucket = dict()

    for num in D:
        if num in bucket.keys():
            bucket[num] += 1
        else:
            bucket[num] = 1

    return len(bucket)

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

print(actual(N, D))

Solution (Python):
def actual(N, D):
    return len(set(D))

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

print(actual(N, D))

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

print(len(lis))

Solution (Python):










import sys

def input(): return sys.stdin.readline()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


N = iIn()
D = iInLV(N)

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

Solution (Python):
import sys
N = int(input())
array = []
for I in range(N):
    array.append(int(input()))

if not ( 1 <= N <= 100 ):
    sys.exit()
for J in range(len(array)):
    if not ( 1 <= array[J] <= 100 ):
        sys.exit()

print(len(set(array)))

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

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

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

Solution (Python):






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

ds = sorted(ds, reverse=True)
es = [ds.pop(0)]

for d in ds:
    if d < es[-1]: es.append(d)

print(len(es))

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

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

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

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

print(len(set(L)))

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

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

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

for i in range(n):
  if d[i] not in d_:
    d_[i] = d[i]
    c += 1
print(c)

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

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

Solution (Python):
n = int(input())
d_i = [0] * n
for x in range(n):
    d_i[x] += int(input())
list.sort(d_i, reverse = True)
ans = 0
preVal = 101
for d in d_i:
    if d < preVal:
        ans += 1
        preVal = d
print(ans)

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

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

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

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

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

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

for k in range(n-1):
    if d[k] == d[k+1]:
        x = x+1

print(n-x)

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

num = [0] * 100

for i in d:
    num[i-1] = 1

print(sum(num))