Problem:
 Score : 300 points    Problem Statement Given is a sequence of integers A_1, A_2, ..., A_N .
If its elements are pairwise distinct, print YES ; otherwise, print NO .      Constraints  2 ≤ N ≤ 200000  1 ≤ A_i ≤ 10^9  All values in input are integers.         Input Input is given from Standard Input in the following format:  N  A_1  ...  A_N       Output If the elements of the sequence are pairwise distinct, print YES ; otherwise, print NO .        Sample Input 1 5
2 6 1 4 5      Sample Output 1 YES  The elements are pairwise distinct.       Sample Input 2 6
4 1 3 1 6 2      Sample Output 2 NO  The second and fourth elements are identical.       Sample Input 3 2
10000000 10000000      Sample Output 3 NO

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

input_line = list(input().split())
input_len = len(input_line)
input_set = len(set(input_line))

if input_len == input_set:
    print('YES')
else:
    print('NO')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

Sorted_A = sorted(A)
for i in range(N-1):
    if Sorted_A[i] == Sorted_A[i+1]:
        print('NO')
        break
else:
    print('YES')

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = "YES"
a.sort()
for i in range(n-1):
    if a[i] == a[i+1]:
        ans="NO"
print(ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A.sort()

for i in range(N-1):
    if A[i] == A[i+1]:
        print("NO")
        exit()

print("YES")

Solution (Python):
n = int(input())
a = list(int(x) for x in input().split())
x = 0
 
a.sort()
for i in range(n-1):
    if a[-1] - a[-2] == 0:
        print("NO")
        x = 1
        break
    a.pop()
 
if x == 0:
    print("YES")

Solution (Python):
a=int(input())
numbers =input().rstrip().split(" ")

delta=list(set(numbers))
b=len(delta)
if b==a:
    print("YES")
else:
    print("NO")

Solution (Python):
aaa = int(input())
la = list(map(int, input().split()))
d = {}
ret = 'YES'
for a in la:
    if a in d:
        ret = 'NO'
        break
    d[a] = ''
print(ret)

Solution (Python):
N = int(input())
a = [""]*N

text = input()
k = 0
for x in text:
    if x == " ":
        k = k+1
    else:
        a[k] = a[k]+x

dic ={}
def judge():
    for i in range(N):
        if (a[i] in dic.keys())==True:
            return "NO"
        else:
            dic[a[i]] = 1
    return "YES"

print(judge())

Solution (Python):
input();x = list(map(int,input().split()))
print("YES" if len(x)==len(set(x)) else "NO")

Solution (Python):
n = int(input())
a = set(map(int, input().split()))
if len(a) == n:
    print('YES')
else:
    print('NO')

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
if len(A)==len(set(A)):
  print("YES")
else:
  print("NO")

Solution (Python):
n = int(input()); d = list(map(int, input().split())); print('YES' if len(d) == len(list(set(d))) else 'NO')

Solution (Python):
a = int(input())
b = list(map(int,input().split()))

c=b.copy()
c=set(c)
if len(b)==len(c):
    print("YES")
else:
    print("NO")

Solution (Python):
n=int(input())
xx=input().split()
x=[]
for k in range(len(xx)):
  x.append(int(xx[k]))
x=sorted(x)
ok='YES'
for k in range(len(x)-1):
  if x[k]==x[k+1]:
    ok='NO'
    break
print(ok)

Solution (Python):
n = input()
a = input().split()
if len(a)== len(set(a)):
  print("YES")
else:
  print("NO")

Solution (Python):
n = input()
a = list(map(int,input().split()))
if len(a)== len(set(a)):
  print("YES")
else:
  print("NO")

Solution (Python):
n = input()
a = list(map(int,input().split()))
if len(set(a)) == len(a):
  print("YES")
elif len(set(a)) != len(a):
  print("NO")

Solution (Python):
N = input()
A = [int(a) for a in input().split()]

if len(A) == len(set(A)):
    print("YES")
else:
    print("NO")

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

tmp = input().split()

for i in range(N):
  A.append(int(tmp[i]))
    
A.sort()

hantei = True

for i in range(N-1):
  if A[i] == A[i+1]:
    hantei = False
    
if hantei == True:
  print("YES")
else:
  print("NO")

Solution (Python):
point=0
N = int(input())
A = list(map(int, input().split()))
A.sort()
for i in range(len(A)-1):
    if A[i]==A[i+1]:
        print("NO")
        break
    else:
        point+=1

if point == len(A)-1:
    print("YES")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = set(a)

if len(a) == len(b):
    print("YES")
else:
    print("NO")

Solution (Python):
n = int(input())
List = list(map(int, input().split()))
Sorted = sorted(List)
ans = 'YES'
for i in range(n - 1):
    if Sorted[i] == Sorted[i + 1]:
        ans = 'NO'
        break

print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = set(a)
print('YES' if len(a)==len(b) else 'NO')

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = set(a)
if len(a) == len(b):
    print('YES')
else:
    print('NO')

Solution (Python):
def solve(n, a):
    return "YES" if len(set(a)) == n else "NO"

n = int(input())
a = list(map(int, input().split()))
print(solve(n, a))

Solution (Python):
n = int(input())
li = list(map(int,input().split()))
a = len(li)
b = len(set(li))
if a==b:
    print('YES')
else:
    print('NO')

Solution (Python):
n = int(input())
a = [int(i) for i in input().split(" ")]
print("YES" if len(set(a)) == n else "NO")

Solution (Python):
n = input()
a = list(map(int,input().split()))
unique = set(a)
if len(a)==len(unique):
  print('YES')
else:
  print('NO')

Solution (Python):
from collections import defaultdict

dd=defaultdict(int)

n=int(input())
arr=list(map(int,input().split()))

for i in arr:
    dd[i]+=1

if max(dd.values())>1:
    print("NO")
else:
    print("YES")

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
x=0
a.sort()
for i in range(n-1):
  if a[i]==a[i+1]:
    x+=1
if x==0:
  print("YES")
else:
  print("NO")

Solution (Python):
n=int(input())
x=list(map(int,input().split()))
x.sort()
v=x[0]
y=True
for i in range(1,len(x)):
  if v==x[i]:
    y=False
    break
  else:
    v=x[i]
    
if y==True:
  print("YES")
else:
  print("NO")

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
A.sort()
for i in range(N-1):
  if A[i]==A[i+1]:
    print('NO')
    break
else:
  print('YES')

Solution (Python):
from collections import defaultdict
dic = defaultdict(lambda : 0)
N = int(input())
A = [int(x) for x in input().split()]
for x in A:
  if dic[x] == 1:
    print("NO")
    exit()
  else:
    dic[x] = 1
print("YES")

Solution (Python):
print('YNEOS'[int(input())!=len(set(list(map(int,input().split()))))::2])

Solution (Python):
import sys

N = int(input())
A = list(map(int,input().split()))

A.sort()
i = 0
while i<N-1:
    if A[i]==A[i+1]:
        print('NO')
        sys.exit()
    else:
        i = i+1
print('YES')

Solution (Python):
input()
Ai = list(map(int,input().split(' ')))
if len(Ai)==len(set(Ai)): print('YES')
else: print('NO')

Solution (Python):
input_length = int(input())
length = len(list(set([int(i) for i in input().split(' ')]))) 
 
if length == input_length:
  print('YES')
else:
  print('NO')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A.sort()
flag = 0
for i in range(N-1):
    if A[i] == A[i+1]:
        flag = 1
        break
if flag == 1:
    print("NO")
else:
    print("YES")

Solution (Python):
n = input()
a_list = list(map(int, input().split()))
a_set = set(a_list)

if len(a_list) == len(a_set):
  print("YES")
else:
  print("NO")

Solution (Python):
N=int(input().replace('\n',''))
L=input().replace('\n','').split()

if len(list(set(L)))==len(L):
  print('YES')
else:
  print('NO')

Solution (Python):
N=int(input())
A=[""]*N

A=list(map(int,input().split()))

if len(set(A))==len(A):
    print("YES")
else:
    print("NO")

Solution (Python):
dic = {}

N = int(input())
A = list(map(int,input().split()))

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

    if a in dic:
        print("NO")
        break
    else:
        dic[a] = 1

else:
    print("YES")

Solution (Python):
N = int(input())
An = map(int, input().split())
tmp = {}
tmp = {}
ans = "YES"
for i in An:
    if i in tmp:
        ans = "NO"
        break
    tmp[i] = True
print(ans)

Solution (Python):
length = int(input())
str_list = input().rstrip().split(' ')
if len(set(str_list)) == length:
  print('YES')
else:
  print('NO')

Solution (Python):
n = int(input())
a = input().split()
a = sorted(list(map(int, a)))
def check(a):
    for i in range(n-1):
        if a[i] == a[i+1]:
            return 0
    return 1
if check(a) == 0:
    print("NO")
else:
    print("YES")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

aa = sorted(a)

for i in range(0,n-1):
    if aa[i] == aa[i+1]:
        print("NO")
        exit()

print("YES")

Solution (Python):
n = input()
li = list(map(int,input().split()))

if len(li) == len(set(li)):
    print('YES')
else:
    print('NO')

Solution (Python):
N = int(input())
As = input().split(" ")
if len(list(set(As)))==N:
    print("YES")
else:
    print("NO")

Solution (Python):
N = int(input())
l = sorted(list(map(int, input().split())))

for i in range(N-1):
    if l[i] == l[i+1]:
        print("NO")
        break
else:
    print("YES")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

if len(a) == len(list(set(a))):
    print("YES")
else:
    print("NO")

Solution (Python):
def is_neighbor_same(lst):
  for i in range(len(lst)-1):
    if(lst[i]==lst[i+1]):
      return True
  return False

input()
input_line=[int(x) for x in input().split()]
input_line.sort()
if(is_neighbor_same(input_line)):
  print("NO")
else:
  print("YES")

Solution (Python):
_ = input()
x = input().strip().split()
y = set(x)
if len(x) == len(y): print('YES')
else: print('NO')

Solution (Python):

import sys
from collections import Counter
n = int(sys.stdin.readline())
L = map(int, sys.stdin.readline().split())
L = Counter(L)
if max(L.values()) >=2:
    print('NO')
else:
    print('YES')

Solution (Python):
N = input()
A = input().split()
a = []
for s in A:
	a.append(int(s))
if len(set(a)) == len(a):
  print('YES')
else:
  print('NO')

Solution (Python):
print("YES") if int(input()) == len(set(list(map(int, input().split())))) else print("NO")

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
l.sort()
s = 'YES'
for i in range(n-1):
    if l[i] == l[i+1]:
        s = 'NO'
print(s)

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

if len(set(a))==n:
    print("YES")
else:
    print("NO")

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
B=set(A)
if len(A)==len(B):
  print("YES")
else:
  print("NO")

Solution (Python):
_ = int(input())
A = list(map(int, input().split()))
X = set(A)
if len(X) == len(A):
    print("YES")
else:
    print("NO")

Solution (Python):
n = int(input())
a = set(map(int, input().split()))

if len(a) == n:
    print('YES')
else:
    print('NO')

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
a = set(a)
if n == len(a):
    print("YES")
else:
    print("NO")

Solution (Python):
n = int(input())
a = list(map(int,input().split()))

a.sort()
ans = 'YES'
for i in range(n - 1):
	if a[i] == a[i+1]:
		ans = 'NO'
		break
print(ans)
"""
setのほうがいいかも
"""

Solution (Python):
N = int(input())
A = input().split()
if len(A) == len(set(A)):
  print("YES")
else:
  print("NO")

Solution (Python):
n=int(input())
s=set(list(map(int,input().split())))
if len(s)==n:
  print("YES")
else:
  print("NO")

Solution (Python):
import collections
def get_input_line():
    return list(map(int, input().split()))
n = int(input())
n_list = get_input_line()
tmp = collections.Counter(n_list)

if(tmp.most_common(1)[0][1] != 1):
    print("NO")
else:
    print("YES")

Solution (Python):
N = int(input())
A = input().split()
if len(A) == len(set(A)):
    print("YES")
else:
    print("NO")

Solution (Python):
n = int(input())
s = list(map(int,input().split()))

s.sort()
flg = True
for i in range(n-1):
    if s[i] == s[i+1]:
        flg = False
        break

if flg:
    print("YES")
else:
    print("NO")

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N=I()
    A=LI()
    print(["NO","YES"][N==len(set(A))])
if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = True

a.sort()

for i in range(len(a)-1):
    if a[i] == a[i+1]:
        ans = False
        break

if ans:
    print('YES')
else:
    print('NO')

Solution (Python):
def main():
    n = int(input())
    a_list = list(map(int, input().split()))

    print('YES' if len(a_list) == len(set(a_list)) else 'NO')


if __name__ == '__main__':
    main()

Solution (Python):

"""
Created on Wed Feb 12 16:01:34 2020

@author: matsui
"""

N=int(input())
A=input().split()
A=[int(a) for a in A]
A.sort()

ans='YES'
for i in range(1,N):
    if A[i]==A[i-1]:
        ans='NO'
        break
    
print(ans)

Solution (Python):
import numpy as np

n = int(input())
An = list(map(int, input().split()))
An = np.array(An)

if len(np.unique(An)) == n:
  print('YES')
else:
  print('NO')

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

A_list = list(map(int,input().split()))

if len(set(A_list)) == N:
  print('YES')
else:
  print('NO')

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

a = list(map(int,input().split()))

A = len(set(a))

if n == A:
    print("YES")
else:
    print("NO")

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

listA=[]

try:
    listA = list(input().split())
    
    
    
except:
    quit();
    


listA.sort()


for i in range(len(listA)-1):
    if listA[i] == listA[i+1]:
        print('NO')
        quit();

print('YES')

Solution (Python):
num = input()
list = list(map(int,input().split()))
list2 = set(list) 
print("YES") if len(list) == len(list2) else print("NO")

Solution (Python):
n = int(input())
li = list(map(int,input().split()))
li2 = set(li)
if len(li) == len(li2):
  print("YES")
else:
  print("NO")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
print('YES' if len(set(a))==len(a) else 'NO')

Solution (Python):
l = int(input())
s_nums = set(input().split(" "))
if len(s_nums)==l:
  print("YES")
else:
  print("NO")

Solution (Python):
N = int(input())
An = list(map(int,input().split()))
An.sort()
import sys
for i in range(N-1):
  if An[i] == An[i+1]:
    print('NO')
    sys.exit()
print('YES')

Solution (Python):
def main():
    N = input()
    A = input().split()

    _A = set(A)

    if len(A) == len(_A):
        print('YES')
    else:
        print('NO')

if __name__ == '__main__':
    main()

Solution (Python):
N = input()
A = input().split()

_A = set(A)

if len(A) == len(_A):
    print('YES')
else:
    print('NO')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

_A = set(A)

if len(A) == len(_A):
    print('YES')
else:
    print('NO')

Solution (Python):
N=input()
l=list(map(int,input().split()))
if len(l)!=len(set(l)):
  print("NO")
else:
  print("YES")

Solution (Python):
l = int(input())
ls = list(set([int(c) for c in input().split()]))
if len(ls) == l:
  print("YES")
else:
  print("NO")

Solution (Python):
N = int(input())
li = list(map(int, input().split()))
li.sort()


S = 1
for i in range(N-1):
    if  li[i+1] == li[i]:
        S = S*0
    else:
        S = S
if S == 0:
    print('NO')
else:
    print('YES')

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
if len(set(a)) == n:
  print("YES")
else:
  print("NO")

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
res = True
a.sort()
for i in range(1,n):
    if a[i-1]==a[i]:
        res = False
        break
if res:
    print("YES")
else:
    print("NO")

Solution (Python):
def merge(l,r,a):
    l1 = len(l)
    r1 = len(r)
    i,j,k = 0,0,0
    while j<l1 and k<r1:
        if l[j]<r[k]:
            a[i] = l[j]
            j+=1
        elif l[j] == r[k]:
            a[i]=l[j]
            j+=1
            global res
            print("NO")
            quit()
            return 0
        else:
            a[i] = r[k]
            k+=1
        i+=1
    while j<l1:
        a[i] = l[j]
        j+=1
        i+=1
    while k<r1:
        a[i] = r[k]
        k+=1
        i+=1
    return a

def mergeSort(a):
    n = len(a)
    if n == 1:
        return a
    else:
        mid = n//2
        left = []
        right = []
        for i in range(mid):
            left.append(a[i])
        for i in range(mid, n):
            right.append(a[i])
        mergeSort(left)
        mergeSort(right)
        merge(left,right,a)
        return a


n = int(input())
a = list(map(int,input().split()))
res = True
s = mergeSort(a)
if res:
    print("YES")
else:
    print("NO")

Solution (Python):
def merge(l,r,a):
    l1 = len(l)
    r1 = len(r)
    i,j,k = 0,0,0
    while j<l1 and k<r1:
        if l[j]<r[k]:
            a[i] = l[j]
            j+=1
        elif l[j] == r[k]:
            a[i]=l[j]
            j+=1
            global res
            res = False
            return 0
        else:
            a[i] = r[k]
            k+=1
        i+=1
    while j<l1:
        a[i] = l[j]
        j+=1
        i+=1
    while k<r1:
        a[i] = r[k]
        k+=1
        i+=1
    return a

def mergeSort(a):
    n = len(a)
    if n == 1:
        return a
    else:
        mid = n//2
        left = []
        right = []
        for i in range(mid):
            left.append(a[i])
        for i in range(mid, n):
            right.append(a[i])
        mergeSort(left)
        mergeSort(right)
        merge(left,right,a)
        return a


n = int(input())
a = list(map(int,input().split()))
res = True
s = mergeSort(a)
if res:
    print("YES")
else:
    print("NO")

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
if len(A) == len(set(A)):
  print('YES')
else:
  print('NO')

Solution (Python):
n = int(input())
a = [int(z) for z in input().split()]
st = set()
for i in a:
  if i in st:
    print("NO")
    exit(0)
  st.add(i)
print("YES")

Solution (Python):
N=int(input())
A=list(map(int, input().split()))
a=set(A)
print('YES' if len(a) == len(A) else 'NO')

Solution (Python):
import collections
N = int(input())
A = list(map(int, input().split()))
l = collections.Counter(A)
if N == len(l):
    print("YES")
elif N != len(l):
    print("NO")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a.sort()
ans = 'YES'
for i in range(n-1):
    if a[i] == a[i+1]:
        ans = 'NO'
        break

print(ans)

Solution (Python):
def checker(arr):
  d = {}
  for x in arr:
    if x not in d:
      d[x] = 1
    else:
      return "NO"
  return "YES"

n = int(input())
arr = list(map(int, input().split()))
print(checker(arr))

Solution (Python):
N = input()
A = list(map(int, input().split()))

flag = True
A = sorted(A)
for i in range(len(A) - 1):
    if A[i] == A[i+1]:
        flag = False
        break
        
if flag:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys

N = int(input())
A = sorted([int(x) for x in input().split()])

for i in range(N-1):
    if A[i] == A[i+1]:
        print("NO")
        sys.exit(0)
        
print("YES")

Solution (Python):
N = int(input())
As = list(map(int, input().split()))

if len(As) == len(set(As)): print("YES")
else: print("NO")

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

C=0

A.sort()

for i in range(N-1):
    if A[i] == A[i+1]:
        C = C+1
    else:
        C = C

if C == 0:
	print('YES')
else:
	print('NO')

Solution (Python):
import sys
import socket

hostname = socket.gethostname()

if hostname == 'F451C':
    sys.stdin = open('c1.in')


def read_int_list():
    return list(map(int, input().split()))


def read_str_list():
    return input().split()


def read_int():
    return int(input())


def read_str():
    return input()


def main():
    N = read_int()
    A = read_int_list()
    A.sort()
    s = []
    for i in range(N-1):
      if A[i+1] != A[i]:
        s.append(A[i])
    l = len(s)
    if l == N - 1:
      res = 'YES'
    else:
      res = 'NO'
    print(res)


main()

Solution (Python):

N = int(input())
A = map(int, input().split())

B = set(A)
if N == len(B):
    print("YES")
else:
    print("NO")

Solution (Python):
import numpy as np

N = int(input())
A = tuple(map(int, input().split()))
A = np.array(A)
A = np.sort(A)

for i in range(N):
    if (i > 0 and A[i-1] == A[i]) or (i < N-1 and A[i] == A[i+1]):
        print('NO')
        break
else:
    print('YES')

Solution (Python):
n = int(input())
li_a = list(map(int, input().split()))

if len(li_a) == len(set(li_a)):
    print("YES")
else:
    print("NO")

Solution (Python):
def main():
    n=int(input())
    aa=list(map(int,input().split()))
    print('YES' if len(set(aa))==n else 'NO')

main()

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
s = set()
for a in A:
    if not a in s:
        s.add(a)
    else:
        print('NO')
        exit()
print('YES')

Solution (Python):
N = int(input())
A = sorted(map(int, input().split()))

flag=False
for i in range(N - 1):
  flag = flag or A[i] == A[i + 1]

print("NO" if flag else "YES")

Solution (Python):
N = int(input())
numbers = set(map(int, input().split()))

if len(numbers) == N:
  print('YES')
else:
  print('NO')

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

A.sort()
flag = False
for count in range(0,len(A)-1):
    if A[count] == A[count+1]:
        flag = True
        break

if flag == False:
    print("YES")
else:
    print("NO")

Solution (Python):
n = int(input())
l = list(map(int, input().split()))

if n == len(set(l)):
    print("YES")
else:
    print("NO")

Solution (Python):
N=int(input())
L=set(map(int,input().split()))
if len(L)!=N:
  print("NO")
else:
  print("YES")

Solution (Python):
N = int(input())
A = map(int, input().split())
if N == len(set(A)):
    print('YES')
else:
    print('NO')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

A.sort()

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

if count == 0:
    print('YES')
else:
    print('NO')

Solution (Python):
n = int(input())
a = list(map(int,input().split()))

p = len(a)
q = len(set(a))

if p == q:
    print("YES")
else:
    print("NO")

Solution (Python):
n = int(input().strip())
a = list(map(int, input().split()))
a.sort()

if len(a) == 1:
    print("YES")
    exit()

for i in range(len(a) - 1):
    if a[i] == a[i + 1]:
        print("NO")
        exit()
print("YES")

Solution (Python):
def solve(string):
    n, *a = map(int, string.split())
    return "YES" if len(a) == len(set(a)) else "NO"


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))

