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.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
n = int(input())
dd = 998244353
dp = [(1,0), (1, 0), (2, 0), (6, 3)]
if n == 1:
print(1)
elif n == 2:
print(2)
for i in range(4, n+1):
np = (dp[-1][0]*i, i*(dp[-1][0]-1) + i*(dp[-1][1]))
np = (np[0] % dd, np[1] % dd)
dp.append(np)
print((dp[-1][0] + dp[-1][1]) % dd)
``` | instruction | 0 | 86,631 | 12 | 173,262 |
No | output | 1 | 86,631 | 12 | 173,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let n be an integer. Consider all permutations on integers 1 to n in lexicographic order, and concatenate them into one big sequence p. For example, if n = 3, then p = [1, 2, 3, 1, 3, 2, 2, 1, 3, 2, 3, 1, 3, 1, 2, 3, 2, 1]. The length of this sequence will be n ⋅ n!.
Let 1 ≤ i ≤ j ≤ n ⋅ n! be a pair of indices. We call the sequence (p_i, p_{i+1}, ..., p_{j-1}, p_j) a subarray of p. Its length is defined as the number of its elements, i.e., j - i + 1. Its sum is the sum of all its elements, i.e., ∑_{k=i}^j p_k.
You are given n. Find the number of subarrays of p of length n having sum (n(n+1))/(2). Since this number may be large, output it modulo 998244353 (a prime number).
Input
The only line contains one integer n (1 ≤ n ≤ 10^6), as described in the problem statement.
Output
Output a single integer — the number of subarrays of length n having sum (n(n+1))/(2), modulo 998244353.
Examples
Input
3
Output
9
Input
4
Output
56
Input
10
Output
30052700
Note
In the first sample, there are 16 subarrays of length 3. In order of appearance, they are:
[1, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 2], [3, 2, 2], [2, 2, 1], [2, 1, 3], [1, 3, 2], [3, 2, 3], [2, 3, 1], [3, 1, 3], [1, 3, 1], [3, 1, 2], [1, 2, 3], [2, 3, 2], [3, 2, 1].
Their sums are 6, 6, 7, 6, 7, 5, 6, 6, 8, 6, 7, 5, 6, 6, 7, 6. As (n(n+1))/(2) = 6, the answer is 9.
Submitted Solution:
```
n = int(input())
x = n
for p in range(1 , n):
x = x * (p + 1) % 998244353
print(x)
``` | instruction | 0 | 86,632 | 12 | 173,264 |
No | output | 1 | 86,632 | 12 | 173,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,633 | 12 | 173,266 |
Tags: greedy, sortings
Correct Solution:
```
n, m, k = map(int, input().split())
length = n
a = [int(i) for i in input().split()]
d = []
for j in range(n-1):
d.append(a[j + 1] - a[j] - 1)
d.sort()
for j in range(n-k):
length += d[j]
print(length)
``` | output | 1 | 86,633 | 12 | 173,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,634 | 12 | 173,268 |
Tags: greedy, sortings
Correct Solution:
```
n,m,w=map(int,input().split())
l=list(map(int,input().split()))
k=[]
for i in range(1,n):
a=l[i]-l[i-1]
k.append(a)
k.sort()
s=0
for i in range(n-w):
s+=k[i]
print(s+w)
``` | output | 1 | 86,634 | 12 | 173,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,635 | 12 | 173,270 |
Tags: greedy, sortings
Correct Solution:
```
n,m,k=map(int,input().split())
b=[int(i) for i in input().split()]
if k==1:
print(b[-1]-b[0]+1)
else:
d=[b[i]-b[i-1] for i in range(1,n)]
d.sort()
d=d[:-k+1]
print(sum(d)+k)
``` | output | 1 | 86,635 | 12 | 173,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,636 | 12 | 173,272 |
Tags: greedy, sortings
Correct Solution:
```
def main():
# accept nmk
[n,m,k]=list(map(int,input().split(" ")))
ar=list(map(int,input().split(" ")))
diff=[]
prev=ar[0]
for i in range(1,len(ar)):
diff.append(ar[i]-prev)
prev=ar[i]
# Sort in ascending order and take first k's sum
diff.sort()
# print(diff)
# now have to find sum of n-k first elements of diff
sumofdiff = sum(diff[:n-k])
# therefore total sum is sum of diff + k
result=sumofdiff+k
print(result)
return
main()
``` | output | 1 | 86,636 | 12 | 173,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,637 | 12 | 173,274 |
Tags: greedy, sortings
Correct Solution:
```
n,m,k = list(map(int,input().split()))
b = list(map(int,input().split()))
s = sorted([b[i]-b[i-1]-1 for i in range(1,n)],reverse=True)
mv = (b[-1]-b[0]+1)-sum(s[:k-1])
print(mv)
``` | output | 1 | 86,637 | 12 | 173,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,638 | 12 | 173,276 |
Tags: greedy, sortings
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
# = input()
# = int(input())
#() = (i for i in input().split())
# = [i for i in input().split()]
(m, n, k) = (int(i) for i in input().split())
b = [int(i) for i in input().split()]
start = time.time()
ans = m
if m > k:
c = sorted([b[i+1] - b[i] for i in range(m-1)])
ans += sum(c[:m-k])+k-m
print(ans)
finish = time.time()
#print(finish - start)
``` | output | 1 | 86,638 | 12 | 173,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,639 | 12 | 173,278 |
Tags: greedy, sortings
Correct Solution:
```
(n,m,k)=map(int,input().split())
l=list(map(int,input().split()))
a=[]
for i in range(1,n):
a.append(l[i]-l[i-1]-1)
a.sort(reverse=True)
c=l[n-1]-l[0]+1
for i in range(k-1):
c-=a[i]
print(c)
``` | output | 1 | 86,639 | 12 | 173,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
Input
The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.
Output
Print the minimum total length of the pieces.
Examples
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
Note
In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.
In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87. | instruction | 0 | 86,640 | 12 | 173,280 |
Tags: greedy, sortings
Correct Solution:
```
import copy
import fractions
import itertools
import numbers
import string
import sys
###
def to_basex(num, x):
while num > 0:
yield num % x
num //= x
def from_basex(it, x):
ret = 0
p = 1
for d in it:
ret += d*p
p *= x
return ret
###
def core():
n, m, k = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
deltas = [y-x for x, y in zip(b[:-1], b[1:])]
# print(b)
# print(deltas)
deltas.sort()
ans = k
ans += sum(deltas[:len(deltas) + 1 - k])
print(ans)
core()
``` | output | 1 | 86,640 | 12 | 173,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1. | instruction | 0 | 86,649 | 12 | 173,298 |
Tags: constructive algorithms, data structures, dfs and similar, graphs, greedy, math, sortings
Correct Solution:
```
import sys
inp = []
inp_idx = 0
def dfs(node, adj, n):
timer = n
perm = [0] * (n + 1)
perm[node] = timer
timer -= 1
stack = [node]
while stack:
node = stack[-1]
if adj[node]:
neighbor = adj[node].pop()
stack.append(neighbor)
perm[neighbor] = timer
timer -= 1
else:
stack.pop()
return perm
def check(n, nxt, perm):
stack = [n]
for i in range(n - 1, -1, -1):
while stack[-1] < perm[i]:
stack.pop()
if stack[-1] != perm[nxt[i]]:
return False
stack.append(perm[i])
return True
def solve():
global inp
global inp_idx
global perm
global timer
n = inp[inp_idx]
inp_idx += 1
nxt = []
for _ in range(n):
nxt.append(inp[inp_idx])
inp_idx += 1
for i in range(n):
nxt[i] = i + 1 if nxt[i] == -1 else nxt[i] - 1
adj = [[] for _ in range(n + 1)]
for i in range(n - 1, -1, -1):
adj[nxt[i]].append(i)
perm = dfs(n, adj, n)
print(-1) if not check(n, nxt, perm) else print(*(list(map(lambda x : x + 1, perm[:-1]))))
if __name__ == '__main__':
inp = [int(x) for x in sys.stdin.read().split()]
t = inp[0]
inp_idx = 1
for test in range(t):
solve()
``` | output | 1 | 86,649 | 12 | 173,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1. | instruction | 0 | 86,650 | 12 | 173,300 |
Tags: constructive algorithms, data structures, dfs and similar, graphs, greedy, math, sortings
Correct Solution:
```
import sys
from array import array # noqa: F401
from typing import List, Tuple, TypeVar, Generic, Sequence, Union # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
t = int(input())
ans = ['-1'] * t
for ti in range(t):
n = int(input())
a = [0] + list(map(int, input().split()))
p = [0] * (n + 1)
lo, i = 1, 1
ok = 1
while i <= n:
if a[i] == -1:
p[i] = lo
i += 1
lo += 1
continue
stack = [[a[i], lo + a[i] - i, lo + (a[i] - i) - 1]]
j = i
while j < a[i]:
if j == stack[-1][0]:
lo = stack.pop()[1]
if a[j] == -1 or a[j] == stack[-1][0]:
pass
elif a[j] > stack[-1][0]:
ok = 0
break
else:
stack.append([a[j], lo + a[j] - j, lo + (a[j] - j) - 1])
p[j] = stack[-1][2]
stack[-1][2] -= 1
j += 1
lo = stack.pop()[1]
i = j
if not ok:
break
else:
ans[ti] = ' '.join(map(str, p[1:]))
sys.stdout.buffer.write(('\n'.join(ans) + '\n').encode('utf-8'))
if __name__ == '__main__':
main()
``` | output | 1 | 86,650 | 12 | 173,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1. | instruction | 0 | 86,651 | 12 | 173,302 |
Tags: constructive algorithms, data structures, dfs and similar, graphs, greedy, math, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
n = int(input())
l = list(map(int, input().split()))
stack = []
out = [-1] * n
curr = 0
works = True
for i in range(n):
while stack and stack[-1][0] == i:
_, j = stack.pop()
curr += 1
out[j] = curr
nex = l[i] - 1
if nex == -2:
curr += 1
out[i] = curr
else:
if stack and nex > stack[-1][0]:
works = False
else:
stack.append((nex, i))
while stack:
_, j = stack.pop()
curr += 1
out[j] = curr
if works:
print(*out)
else:
print(-1)
``` | output | 1 | 86,651 | 12 | 173,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
N = int(input())
P = [int(a) for a in input().split()]
for i in range(N):
if P[i] < 0:
P[i] = i+2
Q = [1]
for i in range(N):
if i+1 == Q[-1]:
Q.pop()
elif P[i] > Q[-1]:
print(-1)
break
Q.append(P[i])
else:
X = [[] for _ in range(N+2)]
for i in range(N):
X[P[i]].append(i)
ANS = [0] * N
ans = N
for i in range(N+1, -1, -1):
for x in X[i]:
# print(x+1)
ANS[x] = ans
ans -= 1
print(*ANS)
``` | instruction | 0 | 86,652 | 12 | 173,304 |
No | output | 1 | 86,652 | 12 | 173,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
# https://codeforces.com/contest/1159/problem/E
from sys import stdin
def shuffle(arr, i, k):
tmp = arr[k-1];
arr[i+1:k] = arr[i:k-1]
arr[i] = tmp
def check(arr):
s = []
for i, el in enumerate(arr):
if el != -2:
if not s:
s.insert(0, el)
continue
if s[0] >= i:
while s and s[0] >= i:
s.pop(0)
s.insert(0, el)
continue
#print(s)
#print(i, el)
if s[0] < el:
return False
return True
def process_permutation():
n = int(input())
arr = [int(x)-1 for x in stdin.readline().split(' ')]
if not check(arr):
print(-1)
return
perm = [i for i in range(n+1)]
for i, el in enumerate(arr):
if el != -2 and el > i+1:
#print('pre shuffle', i, el)
#print(perm)
shuffle(perm, i, el)
#print('post shuffle')
#print(perm)
#print('*')
print(' '.join([str(el+1) for el in perm[:-1]]))
if __name__ == '__main__':
t = int(input())
for i in range(t):
#print('****')
#print(i)
process_permutation()
``` | instruction | 0 | 86,653 | 12 | 173,306 |
No | output | 1 | 86,653 | 12 | 173,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq,bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
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")
# -------------------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=2**51, 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)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=100005, func=lambda a, b: min(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------------------------------------
for ik in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
ans=[0]*n
d=defaultdict(list)
for i in range(n-1,-1,-1):
if i==n-1:
if l[i]==-1:
l[i]=n+1
else:
if l[i]==-1:
l[i]=l[i+1]
for i in range(n):
d[l[i]].append(i)
t=n
for i in sorted(d,reverse=True):
for j in d[i]:
ans[j]=t
t-=1
e=[n+1]*(n+1)
f=0
s=SegmentTree(e)
for i in range(n-1,-1,-1):
e[ans[i]]=i
t = s.query(ans[i],n)
s.__setitem__(ans[i],i+1)
if l[i]!=t:
f=1
break
if f==1:
print(-1)
else:
print(*ans)
``` | instruction | 0 | 86,654 | 12 | 173,308 |
No | output | 1 | 86,654 | 12 | 173,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has written some permutation p_1, p_2, …, p_n of integers from 1 to n, so for all 1 ≤ i ≤ n it is true that 1 ≤ p_i ≤ n and all p_1, p_2, …, p_n are different. After that he wrote n numbers next_1, next_2, …, next_n. The number next_i is equal to the minimal index i < j ≤ n, such that p_j > p_i. If there is no such j let's let's define as next_i = n + 1.
In the evening Vasya went home from school and due to rain, his notebook got wet. Now it is impossible to read some written numbers. Permutation and some values next_i are completely lost! If for some i the value next_i is lost, let's say that next_i = -1.
You are given numbers next_1, next_2, …, next_n (maybe some of them are equal to -1). Help Vasya to find such permutation p_1, p_2, …, p_n of integers from 1 to n, that he can write it to the notebook and all numbers next_i, which are not equal to -1, will be correct.
Input
The first line contains one integer t — the number of test cases (1 ≤ t ≤ 100 000).
Next 2 ⋅ t lines contains the description of test cases,two lines for each. The first line contains one integer n — the length of the permutation, written by Vasya (1 ≤ n ≤ 500 000). The second line contains n integers next_1, next_2, …, next_n, separated by spaces (next_i = -1 or i < next_i ≤ n + 1).
It is guaranteed, that the sum of n in all test cases doesn't exceed 500 000.
In hacks you can only use one test case, so T = 1.
Output
Print T lines, in i-th of them answer to the i-th test case.
If there is no such permutations p_1, p_2, …, p_n of integers from 1 to n, that Vasya could write, print the only number -1.
In the other case print n different integers p_1, p_2, …, p_n, separated by spaces (1 ≤ p_i ≤ n). All defined values of next_i which are not equal to -1 should be computed correctly p_1, p_2, …, p_n using defenition given in the statement of the problem. If there exists more than one solution you can find any of them.
Example
Input
6
3
2 3 4
2
3 3
3
-1 -1 -1
3
3 4 -1
1
2
4
4 -1 4 5
Output
1 2 3
2 1
2 1 3
-1
1
3 2 1 4
Note
In the first test case for permutation p = [1, 2, 3] Vasya should write next = [2, 3, 4], because each number in permutation is less than next. It's easy to see, that it is the only satisfying permutation.
In the third test case, any permutation can be the answer because all numbers next_i are lost.
In the fourth test case, there is no satisfying permutation, so the answer is -1.
Submitted Solution:
```
def main():
from sys import stdin, stdout
def read():
return stdin.readline().rstrip('\n')
def read_array(sep=None, maxsplit=-1):
return read().split(sep, maxsplit)
def read_int():
return int(read())
def read_int_array(sep=None, maxsplit=-1):
return [int(a) for a in read_array(sep, maxsplit)]
def write(*args, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in args) + end)
def write_array(array, **kwargs):
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
stdout.write(sep.join(str(a) for a in array) + end)
def toposort(graph):
n = len(graph)
res, color = [], [0] * n
def dfs(start):
stack = [start]
while stack:
start = stack[-1]
if color[start] == 0:
color[start] = 1
for child in graph[start]:
if color[child] == 0:
stack.append(child)
elif color[child] == 1:
return None
elif color[start] == 1:
color[start] = 2
else:
x = stack.pop()
color[x] = 2
res.append(x)
for i in range(n):
if color[i] == 0:
dfs(i)
return list(reversed(res))
t = read_int()
for _ in range(t):
n = read_int()
nxt = read_int_array()
g = [[] for _ in range(n)]
stack = []
for i in range(n):
while stack and stack[-1][0] == i:
stack.pop()
if stack:
g[i].append(stack[-1][1])
x = nxt[i]
if x == -1:
continue
if x == n + 1:
stack = [(n+1, i)]
else:
idx = x - 1
g[i].append(idx)
stack.append((idx, i))
tpsrt = toposort(g)
if not tpsrt:
write('-1')
else:
write(' '.join(str(x+1) for x in tpsrt))
main()
``` | instruction | 0 | 86,655 | 12 | 173,310 |
No | output | 1 | 86,655 | 12 | 173,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,656 | 12 | 173,312 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
l=[int(i) for i in input().split()]
if n==1:
print(max(l[0],-l[0]-1))
exit()
if l.count(0)==n and n&1:
print(*l)
exit()
if l.count(0)==n and n&1==0:
l=[-1]*n
print(*l)
exit()
if n%2==0:
c=sum(i&1 for i in l)
c1=sum(i&1==0 for i in l)
for i in range(n):
if l[i]>=0:
l[i]=-l[i]-1
print(*l)
exit()
if n&1:
for i in range(n):
if l[i]>=0:
l[i]=-l[i]-1
l=[[l[i],i] for i in range(n)]
l.sort()
f=0
for i in range(n):
if l[i][0]!=-1:
l[i][0]=-l[i][0]-1
f=1
break
if not f:
l=[0]*n
print(*l)
exit()
ans=[0]*n
for i in range(n):
ans[l[i][1]]=l[i][0]
print(*ans)
``` | output | 1 | 86,656 | 12 | 173,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,657 | 12 | 173,314 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
arr = list(map(int,input().split(" ")))
is_zero = 0
neg,pos,zero=0,0,[]
min_neg=-1
def p(array):
print(*array)
# for i in array:
# print(i,sep=' ')
for i in range(len(arr)):
if(arr[i]!=-1):
min_neg=i
break
if(min_neg==-1 and n%2==1):
arr[0]=0
p(arr)
exit()
for i in range(len(arr)):
if(arr[i]<0 and arr[i]!=-1):
neg+=1
elif(arr[i]>0):
arr[i]=-1*arr[i]-1
else:
arr[i] =-1
zero.append(i)
if(arr[i]<arr[min_neg] and arr[i]!=-1):
min_neg = i
if(n%2==0):
p(arr)
else:
arr[min_neg]=-1*arr[min_neg]-1
p(arr)
``` | output | 1 | 86,657 | 12 | 173,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,658 | 12 | 173,316 |
Tags: greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
if n % 2 == 0:
for i in range(n):
if a[i] >= 0:
a[i] = -a[i] - 1
print(" ".join(map(str, a)))
else:
for i in range(n):
if a[i] >= 0:
a[i] = -a[i] - 1
min_a = 10**10
for i in range(n):
if a[i] < min_a:
min_a = a[i]
min_ind = i
a[min_ind] = -a[min_ind] - 1
print(" ".join(map(str, a)))
``` | output | 1 | 86,658 | 12 | 173,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,659 | 12 | 173,318 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
nums = [int(_) for _ in input().strip().split()]
ma_idx = 0
ma = 0
for idx, num in enumerate(nums):
if num >= 0:
nums[idx] = -1*num-1
if -1*nums[idx] > ma:
ma = -1*nums[idx]
ma_idx = idx
if n%2 == 1:
nums[ma_idx] = -1* nums[ma_idx] -1
print(' '.join([str(_) for _ in nums]))
``` | output | 1 | 86,659 | 12 | 173,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,660 | 12 | 173,320 |
Tags: greedy, implementation
Correct Solution:
```
def f(L):
for i in range(len(L)):
if(L[i]>=0):
L[i]=L[i]*(-1)-1
if(len(L)%2!=0):
m=min(L)
L[L.index(m)]=-L[L.index(m)]-1
return(L)
n=int(input())
L=list(map(int,input().split()))
print(*f(L))
``` | output | 1 | 86,660 | 12 | 173,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,661 | 12 | 173,322 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
if (n % 2) == 1:
flag = 1
else:
flag = 0
for i in range(n):
if(l[i] >= 0):
l[i] = -(l[i]+1)
if(flag == 1):
l[l.index(min(l))] = -(l[l.index(min(l))]+1)
for i in l:
print(i,end = " ")
print()
``` | output | 1 | 86,661 | 12 | 173,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,662 | 12 | 173,324 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
for i in range(n):
if a[i]>=0:
a[i]=a[i]*(-1)-1
if n%2!=0:
m=min(a)
a[a.index(m)]=a[a.index(m)]*(-1)-1
print(*a)
``` | output | 1 | 86,662 | 12 | 173,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2 | instruction | 0 | 86,663 | 12 | 173,326 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
c=0
for i in range(n):
if l[i]>=0:c+=1
for i in range(n):
if l[i]>=0:l[i] = -l[i]-1
k = l.index(min(l))
if n%2==0 and (c%2==1 or c%2==0):print(*l)
else:l[k] = -(l[k]+1);print(*l)
``` | output | 1 | 86,663 | 12 | 173,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
mn=100000000
p=1
L=[]
j=0
from math import *
ss=input()
s=ss.split()
for i in range(n):
x=int(s[i])
c=min(x,-x-1)
L.append(c)
if (mn>c):
mn=c
j=i
if (n%2==0):
for i in range(n):
print(L[i],' ',end='')
else:
for i in range(n):
if (i!=j):
print(L[i],' ',end='')
else:
print(-L[j]-1,' ',end='')
``` | instruction | 0 | 86,664 | 12 | 173,328 |
Yes | output | 1 | 86,664 | 12 | 173,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n = int(input())
array = list(map(int, input().split(" ")))
for i in range(len(array)):
if(array[i]>=0):
array[i] = -array[i]-1
if(len(array)%2!=0):
min_index = array.index(min(array))
array[min_index] = -array[min_index]-1
print(*array)
``` | instruction | 0 | 86,665 | 12 | 173,330 |
Yes | output | 1 | 86,665 | 12 | 173,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
l1=[]
l1.extend(l)
l2=[]
for i in range(n):
if l[i]>=0:
l[i]=-l[i]-1
if n%2==0:
print(*l)
else:
m=l.index(min(l))
l[m]=-l[m]-1
print(*l)
``` | instruction | 0 | 86,666 | 12 | 173,332 |
Yes | output | 1 | 86,666 | 12 | 173,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
array = list(map(int,input().split(' ')))
def awesome_array(n, array):
ls = []
for i in array:
if i>=0:
i = i*(-1)-1
ls.append(i)
if (n-1)%2==0:
ls[ls.index(min(ls))]=min(ls)*(-1)-1
return ls
print(' '.join(map(str,awesome_array(n, array))))
``` | instruction | 0 | 86,667 | 12 | 173,334 |
Yes | output | 1 | 86,667 | 12 | 173,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
import math
from decimal import Decimal
def na():
n = int(input())
b = [int(x) for x in input().split()]
return n,b
def nab():
n = int(input())
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
return n,b,c
def dv():
n, m = map(int, input().split())
return n,m
def dva():
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
return n,m,b
def eratosthenes(n):
sieve = list(range(n + 1))
for i in sieve:
if i > 1:
for j in range(i + i, len(sieve), i):
sieve[j] = 0
return sorted(set(sieve))
def nm():
n = int(input())
b = [int(x) for x in input().split()]
m = int(input())
c = [int(x) for x in input().split()]
return n,b,m,c
def dvs():
n = int(input())
m = int(input())
return n, m
n, a = na()
if n == 1 and a[0] == 0:
print(0)
exit()
if n % 2 == 0:
for i in a:
if i < 0:
print(i, end = ' ')
else:
print(-i-1, end = ' ')
else:
mn = 99999999999
for i in a:
if i < mn and i > 0:
mn = i
if mn == 99999999999:
mn = min(a)
f = False
for i in a:
if not f and i == mn:
if mn < 0:
print(abs(i) - 1, end = ' ')
else:
print(i)
f = True
else:
if i < 0:
print(i, end = ' ')
else:
print(-i-1)
``` | instruction | 0 | 86,668 | 12 | 173,336 |
No | output | 1 | 86,668 | 12 | 173,337 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n = int(input())
li = list(map(int,input().split()))
co1 = 0
co2 = 0
co3 = 0
negmin = 10000001
posmin = 10000001
for i in range(len(li)):
if li[i] == -1:
co3 = co3+1
elif li[i] < 0:
co1 = co1+1
val = abs(li[i])
if val < negmin:
negmin = val
else:
co2 = co2+1
if li[i] < posmin:
posmin = li[i]
flag = 0
f=0
g=0
h=0
for j in range(len(li)):
if li[j] > 0:
if co2%2 == 0:
li[j] = -li[j]-1
else:
if li[j] == posmin and flag == 0:
flag = 1
else:
li[j] = -li[j]-1
elif li[j] == -1:
if co3%2 != 0 and g == 0:
g = 1
li[j] = 0
else:
if co1%2 != 0 and co3%2 == 0:
if li[j] == negmin and f == 0:
li[j] = -li[j]-1
f = 0
elif co1%2 == 0 and co3%2 != 0:
if li[j] == negmin and h == 0:
h = 0
li[j] = -li[j]-1
for w in range(len(li)):
print(li[w],end=' ')
``` | instruction | 0 | 86,669 | 12 | 173,338 |
No | output | 1 | 86,669 | 12 | 173,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
n=int(input())
arr=list(map(int,input().split()));
neg=[];ans=[0]*n;cnt=0;ans1=1
for i in range(n):
ans1*=arr[i]
if arr[i]>=0:neg.append([i,(arr[i]+1),1]);cnt+=1;ans[i]=-(arr[i]+1)
elif arr[i]==-1:cnt+=1;ans[i]=-1;continue
elif arr[i]<0:cnt+=1;neg.append([i,abs(arr[i]),-1]);ans[i]=arr[i]
#print(ans,cnt)
if cnt%2==0:print(ans)
else:
neg=sorted(neg,key=lambda x:x[1]);ans2=1
for i in range(len(neg)):
if arr[neg[i][0]]==0:continue
else:ans[neg[i][0]]=neg[i][1]-1;break
for i in range(n):ans2*=ans[i]
if ans1>ans2:print(*arr)
else:print(*ans)
``` | instruction | 0 | 86,670 | 12 | 173,340 |
No | output | 1 | 86,670 | 12 | 173,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick had received an awesome array of integers a=[a_1, a_2, ..., a_n] as a gift for his 5 birthday from his mother. He was already going to explore its various properties but after unpacking he was disappointed a lot because the product a_1 ⋅ a_2 ⋅ ... a_n of its elements seemed to him not large enough.
He was ready to throw out the array, but his mother reassured him. She told him, that array would not be spoiled after the following operation: choose any index i (1 ≤ i ≤ n) and do a_i := -a_i - 1.
For example, he can change array [3, -1, -4, 1] to an array [-4, -1, 3, 1] after applying this operation to elements with indices i=1 and i=3.
Kolya had immediately understood that sometimes it's possible to increase the product of integers of the array a lot. Now he has decided that he wants to get an array with the maximal possible product of integers using only this operation with its elements (possibly zero, one or more times, as many as he wants), it is not forbidden to do this operation several times for the same index.
Help Kolya and print the array with the maximal possible product of elements a_1 ⋅ a_2 ⋅ ... a_n which can be received using only this operation in some order.
If there are multiple answers, print any of them.
Input
The first line contains integer n (1 ≤ n ≤ 10^{5}) — number of integers in the array.
The second line contains n integers a_1, a_2, …, a_n (-10^{6} ≤ a_i ≤ 10^{6}) — elements of the array
Output
Print n numbers — elements of the array with the maximal possible product of elements which can be received using only this operation in some order from the given array.
If there are multiple answers, print any of them.
Examples
Input
4
2 2 2 2
Output
-3 -3 -3 -3
Input
1
0
Output
0
Input
3
-3 -3 2
Output
-3 -3 2
Submitted Solution:
```
# print(solve(0,0,k,0))
n = int(input())
la = list(map(int,input().split()))
count1,count2 = 0,0
l = []
for i in range(len(la)):
l.append([la[i],i])
l.sort(reverse=True)
for i in l:
if i[0]<0 == 0:
count1+=1
else:
count2+=1
if count1%2 == 0:
if count2%2 == 0:
for j,i in enumerate(l):
if i[0]<0:
# ans*=i[0]
continue
else:
# ans*=(i[0]+1)
l[j][0] = -(l[j][0]+1)
# print(ans)
else:
co = 0
for j,i in enumerate(l):
if co == count2-1:
break
else:
l[j][0] = -(l[j][0]+1)
# ans*=(i[0]+1)
co+=1
for i in l:
if i[0]<0:
# ans*=i[0]
continue
# print(ans)
else:
if count2 == 0:
l[-1][0] = abs(l[-1][0])-1
for i in l[1:]:
# ans*=i[0]
continue
# print(ans)
elif count2>0:
if count2%2 == 0:
co = 0
for j,i in enumerate(l):
if co == count2-1:
# ans*=i[0]
continue
else:
l[j][0] = -(l[j][0]+1)
# ans*=(i[0]+1)
co+=1
# print(ans)
else:
for j,i in enumerate(l):
if i[0]<0:
# ans*=i[0]
continue
else:
l[j][0] = -(l[j][0]+1)
# ans*=(i[0]+1)
# print(ans)
for i in l:
la[i[1]] = i[0]
print(*la)
``` | instruction | 0 | 86,671 | 12 | 173,342 |
No | output | 1 | 86,671 | 12 | 173,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,769 | 12 | 173,538 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import string
from collections import defaultdict,Counter
from math import sqrt, log10, log2, log, gcd, ceil, floor,factorial
from bisect import bisect_left, bisect_right
from itertools import combinations,combinations_with_replacement
import sys,io,os
input=sys.stdin.readline
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# print=sys.stdout.write
sys.setrecursionlimit(10000)
mod=10**9+7
inf = float('inf')
def get_list():
return [int(i) for i in input().split()]
def yn(a):
print("YES" if a else "NO",flush=False)
t=1
t=int(input())
for i in range(t):
n,k=get_list()
l=get_list()
pre=[0]*(2*k+2)
for iter1 in range(n):
iter2=n-1-iter1
pre[2]+=2
pre[2*k+1]-=2
mina=min(1+l[iter1],1+l[iter2])
maxa=max(k+l[iter1],k+l[iter2])
pre[mina]-=1
pre[maxa+1]+=1
pre[l[iter1]+l[iter2]]-=1
pre[l[iter1]+l[iter2]+1]+=1
for i in range(1,len(pre)):
pre[i]+=pre[i-1]
print(min(pre[2:2*k+1])//2)
``` | output | 1 | 86,769 | 12 | 173,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,770 | 12 | 173,540 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
from itertools import accumulate
### TEMPLATE <<<
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return (map(int,input().split()))
### TEMPLATE >>>
def sgn(x):
if x>0:
return '+'
else:
return '-'
def solve(n, k, a):
h = [0] * (2*k + 5)
# print(h)
for i in range(n//2):
j = n - i - 1
h[0] += 2;
h[min(a[i], a[j]) + 1] -= 1
h[a[i] + a[j]] -= 1
h[a[i] + a[j] + 1] += 1
h[max(a[i], a[j]) + k + 1] += 1
pref = list(accumulate(h))
return min(pref)
def main():
T = int(input())
for tt in range(T):
n, k = invr()
a = list(invr())
print(solve(n, k, a))
main()
``` | output | 1 | 86,770 | 12 | 173,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,771 | 12 | 173,542 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
from itertools import accumulate
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
A = list(map(int, input().split()))
B = [0]*(2*k+2)
for i in range(n//2):
m = min(A[i], A[n-1-i])
M = max(A[i], A[n-1-i])
s = A[i] + A[n-1-i]
l = m+1
r = M+k
#2
B[0] += 2
B[l] -= 2
B[r+1] += 2
B[-1] -= 2
#1
B[l] += 1
B[s] -= 1
B[s+1] += 1
B[r+1] -= 1
C = list(accumulate(B))
#print(C)
ans = 10**18
for i in range(2, 2*k+1):
ans = min(ans, C[i])
print(ans)
``` | output | 1 | 86,771 | 12 | 173,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,772 | 12 | 173,544 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def rotate(a, i):
t = a[i+2]
a[i + 2] = a[i + 1]
a[i + 1] = a[i]
a[i] = t
def solve(n, a):
sa = sorted(a)
s = []
rolled = False
i = 0
while i < n:
for j in range(i, n):
if a[j] == sa[i]:
break
while j - i >= 2:
j -= 2
rotate(a, j)
s.append(j+1)
if i+1 == j:
if i+2 < n:
rotate(a, i)
rotate(a, i)
s.append(i+1)
s.append(i+1)
else:
if rolled:
wi(-1)
return
found = False
for k in range(n-2, 0, -1):
if len(set(a[k-1:k+2])) == 2:
found = True
break
if found:
if a[k-1] == a[k]:
rotate(a, k - 1)
rotate(a, k - 1)
s.append(k)
s.append(k)
else:
rotate(a, k - 1)
s.append(k)
rolled = True
i = k-2
else:
wi(-1)
return
i += 1
if len(s) <= n*n:
wi(len(s))
wia(s)
else:
wi(-1)
def main():
for _ in range(ri()):
n = ri()
a = ria()
solve(n, a)
if __name__ == '__main__':
main()
``` | output | 1 | 86,772 | 12 | 173,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,773 | 12 | 173,546 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
#!/usr/bin/env python
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def main():
t = inp()
for i in range(t):
solve()
def solve():
nk = inlt()
n = nk[0]
k = nk[1]
lst = inlt()
count_map = {}
prefs = [0] * (2 * k + 2)
for i in range(n // 2):
a = lst[i]
b = lst[n - i - 1]
s = a + b
count_map[s] = count_map.get(s, 0) + 1
start = min(a, b) + 1
end = max(a, b) + k + 1
prefs[start] += 1
prefs[end] -= 1
sums = []
total = 0
for num in prefs:
total += num
sums.append(total)
min_len = n
for x in range(2, 2 * k + 1):
cur = sums[x] - count_map.get(x, 0) + (n // 2 - sums[x]) * 2
min_len = min(min_len, cur)
print(min_len)
BUFSIZE = 8192
def inp():
return (int(input()))
def inlt():
return (list(map(int, input().split())))
def insr():
return (input().strip())
def invr():
return (map(int, input().split()))
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 86,773 | 12 | 173,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,774 | 12 | 173,548 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
s=[]
for i in range(n):
for j in range(n-2):
if(l[j]>l[j+1]):
l[j],l[j+2]=l[j+2],l[j]
l[j],l[j+1]=l[j+1],l[j]
s.append(j+1)
s.append(j+1)
elif(l[j+1]>l[j+2]):
l[j],l[j+1]=l[j+1],l[j]
l[j],l[j+2]=l[j+2],l[j]
s.append(j+1)
if(l!=sorted(l)):
print(-1)
else:
print(len(s))
print(*s)
``` | output | 1 | 86,774 | 12 | 173,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,775 | 12 | 173,550 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import sys
input=sys.stdin.readline
def bs(l,target,n):
low=0
high=n
ans=-1
while low<=high:
mid=low+(high-low)//2
if l[mid]<=target:
ans=max(ans,mid)
low=mid+1
else:
high=mid-1
return ans
t=int(input())
for r in range(t):
n,k=map(int,input().split())
l=list(map(int,input().split()))
d={}
start=[]
end=[]
i=0
j=n-1
while i<j:
start.append(min(l[i],l[j])+1)
end.append(max(l[i],l[j])+k)
try:
d[l[i]+l[j]]+=1
except:
d[l[i]+l[j]]=1
i+=1
j-=1
start.sort()
end.sort()
mini=999999999999999
for i in range(1,(2*k)+1):
a=bs(start,i,len(start)-1)+1
b=bs(end,i-1,len(end)-1)+1
# print(a,b)
one=a-b
zero=0
try:
zero=d[i]
except:
pass
twos=(n//2)-(one)
ans=(twos*2)+(one-zero)
# print("x: "+str(i)+" ans: "+str(ans))
# print("0: "+str(zero)+" 1: "+str(one-zero)+" 2: "+str(twos))
mini=min(mini,ans)
print(mini)
``` | output | 1 | 86,775 | 12 | 173,551 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2 | instruction | 0 | 86,776 | 12 | 173,552 |
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import math
from decimal import *
getcontext().prec = 30
t = int(input())
while t:
t -= 1
n, k = map(int, input().split())
a = list(map(int, input().split()))
l=[0]*(2*k+2)
for i in range(n//2):
l[1]+=2
l[2*k+1]-=2
mini=min(a[i],a[n-1-i])+1
maxi=max(a[i],a[n-1-i])+k
sum=a[i]+a[n-1-i]
l[mini]+=-1
l[maxi+1]+=1
l[sum]+=-1
l[sum+1]+=1
ans=10**10
for i in range(2,2*k+1):
l[i]+=l[i-1]
ans=min(ans,l[i])
print(ans)
``` | output | 1 | 86,776 | 12 | 173,553 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
from bisect import bisect, bisect_left, bisect_right
def solve():
n, k = map(int, input().split())
ar = list(map(int, input().split()))
ocr = {}
mpv = [None] * (n // 2)
spv = [None] * (n // 2)
for i in range(n // 2):
x = ar[i] + ar[n - i - 1]
mpx = max(ar[i], ar[n - i - 1]) + k
spx = min(ar[i], ar[n - i - 1]) + 1
spv[i] = spx
mpv[i] = mpx
if x in ocr:
ocr[x] += 1
else:
ocr[x] = 1
mpv.sort()
spv.sort()
items = [(v, k) for k, v in ocr.items()]
items.sort()
items.reverse()
best = n // 2
for ocr, x in items:
over = bisect_left(mpv, x, 0, len(mpv))
under = n // 2 - bisect_right(spv, x, 0, len(spv))
cur = n // 2 - ocr + over + under
if cur < best:
best = cur
print(best)
t = int(input())
for _ in range(t):
solve()
# solve()
``` | instruction | 0 | 86,777 | 12 | 173,554 |
Yes | output | 1 | 86,777 | 12 | 173,555 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
def solve(n, k, arr):
temp = [0 for i in range(0, 2*k + 10)]
for i in range(0, n//2):
v1 = arr[i]
v2 = arr[n - 1 - i]
# p1 = 2
p1 = min(v1, v2) + 1
p2 = v1 + v2
p3 = max(v1, v2) + k
# p5 = k + k
temp[2] += 2
temp[p1] -= 1
temp[p2] -= 1
temp[p2 + 1] += 1
temp[p3 + 1] += 1
res = n
cur = 0
for i in range(2, 2*k + 1):
cur += temp[i]
res = min(cur, res)
return res
t = int(input())
for i in range(0, t):
n, k = map(int, input().split())
arr = list(map(int, input().split()))
res = solve(n, k, arr)
print(res)
``` | instruction | 0 | 86,778 | 12 | 173,556 |
Yes | output | 1 | 86,778 | 12 | 173,557 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
t=int(input())
for _ in range(t):
n,k=map(int,input().split(" "))
arr=list(map(int,input().split(" ")))
start,end=2,2*k
ans=float('inf')
pairs=n//2
temp=[0]*(2*k+1)
d={}
for i in range(n//2):
val=arr[i]+arr[n-i-1]
if val not in d:
d[val]=1
else:
d[val]+=1
for i in range(n//2):
mm=min(arr[i],arr[n-i-1])+1
maxx=max(min(arr[i]+k,2*k),min(arr[n-i-1]+k,2*k))
temp[mm]+=1
if maxx+1<=2*k:
temp[maxx+1]-=1
for i in range(1,2*k+1):
temp[i]+=temp[i-1]
for num in range(start,end+1):
zeros=ones=twos=0
if num in d:
zeros=d[num]
ones=temp[num]-zeros
twos=pairs-ones-zeros
val=ones+(twos*2)
ans=min(ans,val)
print(ans)
``` | instruction | 0 | 86,779 | 12 | 173,558 |
Yes | output | 1 | 86,779 | 12 | 173,559 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
def foo(n, data, k):
farr = [0] * (2 * k + 1)
sarr = [0] * (2 * k + 2)
i = 0
while i < n // 2:
farr[data[i] + data[size - i - 1]] += 1
i += 1
i = 0
while i < n // 2:
sarr[min(data[i], data[size - i - 1]) + 1] += 1
sarr[max(data[i], data[size - i - 1]) + k + 1] -= 1
i += 1
i = 1
while i < (2 * k + 1):
sarr[i] += sarr[i - 1]
i += 1
i = 0
minimum = int(2 * 10e5)
while i <= k * 2:
minimum = min(minimum, (sarr[i] - farr[i]) + 2 * (n // 2 - sarr[i]))
i += 1
print(minimum)
if __name__ == '__main__':
test = int(input())
while test:
size, k = [int(x) for x in input().split()]
data = [int(i) for i in input().split()]
foo(size, data, k)
test -= 1
``` | instruction | 0 | 86,780 | 12 | 173,560 |
Yes | output | 1 | 86,780 | 12 | 173,561 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
import collections
line = input()
t = int(line)
for _ in range(t):
line = input()
n = int(line)
line = input()
nums = [int(i) for i in line.split(' ')]
res = collections.deque()
for i in range(n - 2):
for j in range(n - 3, i-1, -1):
if nums[j + 2] < nums[j + 1] and nums[j + 2] < nums[j]:
a, b, c = nums[j + 2], nums[j + 1], nums[j]
nums[j], nums[j + 1], nums[j + 2] = a, c, b
res.append(j + 1)
if nums[i] > nums[i + 1]:
a, b, c = nums[i], nums[i + 1], nums[i + 2]
nums[i], nums[i + 1], nums[i + 2] = b, c, a
res.append(i + 1)
res.append(i + 1)
# print(nums)
if nums[-1] < nums[-2]:
i = n - 2
while i >= 0 and nums[i] != nums[i + 1]:
i -= 1
if i < 0:
print(-1)
else:
while i < n - 2:
res.append(i + 1)
res.append(i + 1)
i += 1
print(len(res))
for i in res:
print(i, end= ' ')
print()
else:
print(len(res))
for i in res:
print(i, end= ' ')
print()
``` | instruction | 0 | 86,781 | 12 | 173,562 |
No | output | 1 | 86,781 | 12 | 173,563 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
q = int(input())
for _ in range(q):
n, k = list(map(int, input().split(" ")))
arr = list(map(int, input().split(" ")))
ans = [0 for i in range(2*k + 1)]
# MIN = float("inf")
# for i in range(2, 2*k + 1):
# count = 0
if n == 2:
print(0)
continue
for j in range(n//2):
x, y = arr[j], arr[n-1-j]
mid = x + y
if 2 < mid < 2*k :
ans[mid+1] += 1
ans[mid] -= 1
endr = max(x, y) + k
endl = min(x, y) + 1
if endr < 2*k :
ans[endr+1] += 1
ans[endl] += 1
if endl != 2:
ans[2] += 2
ans[endl] -= 2
for i in range(1, 2*k + 1):
ans[i] += ans[i-1]
ans[0], ans[1] =float("inf"), float("inf")
print(min(ans))
# val = arr[j] + arr[n-1-j]
# if val == i:
# continue
# elif val > i:
# if 1 + min(arr[j] , arr[n-1-j]) > i:
# count += 2
# else:
# count += 1
#
# else:
# if max(arr[j] , arr[n-1-j]) + k < i:
# count += 2
# else:
# count += 1
#
# MIN = min(MIN, count)
# print(MIN)
``` | instruction | 0 | 86,782 | 12 | 173,564 |
No | output | 1 | 86,782 | 12 | 173,565 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
''' Constant Palindrome Sum
'''
def search(ls, bound, dxn, home, outer):
print(ls, bound, dxn, home, outer)
if home == outer:
return home
if home - outer == 1:
if (ls[outer] - bound)*dxn <= 0:
return outer
elif (ls[home] - bound)*dxn <= 0:
return home
avg = (home + outer) // 2
val = ls[avg]
if (val - bound)*dxn > 0:
return search(ls, bound, dxn, home, avg)
elif (val - bound)*dxn < 0:
return search(ls, bound, dxn, avg, outer)
else:
return avg
''' routine '''
T = int(input())
for test in range(T):
N , K = list(map(int, input().split()))
array = list(map(int, input().split()))
totalpairs = N // 2
pairsum = {}
lowerbound = 2
upperbound = 2*K
bothexceed = 0
exceed = 0
for n in range(totalpairs):
a1 = array[n]
a2 = array[N - 1 - n]
sm = a1 + a2
if a1 > K and a2 > K:
bothexceed += 1
continue
elif a1 > K or a2 > K:
exceed += 1
elif a1 <= K and a2 <= K and sm > K and sm <= 2*K:
if sm in pairsum.keys():
pairsum[sm] += 1
else:
pairsum[sm] = 1
lowerbound = max(min(a1, a2) + 1, lowerbound)
upperbound = min(max(a1, a2) + K, upperbound)
# print(lowerbound, upperbound)
pairsum = list(pairsum.items())
pairsum.sort(key=lambda x:x[0])
if len(pairsum) == 0:
print(2*bothexceed + exceed)
continue
sums = [pair[0] for pair in pairsum]
mincoord = len(sums)
while True:
if mincoord == 0:
break
elif sums[mincoord - 1] >= lowerbound:
mincoord -= 1
else: break
maxcoord = -1
while True:
if maxcoord == len(sums) - 1:
break
elif sums[maxcoord + 1] <= upperbound:
maxcoord += 1
else: break
# print(mincoord, maxcoord)
if maxcoord + 1 - mincoord > 0:
shortlist = pairsum[mincoord:maxcoord + 1]
shortlist.sort(key=lambda x:x[1])
# print(shortlist)
modesum = shortlist[-1][0]
modeqty = shortlist[-1][1]
changes = totalpairs - modeqty + bothexceed
else:
changes = totalpairs + bothexceed
# no common sum in range without
print(changes)
``` | instruction | 0 | 86,783 | 12 | 173,566 |
No | output | 1 | 86,783 | 12 | 173,567 |
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 a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
def solve(arr,s,k):
hs = s // 2
psum = [0]*hs
for i in range(hs):
psum[i] = arr[i]+arr[s-i-1]
highsum = [0]*hs
lowsum = [0]*hs
ans = 10**10
loh = ans
hol = 0
for i in range(hs) :
lowsum[i] = min(arr[i],arr[s-i-1])+1
highsum[i] = max(arr[i],arr[s-i-1])+k
hol = max(hol,lowsum[i])
loh = min(loh,highsum[i])
# print("hol {}".format(hol))
# print("loh {}".format(loh))
for ele in range(hol,loh+1) :
changes = 0
for i in range(hs) :
if(ele != psum[i]) :
if(ele >= lowsum[i] and ele <= highsum[i]) :
changes += 1
else :
changes += 2
ans = min(ans,changes)
return ans
tc = int(input())
fun = solve
ans = ""
for ll in range(tc) :
_,k = map(int,input().split())
li = [int(x) for x in input().split()]
ans += "{}\n".format(fun(li,_,k))
print(ans)
``` | instruction | 0 | 86,784 | 12 | 173,568 |
No | output | 1 | 86,784 | 12 | 173,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7. | instruction | 0 | 86,785 | 12 | 173,570 |
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
lis = list(map(int,input().split()))
ans=0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
ans = max(ans,lis[i] | lis[j] | lis[k])
print(ans)
``` | output | 1 | 86,785 | 12 | 173,571 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.