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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example. | instruction | 0 | 64,933 | 12 | 129,866 |
Tags: constructive algorithms
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
l = set(a)
s = sorted(list(i for i in range(1, 1+n) if i not in l))[::-1]
ar = a.copy()
ok = True
for i in range(1, n):
if a[i] == a[i-1]:
e = s.pop()
if a[i] < e:
ok = False
break
else:
ar[i] = e
if ok:
print(*ar)
else:
print(-1)
``` | output | 1 | 64,933 | 12 | 129,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example. | instruction | 0 | 64,934 | 12 | 129,868 |
Tags: constructive algorithms
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
q=[int(x) for x in input().strip().split()]
boo=[True]*(n+1)
p=[0]*n
p[0]=q[0]
boo[q[0]-1]=False
for j in range(1,n):
if q[j]!=q[j-1]:
p[j]=q[j]
boo[q[j]-1]=False
else:
p[j]=-q[j]
j=0
g=0
a=0
while not boo[j]:
j+=1
while j<n:
w=0
while p[g]>0:
g+=1
if g==n:
w=1
break
if w==1:
break
if j+1<-p[g]:
p[g]=j+1
boo[j]=False
else:
a=1
break
while not boo[j]:
j+=1
if a==0:
print(*p)
else:
print(-1)
``` | output | 1 | 64,934 | 12 | 129,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
from __future__ import print_function # for PyPy2
# from itertools import permutations
# from functools import cmp_to_key # for adding custom comparator
# from fractions import Fraction
from collections import *
from sys import stdin
import sys
# from bisect import *
from heapq import *
from math import log2, ceil, sqrt, gcd, log
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")
# range = xrange
t, = gil()
for _ in range(t):
n, = gil()
a = gil()
ans = [None]*n
left = set(range(1, n+1))
left.remove(a[0])
ans[0] = a[0]
for i in range(1, n):
if a[i] != a[i-1]:
ans[i] = a[i]
if ans[i] in left:left.remove(ans[i])
left = list(left)
left.sort(reverse=True)
for i in range(n):
if ans[i] == None:
if left:ans[i] = left.pop()
# print(ans, a)
if None in ans:
print(-1)
else:
maxi = 0
for i in range(n):
maxi = max(maxi, ans[i])
if a[i] != maxi:
break
if a[i] == maxi:
print(*ans)
else:
print(-1)
``` | instruction | 0 | 64,935 | 12 | 129,870 |
Yes | output | 1 | 64,935 | 12 | 129,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
import sys, os, io
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')
import math,datetime,functools
from collections import deque,defaultdict,OrderedDict
import collections
def main():
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
#Solving Area Starts-->
for _ in range(ri()):
n=ri()
a=ria()
d={}
d[a[0]]=1
ans=[0]*n
ans[0]=a[0]
t=0
for i in range(n):
if a[i]<i+1:
wi(-1)
t=1
break
if t==1:continue
k=0
for i in range(1,n):
if a[i]!=a[i-1]:
if a[i] not in d:
d[a[i]]=1
ans[i]=a[i]
dict = OrderedDict(sorted(d.items()))
need=[]
for i in range(1,n+1):
if i not in d:
need.append(i)
de=collections.deque(need)
# print(de,"deq")
for i in range(n):
if ans[i]==0:
ans[i]=de[0]
de.popleft()
print(*ans)
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
``` | instruction | 0 | 64,936 | 12 | 129,872 |
Yes | output | 1 | 64,936 | 12 | 129,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
for i in range(0,int(input())):
n=int(input())
l=list(map(int,input().split()))
f=0
if len(l)==1:
print(l[0])
else:
for j in range(0,n):
if l[j]<=j:
print(-1)
f=1
break
if f!=1:
l2=[]
for j in range(0,n):
l2.append(0)
for j in range(0,n):
l2[l[j]-1]+=1
np=[]
for j in range(n-1,-1,-1):
if l2[j]==0:
np.append(j+1)
k=0
for j in range(n-1,-1,-1):
if l[j]==l[j-1]:
l[j]=np[k]
k+=1
#print(l)
for j in l:
print(j,end=" ")
print()
``` | instruction | 0 | 64,937 | 12 | 129,874 |
Yes | output | 1 | 64,937 | 12 | 129,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for tc in range(t):
n = int(input())
arr = [int(z) for z in input().split()]
maxsofar = 0
used = set()
res = []
ans = 0
for i in range(n):
if arr[i] > maxsofar:
res.append(arr[i])
for b in range(maxsofar + 1, arr[i]):
used.add(b)
maxsofar = max(maxsofar, arr[i])
else:
if len(used) > 0:
res.append(used.pop())
else:
ans = 1
break
if ans == 1:
print(-1)
continue
#print(res)
print(' '.join([str(i) for i in res]))
# arrinp = arr[:]
#
# used = []
#
# for i in range(n):
# used.append(arr[i])
#
# unused = []
#
# for x in range(1, n+1):
# if x not in used:
# unused.append(x)
#
# unused.sort(reverse=True)
#
# #print(unused)
#
# for i in range(1, n):
# if arr[i] == arr[i - 1]:
# arr[i] = unused.pop()
#
# maxsofar = 0
# maxreslst = []
#
# for i in range(n):
# maxsofar = max(maxsofar, arr[i])
# maxreslst.append(maxsofar)
#
# #print(maxreslst, arrinp)
#
# if maxreslst == arrinp and len(set(arr)) == len(arr):
# print(' '.join([str(i) for i in arr]))
# else:
# print(-1)
``` | instruction | 0 | 64,938 | 12 | 129,876 |
Yes | output | 1 | 64,938 | 12 | 129,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
for i in range(int(input())):
n = int(input())
s = list(map(int, input().split()))
ans = []
ch = []
for j in range(len(s)):
if j == 0:
if s[0] > 1:
for o in range(1, s[0]):
ch.append(o)
else:
if s[j] - ans[-1] > 1:
for o in range(ans[-1] + 1, s[j]):
ch.append(o)
ans.append(s[j])
k = 0
chh = True
for j in range(len(ans)):
if j > 0 and ans[j] < j:
if ans[j] == ans[j - 1]:
ans[j] = ch[k]
k += 1
if ans[j] > s[j]:
chh = False
print(-1)
break
else:
chh = False
print(-1)
break
if chh:
print(*ans)
``` | instruction | 0 | 64,939 | 12 | 129,878 |
No | output | 1 | 64,939 | 12 | 129,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
p = []
b = False
if n == 1:
if a[0] == 1:
print(1)
else:
print(-1)
continue
for i in range(n - 1):
if a[i] == a[i + 1]:
if a[i] != n:
b = True
break
else:
a = a[:i + 1]
break
if b:
print(-1)
else:
for i in range(1, n + 1):
if i not in a:
a.append(i)
print(*a)
``` | instruction | 0 | 64,940 | 12 | 129,880 |
No | output | 1 | 64,940 | 12 | 129,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
import math,sys
t=int(input())
while t!=0:
t-=1
n=int(input())
a = list(map(int,input().split()))
p = [i for i in range(1,n+1)]
ans=[None]*n
piku=None
for i in range(n):
if a[i] in p:
ans[i] = a[i]
p[p.index(a[i])]=pow(2,40)
if i>0 and max(ans[0:i+1])!=a[i]:
print('-1')
piku=1
break
else:
ans[i]=min(p)
if i>0 and max(ans[0:i+1])!=a[i]:
print('-1')
piku=1
break
if piku:
continue
else:
print(' '.join(map(str,ans)))
``` | instruction | 0 | 64,941 | 12 | 129,882 |
No | output | 1 | 64,941 | 12 | 129,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n.
You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:
* q_1=p_1,
* q_2=max(p_1, p_2),
* q_3=max(p_1, p_2,p_3),
* ...
* q_n=max(p_1, p_2,...,p_n).
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).
Input
The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.
The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).
The sum of all values n over all the test cases in the input doesn't exceed 10^5.
Output
For each test case, print:
* If it's impossible to find such a permutation p, print "-1" (without quotes).
* Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them.
Example
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
Note
In the first test case of the example answer [1,3,4,5,2] is the only possible answer:
* q_{1} = p_{1} = 1;
* q_{2} = max(p_{1}, p_{2}) = 3;
* q_{3} = max(p_{1}, p_{2}, p_{3}) = 4;
* q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5;
* q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5.
It can be proved that there are no answers for the second test case of the example.
Submitted Solution:
```
from collections import Counter
kolvo = int(input())
for i in range(kolvo):
long = int(input())
sp = input().split()
q = [int(x) for x in sp]
c = Counter(q)
doing = True
for n in c:
if int(n) < int(c[n]):
doing = False
print(-1)
if len(q) > 10000:
doing = False
print(-1)
if doing:
p = ["" for x in sp]
first = True
for j in range(len(q)):
if first:
first = False
p[0] = q[0]
else:
if q[j] != q[j-1]:
p[j] = q[j]
else:
k = q[j]-1
while k in (p):
k -= 1
p[j] = k
if (sorted(p)[0] == 1) and (sorted(p)[-1] == len(p)):
print(*p)
else:
print(-1)
``` | instruction | 0 | 64,942 | 12 | 129,884 |
No | output | 1 | 64,942 | 12 | 129,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,007 | 12 | 130,014 |
Tags: binary search, data structures
Correct Solution:
```
import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def read_int():
res = b''
while True:
d = sys.stdin.buffer.read(1)
if d == b'-' or d.isdigit():
res += d
elif res:
break
return int(res)
def main():
from gc import collect
n, m = (read_int(), read_int())
acc = array('i', [0]) * (n + 1)
for _ in range(n):
acc[read_int()] += 1
for i in range(n):
acc[i + 1] += acc[i]
collect()
query = array('i', [0]) * m
for i in range(m):
query[i] = read_int()
collect()
ok, ng = n + 1, 0
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
cnt = acc[mid]
for q in query:
if q > 0:
if mid >= q:
cnt += 1
else:
if cnt >= -q:
cnt -= 1
if cnt:
ok = mid
else:
ng = mid
print(ok if ok < n + 1 else 0)
if __name__ == '__main__':
main()
``` | output | 1 | 65,007 | 12 | 130,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,008 | 12 | 130,016 |
Tags: binary search, data structures
Correct Solution:
```
from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
#from functools import lru_cache #use @lru_cache(None)
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
#
#scan integer
import gc, os
ii,_inp =0, b''
#fd = os.open("in.txt", os.O_RDONLY)
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 50000)
#_inp = os.read(fd, 50000)
gc.collect(); ii = 0
if not _inp: return b' '[0]
ii += 1
return _inp[ii - 1]
def intut():
c = getchar()
if c == b'-'[0]: x = 0; sign = 1
else: x = c - b'0'[0]; sign = 0
c = getchar()
while c >= b'0'[0]: x = 10*x + c - b'0'[0]; c=getchar()
if c == b'\r'[0]: getchar()
return -x if sign else x
#def input(): return sys.stdin.readline()
def mapi(arg=0): return map(int if arg==0 else str,input().split())
#------------------------------------------------------------------
n = intut()
q = intut()
mx = n+1
bit = [0]*(mx)
def update(idx,val):
while idx<n:
bit[idx]+=val
idx|=idx+1
def query(x):
idx = -1; m=n.bit_length()
for i in range(m-1,-1,-1):
rightIdx = idx+(1<<i)
if rightIdx<n and x>=bit[rightIdx]:
idx = rightIdx
x-=bit[idx]
return idx+1
for i in range(n+q):
x = intut()
ans = x-1
val = 1
if x<0:
val = -1
ans = query(-x-1)
update(ans,val)
res = 0
for i in range(n):
if bit[i]>0:
res = i+1
break
print(res)
#os.close(fd)
``` | output | 1 | 65,008 | 12 | 130,017 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,009 | 12 | 130,018 |
Tags: binary search, data structures
Correct Solution:
```
from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
#from functools import lru_cache #use @lru_cache(None)
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
#
#scan integer
import gc, os
ii,_inp =0, b''
#fd = os.open("in.txt", os.O_RDONLY)
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 50000)
#_inp = os.read(fd, 50000)
gc.collect(); ii = 0
if not _inp: return b' '[0]
ii += 1
return _inp[ii - 1]
def intut():
c = getchar()
if c == b'-'[0]: x = 0; sign = 1
else: x = c - b'0'[0]; sign = 0
c = getchar()
while c >= b'0'[0]: x = 10*x + c - b'0'[0]; c=getchar()
if c == b'\r'[0]: getchar()
return -x if sign else x
#def input(): return sys.stdin.readline()
def mapi(arg=0): return map(int if arg==0 else str,input().split())
#------------------------------------------------------------------
n = intut()
q = intut()
mx = n+1
bit = [0]*(mx)
def update(idx,val):
while idx<n:
bit[idx]+=val
#idx+=idx&(-idx)
idx|=idx+1
def query(x):
idx = -1
m = n.bit_length()
for i in range(m-1,-1,-1):
rightIdx = idx+(1<<i)
if rightIdx<n and x>=bit[rightIdx]:
idx = rightIdx
x-=bit[idx]
return idx+1
for i in range(n):
x = intut()
update(x-1,1)
for i in range(q):
x = intut()
ans = x-1
val = 1
if x<0:
val = -1
ans = query(-x-1)
#while r-l>=0:
# mid = (l+r)>>1
# #print("YES")
# if query(mid)>=-x:
# ans = mid
# r = mid-1
# else:
# l = mid+1
update(ans,val)
res = 0
for i in range(n):
if bit[i]>0:
res = i+1
break
print(res)
#os.close(fd)
``` | output | 1 | 65,009 | 12 | 130,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,010 | 12 | 130,020 |
Tags: binary search, data structures
Correct Solution:
```
# ll = lambda: list(map(int, input().split()))
# s = lambda: input()
# v = lambda: map(int, input().split())
# ii = lambda: int(input())
import math
import os
import sys
input = sys.stdin.readline
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 4000)
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
def update(i,add):
while(i<n+1):
l[i]+=add
i+=(i&(-i))
def sum(i):
s=0
while(i>0):
s+=l[i]
i-=(i&(-i))
return s
def find(k):
curr=0
ans=0
prevsum=0
for i in range(19,-1,-1):
if((curr+(1<<i)<n+1) and l[curr+(1<<i)]+prevsum<k):
ans=curr+(1<<i)
curr=ans
prevsum+=l[curr]
return ans+1
n=input()
q=input()
l=[0]*(n+1)
for i in range(n):
update(input(),1)
for m in range(q):
i=input()
if(i<0):
i=abs(i)
o=find(i)
update(o,-1)
else:
update(i, 1)
ss=sum(n)
i=n
if(ss!=0):
hi = n
lo = 0
while (hi > lo):
mid = (hi + lo) // 2
if (sum(mid) >= ss):
hi = mid
else:
lo = mid + 1
print(lo)
else:
print(0)
#print(l)
#print(sum(5))
#
# 5 5
# 1 2 3 4 5
# -1 -1 -1 -1 -1
``` | output | 1 | 65,010 | 12 | 130,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,011 | 12 | 130,022 |
Tags: binary search, data structures
Correct Solution:
```
import os
import sys
input = sys.stdin.readline
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 4000)
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
class FenwickTree:
def __init__(self, x):
"""transform list into BIT"""
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def add(self, idx, x):
"""updates bit[idx] += x"""
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
"""calc sum(bit[:end])"""
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def find(self, k):
"""Find largest idx such that sum(bit[:idx]) <= k"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
n = input()
q = input()
final = [0]*n
ft= FenwickTree(final)
#Agregamos los elementos al array. Guardamos en nuestro fenwick tree la cantidad total de cada elemento en cada hoja.
for i in range(n):
x = input()
ft.add(x-1,1)
#Realizamos los query
#1-indexed, por lo que hay que restar 1 al valor de la query
for i in range(q):
k = input()
#Si es mayor a 0, agregamos 1 al contador del kesimo elemento
if k >= 0:
ft.add(k-1,1)
#Si es menor, encontramos el kesimo y le restamos 1
else:
kth = ft.find(-k-1)
ft.add(kth,-1)
#Si nuestra lista al final contiene solo 0, siginifica que no hay elementos en el multiset.
#1-indexed, por lo que hay que sumar uno al index de nuestro array
for i in range(n+1):
if i == n:
print(0)
break
if final[i] != 0:
print(i+1)
break
``` | output | 1 | 65,011 | 12 | 130,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,012 | 12 | 130,024 |
Tags: binary search, data structures
Correct Solution:
```
import sys, os, gc
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 25000)
gc.collect()
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
def main():
n = input()
q = input()
bit = [0]*n
for _ in range(n + q):
x = input()
if x < 0:
val = -1
k = -x - 1
idx = -1
for d in reversed(range(n.bit_length())):
right_idx = idx + (1 << d)
if right_idx < n and k >= bit[right_idx]:
idx = right_idx
k -= bit[idx]
idx += 1
else:
val = 1
idx = x - 1
while idx < n:
bit[idx] += val
idx |= idx + 1
i = 0
while i < n and not bit[i]:
i += 1
if i == n:
os.write(1, b'0')
else:
os.write(1, str(i + 1).encode('ascii'))
main()
``` | output | 1 | 65,012 | 12 | 130,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,013 | 12 | 130,026 |
Tags: binary search, data structures
Correct Solution:
```
'''
#------------------------------------------------------------------------
import os
import sys
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------'''
import sys
import gc, os
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 100000)
gc.collect()
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
def f(x):
fi=0
for y in a:
if y<=x:
fi+=1
for i in range(q):
if k[i]>0 and k[i]<=x:
fi+=1
elif k[i]<0 and -k[i]<=fi:
fi-=1
return fi>0
t=1
for i in range(t):
n=input()
q=input()
a=[]
k=[]
for i in range(n):
a.append(input())
for i in range(q):
k.append(input())
l=1
r=n+1
while l<r:
mid=(l+r)//2
if f(mid):
r=mid
else:
l=mid+1
ans=l if l<n+1 else 0
print(ans)
``` | output | 1 | 65,013 | 12 | 130,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer. | instruction | 0 | 65,014 | 12 | 130,028 |
Tags: binary search, data structures
Correct Solution:
```
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import sys, os, gc
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 50000)
gc.collect()
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
"""
1 2 3 4 5
1 2 3 4
2 3 4
2 3
3
"""
def solve():
N = input()
Q = input()
binary_tree = [0]*(N+1)
def update(index, value, bi_tree):
"""
Updates the binary indexed tree with the given value
:param index: index at which the update is to be made
:param value: the new element at the index
:param array: the input array
:param bi_tree: the array representation of the binary indexed tree
:return: void
"""
while index < N+1:
bi_tree[index] += value
index += index & -index
for i in range(N+Q):
x = input()
if x > 0:
while x < N+1:
binary_tree[x] += 1
x += x & -x
else:
idx = 0
K = -x-1
L = len(bin(N))-2
for j in range(L-1,-1,-1):
R = idx + pow(2,j)
if R < N+1 and K >= binary_tree[R]:
idx = R
K -= binary_tree[idx]
idx += 1
while idx < N+1:
binary_tree[idx] -= 1
idx += idx & -idx
#print(binary_tree)
for i in range(1,N+1):
if binary_tree[i] > 0:
return i
return 0
#for _ in range(getInt()):
print(solve())
#solve()
``` | output | 1 | 65,014 | 12 | 130,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
import sys, os
class FenwickTree:
def __init__(self, x):
"""transform list into BIT"""
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
"""updates bit[idx] += x"""
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
"""calc sum(bit[:end])"""
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""Find largest idx such that sum(bit[:idx]) <= k"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 4000)
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
n = input()
q = input()
A = [0]*n
for _ in range(n):
A[input() - 1] += 1
fen = FenwickTree(A)
for _ in range(q):
x = input()
if x < 0:
fen.update(fen.findkth(-x - 1), -1)
else:
fen.update(x - 1, 1)
i = 0
while i < n and not A[i]:
i += 1
if i == n:
os.write(1, b'0')
else:
os.write(1, str(i + 1).encode('ascii'))
``` | instruction | 0 | 65,015 | 12 | 130,030 |
Yes | output | 1 | 65,015 | 12 | 130,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import sys, os, gc
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 50000)
gc.collect()
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
class FenwickTree:
def __init__(self, x):
"""transform list into BIT"""
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
"""updates bit[idx] += x"""
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
"""calc sum(bit[:end])"""
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""Find largest idx such that sum(bit[:idx]) <= k"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
"""
1 2 3 4 5
1 2 3 4
2 3 4
2 3
3
"""
def solve():
N = input()
Q = input()
binary_tree = [0]*N
bit = FenwickTree(binary_tree)
for i in range(N+Q):
x = input()
if x >= 0:
bit.update(x-1,1)
else:
bit.update(bit.findkth(-x-1),-1)
for i in range(N):
if bit.bit[i] > 0:
return i+1
return 0
#for _ in range(getInt()):
print(solve())
#solve()
``` | instruction | 0 | 65,016 | 12 | 130,032 |
Yes | output | 1 | 65,016 | 12 | 130,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
# pajenegod's input
import os
from array import array
# From https://github.com/cheran-senthil/PyRival/blob/master/pyrival/data_structures/SegmentTree.py
class SegmentTree: # modified: using typed array with initial size, added bisect method
def __init__(self, size, default=0, func=max):
"""initialize the segment tree with default at size length"""
self._default = default
self._func = func
self._len = size
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = array("i", (default for i in range(2 * _size)))
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):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def bisect(self, k):
# Return index such that: self.query(0, index) < k <= self.query(0, index + 1)
i = 1
res = self._default
while i < self._size:
i = 2 * i # left child
nextRes = self._func(res, self.data[i])
if nextRes < k:
res = nextRes
i += 1 # right child
index = i - self._size
# assert index == self.bisectSlow(k)
return index
def bisectSlow(self, k):
# Return index such that: self.query(0, index) < k <= self.query(0, index + 1)
# Naive implementation
DEBUG = False
lo = 0
hi = self._len
if DEBUG:
assert self.query(0, lo) < k <= self.query(0, hi)
while hi - lo > 1:
mid = (lo + hi) // 2
if self.query(0, mid) >= k:
hi = mid
else:
lo = mid
if DEBUG:
assert self.query(0, lo) < k <= self.query(0, hi)
assert lo + 1 == hi
if DEBUG:
assert self.query(0, lo) < k <= self.query(0, lo + 1)
return lo
def solve(N, Q, A, K):
# Note both A and K are generators that should only be consumed once
M = 10 ** 6
segTree = SegmentTree(M + 1, 0, lambda x, y: x + y)
for x in A:
segTree[x] += 1
for k in K:
if k > 0:
segTree[k] += 1
else:
assert k < 0
k *= -1
# search for first point where func of the prefix >= k
index = segTree.bisect(k)
assert segTree[index] > 0
segTree[index] -= 1
for i in range(len(segTree)):
if segTree[i] > 0:
return i
return 0
ii = 0
_inp = b""
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 4096)
ii = 0
if not _inp:
return b" "[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b"-"[0]:
x = 0
sign = 1
else:
x = c - b"0"[0]
sign = 0
c = getchar()
while c >= b"0"[0]:
x = 10 * x + c - b"0"[0]
c = getchar()
if c == b"\r"[0]:
getchar()
return -x if sign else x
def inputIntArray(N):
for i in range(N):
yield input()
if __name__ == "__main__":
N, Q = inputIntArray(2)
A = inputIntArray(N)
K = inputIntArray(Q)
ans = solve(N, Q, A, K)
print(ans)
``` | instruction | 0 | 65,017 | 12 | 130,034 |
Yes | output | 1 | 65,017 | 12 | 130,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
import sys, os, gc
class FenwickTree:
def __init__(self, x):
"""transform list into BIT"""
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
"""updates bit[idx] += x"""
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
"""calc sum(bit[:end])"""
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""Find largest idx such that sum(bit[:idx]) <= k"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
ii = 0
_inp = b''
def getchar():
global ii, _inp
if ii >= len(_inp):
_inp = os.read(0, 100000)
gc.collect()
ii = 0
if not _inp:
return b' '[0]
ii += 1
return _inp[ii - 1]
def input():
c = getchar()
if c == b'-'[0]:
x = 0
sign = 1
else:
x = c - b'0'[0]
sign = 0
c = getchar()
while c >= b'0'[0]:
x = 10 * x + c - b'0'[0]
c = getchar()
if c == b'\r'[0]:
getchar()
return -x if sign else x
def main():
n = input()
q = input()
A = [0]*n
for _ in range(n):
A[input() - 1] += 1
fen = FenwickTree(A)
for _ in range(q):
x = input()
if x < 0:
fen.update(fen.findkth(-x - 1), -1)
else:
fen.update(x - 1, 1)
i = 0
while i < n and not A[i]:
i += 1
if i == n:
os.write(1, b'0')
else:
os.write(1, str(i + 1).encode('ascii'))
main()
``` | instruction | 0 | 65,018 | 12 | 130,036 |
Yes | output | 1 | 65,018 | 12 | 130,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
from sys import stdout, stdin
_input, _print = stdin.buffer.readline, stdout.write
_int, _dict, _sorted = int, dict, sorted
from collections import defaultdict
def solution():
n, q = [_int(i) for i in _input().split()]
arr = defaultdict(_int)
temp = stdin.readline(100)
while temp[-1] != '\n':
for i in temp.split():
arr[_int(i)] += 1
keys = _sorted(arr.keys())
temp = stdin.readline(100)
while temp[-1] != '\n':
for i in temp.split():
t = _int(i)
if t < 0:
t = -t
for j in keys:
t -= arr[j]
if t <= 0:
arr[j] -= 1
break
else:
arr[t] += 1
for i in keys:
if arr[i] > 0:
print(i)
break
else:
print(0)
solution()
``` | instruction | 0 | 65,019 | 12 | 130,038 |
No | output | 1 | 65,019 | 12 | 130,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def read_int():
res = b''
while True:
d = sys.stdin.buffer.read(1)
if d == b'-' or d.isdigit():
res += d
elif res:
break
return int(res)
def main():
from gc import collect
n, m = (read_int(), read_int())
acc = array('i', [0]) * (n + 1)
for _ in range(n):
acc[read_int()] += 1
for i in range(n):
acc[i + 1] += acc[i]
collect()
query = array('i', [0]) * m
for i in range(m):
query[i] = read_int()
collect()
ok, ng = n + 1, 0
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
cnt = acc[mid]
for q in query:
if q > 0:
if mid <= q:
cnt += 1
else:
if cnt >= -q:
cnt -= 1
if cnt:
ok = mid
else:
ng = mid
print(ok if ok < n + 1 else 0)
if __name__ == '__main__':
main()
``` | instruction | 0 | 65,020 | 12 | 130,040 |
No | output | 1 | 65,020 | 12 | 130,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
# cook your dish here
n,q=map(int,input().split())
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
def solve(x):
c=0
for i in range(n):
if(l1[i]<=x):
c+=1
for i in range(q):
if(l2[i]>0 and l2[i]<=x):
c+=1
elif(l2[i]<0 and abs(l2[i])<=x):
c-=1
return c
x=0
y=n
while(x<y):
mid=(x+y)//2
if(solve(mid)>0):
x=mid+1
else:
y=mid-1
print(x)
``` | instruction | 0 | 65,021 | 12 | 130,042 |
No | output | 1 | 65,021 | 12 | 130,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Note that the memory limit is unusual.
You are given a multiset consisting of n integers. You have to process queries of two types:
* add integer k into the multiset;
* find the k-th order statistics in the multiset and remove it.
k-th order statistics in the multiset is the k-th element in the sorted list of all elements of the multiset. For example, if the multiset contains elements 1, 4, 2, 1, 4, 5, 7, and k = 3, then you have to find the 3-rd element in [1, 1, 2, 4, 4, 5, 7], which is 2. If you try to delete an element which occurs multiple times in the multiset, only one occurence is removed.
After processing all queries, print any number belonging to the multiset, or say that it is empty.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^6) — the number of elements in the initial multiset and the number of queries, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ n) — the elements of the multiset.
The third line contains q integers k_1, k_2, ..., k_q, each representing a query:
* if 1 ≤ k_i ≤ n, then the i-th query is "insert k_i into the multiset";
* if k_i < 0, then the i-th query is "remove the |k_i|-th order statistics from the multiset". For this query, it is guaranteed that |k_i| is not greater than the size of the multiset.
Output
If the multiset is empty after all queries, print 0.
Otherwise, print any integer that belongs to the resulting multiset.
Examples
Input
5 5
1 2 3 4 5
-1 -1 -1 -1 -1
Output
0
Input
5 4
1 2 3 4 5
-5 -1 -3 -1
Output
3
Input
6 2
1 1 1 2 3 4
5 6
Output
6
Note
In the first example, all elements of the multiset are deleted.
In the second example, the elements 5, 1, 4, 2 are deleted (they are listed in chronological order of their removal).
In the third example, 6 is not the only answer.
Submitted Solution:
```
def inp():
return(int(input()))
import math
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
import bisect
#python3 codeforces_1354D.py
N,Q = inlt()
li = sorted(inlt())
k = inlt()
def check(value):
total = 0
for i in range(len(li)):
if li[i] <= value:
total +=1
for i in range(len(k)):
if k[i] > 0 and k[i] <= value:
total +=1
else:
if abs(k[i]) <= total:
total -=1
return total
lo = 1
hi = 10 ** 6 + 1
while lo < hi - 1:
mid = (lo + hi) // 2
if check(mid) > 0:
hi = mid
else:
lo = mid
print(lo)
``` | instruction | 0 | 65,022 | 12 | 130,044 |
No | output | 1 | 65,022 | 12 | 130,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,092 | 12 | 130,184 |
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n,k = map(int,input().split())
l=[]
m=[]
if (k*2+1)>n:
print(-1)
else:
l.append(1)
for i in range(2,n+1):
if i not in m:
if k:
l.append(i+1)
m.append(i+1)
l.append(i)
k-=1
else:
l.append(i)
print(*l)
``` | output | 1 | 65,092 | 12 | 130,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,093 | 12 | 130,186 |
Tags: constructive algorithms, implementation
Correct Solution:
```
for s in[*open(0)][1:]:
n,k=map(int,s.split());a=[*range(1,n+1)];i=1
while i<min(n-1,2*k):a[i],a[i+1]=a[i+1],a[i];i+=2
print(*(a,[-1])[i<2*k])
``` | output | 1 | 65,093 | 12 | 130,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,094 | 12 | 130,188 |
Tags: constructive algorithms, implementation
Correct Solution:
```
# import sys
# sys.stdin=open('input.txt','r')
# sys.stdout=open('output.txt','w')
def arrIn():
return list(map(int,input().split()))
def mapIn():
return map(int,input().split())
def check_palindrome(s):
n=len(s)
for i in range(n):
if s[i]!=s[n-i-1]:return False
return True
for ii in range(int(input())):
n,p=mapIn()
x=n//2
# if n==1:
# print(a[i])
# continue
x=n//2
if n%2==0:x-=1
# print(x)
if p>x:print(-1)
else:
a=[0]*n
c=0
x=n
if p!=0:
for i in range(1,n,2):
a[i]=x
x-=1
c+=1
if c==p:
break
y=1
for i in range(n):
if a[i]==0:
a[i]=y
y+=1
for i in range(n):
print(a[i],end=" ")
print()
``` | output | 1 | 65,094 | 12 | 130,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,095 | 12 | 130,190 |
Tags: constructive algorithms, implementation
Correct Solution:
```
# right answer
import math
t = int(input())
for asdfasfd in range(0, t):
n, a = map(int, input().split())
perm = [x for x in range(1, n + 1)]
if a > math.ceil(n/2) - 1:
print("-1")
else:
# there is the permutation
for i in range(0, a):
tmp = perm[-1 - 2*i]
perm[-1 - 2*i] = perm[-1 - (2*i + 1)]
perm[-1 - (2*i + 1)] = tmp
print(" ".join(str(x) for x in perm))
``` | output | 1 | 65,095 | 12 | 130,191 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,096 | 12 | 130,192 |
Tags: constructive algorithms, implementation
Correct Solution:
```
test_count = int(input())
for _ in range(test_count):
n,k = [int(x) for x in input().split()]
max_k = (n-1)//2
if k>max_k:
print ('-1')
continue
arr = list(range(1,n+1))
for i in range(k):
arr[2*i+1]= 2*i+3
arr[2*i+2] = 2*i+2
print (' '.join([str(x) for x in arr] ))
``` | output | 1 | 65,096 | 12 | 130,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,097 | 12 | 130,194 |
Tags: constructive algorithms, implementation
Correct Solution:
```
for s in[*open(0)][1:]:
n,k=map(int,s.split());a=[*range(1,n+1)];i=1
while i<2*k:a[i:i+2]=a[i+1:i-1:-1];i+=2
print(*(a,[-1])[i>n])
``` | output | 1 | 65,097 | 12 | 130,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,098 | 12 | 130,196 |
Tags: constructive algorithms, implementation
Correct Solution:
```
def solve(n,k):
if k==0:
print(*range(1,n+1))
elif k==1 and n==2:
print(-1)
elif k==n:
print(-1)
elif k>=(n+1)//2:
print(-1)
else:
ans = [0 for i in range(n)]
i = 1
c=0
d = n
while i<n-1 and c<k:
ans[i] = d
i+=2
c+=1
d-=1
for i in range(n):
if ans[i]==0:
ans[i] = d
d-=1
print(*ans)
t = int(input())
for _ in range(t):
n,k = map(int,input().split())
solve(n,k)
``` | output | 1 | 65,098 | 12 | 130,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}). | instruction | 0 | 65,099 | 12 | 130,198 |
Tags: constructive algorithms, implementation
Correct Solution:
```
'''
Author : Shubhanshu Jain;
'''
import math
import random;
from collections import *
mod =1000000007
r1 = lambda : int(input());
rm = lambda : map(int,input().split());
rms = lambda : map(str,input().split());
rls = lambda : list(rm())
def solve():
test = r1();
while(test):
test-=1;
n, k = rm();
if(((n-1)//2)>=k):
ls = [0]*n;
i = 0;
c = 0;
x = 0;
while(i<n):
if(i%2 and c<k):
c+=1;
else:
ls[i] = x+1;
x+=1;
i+=1;
i = 1;
while(k):
k-=1;
ls[i] = n;
i+=2;
n-=1;
print(*ls)
else:
print(-1);
def def_value():
return "nan"
solve();
``` | output | 1 | 65,099 | 12 | 130,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
if k==0:
ans = [i for i in range(1,n+1)]
print(*ans)
else:
if n==1:
if k==0:
print(1)
else:
print(-1)
elif (n%2==0 and k>=n//2) or (n%2==1 and k>n//2) or n==2:
print(-1)
else:
ans = [0]*n
t = n
for i in range(1,n,2):
if k:
ans[i] = t
t-=1
k-=1
else:
break
for i in range(n):
if ans[i]==0:
ans[i] = t
t-=1
print(*ans)
``` | instruction | 0 | 65,100 | 12 | 130,200 |
Yes | output | 1 | 65,100 | 12 | 130,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
for t in range(int(input())):
n, k = map(int, input().split())
check = 3 + (2)*(k-1)
if n < check:
print(-1)
else:
a = [i for i in range(1, n+1)]
i = 1
while k > 0 and i < (n-1):
a[i], a[i+1] = a[i+1], a[i]
k -= 1
i += 2
print(*a)
``` | instruction | 0 | 65,101 | 12 | 130,202 |
Yes | output | 1 | 65,101 | 12 | 130,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
import math
for _ in range(int(input())):
n,k=map(int,input().split())
t=0
if n%2==0:
t=math.floor((n-1)/2)
else:
t=math.floor(n/2)
if k>t or (n<=2 and k!=0):
print("-1")
else:
newlist = [x for x in range(1,n+1)]
temp=0
for i in range(1,n):
if i%2==0 and k!=0:
temp=newlist[i-1]
newlist[i-1]=newlist[i]
newlist[i]=temp
k-=1
print(*newlist)
``` | instruction | 0 | 65,102 | 12 | 130,204 |
Yes | output | 1 | 65,102 | 12 | 130,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
for _ in range(int(input())):
n, k = map(int, input().split())
if(n < 3 and k == 0):
print(' '.join(map(str, [i for i in range(1, n + 1)])))
elif(n < 3):
print(-1)
else:
if(n % 2 == 0 and k <= n // 2 - 1):
ans = [i for i in range(n + 1)]
count = 0
if(k > 0):
for i in range(2, n):
if(i % 2 == 0):
ans[i] += 1
else:
ans[i] -= 1
count += 1
if(count == k * 2):
break
print(*ans[1:])
elif(n % 2 == 0):
print(-1)
elif(n % 2 == 1 and k <= n // 2):
ans = [i for i in range(n + 1)]
count = 0
if(k > 0):
for i in range(2, n + 1):
if(i % 2 == 0):
ans[i] += 1
else:
ans[i] -= 1
count += 1
if(count == k * 2):
break
print(*ans[1:])
else:
print(-1)
``` | instruction | 0 | 65,103 | 12 | 130,206 |
Yes | output | 1 | 65,103 | 12 | 130,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
t = int(input())
for _ in range(1, t+1):
n, k = map(int, input().split())
if k > int((n-1)/2):
print('-1')
else:
l = list(range(1, n+1))
i = 1
for _ in range(0, k):
l[i], l[i+1] = l[i+1], l[i]
i += 2
print(' '.join(map(str, l)))
``` | instruction | 0 | 65,104 | 12 | 130,208 |
No | output | 1 | 65,104 | 12 | 130,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
def decideK(x):
maxk = 0
if x >= 3:
tmpn = x
maxk += 1; tmpn -= 3
maxk += tmpn // 2
return maxk
def printPeak(n):
x = 1; y = n;
while True:
if x <= y:
print(x, end=' ')
else:
break
if x < y:
print(y, end=' ')
else:
break
x += 1; y -= 1
print()
for _ in range(int(input())):
n, k = map(int, input().split())
if k > decideK(n):
print(-1)
else:
printPeak(n)
``` | instruction | 0 | 65,105 | 12 | 130,210 |
No | output | 1 | 65,105 | 12 | 130,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
arr = []
count = k
for i in range(1,n+1):
arr.append(i)
if n>=3:
for j in range(1,n-1,2):
arr[j],arr[j+1] = arr[j+1],arr[j]
count-=1
if count==0:
break
if count==0:
print(" ".join(map(str,arr)))
else:
print('-1')
elif n==1 and k==0:
print(1)
else:
print('-1')
``` | instruction | 0 | 65,106 | 12 | 130,212 |
No | output | 1 | 65,106 | 12 | 130,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
Given two integers n and k, construct a permutation a of numbers from 1 to n which has exactly k peaks. An index i of an array a of size n is said to be a peak if 1 < i < n and a_i \gt a_{i-1} and a_i \gt a_{i+1}. If such permutation is not possible, then print -1.
Input
The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t lines follow, each containing two space-separated integers n (1 ≤ n ≤ 100) and k (0 ≤ k ≤ n) — the length of an array and the required number of peaks.
Output
Output t lines. For each test case, if there is no permutation with given length and number of peaks, then print -1. Otherwise print a line containing n space-separated integers which forms a permutation of numbers from 1 to n and contains exactly k peaks.
If there are multiple answers, print any.
Example
Input
5
1 0
5 2
6 6
2 1
6 1
Output
1
2 4 1 5 3
-1
-1
1 3 6 5 4 2
Note
In the second test case of the example, we have array a = [2,4,1,5,3]. Here, indices i=2 and i=4 are the peaks of the array. This is because (a_{2} \gt a_{1} , a_{2} \gt a_{3}) and (a_{4} \gt a_{3}, a_{4} \gt a_{5}).
Submitted Solution:
```
y=0
x=int(((y-1960)/10 + 2))
import math
# k=2**(2+(y-1960)/10)
#
# print(x,k)
#
# sum=0
# i=0
# while sum<k:
#
# sum+=math.log2(i+1)
# i+=1
#
# print(sum,i)
########## the next permutations problem solve,,,
def nxtper(arr):## the element before the last element......[1,2] >> take as example.....
inv=len(arr)-2# this is actually one of the base case for the recursive approach if you think that...
while inv>=0 and arr[inv]>=arr[inv+1]:
inv-=1
if(inv<0):
return []
for x in reversed(range(inv,len(arr))):## reversed range does is iterate from the reversed order.....
if arr[x]>arr[inv]:
arr[x],arr[inv]=arr[inv],arr[x]
break
arr[inv+1:]=reversed(arr[inv+1:])
return arr
# ar=[9,1,2,4,3,1,0]
# a=ar=['a','b','a','a','b','c']
# a=ar=['c','b','b','a','a']
# a=input()
# while a!='#':
# ar=list(a)
# a=(nxtper(ar))
# if(a):
# print(''.join(a))
# else:
# print('No Successor')
#
# a=input()
def josf(n, k):
if n == 0:
return 0
else:
return (josf(n - 1, k) + k) % n
t=int(input())
while t:
n,k=map(int,input().split())
ar=[x+1 for x in range(n)]
a=[]
if k<n/2:
if n==1 and k==0:
for x in ar:
print(x, end=' ')
t-=1
print()
continue
p1,p2=0,n-1
if (n%2!=0):
rn=(n)//2+1
else:
rn=n//2
cn=0
for x in range(rn):
if cn>k:
# print(ar[p1-1:p2+2])
a[p1:] =(ar[p1-1:p2+2])
# print(a)
break
a.append(ar[p1])
a.append(ar[p2])
cn+=1
p1+=1
p2-=1
if p2==p1:
a.append(ar[p1])
break
for x in a:
print(x,end=' ')
print()
else:
print(-1)
t-=1
``` | instruction | 0 | 65,107 | 12 | 130,214 |
No | output | 1 | 65,107 | 12 | 130,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's got a birthday coming up and his mom decided to give him an array of positive integers a of length n.
Vasya thinks that an array's beauty is the greatest common divisor of all its elements. His mom, of course, wants to give him as beautiful an array as possible (with largest possible beauty). Unfortunately, the shop has only one array a left. On the plus side, the seller said that he could decrease some numbers in the array (no more than by k for each number).
The seller can obtain array b from array a if the following conditions hold: bi > 0; 0 ≤ ai - bi ≤ k for all 1 ≤ i ≤ n.
Help mom find the maximum possible beauty of the array she will give to Vasya (that seller can obtain).
Input
The first line contains two integers n and k (1 ≤ n ≤ 3·105; 1 ≤ k ≤ 106). The second line contains n integers ai (1 ≤ ai ≤ 106) — array a.
Output
In the single line print a single number — the maximum possible beauty of the resulting array.
Examples
Input
6 1
3 6 10 12 13 16
Output
3
Input
5 3
8 21 52 15 77
Output
7
Note
In the first sample we can obtain the array:
3 6 9 12 12 15
In the second sample we can obtain the next array:
7 21 49 14 77
Submitted Solution:
```
n, k = map(int, input().split())
t = set(map(int, input().split()))
y = x = min(t)
t.remove(x)
t = list(t)
while True:
for i in t:
while i % x > k: x -= 1
if y == x: break
y = x
print(y)
``` | instruction | 0 | 65,153 | 12 | 130,306 |
No | output | 1 | 65,153 | 12 | 130,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's got a birthday coming up and his mom decided to give him an array of positive integers a of length n.
Vasya thinks that an array's beauty is the greatest common divisor of all its elements. His mom, of course, wants to give him as beautiful an array as possible (with largest possible beauty). Unfortunately, the shop has only one array a left. On the plus side, the seller said that he could decrease some numbers in the array (no more than by k for each number).
The seller can obtain array b from array a if the following conditions hold: bi > 0; 0 ≤ ai - bi ≤ k for all 1 ≤ i ≤ n.
Help mom find the maximum possible beauty of the array she will give to Vasya (that seller can obtain).
Input
The first line contains two integers n and k (1 ≤ n ≤ 3·105; 1 ≤ k ≤ 106). The second line contains n integers ai (1 ≤ ai ≤ 106) — array a.
Output
In the single line print a single number — the maximum possible beauty of the resulting array.
Examples
Input
6 1
3 6 10 12 13 16
Output
3
Input
5 3
8 21 52 15 77
Output
7
Note
In the first sample we can obtain the array:
3 6 9 12 12 15
In the second sample we can obtain the next array:
7 21 49 14 77
Submitted Solution:
```
import sys
line = sys.stdin.readline()
n, k = [int(i) for i in line.split()]
line = sys.stdin.readline()
a = []
_min = int(1e7)
_max = 0
accum = [0] * int(1e6+2)
for i in line.split():
j = int(i)
a.append(j)
accum[j]+=1
if j > _max:
_max = j
if j < _min:
_min = j
for i in range(1, _max+1):
accum[i] += accum[i-1]
# 0 1 2 3 4 5 6
# 7 8 9 10 11 12
gcd = k+1;
for i in range(_max, k, -1):
div = True
j = i
comp = i-k
while div:
if j-1 <= _max:
div = accum[j-1] == accum[j-comp]
elif j-comp <= _max:
div = accum[_max] == accum[j-comp]
else:
break
j+=i
if div:
gcd = i
break
print(gcd)
# 1494017343499
``` | instruction | 0 | 65,154 | 12 | 130,308 |
No | output | 1 | 65,154 | 12 | 130,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's got a birthday coming up and his mom decided to give him an array of positive integers a of length n.
Vasya thinks that an array's beauty is the greatest common divisor of all its elements. His mom, of course, wants to give him as beautiful an array as possible (with largest possible beauty). Unfortunately, the shop has only one array a left. On the plus side, the seller said that he could decrease some numbers in the array (no more than by k for each number).
The seller can obtain array b from array a if the following conditions hold: bi > 0; 0 ≤ ai - bi ≤ k for all 1 ≤ i ≤ n.
Help mom find the maximum possible beauty of the array she will give to Vasya (that seller can obtain).
Input
The first line contains two integers n and k (1 ≤ n ≤ 3·105; 1 ≤ k ≤ 106). The second line contains n integers ai (1 ≤ ai ≤ 106) — array a.
Output
In the single line print a single number — the maximum possible beauty of the resulting array.
Examples
Input
6 1
3 6 10 12 13 16
Output
3
Input
5 3
8 21 52 15 77
Output
7
Note
In the first sample we can obtain the array:
3 6 9 12 12 15
In the second sample we can obtain the next array:
7 21 49 14 77
Submitted Solution:
```
import sys
line = sys.stdin.readline()
n, k = [int(i) for i in line.split()]
line = sys.stdin.readline()
a = []
_min = int(1e7)
_max = 0
accum = [0] * int(1e6+2)
for i in line.split():
j = int(i)
a.append(j)
accum[j]+=1
if j > _max:
_max = j
elif j < _min:
_min = j
for i in range(1, _max+1):
accum[i] += accum[i-1]
# 0 1 2 3 4 5 6 7
gcd = k+1;
for i in range(_max, k, -1):
div = True
j = i
comp = i-k
while div:
if j-1 <= _max:
div = accum[j-1] - accum[j-comp] == 0
elif j-comp <= _max:
div = accum[_max] - accum[j-comp] == 0
else:
break
j+=i
if div:
gcd = i
break
print(gcd)
# 1494013162164
``` | instruction | 0 | 65,155 | 12 | 130,310 |
No | output | 1 | 65,155 | 12 | 130,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya's got a birthday coming up and his mom decided to give him an array of positive integers a of length n.
Vasya thinks that an array's beauty is the greatest common divisor of all its elements. His mom, of course, wants to give him as beautiful an array as possible (with largest possible beauty). Unfortunately, the shop has only one array a left. On the plus side, the seller said that he could decrease some numbers in the array (no more than by k for each number).
The seller can obtain array b from array a if the following conditions hold: bi > 0; 0 ≤ ai - bi ≤ k for all 1 ≤ i ≤ n.
Help mom find the maximum possible beauty of the array she will give to Vasya (that seller can obtain).
Input
The first line contains two integers n and k (1 ≤ n ≤ 3·105; 1 ≤ k ≤ 106). The second line contains n integers ai (1 ≤ ai ≤ 106) — array a.
Output
In the single line print a single number — the maximum possible beauty of the resulting array.
Examples
Input
6 1
3 6 10 12 13 16
Output
3
Input
5 3
8 21 52 15 77
Output
7
Note
In the first sample we can obtain the array:
3 6 9 12 12 15
In the second sample we can obtain the next array:
7 21 49 14 77
Submitted Solution:
```
n,k = map(int,input().split())
array = list(map(int,input().split()))
array.sort()
most = array[0]+k
for i in range(most,-1,-1):
arrayCopy = array[:]
count = 0
for element in arrayCopy:
element -= i
remainder = element%i
if remainder<=k:
count+=1
else:
break
if count == len(array):
print(i)
break
``` | instruction | 0 | 65,156 | 12 | 130,312 |
No | output | 1 | 65,156 | 12 | 130,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integer numbers. Let sum(l, r) be the sum of all numbers on positions from l to r non-inclusive (l-th element is counted, r-th element is not counted). For indices l and r holds 0 ≤ l ≤ r ≤ n. Indices in array are numbered from 0.
For example, if a = [ - 5, 3, 9, 4], then sum(0, 1) = - 5, sum(0, 2) = - 2, sum(1, 4) = 16 and sum(i, i) = 0 for each i from 0 to 4.
Choose the indices of three delimiters delim0, delim1, delim2 (0 ≤ delim0 ≤ delim1 ≤ delim2 ≤ n) and divide the array in such a way that the value of res = sum(0, delim0) - sum(delim0, delim1) + sum(delim1, delim2) - sum(delim2, n) is maximal.
Note that some of the expressions sum(l, r) can correspond to empty segments (if l = r for some segment).
Input
The first line contains one integer number n (1 ≤ n ≤ 5000).
The second line contains n numbers a0, a1, ..., an - 1 ( - 109 ≤ ai ≤ 109).
Output
Choose three indices so that the value of res is maximal. If there are multiple answers, print any of them.
Examples
Input
3
-1 2 3
Output
0 1 3
Input
4
0 0 -1 0
Output
0 0 0
Input
1
10000
Output
1 1 1 | instruction | 0 | 65,357 | 12 | 130,714 |
Tags: brute force, data structures, dp
Correct Solution:
```
class MaxSegTree:
def __init__(self, zero, data=None, size=None):
if data is None and size is None:
raise Exception('data and size both cannot be None simultaneously')
if size is None:
size = len(data)
depth = (size-1).bit_length()
self.size = 1 << depth
self.zero = zero
if data is None:
self.data = [zero]*(2*self.size)
else:
self.data = [zero]*self.size + data + [zero]*(self.size-size)
for d in reversed(range(depth)):
t = 1 << d
for i in range(t, 2*t):
self.data[i] = max(self.data[2*i],self.data[2*i+1])
def _max_interval(self, a, b):
result = self.zero
a += self.size
b += self.size
while a < b:
if a & 1:
result = max(result,self.data[a])
a += 1
if b & 1:
b -= 1
result = max(result,self.data[b])
a >>= 1
b >>= 1
return result
def _set_val(self, a, val):
a += self.size
while self.data[a] != val and a > 0:
self.data[a] = val
val = max(val,self.data[a^1])
a >>= 1
def __getitem__(self, i):
if isinstance(i, slice):
return self._max_interval(
0 if i.start is None else i.start,
self.size if i.stop is None else i.stop)
elif isinstance(i, int):
return self.data[i+self.size]
def __setitem__(self, i, x):
self._set_val(i,x)
def __iter__(self):
return iter(self.data[self.size:])
n = int(input())
from itertools import accumulate, chain
C = list((v,i) for i,v in enumerate(chain((0,), accumulate(map(int,input().split())))))
mst = MaxSegTree((-float('inf'),0),C)
a,b,c = None,None,None
best = -float('inf')
for v2,j in C:
v1,i = mst[:j+1]
v3,k = mst[j:]
if v1-v2+v3 > best:
best = v1-v2+v3
a,b,c = i,j,k
print(a,b,c)
``` | output | 1 | 65,357 | 12 | 130,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integer numbers. Let sum(l, r) be the sum of all numbers on positions from l to r non-inclusive (l-th element is counted, r-th element is not counted). For indices l and r holds 0 ≤ l ≤ r ≤ n. Indices in array are numbered from 0.
For example, if a = [ - 5, 3, 9, 4], then sum(0, 1) = - 5, sum(0, 2) = - 2, sum(1, 4) = 16 and sum(i, i) = 0 for each i from 0 to 4.
Choose the indices of three delimiters delim0, delim1, delim2 (0 ≤ delim0 ≤ delim1 ≤ delim2 ≤ n) and divide the array in such a way that the value of res = sum(0, delim0) - sum(delim0, delim1) + sum(delim1, delim2) - sum(delim2, n) is maximal.
Note that some of the expressions sum(l, r) can correspond to empty segments (if l = r for some segment).
Input
The first line contains one integer number n (1 ≤ n ≤ 5000).
The second line contains n numbers a0, a1, ..., an - 1 ( - 109 ≤ ai ≤ 109).
Output
Choose three indices so that the value of res is maximal. If there are multiple answers, print any of them.
Examples
Input
3
-1 2 3
Output
0 1 3
Input
4
0 0 -1 0
Output
0 0 0
Input
1
10000
Output
1 1 1 | instruction | 0 | 65,358 | 12 | 130,716 |
Tags: brute force, data structures, dp
Correct Solution:
```
n=int(input())
a=[5]+list(map(int,input().split()))
dp=[[[i,0] for i in range(n+1)] for j in range(4)]
end=n
indx_a,indx_b,indx_c=0,0,0
for i in range(1,n+1):
dp[0][i][1]=dp[0][i-1][1]+a[i]
dp[1][i][1]=max(dp[0][i-1][1],dp[1][i-1][1])-a[i]
dp[2][i][1]=max(dp[1][i-1][1],dp[2][i-1][1])+a[i]
dp[3][i][1]=max(dp[2][i-1][1],dp[3][i-1][1])-a[i]
dp_indx=[0,0,0,0]
indx=0
pt=3
for i in range(n,0,-1):
if dp[pt][i][1] < dp[pt-1][i][1] :
pt-=1
dp_indx[pt]=i
if pt==0:
break
print(dp_indx[0],dp_indx[1],dp_indx[2])
``` | output | 1 | 65,358 | 12 | 130,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integer numbers. Let sum(l, r) be the sum of all numbers on positions from l to r non-inclusive (l-th element is counted, r-th element is not counted). For indices l and r holds 0 ≤ l ≤ r ≤ n. Indices in array are numbered from 0.
For example, if a = [ - 5, 3, 9, 4], then sum(0, 1) = - 5, sum(0, 2) = - 2, sum(1, 4) = 16 and sum(i, i) = 0 for each i from 0 to 4.
Choose the indices of three delimiters delim0, delim1, delim2 (0 ≤ delim0 ≤ delim1 ≤ delim2 ≤ n) and divide the array in such a way that the value of res = sum(0, delim0) - sum(delim0, delim1) + sum(delim1, delim2) - sum(delim2, n) is maximal.
Note that some of the expressions sum(l, r) can correspond to empty segments (if l = r for some segment).
Input
The first line contains one integer number n (1 ≤ n ≤ 5000).
The second line contains n numbers a0, a1, ..., an - 1 ( - 109 ≤ ai ≤ 109).
Output
Choose three indices so that the value of res is maximal. If there are multiple answers, print any of them.
Examples
Input
3
-1 2 3
Output
0 1 3
Input
4
0 0 -1 0
Output
0 0 0
Input
1
10000
Output
1 1 1 | instruction | 0 | 65,359 | 12 | 130,718 |
Tags: brute force, data structures, dp
Correct Solution:
```
n = int(input())
nums = [int(x) for x in input().split()]
best = [None for x in range(len(nums))]
way = [None for x in range(len(nums))]
def find_best_way():
global best, n, nums, way
for j in range(n - 1, -1, -1):
best[j] = dict()
way[j] = dict()
previous = {'s1':0, 's2':0, 's3':0, 's4':0} if j + 1 == n else best[j + 1]
best[j]['s1'] = -nums[j] + previous['s1']
way[j]['s1'] = 's1'
for i in range(2, 5):
changed = (1 if i % 2 == 0 else -1) * nums[j] + previous[f's{i}']
unchanged = (-1 if i % 2 == 0 else 1) * nums[j] + previous[f's{i - 1}']
if (unchanged >= changed):
best[j][f's{i}'] = unchanged
way[j][f's{i}'] = f's{i - 1}'
continue
best[j][f's{i}'] = changed
way[j][f's{i}'] = f's{i}'
def get_delimiters():
global way, nums, n
qnt = {'s1':0, 's2':0, 's3':0, 's4':0}
s = 's4'
for i in range(n):
qnt[way[i][s]] += 1
s = way[i][s]
d1 = qnt['s4']
d2 = d1 + qnt['s3']
d3 = d2 + qnt['s2']
return d1, d2, d3
find_best_way()
#print(best[0]['s4'])
print(*get_delimiters())
#print(way)
``` | output | 1 | 65,359 | 12 | 130,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call beauty of an array b_1, b_2, …, b_n (n > 1) — min_{1 ≤ i < j ≤ n} |b_i - b_j|.
You're given an array a_1, a_2, … a_n and a number k. Calculate the sum of beauty over all subsequences of the array of length exactly k. As this number can be very large, output it modulo 998244353.
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements.
Input
The first line contains integers n, k (2 ≤ k ≤ n ≤ 1000).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^5).
Output
Output one integer — the sum of beauty over all subsequences of the array of length exactly k. As this number can be very large, output it modulo 998244353.
Examples
Input
4 3
1 7 3 5
Output
8
Input
5 5
1 10 100 1000 10000
Output
9
Note
In the first example, there are 4 subsequences of length 3 — [1, 7, 3], [1, 3, 5], [7, 3, 5], [1, 7, 5], each of which has beauty 2, so answer is 8.
In the second example, there is only one subsequence of length 5 — the whole array, which has the beauty equal to |10-1| = 9. | instruction | 0 | 65,681 | 12 | 131,362 |
Tags: dp
Correct Solution:
```
from collections import defaultdict
import sys
input = sys.stdin.readline
'''
for CASES in range(int(input())):
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
sys.stdout.write(" ".join(map(str,ans))+"\n")
'''
inf = 100000000000000000 # 1e17
mod = 998244353
n, m = map(int, input().split())
A = [0] + sorted(list(map(int, input().split())))
ans = 0
f = [[0] * (n + 10) for _ in range(m + 10)]
for x in range(1,(A[n] - A[1]) // (m - 1) + 1):
for i in range(1, n + 1):
f[1][i] = 1
for i in range(2, m + 1):
sum = 0
pre = 1
for j in range(1, n + 1):
while pre <= n and A[pre] + x <= A[j]:
sum += f[i - 1][pre]
sum %= mod
pre += 1
f[i][j] = sum
for i in range(1, n + 1):
ans += f[m][i]
ans %= mod
print(ans)
# the end
``` | output | 1 | 65,681 | 12 | 131,363 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.