Solution (Python):
n = int(input())
s = set(map(int, input().split()))
print("YES" if len(s) == n else "NO")

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def solve():
    n = II()
    a = LI()
    print("YES" if len(a) == len(set(a)) else "NO")
    return



if __name__ == '__main__':
    solve()

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
if len(a) == len(set(a)):
  print("YES")
else:
  print("NO")

Solution (Python):
def main():
    n = int(input())
    num_list = list(map(int, input().split()))

    beforeLen = len(num_list)

    num_list = set(num_list)

    afterLen = len(num_list)

    print('YES' if beforeLen == afterLen else 'NO')

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = set(map(int, input().split()))

print("YES" if len(A) == N else "NO")

Solution (Python):
N=(int)(input())
A=(input()).split()
A.sort()
 
for i in range(N-1):
    if A[i]==A[i+1]:
        print('NO')
        break
    elif i==N-2:
        print('YES')

Solution (Python):
N=int(input())
A=map(int,input().split())
n=len(set(A))
if N!=n:
  print("NO")
else:
  print("YES")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

a = set(a)
if n == len(a):
    print('YES')
else:
    print("NO")

Solution (Python):
n = int(input())
a= map(int, input().split())
s = set(a)
if len(s) == n:
    print('YES')
else:
    print('NO')

