message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers. While there are at least two equal elements, we will perform the following operation. We choose the smallest value x that occurs in the array 2 or more times. Take the first two occurrences of x in this array (the two leftmost occurrences). Remove the left of these two occurrences, and the right one is replaced by the sum of this two values (that is, 2 โ
x).
Determine how the array will look after described operations are performed.
For example, consider the given array looks like [3, 4, 1, 2, 2, 1, 1]. It will be changed in the following way: [3, 4, 1, 2, 2, 1, 1]~โ~[3, 4, 2, 2, 2, 1]~โ~[3, 4, 4, 2, 1]~โ~[3, 8, 2, 1].
If the given array is look like [1, 1, 3, 1, 1] it will be changed in the following way: [1, 1, 3, 1, 1]~โ~[2, 3, 1, 1]~โ~[2, 3, 2]~โ~[3, 4].
Input
The first line contains a single integer n (2 โค n โค 150 000) โ the number of elements in the array.
The second line contains a sequence from n elements a_1, a_2, ..., a_n (1 โค a_i โค 10^{9}) โ the elements of the array.
Output
In the first line print an integer k โ the number of elements in the array after all the performed operations. In the second line print k integers โ the elements of the array after all the performed operations.
Examples
Input
7
3 4 1 2 2 1 1
Output
4
3 8 2 1
Input
5
1 1 3 1 1
Output
2
3 4
Input
5
10 40 20 50 30
Output
5
10 40 20 50 30
Note
The first two examples were considered in the statement.
In the third example all integers in the given array are distinct, so it will not change.
Submitted Solution:
```
import sys
# # For getting input from input.txt file
# sys.stdin = open('input.txt', 'r')
# # Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')
n = int(input())
s = input()
num = list(map(int, s.split(' ')))
frq = {i: num.count(i) for i in set(num)}
for key in frq:
while frq[key] >= 2:
num.remove(key)
for i in range(len(num)):
if num[i] == key:
num[i] = key * 2
if key * 2 in frq:
frq[key * 2] += 1
break
frq[key] = frq[key] - 2
print(len(num))
print(' '.join(map(str, num)))
``` | instruction | 0 | 42,645 | 12 | 85,290 |
No | output | 1 | 42,645 | 12 | 85,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of positive integers. While there are at least two equal elements, we will perform the following operation. We choose the smallest value x that occurs in the array 2 or more times. Take the first two occurrences of x in this array (the two leftmost occurrences). Remove the left of these two occurrences, and the right one is replaced by the sum of this two values (that is, 2 โ
x).
Determine how the array will look after described operations are performed.
For example, consider the given array looks like [3, 4, 1, 2, 2, 1, 1]. It will be changed in the following way: [3, 4, 1, 2, 2, 1, 1]~โ~[3, 4, 2, 2, 2, 1]~โ~[3, 4, 4, 2, 1]~โ~[3, 8, 2, 1].
If the given array is look like [1, 1, 3, 1, 1] it will be changed in the following way: [1, 1, 3, 1, 1]~โ~[2, 3, 1, 1]~โ~[2, 3, 2]~โ~[3, 4].
Input
The first line contains a single integer n (2 โค n โค 150 000) โ the number of elements in the array.
The second line contains a sequence from n elements a_1, a_2, ..., a_n (1 โค a_i โค 10^{9}) โ the elements of the array.
Output
In the first line print an integer k โ the number of elements in the array after all the performed operations. In the second line print k integers โ the elements of the array after all the performed operations.
Examples
Input
7
3 4 1 2 2 1 1
Output
4
3 8 2 1
Input
5
1 1 3 1 1
Output
2
3 4
Input
5
10 40 20 50 30
Output
5
10 40 20 50 30
Note
The first two examples were considered in the statement.
In the third example all integers in the given array are distinct, so it will not change.
Submitted Solution:
```
n=int(input())
m=list(map(int,input().split()))
i=0
while i<len(m):
pepe=0
for j in range(i+1,len(m)):
if m[i]==m[j]:
m[i]*=2
m.pop(j)
pepe=5
i=0
break
if pepe==0:
i+=1
print(len(m))
print(*m)
``` | instruction | 0 | 42,646 | 12 | 85,292 |
No | output | 1 | 42,646 | 12 | 85,293 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,784 | 12 | 85,568 |
"Correct Solution:
```
n = int(input())
p = [i for i,j in sorted([[i,pp] for i,pp in enumerate(map(int, input().split()))], key=lambda t:t[1])]
a = []
acc = 0
for i in range(n):
acc += p[i]
a.append(i + 1 + acc)
b = []
acc = 0
for i in range(n):
acc += p[-i-1]
b.append(i + 1 + acc)
print(*a)
print(*b[::-1])
``` | output | 1 | 42,784 | 12 | 85,569 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,785 | 12 | 85,570 |
"Correct Solution:
```
f = lambda: map(int, input().split())
n = int(input())
p = list(f())
m = 3*10**4
k = 10**9
a = [i*m for i in range(1, n+1)]
b = [k-a[i] for i in range(n)]
for i in range(n):
b[p[i]-1] += i
print(*a)
print(*b)
``` | output | 1 | 42,785 | 12 | 85,571 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,786 | 12 | 85,572 |
"Correct Solution:
```
from itertools import*
from math import*
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = float("inf")
mod = 10**9+7
from functools import reduce
import sys
sys.setrecursionlimit(10**7)
N = int(input())
p = list(map(int,input().split()))
d = defaultdict(int)
for i in range(N):
d[p[i]] = i
a,b = [],[]
for i in range(1,N+1):
a.append(N*i+d[i])
b.append((N-i+1)*N+d[i])
print(*a,sep=" ")
print(*b,sep=" ")
``` | output | 1 | 42,786 | 12 | 85,573 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,787 | 12 | 85,574 |
"Correct Solution:
```
N = int(input())
p = list(map(int,input().split()))
a = [0] * N
b = [0] * N
for i in range(N):
b[i] = (N-i) * N
a[i] = (i + 1) * N
for i in range(N):
b[p[i]-1] += i
print (" ".join(map(str,a)))
print (" ".join(map(str,b)))
``` | output | 1 | 42,787 | 12 | 85,575 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,788 | 12 | 85,576 |
"Correct Solution:
```
N=int(input())
p=list(map(int,input().split()))
M,S=10**9,30000
a=list(range(1,S*N,S))
b=list(reversed(a))
for i in range(N-1):
b[p[i+1]-1]+=i+1
print(*a)
print(*b)
``` | output | 1 | 42,788 | 12 | 85,577 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,789 | 12 | 85,578 |
"Correct Solution:
```
n=int(input())
pprr = list(map(int,input().split()))
prr=[0]*n
for ix,p in enumerate(pprr):
prr[p-1]=ix+1
arr=[]
brr=[]
cumsum=0
for p in prr:
cumsum+=p
arr.append(cumsum)
cumsum=0
print(" ".join(map(str,arr)))
for p in reversed(prr):
cumsum+=p
brr.append(cumsum)
print(" ".join(map(str,reversed(brr))))
``` | output | 1 | 42,789 | 12 | 85,579 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,790 | 12 | 85,580 |
"Correct Solution:
```
n=int(input());p=20000;a=range(p,p*n+1,p);*b,=a[::-1];print(*a)
for t,i in zip(range(n),input().split()):b[int(i)-1]+=t
print(*b)
``` | output | 1 | 42,790 | 12 | 85,581 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p of the set {1, 2, ..., N}. Please construct two sequences of positive integers a_1, a_2, ..., a_N and b_1, b_2, ..., b_N satisfying the following conditions:
* 1 \leq a_i, b_i \leq 10^9 for all i
* a_1 < a_2 < ... < a_N
* b_1 > b_2 > ... > b_N
* a_{p_1}+b_{p_1} < a_{p_2}+b_{p_2} < ... < a_{p_N}+b_{p_N}
Constraints
* 2 \leq N \leq 20,000
* p is a permutation of the set {1, 2, ..., N}
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
The output consists of two lines. The first line contains a_1, a_2, ..., a_N seperated by a space. The second line contains b_1, b_2, ..., b_N seperated by a space.
It can be shown that there always exists a solution for any input satisfying the constraints.
Examples
Input
2
1 2
Output
1 4
5 4
Input
3
3 2 1
Output
1 2 3
5 3 1
Input
3
2 3 1
Output
5 10 100
100 10 1 | instruction | 0 | 42,791 | 12 | 85,582 |
"Correct Solution:
```
N = int(input())
p = list(map(int, input().split()))
A = [0 for _ in range(N)]
B = [0 for _ in range(N)]
X = [0 for _ in range(N)]
S = N
A[0] = 1
for i in range(N - 1):
S += abs(p[i] - p[i-1])
for i in range(N):
X[p[i]-1] = S + i
B[0] = X[0] - 1
for i in range(1, N):
s = max(A[i-1] + 1, X[i] - B[i-1] + 1)
A[i] = s
B[i] = X[i] - s
if min(min(A), min(B)) <= 0:
m = -min(min(A), min(B)) + 1
for i in range(N):
A[i] += m
B[i] += m
for i in range(N):
if i != N - 1:
print(A[i], end = ' ')
else:
print(A[i])
for i in range(N):
if i != N - 1:
print(B[i], end = ' ')
else:
print(B[i])
``` | output | 1 | 42,791 | 12 | 85,583 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,864 | 12 | 85,728 |
"Correct Solution:
```
n=int(input())
A=list(map(int,input().split()))
print(*A)
for i in range(1,n):
v=A[i]
j=i-1
while j>=0 and v<A[j]:
A[j+1]=A[j]
j-=1
A[j+1]=v
print(*A)
``` | output | 1 | 42,864 | 12 | 85,729 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,865 | 12 | 85,730 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
v = a[i]
j = i-1
while a[j]>v and j>=0:
a[j+1] = a[j]
j -=1
a[j+1] = v
print(*a)
``` | output | 1 | 42,865 | 12 | 85,731 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,866 | 12 | 85,732 |
"Correct Solution:
```
N=int(input())
A=[int(x) for x in input().split()]
for i in range(N):
v=A[i]
j=i-1
while j>=0 and v<A[j]:
A[j+1]=A[j]
j-=1
A[j+1]=v
print(' '.join(map(str,A)))
``` | output | 1 | 42,866 | 12 | 85,733 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,867 | 12 | 85,734 |
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
for i in range(N):
p = i - 1
while p >= 0 and A[p] > A[p + 1]:
A[p], A[p + 1] = A[p + 1], A[p]
p -= 1
for j in range(N):
print(A[j], end = " \n"[j + 1 == N])
``` | output | 1 | 42,867 | 12 | 85,735 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,868 | 12 | 85,736 |
"Correct Solution:
```
def main(n):
a = list(map(int, input().split()))
for i in range(n):
v = a[i]
j = i-1
while j >= 0 and a[j] > v:
a[j+1] = a[j]
j -= 1
a[j+1] = v
print(" ".join(map(str,a)))
return
main(int(input()))
``` | output | 1 | 42,868 | 12 | 85,737 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,869 | 12 | 85,738 |
"Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
for i in range(0,n):
v = a[i]
j = i - 1
while 0 <= j and v < a[j]:
a[j+1] = a[j]
j = j - 1
a[j+1] = v
print(*a)
``` | output | 1 | 42,869 | 12 | 85,739 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,870 | 12 | 85,740 |
"Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
for i in range(n):
v = a[i]
j = i - 1
while j >= 0 and a[j] > v:
a[j+1] = a[j]
j -= 1
a[j+1] = v
print(" ".join(map(str,a)))
``` | output | 1 | 42,870 | 12 | 85,741 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3 | instruction | 0 | 42,871 | 12 | 85,742 |
"Correct Solution:
```
n=int(input())
A=list(map(int,input().split()))
print(" ".join(map(str,A)))
for i in range(1,n):
v=A[i]
j=i-1
while j>=0 and A[j]>v:
A[j+1]=A[j]
j=j-1
A[j+1]=v
print(" ".join(map(str,A)))
``` | output | 1 | 42,871 | 12 | 85,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
for i in range(0,n):
v=a[i]
j=i-1
while j>=0 and a[j]>v:
a[j+1]=a[j]
j-=1
a[j+1]=v
print(" ".join(map(str,a)))
``` | instruction | 0 | 42,872 | 12 | 85,744 |
Yes | output | 1 | 42,872 | 12 | 85,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
n = int(input())
nums = list(map(int, input().split()))
for i in range(n):
v = nums[i]
j = i - 1
while j >= 0 and nums[j] > v:
nums[j+1] = nums[j]
j -= 1
nums[j+1] = v
print(' '.join(map(str, nums)))
``` | instruction | 0 | 42,873 | 12 | 85,746 |
Yes | output | 1 | 42,873 | 12 | 85,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
print(" ".join(map(str,l)))
for i in range(1,n):
v=l[i]
j=i-1
while j>=0 and l[j]>v:
l[j+1]=l[j]
j-=1
l[j+1]=v
print(" ".join(map(str,l)))
``` | instruction | 0 | 42,874 | 12 | 85,748 |
Yes | output | 1 | 42,874 | 12 | 85,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
print(*arr)
for i in range(1, n):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
print(*arr)
``` | instruction | 0 | 42,875 | 12 | 85,750 |
Yes | output | 1 | 42,875 | 12 | 85,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
def insertionSort(A,N):
for i in range(1, N-1):
v = A[i]
j = i-1
while j >= 0 and A[j]>v:
A[j+1] = A[j]
j += -1
A[j+1] = v
``` | instruction | 0 | 42,876 | 12 | 85,752 |
No | output | 1 | 42,876 | 12 | 85,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
N = int(input())
#print(N)
card = list(map(int, input().split()))
#print(card)
for i in range(N):
v = card[i]
j = i - 1
while j >= 0 and card[j] > v:
card[j+1] = card[j]
j = j -1
card[j+1] = v
#print(card)
card_str = ""
for k in range(N):
card_str += str(card[k])
print(card_str)
``` | instruction | 0 | 42,877 | 12 | 85,754 |
No | output | 1 | 42,877 | 12 | 85,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
n = int(input())
a = [i in int(input().split())]
for i in range(1,n+1):
v = a[i]
j = i-1
while a[j]>v and j>=0:
a[j+1] = a[j]
j -=1
a[j] = v
print(*a)
``` | instruction | 0 | 42,878 | 12 | 85,756 |
No | output | 1 | 42,878 | 12 | 85,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:
for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key
Note that, indices for array elements are based on 0-origin.
To illustrate the algorithms, your program should trace intermediate result for each step.
Hint
Template in C
Constraints
1 โค N โค 100
Input
The first line of the input includes an integer N, the number of elements in the sequence.
In the second line, N elements of the sequence are given separated by a single space.
Output
The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.
Examples
Input
6
5 2 4 6 1 3
Output
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6
Input
3
1 2 3
Output
1 2 3
1 2 3
1 2 3
Submitted Solution:
```
def output(list):
for i,row in enumerate(list):
if i == 0:
print(row,end='')
else:
print('',row,end='')
s = input()
list = list(map(int,input().split()))
output(list)
print()
#print(list)
start = time.time()
i = 0
for count in range(len(list)-1):
# Judge: now > next
if list[i] > list[i+1]:
# Change: now > next
ins_num = list[i+1]
list[i+1] = list[i]
list[i] = ins_num
j = i - 1
while j >= 0:
if list[j] > ins_num:
list[j+1] = list[j]
list[j] = ins_num
j -= 1
output(list)
else:
output(list)
print()
i += 1
``` | instruction | 0 | 42,879 | 12 | 85,758 |
No | output | 1 | 42,879 | 12 | 85,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,932 | 12 | 85,864 |
Tags: constructive algorithms
Correct Solution:
```
def ii():
return int(input())
def mi():
return map(int, input().split())
def li():
return list(mi())
# D. Similar Arrays
n, m = mi()
g = [[] for i in range(n + 1)]
e = []
for i in range(m):
a, b = mi()
e.append((a, b))
g[a].append(b)
g[b].append(a)
eq = None
if n > 1:
for i in range(1, n + 1):
if len(g[i]) == n - 1:
continue
s = set(g[i])
for j in range(1, n + 1):
if i != j and j not in s:
eq = i, j
break
if eq: break
if eq:
a, b = [0] * n, [0] * n
a[eq[0] - 1] = 1
a[eq[1] - 1] = 2
b[eq[0] - 1] = b[eq[1] - 1] = 1
c = 3
for i in range(n):
if not a[i]:
a[i] = b[i] = c
c += 1
for i, j in e:
if (a[i - 1] < a[j - 1]) != (b[i - 1] < b[j - 1]):
eq = None
break
if eq:
print('YES')
print(*a)
print(*b)
else:
print('NO')
``` | output | 1 | 42,932 | 12 | 85,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,933 | 12 | 85,866 |
Tags: constructive algorithms
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
sys.setrecursionlimit(300000)
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n,m=map(int,input().split())
c=defaultdict(int)
ans=[i for i in range(1,n+1)]
ori=[i for i in range(1,n+1)]
s=set()
ma=defaultdict(int)
con=defaultdict(list)
for i in range(m):
a,b=map(int,input().split())
c[a]+=1
c[b]+=1
ma[a]=max(ma[a],b)
ma[b] = max(ma[b], a)
con[a].append(b)
con[b].append(a)
s.add((a,b))
e=-1
if m==(n*(n-1))//2:
print("NO")
sys.exit(0)
for i in range(1,n+1):
if (i,i+1) not in s and (i+1,i) not in s and i+1<=n:
e=1
ans[i+1-1]=ans[i-1]
break
if (i,i-1) not in s and (i-1,i) not in s and i-1>=1:
e=1
ans[i-1-1]=ans[i-1]
break
if e==-1:
for i in range(1,n+1):
if e==1:
break
if c[i]==0:
e = 1
ans[i- 1] = 1
break
for j in range(i+1,n+1):
if (i,j) not in s and (j,i) not in s:
e=1
ori[0]=ori[i-1]
ori[1]=ori[j-1]
ori[i-1]=1
ori[j-1]=2
ans[0] = ans[i - 1]
ans[1] = ans[j - 1]
ans[i - 1] = 1
ans[j - 1] = 1
break
if e==-1:
print("NO")
sys.exit(0)
print("YES")
print(*ori)
print(*ans)
``` | output | 1 | 42,933 | 12 | 85,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,934 | 12 | 85,868 |
Tags: constructive algorithms
Correct Solution:
```
n, m = map(int, input().split())
d = [set() for q in range(n)]
for q in range(m):
l, r = map(int, input().split())
l, r = l-1, r-1
d[l].add(r)
d[r].add(l)
ans = -1
for q in range(n):
if len(d[q]) < n-1:
ans = q
break
if ans == -1:
print('NO')
else:
for q in range(n):
if q != ans and q not in d[ans]:
ans = [ans, q]
break
ans, ans1 = min(ans), max(ans)
a = []
s = []
for q in range(ans+1):
a.append(1+q)
s.append(1 + q)
for q in range(ans+1, ans1):
a.append(2+q)
s.append(2+q)
a.append(ans+1)
s.append(ans+2)
for q in range(ans1+1, n):
a.append(1+q)
s.append(1 + q)
print('YES')
print(*s)
print(*a)
``` | output | 1 | 42,934 | 12 | 85,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,935 | 12 | 85,870 |
Tags: constructive algorithms
Correct Solution:
```
# SHRi GANESHA author: Kunal Verma #
import os
import sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from functools import reduce
from io import BytesIO, IOBase
from itertools import combinations
from math import gcd, inf, sqrt, ceil, floor
#sys.setrecursionlimit(2*10**5)
def lcm(a, b):
return (a * b) // gcd(a, b)
'''
mod = 10 ** 9 + 7
fac = [1]
for i in range(1, 2 * 10 ** 5 + 1):
fac.append((fac[-1] * i) % mod)
fac_in = [pow(fac[-1], mod - 2, mod)]
for i in range(2 * 10 ** 5, 0, -1):
fac_in.append((fac_in[-1] * i) % mod)
fac_in.reverse()
def comb(a, b):
if a < b:
return 0
return (fac[a] * fac_in[b] * fac_in[a - b]) % mod
'''
MAXN = 1000004
spf = [0 for i in range(MAXN)]
def sieve():
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, ceil(sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
def getFactorization(x):
ret = Counter()
while (x != 1):
ret[spf[x]] += 1
x = x // spf[x]
return ret
def printDivisors(n):
i = 2
z = [1, n]
while i <= sqrt(n):
if (n % i == 0):
if (n / i == i):
z.append(i)
else:
z.append(i)
z.append(n // i)
i = i + 1
return z
def create(n, x, f):
pq = len(bin(n)[2:])
if f == 0:
tt = min
else:
tt = max
dp = [[inf] * n for _ in range(pq)]
dp[0] = x
for i in range(1, pq):
for j in range(n - (1 << i) + 1):
dp[i][j] = tt(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))])
return dp
def enquiry(l, r, dp, f):
if l > r:
return inf if not f else -inf
if f == 1:
tt = max
else:
tt = min
pq1 = len(bin(r - l + 1)[2:]) - 1
return tt(dp[pq1][l], dp[pq1][r - (1 << pq1) + 1])
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
x = []
for i in range(2, n + 1):
if prime[i]:
x.append(i)
return x
def main():
from collections import defaultdict
import sys
n, m = map(int, input().split())
c = defaultdict(int)
ans = [i for i in range(1, n + 1)]
ori = [i for i in range(1, n + 1)]
s = set()
ma = defaultdict(int)
con = defaultdict(list)
for i in range(m):
a, b = map(int, input().split())
c[a] += 1
c[b] += 1
ma[a] = max(ma[a], b)
ma[b] = max(ma[b], a)
con[a].append(b)
con[b].append(a)
s.add((a, b))
e = -1
if m == (n * (n - 1)) // 2:
print("NO")
sys.exit(0)
for i in range(1, n + 1):
if (i, i + 1) not in s and (i + 1, i) not in s and i + 1 <= n:
e = 1
ans[i + 1 - 1] = ans[i - 1]
break
if (i, i - 1) not in s and (i - 1, i) not in s and i - 1 >= 1:
e = 1
ans[i - 1 - 1] = ans[i - 1]
break
if e == -1:
for i in range(1, n + 1):
if e == 1:
break
if c[i] == 0:
e = 1
ans[i - 1] = 1
break
for j in range(i + 1, n + 1):
if (i, j) not in s and (j, i) not in s:
e = 1
ori[0] = ori[i - 1]
ori[1] = ori[j - 1]
ori[i - 1] = 1
ori[j - 1] = 2
ans[0] = ans[i - 1]
ans[1] = ans[j - 1]
ans[i - 1] = 1
ans[j - 1] = 1
break
if e == -1:
print("NO")
sys.exit(0)
print("YES")
print(*ori)
print(*ans)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | output | 1 | 42,935 | 12 | 85,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,936 | 12 | 85,872 |
Tags: constructive algorithms
Correct Solution:
```
def read(type = 1):
if type:
file = open("input.dat", "r")
line = list(map(int, file.readline().split()))
n = line[0]
m = line[1]
a = []
for i in range(m):
line = tuple(map(int, file.readline().split()))
if line[0] < line[1]:
a.append(line)
else:
a.append([line[1], line[0]])
file.close()
else:
line = list(map(int, input().strip().split()))
n = line[0]
m = line[1]
a = []
for i in range(m):
line = tuple(map(int, input().strip().split()))
if line[0] < line[1]:
a.append(line)
else:
a.append([line[1], line[0]])
return n, m, a
def write(sol, x):
print("YES")
print(" ".join(map(str, sol[1:-1])))
sol[x[1]] = sol[x[0]]
print(" ".join(map(str, sol[1:-1])))
def solve(a):
if len(a) == n * (n-1) // 2:
print("NO")
return 0
a = sorted(a, key = lambda x: (x[0], x[1]))
x = [1,2]
for t in a:
if list(t) != x:
break
if x[1] == n:
x[0] += 1
x[1] = x[0] + 1
else:
x[1] += 1
sol = [0 for i in range(n+2)]
sol[x[0]] = 1
sol[x[1]] = 2
v = 3
for i in range(1,n+1):
if i not in x:
sol[i] = v
v += 1
write(sol, x)
n, m, a = read(0)
solve(a)
``` | output | 1 | 42,936 | 12 | 85,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,937 | 12 | 85,874 |
Tags: constructive algorithms
Correct Solution:
```
n,m = map(int,input().split())
member = [0 for _ in range(n+1)]
linked = set()
for i in range(m):
a,b = map(int,input().split())
linked.add(str(a)+'-'+str(b))
linked.add(str(b) + '-' + str(a))
member[a]+=1
member[b]+=1
num=0
for i in range(1,n+1):
if member[i]<n-1:
num=i
break
# print(linked)
if num:
for i in range(1,n+1):
if i!=num:
text =str(num) + '-' + str(i)
if text not in linked:
pair = i
break
arr= [num,pair]
arr.sort()
sa = [0]*n
sb = [0]*n
sa[arr[0]-1]=1
sa[arr[1]-1] = 2
sb[arr[0]-1] = 1
sb[arr[1]-1] = 1
cur=3
for i in range(n):
if sa[i]==0:
sa[i]=cur
sb[i]=cur
cur+=1
print('YES')
print(*sa)
print(*sb)
else:
print('NO')
``` | output | 1 | 42,937 | 12 | 85,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,938 | 12 | 85,876 |
Tags: constructive algorithms
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
for _ in range(1):
n,m=map(int,input().split())
ans=[0]*(n+1)
a=[]
for i in range(m):
l,r=map(int,input().split())
if l>r:
l,r=r,l
a.append([l,r])
if m==int((n*(n-1))//2):
print("NO")
continue
a.sort()
f=-1
s=-1
count=0
l,r=1,2
add=n*(n-1)//2
for i in range(add):
if r==n+1:
l+=1
r=l+1
if i==m:
f=l
s=r
break
if a[i][0]!=l or a[i][1]!=r:
f=l
s=r
break
r+=1
if l!=n-1 or r!=n:
f=l
s=r
ans1=[0]*(n+1)
ans2=[0]*(n+1)
ans1[f]=ans2[f]=ans1[s]=1
ans2[s]=2
count=3
i=1
while i<=n:
if ans1[i]==0:
ans1[i]=ans2[i]=count
count+=1
i+=1
if f==-1:
print("NO")
else:
print("YES")
print(*ans2[1:])
print(*ans1[1:])
``` | output | 1 | 42,938 | 12 | 85,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1 | instruction | 0 | 42,939 | 12 | 85,878 |
Tags: constructive algorithms
Correct Solution:
```
n, m= map(int, input().split())
s=set()
for i in range(m):
x,y=map(int, input().split())
s.add((x,y))
if m*2 == n*(n-1) or n<2 or n==2 and m==1:
print('NO')
exit()
x, y = 0,0
for i in range(1,n+1):
for j in range(i+1,n+1):
if (i, j) not in s and (j, i) not in s:
x=i
y=j
break
x-=1
y-=1
print('YES')
l = list(range(1,n+1))
if x == 1:
y,x=x,y
if y == 0:
x, y=y,x
l[x], l[0] = 1, l[x]
l[y], l[1] = 2, l[y]
print(*l)
l[y]=1
print(*l)
``` | output | 1 | 42,939 | 12 | 85,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1
Submitted Solution:
```
n, m = map(int, input().split())
c = [ [0, i, []] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
c[a-1][0]+=1
c[a-1][2].append(b-1)
c[b-1][0]+=1
c[b-1][2].append(a-1)
if(n==1):
print("NO")
else:
ans = ((n*(n-1))//2)
if(m>=ans):
print("NO")
else:
c.sort(key = lambda x: x[0])
vall = c[0][1]
c[0][2].append(vall)
c[0][2].sort()
final = -1
for i in range(len(c[0][2])):
if(c[0][2][i]!=i and i!=vall):
final = i
break
if(final==-1):
final = len(c[0][2])
print("YES")
flag = True
s1=""
s2=""
val = 1
temp = min(vall,final)
temp2 = max(vall, final)
for i in range(n):
if(i==temp):
s1+=str(n) + " "
s2+=str(n) + " "
elif(i==temp2):
s1+=str(n-1) +" "
s2+=str(n) +" "
else:
s1+=str(val) + " "
s2+=str(val) + " "
val+=1
print(s1[:-1])
print(s2[:-1])
``` | instruction | 0 | 42,940 | 12 | 85,880 |
Yes | output | 1 | 42,940 | 12 | 85,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1
Submitted Solution:
```
n, m = map(int, input().split(' '))
N = set(range(1,n+1))
a = []
for i in range(m):
temp = list(map(int, input().split(' ')))
a += temp
b = set(a)
if m != 0:
ans1 = list(N)
ans2 = list(N)
ans2[n - 1] = ans2[0]
print('YES')
print(*ans1, sep=' ')
print(*ans2, sep=' ')
else:
print('NO')
``` | instruction | 0 | 42,941 | 12 | 85,882 |
No | output | 1 | 42,941 | 12 | 85,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1
Submitted Solution:
```
import time
startTimeProblem=time.time()
import fileinput, sys, itertools, functools, math
from bisect import *
from heapq import *
from collections import *
MOD = 10**9+7 #isprime
def lcm(a, b):
return (a*b)/math.gcd(a, b)
def precompute_binom(n,p):
facts = [0]*n
invfacts = [0]*n
facts[0] = 1
invfacts[0] = 1
for i in range(1,n):
facts[i] = (facts[i-1]*i)%p
invfacts[i] = pow(facts[i],p-2,p)
return facts, invfacts
def binom_pre_computed(facts, invfacts, n, k, p):
# n! / (k!^(p-2) * (n-k)!^(p-2)) (mod p)
return (facts[n] * ((invfacts[k]*invfacts[n-k] % p))) % p
class UnionFind:
def __init__(self, n):
self.link = [i for i in range(n)]
self.size = [i for i in range(n)]
def find(self, i):
while i!=self.link[i]:
i = self.link[i]
return i
def same(self, i, j):
return self.find(i) == self.find(j)
def unite(self, i, j):
i = self.find(i)
j = self.find(j)
if self.size[i] < self.size[j]:
i, j = j,i
size[i]+=size[j]
link[j] = i
class InputHelper:
def __init__(self):
self.myinput = fileinput.input()
def isLocal(self):
return not fileinput.isstdin()
def int(self):
return int(self.myinput.readline().rstrip())
def ints(self):
return [int(_) for _ in self.myinput.readline().rstrip().split()]
def str(self):
return self.myinput.readline().rstrip()
def strs(self):
return [_ for _ in self.myinput.readline().rstrip().split()]
class OutputHelper:
def int(self, a):
print(a)
def ints(self, a):
print(" ".join([str(_) for _ in a]))
def intsNL(self, a):
for _ in a:
print(_)
def str(self, s):
print(s)
def strs(self, s):
print(" ".join([_ for _ in s]))
def strsNL(self, s):
for st in s:
print(st)
class ListNode:
def __init__(self, val):
self.val = val
self.next = None
self.prev = None
class SegmentTree:
def __init__(self, arr):
self.n = 2**math.ceil(math.log2(len(arr)))
self.me = [0]*(self.n*2)
for i in range(self.n, 2*self.n):
ct = i-self.n
if ct>=len(arr):
break
self.me[i] = arr[ct] if ct<len(arr) else 0
for i in range(2*self.n-1, 0, -1):
self.me[i//2] += self.me[i]
def getFromToIncl(self, a, b):
"""
O(log n)
"""
a+=self.n
b+=self.n
s = 0
while a<=b:
if a%2==1:
s += self.me[a]
a+=1
if b%2==0:
s += self.me[b]
b-=1
a//=2
b//=2
return s
def op(self, pos, val):
"""
O(log n)
"""
pos+=self.n
self.me[pos]+=val
pos//=2
while pos>=1:
self.me[pos] = self.me[2*pos]+self.me[2*pos+1]
pos//=2
In = InputHelper()
Out = OutputHelper()
#######################################
#sys.setrecursionlimit(10000)
n, m = In.ints()
if n==1:
Out.str("NO")
else:
seen = set()
possi = set([(i,i+1) for i in range(n-1)])
possi.add((0,n-1))
for i in range(m):
a,b = In.ints()
a, b = min(a,b), max(a,b)
a-=1
b-=1
if (a,b) in possi:
possi.remove((a,b))
if len(possi)==0:
Out.str("NO")
else:
val = 0
for key in possi:
val=key
break
Out.str("YES")
if val==(0,n-1):
Out.ints([i+1 for i in range(n-1,-1,-1)])
Out.ints([1] + [i+1 for i in range(n-2,-1,-1)])
else:
Out.ints([i+1 for i in range(n)])
mofified = [i+1 for i in range(n)]
mofified[val[0]] += 1
Out.ints(mofified)
######################################
if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
fin = (time.time()-startTimeProblem)*1000
print("{:.2f}".format(fin) + "ms")
``` | instruction | 0 | 42,942 | 12 | 85,884 |
No | output | 1 | 42,942 | 12 | 85,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1
Submitted Solution:
```
n,m = map(int,input().split())
member = [0 for _ in range(n+1)]
linked = set()
for i in range(m):
a,b = map(int,input().split())
linked.add(str(a)+'-'+str(b))
linked.add(str(b) + '-' + str(a))
member[a]+=1
member[b]+=1
num=0
for i in range(1,n+1):
if member[i]<n-1:
num=i
break
# print(linked)
if num:
for i in range(1,n+1):
if i!=num:
text =str(num) + '-' + str(i)
if text not in linked:
pair = i
break
arr= [num,pair]
arr.sort()
sa = [0]*n
sb = [0]*n
sa[arr[0]-1]=1
sa[arr[1]-1] = 2
sb[arr[0]-1] = 1
sb[arr[1]-1] = 1
cur=3
for i in range(n):
if sa[i]==0:
sa[i]=cur
sb[i]=cur
cur+=1
print(*sa)
print(*sb)
else:
print('NO')
``` | instruction | 0 | 42,943 | 12 | 85,886 |
No | output | 1 | 42,943 | 12 | 85,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya had an array of n integers, each element of the array was from 1 to n. He chose m pairs of different positions and wrote them down to a sheet of paper. Then Vasya compared the elements at these positions, and wrote down the results of the comparisons to another sheet of paper. For each pair he wrote either "greater", "less", or "equal".
After several years, he has found the first sheet of paper, but he couldn't find the second one. Also he doesn't remember the array he had. In particular, he doesn't remember if the array had equal elements. He has told this sad story to his informatics teacher Dr Helen.
She told him that it could be the case that even if Vasya finds his second sheet, he would still not be able to find out whether the array had two equal elements.
Now Vasya wants to find two arrays of integers, each of length n. All elements of the first array must be distinct, and there must be two equal elements in the second array. For each pair of positions Vasya wrote at the first sheet of paper, the result of the comparison must be the same for the corresponding elements of the first array, and the corresponding elements of the second array.
Help Vasya find two such arrays of length n, or find out that there are no such arrays for his sets of pairs.
Input
The first line of input contains two integers n, m โ the number of elements in the array and number of comparisons made by Vasya (1 โค n โค 100 000, 0 โค m โค 100 000).
Each of the following m lines contains two integers a_i, b_i โ the positions of the i-th comparison (1 โค a_i, b_i โค n; a_i โ b_i). It's guaranteed that any unordered pair is given in the input at most once.
Output
The first line of output must contain "YES" if there exist two arrays, such that the results of comparisons would be the same, and all numbers in the first one are distinct, and the second one contains two equal numbers. Otherwise it must contain "NO".
If the arrays exist, the second line must contain the array of distinct integers, the third line must contain the array, that contains at least one pair of equal elements. Elements of the arrays must be integers from 1 to n.
Examples
Input
1 0
Output
NO
Input
3 1
1 2
Output
YES
1 3 2
1 3 1
Input
4 3
1 2
1 3
2 4
Output
YES
1 3 4 2
1 3 4 1
Submitted Solution:
```
n, m= map(int, input().split())
s=set()
for i in range(m):
x,y=map(int, input().split())
s.add((x,y))
if m*2 == n*(n-1) or n<3:
print('NO')
exit()
x, y = 0,0
for i in range(1,n+1):
for j in range(i+1,n+1):
if (i, j) not in s and (j, i) not in s:
x=i
y=j
x-=1
y-=1
print('YES')
l = list(range(1,n+1))
print(*l)
l[y]=l[x]
print(*l)
``` | instruction | 0 | 42,944 | 12 | 85,888 |
No | output | 1 | 42,944 | 12 | 85,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,140 | 12 | 86,280 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
A=sorted([int(_) for _ in input().split()])
x=A[n-5]*A[n-4]*A[n-3]*A[n-2]*A[n-1]
y=A[0]*A[1]*A[n-3]*A[n-2]*A[n-1]
z=A[0]*A[1]*A[2]*A[3]*A[n-1]
print(max(x,y,z))
``` | output | 1 | 43,140 | 12 | 86,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,141 | 12 | 86,282 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
import sys, math
input = lambda: sys.stdin.readline().rstrip()
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
a1 = a.copy()
mas = []
for i in range(n):
if a[i] == 0:
mas.append(i)
if n - len(mas) >= 5:
f = 0
for i in mas:
del a[i - f]
f += 1
ans = []
cur = 1
for i in range(5):
cur *= a[i]
ans.append(cur)
cur = 1
for i in range(4):
# cur = 1
cur *= a[i]
cur *= a[-1]
ans.append(cur)
cur = 1
for i in range(3):
cur *= a[i]
cur *= a[-1]
cur *= a[-2]
ans.append(cur)
cur = 1
for i in range(2):
cur *= a[i]
cur *= a[-1]
cur *= a[-2]
cur *= a[-3]
ans.append(cur)
cur = 1
for i in range(1):
cur *= a[i]
cur *= a[-1]
cur *= a[-2]
cur *= a[-3]
cur *= a[-4]
ans.append(cur)
cur = 1
cur *= a[-1]
cur *= a[-2]
cur *= a[-3]
cur *= a[-4]
cur *= a[-5]
ans.append(cur)
aa = max(ans)
if 0 in a1:
aa = max(0, aa)
print(aa)
``` | output | 1 | 43,141 | 12 | 86,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,142 | 12 | 86,284 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
def getMagnitude(pair):
return pair[0]
def getProductOfElems(elems):
numElems = len(elems)
product = 1
for index in range(numElems):
elem = elems[index]
product *= (elem[0] * elem[1])
return product
def getNegativeNonNegativeElements(elems):
nonNegativeElems = []
negativeElems = []
for index in range(N):
elem = elems[index]
if elem[1] == -1:
negativeElems.append(elem)
else:
nonNegativeElems.append(elem)
return negativeElems, nonNegativeElems
def findMaximumProductOf5(arrayWithMagnitudeAndSign):
N = len(arrayWithMagnitudeAndSign)
# base cases
if N < 5:
return 0
elif N == 5:
return getProductOfElems(arrayWithMagnitudeAndSign)
# note that only lists with at least 6 elements get till here
# sort elements by magnitude
arrayWithMagnitudeAndSign.sort(key=getMagnitude, reverse=True)
# separate out negative and non-negative
negativeElems, nonNegativeElems = getNegativeNonNegativeElements(arrayWithMagnitudeAndSign)
numNonNeg = len(nonNegativeElems)
numNeg = len(negativeElems)
# no non-negative element: find the product of negative elements with smallest magnitude
if (numNonNeg == 0):
return getProductOfElems(negativeElems[numNeg-5:numNeg])
# product of 4 largest negative elements and largest non-negative element
elif (numNonNeg == 1 or numNonNeg == 2):
return nonNegativeElems[0][0] * getProductOfElems(negativeElems[0:4])
# product of 5 largest non-negative elements
elif (numNeg == 0 or numNeg == 1):
return getProductOfElems(nonNegativeElems[0:5])
# here, we have at least 2 negative, 3 non-negative elements
# mixed product: product of 2 largest (by magnitude) negative
# and three largest non-negative elements
mixedProduct = getProductOfElems(negativeElems[0:2]) * getProductOfElems(nonNegativeElems[0:3])
# mixed product
if (numNeg < 4 and numNonNeg <= 4):
return mixedProduct
# max. out of mixed product, and product of 5 largest non-negative elements
elif (numNeg < 4 and numNonNeg > 4):
allNonNegProduct = getProductOfElems(nonNegativeElems[0:5])
return max(allNonNegProduct, mixedProduct)
# here, we have at least 4 negative, 3 non-negative elements
# four negative product: product of largest non-negative and
# four largest negative (by magnitude) elements
fourNegProduct = nonNegativeElems[0][0] * getProductOfElems(negativeElems[0:4])
# max. out of mixed product, four negative product
if (numNonNeg <= 4):
return max(fourNegProduct, mixedProduct)
# max. out of mixed, four negative, all non-negative products
allNonNegProduct = getProductOfElems(nonNegativeElems[0:5])
return max(allNonNegProduct, fourNegProduct, mixedProduct)
# helper function to get (magnitude, sign) tuple for a number
def getMagnitudeAndSign(number):
if number < 0:
return (-number, -1)
return (number, 1)
# main code: user input
T = int(input())
for t in range(T):
N = int(input())
arrayOfNumbers = list(map(int, input().split()))
arrayWithMagnitudeAndSign = list(map(getMagnitudeAndSign, arrayOfNumbers))
print(findMaximumProductOf5(arrayWithMagnitudeAndSign=arrayWithMagnitudeAndSign))
``` | output | 1 | 43,142 | 12 | 86,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,143 | 12 | 86,286 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
# from math import factorial
# ans= 0
# for x in range(1,5):
# for y in range(1,5-x+1):
# print(x,y,5-x-y)
# print(pow(12,x)*pow(33,y)*pow(52,5-x-y)*factorial(5)//(factorial(x)*factorial(y)*factorial(5-x-y)))
# ans += pow(12,x)*pow(33,y)*pow(52,5-x-y)*factorial(5)//(factorial(x)*factorial(y)*factorial(5-x-y))
# print(ans*52)
def prod(arr):
p = 1
for i in arr:
p*=i
return p
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
arr.sort()
maxx = prod(arr[:5])
maxx = max(maxx,prod(arr[:4] + arr[-1:]))
maxx = max(maxx,prod(arr[:3] + arr[-2:]))
maxx = max(maxx,prod(arr[:2] + arr[-3:]))
maxx = max(maxx,prod(arr[:1] + arr[-4:]))
maxx = max(maxx,prod(arr[:0] + arr[-5:]))
print(maxx)
``` | output | 1 | 43,143 | 12 | 86,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,144 | 12 | 86,288 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a.sort()
ans=0
t1=a[0]*a[1]*a[2]*a[3]*a[-1]
t2=a[0]*a[1]*a[-2]*a[-3]*a[-1]
t3=a[-5]*a[-4]*a[-2]*a[-3]*a[-1]
print(max(t1,t2,t3))
``` | output | 1 | 43,144 | 12 | 86,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,145 | 12 | 86,290 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=sorted(list(map(int,input().split())))
print(max(l[0]*l[1]*l[2]*l[3]*l[-1],l[0]*l[1]*l[-3]*l[-2]*l[-1],l[-5]*l[-4]*l[-3]*l[-2]*l[-1],))
``` | output | 1 | 43,145 | 12 | 86,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,146 | 12 | 86,292 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
for i in range(int(input())):
n = int(input())
list1 = list(map(int, input().split()))
a = sorted(list1)
neg_ans = a[-1]*a[-2]*a[-3]*a[0]*a[1]
neg_ans1 = a[-1]*a[3]*a[2]*a[1]*a[0]
pos_value = a[-1]*a[-2]*a[-3]*a[-4]*a[-5]
d = max(pos_value, neg_ans1, neg_ans)
print(d)
``` | output | 1 | 43,146 | 12 | 86,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers a_1,a_2,โฆ,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1โค tโค 2 โ
10^4) โ the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5โค nโค 10^5) โ the size of the array.
The second line of each test case contains n integers a_1,a_2,โฆ,a_n (-3ร 10^3โค a_iโค 3ร 10^3) โ given array.
It's guaranteed that the sum of n over all test cases does not exceed 2โ
10^5.
Output
For each test case, print one integer โ the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
(-2) โ
(-3)โ
(-4)โ
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)โ
(-2) โ
(-3)โ
2โ
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)โ
0โ
0โ
0โ
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)โ
(-7) โ
(-5)โ
(-3)โ
1=945. | instruction | 0 | 43,147 | 12 | 86,294 |
Tags: brute force, dp, greedy, implementation, sortings
Correct Solution:
```
def solve():
n = int(input())
arr = [int(i) for i in input().strip().split()]
pos = []
neg = []
for val in arr:
if val >= 0:
pos.append(val)
else:
neg.append(val)
pos.sort(reverse=True)
neg.sort(reverse=True)
res = -1e18
for posv in range(0, 6):
negv = 5 - posv
if posv <= len(pos) and negv <= len(neg):
# print(posv, negv)
cres = 1
for j in range(0, posv):
cres *= pos[j]
if negv%2 != 0:
for j in range(0, negv):
cres *= neg[j]
else:
for j in range(len(neg) - 1, len(neg) - 1 - negv , -1):
cres *= neg[j]
# print(cres)
res = max(res, cres)
print(res)
if(__name__ == "__main__"):
t = 1
t = int(input())
for i in range(0, t):
solve()
``` | output | 1 | 43,147 | 12 | 86,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 โค lj โค rj โค n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 โค n, m โค 105) โ the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 โค ai โค 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 โค lj โค rj โค n).
Output
In m lines print m integers โ the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 43,265 | 12 | 86,530 |
Tags: constructive algorithms, data structures
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
class query():
global z
def __init__(self,l,r,i):
self.lb=(l-1)//z
self.l=l
self.r=r
self.ind=i
def __lt__(a,b):
return (a.lb<b.lb or (a.lb==b.lb and a.r<b.r))
n,m=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n):
if a[i]>n:
a[i]=-1
l1=[]
z=int(n**0.5)
for i in range(m):
x,y=map(int,input().split())
l1.append(query(x,y,i))
l1.sort()
d=[0]*(n+2)
l=1
r=0
ans=0
fans=[0]*m
for i in l1:
while r<i.r:
r+=1
if d[a[r-1]]==a[r-1]:
ans-=1
d[a[r-1]]+=1
if d[a[r-1]]==a[r-1]:
ans+=1
while l>i.l:
l-=1
if d[a[l-1]]==a[l-1]:
ans-=1
d[a[l-1]]+=1
if d[a[l-1]]==a[l-1]:
ans+=1
while l<i.l:
if d[a[l-1]]==a[l-1]:
ans-=1
d[a[l-1]]-=1
if d[a[l-1]]==a[l-1]:
ans+=1
l+=1
while r>i.r:
if d[a[r-1]]==a[r-1]:
ans-=1
d[a[r-1]]-=1
if d[a[r-1]]==a[r-1]:
ans+=1
r-=1
fans[i.ind]=ans
for i in fans:
print(i)
``` | output | 1 | 43,265 | 12 | 86,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is so happy about inventing bubble sort graphs that he's staying all day long at the office and writing permutations. Iahubina is angry that she is no more important for Iahub. When Iahub goes away, Iahubina comes to his office and sabotage his research work.
The girl finds an important permutation for the research. The permutation contains n distinct integers a1, a2, ..., an (1 โค ai โค n). She replaces some of permutation elements with -1 value as a revenge.
When Iahub finds out his important permutation is broken, he tries to recover it. The only thing he remembers about the permutation is it didn't have any fixed point. A fixed point for a permutation is an element ak which has value equal to k (ak = k). Your job is to proof to Iahub that trying to recover it is not a good idea. Output the number of permutations which could be originally Iahub's important permutation, modulo 1000000007 (109 + 7).
Input
The first line contains integer n (2 โค n โค 2000). On the second line, there are n integers, representing Iahub's important permutation after Iahubina replaces some values with -1.
It's guaranteed that there are no fixed points in the given permutation. Also, the given sequence contains at least two numbers -1 and each positive number occurs in the sequence at most once. It's guaranteed that there is at least one suitable permutation.
Output
Output a single integer, the number of ways Iahub could recover his permutation, modulo 1000000007 (109 + 7).
Examples
Input
5
-1 -1 4 3 -1
Output
2
Note
For the first test example there are two permutations with no fixed points are [2, 5, 4, 3, 1] and [5, 1, 4, 3, 2]. Any other permutation would have at least one fixed point. | instruction | 0 | 43,306 | 12 | 86,612 |
Tags: combinatorics, math
Correct Solution:
```
#lahub and Permutations
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
mod = 10**9+7
def pow(n,p,mod=mod): #็นฐใ่ฟใไบไนๆณ(nใฎpไน)
res = 1
while p > 0:
if p % 2 == 0:
n = n ** 2 % mod
p //= 2
else:
res = res * n % mod
p -= 1
return res % mod
def factrial_memo(n=10**5,mod=mod):
fact = [1, 1]
for i in range(2, n + 1):
fact.append((fact[-1] * i) % mod)
return fact
fact = factrial_memo()
def permutation(n,r): #nPr
return fact[n]*pow(fact[n-r],mod-2)%mod
def combination(n,r): #nCr
return permutation(n,r)*pow(fact[r],mod-2)%mod
#return fact[n]*pow(fact[n-r],mod-2)*pow(fact[r],mod-2)
def homogeneous(n,r): #nHr
return combination(n+r-1,r)%mod
#return fact[n+m-1]*pow(fact[n-1],mod-2)*pow(fact[r],mod-2)
n = int(readline())
lst1 = list(map(int,readline().split()))
ct = 0
lst2 = [0]*2_001
lst3 = [0]*2_001
for i in range(n):
if i+1 == lst1[i]:
print(0)
exit()
if lst1[i] == -1:
ct += 1
lst3[i+1] = 1
else:
lst2[lst1[i]] = 1
ct2 = 0
for i in range(1,n+1):
if lst3[i] == 1 and lst2[i] == 0:
ct2 += 1
#lst2:ใใฎๅ ดๆใๅใพใฃใฆใชใindex
#lst3:ใใฎๆฐๅญใไฝฟใใใฆใindex
#ไฝๅๅ
ฅใใกใใใใชใไฝ็ฝฎใซๅ
ฅใใใใงๆฐใไธใใ
#ๅ
ฅใใกใใใใชใใใฎใฏct2ๅใฃใฆใ
#ct-ct2ๅใฎใใฎใฏใฉใใซๅ
ฅใใฆใ่ฆไปถใๆบใใ
ans = 0
for i in range(ct2+1):
ans += pow(-1,i)*combination(ct2,i)*fact[ct-i]
ans %= mod
print(ans)
``` | output | 1 | 43,306 | 12 | 86,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is so happy about inventing bubble sort graphs that he's staying all day long at the office and writing permutations. Iahubina is angry that she is no more important for Iahub. When Iahub goes away, Iahubina comes to his office and sabotage his research work.
The girl finds an important permutation for the research. The permutation contains n distinct integers a1, a2, ..., an (1 โค ai โค n). She replaces some of permutation elements with -1 value as a revenge.
When Iahub finds out his important permutation is broken, he tries to recover it. The only thing he remembers about the permutation is it didn't have any fixed point. A fixed point for a permutation is an element ak which has value equal to k (ak = k). Your job is to proof to Iahub that trying to recover it is not a good idea. Output the number of permutations which could be originally Iahub's important permutation, modulo 1000000007 (109 + 7).
Input
The first line contains integer n (2 โค n โค 2000). On the second line, there are n integers, representing Iahub's important permutation after Iahubina replaces some values with -1.
It's guaranteed that there are no fixed points in the given permutation. Also, the given sequence contains at least two numbers -1 and each positive number occurs in the sequence at most once. It's guaranteed that there is at least one suitable permutation.
Output
Output a single integer, the number of ways Iahub could recover his permutation, modulo 1000000007 (109 + 7).
Examples
Input
5
-1 -1 4 3 -1
Output
2
Note
For the first test example there are two permutations with no fixed points are [2, 5, 4, 3, 1] and [5, 1, 4, 3, 2]. Any other permutation would have at least one fixed point. | instruction | 0 | 43,307 | 12 | 86,614 |
Tags: combinatorics, math
Correct Solution:
```
def fact(x):
ans=1
for i in range(2,x+1):
ans*=i
return ans
n=int(input())
a=[int(x) for x in input().split()]
s=set(a)
x=0
y=0
for i in range(1,n+1):
if a[i-1]==-1:
g=i in s
(x,y)=(x+1-g,y+g)
otv=fact(x+y)
currf=fact(x+y-1)//fact(x-1)*fact(x)
if x:
otv-=currf
for i in range(2,x+1):
currf//=i
currf*=x-i+1
currf//=x+y-i+1
if i&1:
otv-=currf
else:
otv+=currf
otv%=1000000007
print(otv)
``` | output | 1 | 43,307 | 12 | 86,615 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.