Solution (Python):
n = int(input())
a = map(int,input().split())
A = set(a)
if len(A) == n:
    print("YES")
else:
    print("NO")

Solution (Python):
N = int(input())
num = sorted(list(map(int,input().split())))
f = 0

for i in range(N-1):
  if num[i] == num[i+1]:
    print("NO")
    f+=1
    break
if not f:
  print("YES")

Solution (Python):
n = int(input())
list_1 = list(map(int, input().split()))
if len(list(set(list_1))) == n:
    print("YES")
else:
    print("NO")

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A.sort()
cnt=0
for i in range(N-1):
    if A[i]==A[i+1]:
        print('NO')
        break
    else:
        cnt+=1
if cnt==N-1:
    print('YES')

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]

m = {}
res = True

for i in A:
    if i in m:
        res = False
        break
    else:
        m[i] = True

if res:
    print('YES')
else:
    print('NO')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = list(set(A))
print('YES' if sorted(A) == sorted(B) else 'NO')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

print('YES' if len(A) == len(set(A)) else 'NO')

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
lst = []
if len(set(a)) != len(a):
  print('NO')
else:
  print('YES')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
print('YES' if len(set(A)) == N else 'NO')

Solution (Python):
import sys
input()
s=sorted(input().split())
for i in range(len(s)-1):
    if s[i]==s[i+1]:
        print("NO")
        sys.exit(0)
print("YES")

Solution (Python):
n=int(input())
List=list(map(int,input().split()))
Set=set()
for i in range(len(List)):
    Set.add(List[i])
if len(Set)==n :
    print("YES")
else :
    print("NO")

Solution (Python):
N=int(input())
A=list(map(int, input().split()))
 
if len(set(A))==len(A):
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
n = int(input())
a = sorted(list(map(lambda x: int(x),input().split())))
for i in range(n - 1):
    if a[i] == a[i+1] :
        print('NO')
        sys.exit()
print('YES')

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

a.sort()

bef = a[0]
for i in range(1, n):
    if a[i] == bef:
        print('NO')
        exit(0)
    bef = a[i]
print('YES')

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

if len(set(a)) == len(a):
    print("YES")
else:
    print("NO")

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
tmp=set(A)
tmp=list(tmp)


if len(tmp)==len(A):
  print ("YES")
else:
  print ("NO")

Solution (Python):
N = int(input())
n = [int(i) for i in input().split()]
print("YES" if len(set(n)) == N else "NO")

Solution (Python):
n = int(input())
a = list(map(int,input().split(" ")))

if n == len(set(a)):
    print("YES")
else:
    print("NO")

Solution (Python):

n=int(raw_input())
a=map(int,raw_input().split())
if len(a)==len(set(a)):
 print 'YES'
else:
 print 'NO'

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
A.sort()
if all(A[i] != A[i - 1] for i in range(1, n)):
    print('YES')
else:
    print('NO')

Solution (Python):
from collections import Counter

input()
print("YES" if not set(Counter(input().split()).values()) - {1} else "NO")

Solution (Python):
N = int(input())
A = input().split()
if len(A) == len(set(A)):
  print('YES')
else:
  print('NO')

Solution (Python):
n = int(input()) 
N = list(map(int,input().split()))
N.sort()
for i in range(0,n-1):
    if N[i] == N[i+1]:
        print('NO')
        break
else:
    print('YES')

Solution (Python):
import hashlib
import math

class BloomFilter:

    def __init__(self, num_item, false_positive):
        assert 0 <= false_positive <= 1
        
        
        log2 = math.log(2)
        logp = math.log(false_positive)
        size = - num_item * logp / (log2 * log2)
        num_hash = size / num_item * log2

        self.size = int(math.ceil(size))
        self.num_hash = int(math.ceil(num_hash))

        self.array = self.BitArray(self.size)
        self.hash_functions = [self.HashFunction(i, self.size)
                               for i in range(self.num_hash)]

    def add(self, item):
        for hash_func in self.hash_functions:
            i = hash_func(item)
            self.array[i] = True

    def __contains__(self, item):
        return self.contains(item)

    def contains(self, item):
        for hash_func in self.hash_functions:
            i = hash_func(item)
            if self.array[i] is False:
                return False
        return True

    class BitArray:

        def __init__(self, length):
            
            self.array = [False for _ in range(length)]

        def __getitem__(self, index):
            return self.get(index)

        def get(self, index):
            return self.array[index]

        def __setitem__(self, index, bit):
            return self.set(index, bit)

        def set(self, index, bit):
            if bit > 0 or bit is True:
                self.array[index] = True
            else:
                self.array[index] = False

    class HashFunction:

        def __init__(self, seed, maximum):
            self.seed = seed.to_bytes(
                seed.bit_length() // 8 + 1, byteorder='big')
            self.maximum = maximum

        def __call__(self, byte_buffer):
            return self.call(byte_buffer)

        def call(self, byte_buffer):
            
            b = hashlib.md5(byte_buffer + self.seed).digest()
            i = int.from_bytes(b, byteorder='big', signed=False)
            return i % self.maximum

N = int(input())
L = list(map(int,input().split()))
bf = BloomFilter(num_item=5 * 10 ** 5, false_positive=0.001)

L = sorted(L)
for i in range(len(L) - 1):
    if L[i] == L[i+1]:
        print("NO")
        quit()
print("YES")