message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
#!/usr/bin/python3
def fix(N, Q, A):
if A.count(Q) == 0:
try:
p = A.index(0)
if p != -1:
A[p] = Q
except ValueError:
pass
if A[0] == 0:
p = -1
for i in range(1, N):
if A[i] > 0:
p = i
break
if p == -1:
return [1] * N
v = A[p]
for i in range(p):
A[i] = v
v = -1
for i in range(N):
if A[i] == 0:
assert v != -1
A[i] = v
else:
v = A[i]
return A
def findseg(segs, segi, i, j, inf):
assert i <= j
seg = segs[segi]
if j - i == 0:
return inf
if j - i == 1:
return seg[i]
acc = inf
if i % 2 == 1:
acc = min(acc, seg[i])
i += 1
if j % 2 == 1:
acc = min(acc, seg[j - 1])
j -= 1
return min(acc, findseg(segs, segi + 1, i // 2, j // 2, inf))
def solve(N, Q, A):
INF = Q + 1
A = fix(N, Q, A)
if A.count(Q) == 0:
return None
segs = [list(A)]
while len(segs[-1]) > 1:
lseg = segs[-1]
if len(lseg) % 2 == 1:
lseg.append(INF)
seg = [min(lseg[2 * i], lseg[2 * i + 1]) for i in range(len(lseg) // 2)]
segs.append(seg)
lefts = [N + 1] * (Q + 1)
rights = [-1] * (Q + 1)
for i in range(N):
v = A[i]
lefts[v] = min(lefts[v], i)
rights[v] = max(rights[v], i)
for v in range(1, Q + 1):
if rights[v] == -1:
continue
left = lefts[v]
right = rights[v]
if findseg(segs, 0, left, right + 1, INF) != v:
return None
return A
def main():
N, Q = [int(e) for e in input().split(' ')]
A = [int(e) for e in input().split(' ')]
ans = solve(N, Q, A)
if ans is None:
print('NO')
else:
print('YES')
print(*ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 30,069 | 12 | 60,138 |
Yes | output | 1 | 30,069 | 12 | 60,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
import sys
n,q = map(int,input().split())
a = list(map(int,input().split()))
l = len(a)
zeros = []
last = dict()
cur_max = 0
last_max = 1
stack = []
for i in range(l-1,-1,-1):
if a[i] == 0:
zeros.append(i)
elif a[i] not in last:
last[a[i]] = i
for i in range(l):
#print("********")
#print(last)
#print(a[i])
if a[i] == 0:
a[i] = max(cur_max,1)
elif a[i] > cur_max and last[a[i]] != i: # ζ³’ε³°
stack.append(cur_max)
cur_max = a[i]
elif cur_max != 0 and i == last[cur_max]:
cur_max = stack.pop()
elif a[i] < cur_max: # ζ³’θ°·
print("NO")
sys.exit(0)
#print(a[i])
#print(cur_max)
#print(stack)
#print("--------")
#print("########")
#print(a)
#print(zeros)
if q > max(a):
if zeros:
print("YES")
a[zeros[0]] = q
print(*a)
else:
print("NO")
elif q == max(a):
print("YES")
print(*a)
elif q < max(a):
print("NO")
``` | instruction | 0 | 30,070 | 12 | 60,140 |
Yes | output | 1 | 30,070 | 12 | 60,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
def isPrime(x):
for i in range(2,x):
if i*i>x:
break
if (x%i==0):
return False
return True
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def si():
return input()
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def power_set(L):
"""
L is a list.
The function returns the power set, but as a list of lists.
"""
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
#the function could stop here closing with
#return powerset
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
def fastPlrintNextLines(a):
# 12
# 3
# 1
#like this
#a is list of strings
print('\n'.join(map(str,a)))
def sortByFirstAndSecond(A):
A = sorted(A,key = lambda x:x[0])
A = sorted(A,key = lambda x:x[1])
return list(A)
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = 1
# t = int(input())
for _ in range(t):
n,q = li()
a = li()
d = defaultdict(lambda:0)
f = 0
current = 0
if q not in a:
if 0 not in a:
print("NO")
continue
a[a.index(0)]=q
for i in range(n):
if a[i]==0:
if i>0:
a[i]=a[i-1]
for i in range(n-2,-1,-1):
if a[i]==0:
a[i]=a[i+1]
d = defaultdict(lambda:0)
for i in range(n):
d[a[i]]=i
f = 0
# print(a)
for i in range(1,n):
if a[i]>=a[i-1]:
continue
if d[a[i-1]]==i-1:
continue
# print(i,d[a[i]],a[i])
f = 1
break
if f==1:
print("NO")
continue
print("YES")
print(*a)
``` | instruction | 0 | 30,071 | 12 | 60,142 |
Yes | output | 1 | 30,071 | 12 | 60,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
n,q=map(int,input().split())
a=list(map(int,input().split()))
b=[0]*(q+1)
nonz=1
nonzi=0
for i in range(n):
if a[i]!=0:
nonz=a[i]
nonzi=i
break
for i in range(nonzi+1):
a[i]=nonz
for i in range(n):
if a[i]>q:
print("NO")
exit(0)
else:
if a[i]==0:
a[i]=a[i-1]
if b[a[i]]==0:
b[a[i]]=1
else:
if a[i-1]!=a[i]:
print("NO")
exit(0)
else:
continue
print("YES")
print(*a)
``` | instruction | 0 | 30,072 | 12 | 60,144 |
No | output | 1 | 30,072 | 12 | 60,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n,q = map(int,input().split())
a = list(map(int,input().split()))
zero = [0]*(n+1)
for ind,i in enumerate(a):
zero[ind+1] = zero[ind]+(not i)
if zero[-1] == n:
print('YES')
print(*[q]*n)
return
if not a.count(q):
print('NO')
return
pos = [-1]*(q+1)
fi = 0
for ind,i in enumerate(a):
if not i:
continue
if not fi:
fi = i
if pos[i] != -1:
x = zero[ind+1]-zero[pos[i]]
if x != ind-pos[i]-1:
print('NO')
return
pos[i] = ind
if not a[0]:
a[0] = fi
for i in range(1,n):
if not a[i]:
a[i] = a[i-1]
print('YES')
print(*a)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | instruction | 0 | 30,073 | 12 | 60,146 |
No | output | 1 | 30,073 | 12 | 60,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
#include <GOD>
#Pato Boride Azin Khone , Vase Hamine Delet Khune
import sys
import math
n , q= map(int , input().split())
arr= [int(i) for i in input().split()]
dd = {}
ddt= {}
isvis = [False]*n
isq=False
iszer=False
for i in range(n):
if(arr[i]==q):
isq=True
if(arr[i]==0):
iszer=True
if(isq==False and iszer ==False ):
print("NO")
sys.exit()
if(isq==False and iszer==True):
for i in range(n) :
if(arr[i] == 0):
arr[i]=q
break
for i in range(n) :
if(arr[i] == 0):
if(i== 0 and n>1 and arr[i+1] != 0) :
arr[i]= arr[i+1]
elif(i != 0) :
arr[i]=arr[i-1]
for i in range(n-1 , -1 , -1) :
if(arr[i] == 0):
if(i== n-1 and n>1 and arr[i-1] != 0) :
arr[i]= arr[i-1]
elif(i != n-1) :
arr[i]=arr[i+1]
if(arr[0]==0) :
for i in range(n):
arr[i] = n
for i in range(n):
if(dd.get(arr[i]) == None) :
dd[arr[i]] = i
for i in range(n-1 , -1 , -1) :
if(ddt.get(arr[i]) == None):
ddt[arr[i]] = i
ans= True
for i in range(1, q+1):
if(ddt.get(i) != None):
for j in range(dd[i] , ddt[i]+1):
if(isvis[j]):
ans=False
break
isvis[j]=True
if(ans == False):
break
if(ans == False):
print("NO")
else:
print("YES")
for i in range(n):
print(arr[i] , end=" ")
``` | instruction | 0 | 30,074 | 12 | 60,148 |
No | output | 1 | 30,074 | 12 | 60,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially there was an array a consisting of n integers. Positions in it are numbered from 1 to n.
Exactly q queries were performed on the array. During the i-th query some segment (l_i, r_i) (1 β€ l_i β€ r_i β€ n) was selected and values of elements on positions from l_i to r_i inclusive got changed to i. The order of the queries couldn't be changed and all q queries were applied. It is also known that every position from 1 to n got covered by at least one segment.
We could have offered you the problem about checking if some given array (consisting of n integers with values from 1 to q) can be obtained by the aforementioned queries. However, we decided that it will come too easy for you.
So the enhancement we introduced to it is the following. Some set of positions (possibly empty) in this array is selected and values of elements on these positions are set to 0.
Your task is to check if this array can be obtained by the aforementioned queries. Also if it can be obtained then restore this array.
If there are multiple possible arrays then print any of them.
Input
The first line contains two integers n and q (1 β€ n, q β€ 2 β
10^5) β the number of elements of the array and the number of queries perfomed on it.
The second line contains n integer numbers a_1, a_2, ..., a_n (0 β€ a_i β€ q) β the resulting array. If element at some position j is equal to 0 then the value of element at this position can be any integer from 1 to q.
Output
Print "YES" if the array a can be obtained by performing q queries. Segments (l_i, r_i) (1 β€ l_i β€ r_i β€ n) are chosen separately for each query. Every position from 1 to n should be covered by at least one segment.
Otherwise print "NO".
If some array can be obtained then print n integers on the second line β the i-th number should be equal to the i-th element of the resulting array and should have value from 1 to q. This array should be obtainable by performing exactly q queries.
If there are multiple possible arrays then print any of them.
Examples
Input
4 3
1 0 2 3
Output
YES
1 2 2 3
Input
3 10
10 10 10
Output
YES
10 10 10
Input
5 6
6 5 6 2 2
Output
NO
Input
3 5
0 0 0
Output
YES
5 4 2
Note
In the first example you can also replace 0 with 1 but not with 3.
In the second example it doesn't really matter what segments to choose until query 10 when the segment is (1, 3).
The third example showcases the fact that the order of queries can't be changed, you can't firstly set (1, 3) to 6 and after that change (2, 2) to 5. The segment of 5 should be applied before segment of 6.
There is a lot of correct resulting arrays for the fourth example.
Submitted Solution:
```
[n, q] = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
if n > 1 and A[0] == 0:
for i in range(1, n):
if A[i] != 0:
A[0] = A[i]
break
if n > 1 and A[n-1] == 0:
for i in range(n-2, -1, -1):
if A[i] != 0:
A[n-1] = A[i]
break
if A[0] == 0:
print('YES')
for i in range(n):
print(q, end = ' ')
else:
for i in range(1, n-1):
if A[i] == 0:
A[i] = max(A[i-1], A[i+1])
checker = [-1] * (q + 1)
t1 = 1
for i in A:
if checker[i] == 1:
t1 = -1
break
else:
if checker[i] == -1:
checker[i] = 0
for j in range(i+1, q+1):
if checker[j] == 1:
t1 = -1
break
elif checker[j] == 0:
checker[j] = 1
if t1 == -1:
print('NO')
else:
print('YES')
for i in A:
print(i, end = ' ')
``` | instruction | 0 | 30,075 | 12 | 60,150 |
No | output | 1 | 30,075 | 12 | 60,151 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,093 | 12 | 60,186 |
Tags: dp, implementation
Correct Solution:
```
# from debug import debug
import sys; input = sys.stdin.readline
n = int(input())
lis = list(map(int, input().split()))
xor = [0]*(n+1)
for i in range(1, n+1): xor[i] = xor[i-1]^lis[i-1]
cnt = [[0]*(max(xor)+1) for i in range(2)]
ans = 0
for i in range(n+1):
ans += cnt[i&1][xor[i]]
cnt[i&1][xor[i]] += 1
print(ans)
``` | output | 1 | 30,093 | 12 | 60,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,094 | 12 | 60,188 |
Tags: dp, implementation
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n=int(input())
a=list(map(int,input().split()))
pre=[0]
for i in a:
pre.append(pre[-1]^i)
#print(pre)
odd=dict()
even=dict()
for i in range (len(pre)):
if i%2==0:
if pre[i] in even:
even[pre[i]]+=1
else:
even[pre[i]]=1
else:
if pre[i] in odd:
odd[pre[i]]+=1
else:
odd[pre[i]]=1
r=0
for i in odd:
r+=((odd[i]-1)*odd[i])//2
for i in even:
r+=((even[i]-1)*even[i])//2
print(r)
``` | output | 1 | 30,094 | 12 | 60,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,095 | 12 | 60,190 |
Tags: dp, implementation
Correct Solution:
```
import sys
from collections import defaultdict
input = sys.stdin.readline
if __name__ == '__main__':
n = int(input())
arr = list(map(int, input().strip().split()))
xr = 0
ev = defaultdict(int)
od = defaultdict(int)
od[0] += 1
ans = 0
for i in range(n):
xr ^= arr[i]
if i & 1:
ans += od[xr]
od[xr] += 1
else:
ans += ev[xr]
ev[xr] += 1
print(ans)
``` | output | 1 | 30,095 | 12 | 60,191 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,096 | 12 | 60,192 |
Tags: dp, implementation
Correct Solution:
```
import sys
import math
from collections import defaultdict
dp=defaultdict(list)
dp[0]=[1,0]
n=int(sys.stdin.readline())
arr=list(map(int,sys.stdin.readline().split()))
x=0
ans=0
for i in range(1,n+1):
x=x^arr[i-1]
if dp[x]==[]:
dp[x]=[0,0]
if i%2==0:
dp[x][0]+=1
else:
dp[x][1]+=1
else:
if i%2==0:
ans+=dp[x][0]
dp[x][0]+=1
else:
ans+=dp[x][1]
dp[x][1]+=1
print(ans)
``` | output | 1 | 30,096 | 12 | 60,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,097 | 12 | 60,194 |
Tags: dp, implementation
Correct Solution:
```
from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
pf = [0]
for i in range(n):
pf.append(pf[-1]^a[i])
indices = defaultdict(list)
for i in range(n+1):
indices[pf[i]].append(i)
ct = 0
for k,v in indices.items():
odd = 0
even = 0
for i in v:
if i%2:
odd += 1
else:
even += 1
ct += (odd*(odd-1))//2 + (even*(even-1))//2
print(ct)
``` | output | 1 | 30,097 | 12 | 60,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,098 | 12 | 60,196 |
Tags: dp, implementation
Correct Solution:
```
from math import sqrt, pow, ceil
from decimal import *
#getcontext().prec = 10
l1 = int(input())
#l1 = input().split()
#l2 = input()
l2 = input().split()
#l1 = [int(i) for i in l1]
l2 = [int(i) for i in l2]
arr = [[0 for col in range(2000000)] for row in range(2)]
arr[1][0] = 1;
a = 0;
resp = 0;
for i in range(l1):
a ^= l2[i];
resp += arr[i % 2][a];
arr[i % 2][a] += 1;
print(resp)
``` | output | 1 | 30,098 | 12 | 60,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,099 | 12 | 60,198 |
Tags: dp, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
dp = [[0 for _ in range(1 << 20)] for _ in range(2)]
dp[1][0] = 1
xor = 0
ret = 0
for i in range(n):
xor ^= a[i]
ret += dp[i & 1][xor]
dp[i & 1][xor] += 1
print(ret)
``` | output | 1 | 30,099 | 12 | 60,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l β€ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l β a_{l+1} β β¦ β a_{mid} = a_{mid + 1} β a_{mid + 2} β β¦ β a_r, then the pair is funny. In other words, β of elements of the left half of the subarray from l to r should be equal to β of elements of the right half. Note that β denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 β€ n β€ 3 β
10^5) β the size of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i < 2^{20}) β array itself.
Output
Print one integer β the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 β 3 = 4 β 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs. | instruction | 0 | 30,100 | 12 | 60,200 |
Tags: dp, implementation
Correct Solution:
```
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from collections import Counter as C
n = ii()
a = li()
oe = [C(), C()]
oe[1][0] = 1
x = 0
ans = 0
for i in range(n):
x ^= a[i]
ans += oe[i % 2][x]
oe[i % 2][x] += 1
print(ans)
``` | output | 1 | 30,100 | 12 | 60,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Ayush devised a new scheme to set the password of his lock. The lock has k slots where each slot can hold integers from 1 to n. The password P is a sequence of k integers each in the range [1, n], i-th element of which goes into the i-th slot of the lock.
To set the password of his lock, Ayush comes up with an array A of n integers each in the range [1, n] (not necessarily distinct). He then picks k non-empty mutually disjoint subsets of indices S_1, S_2, ..., S_k (S_i \underset{i β j} β© S_j = β
) and sets his password as P_i = max_{j β S_i} A[j]. In other words, the i-th integer in the password is equal to the maximum over all elements of A whose indices do not belong to S_i.
You are given the subsets of indices chosen by Ayush. You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the maximum of all elements of the array with index in this subset. You can ask no more than 12 queries.
Input
The first line of the input contains a single integer t (1 β€ t β€ 10) β the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. k lines follow. The i-th line contains an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
It is guaranteed that the intersection of any two subsets is empty.
Interaction
To ask a query print a single line:
* In the beginning print "? c " (without quotes) where c (1 β€ c β€ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n].
For each query, you will receive an integer x β the maximum of value in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries (for example one of the indices is greater than n) then you will get x = -1. In this case, you should terminate the program immediately.
When you have guessed the password, print a single line "! " (without quotes), followed by k space-separated integers β the password sequence.
Guessing the password does not count towards the number of queries asked.
After this, you should read a string. If you guess the password correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases. If the guessed password is incorrect, you will receive the string "Incorrect". In this case, you should terminate the program immediately.
The interactor is not adaptive. The array A does not change with queries.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks
To hack the solution use the following test format:
The first line of the input should contain a single integer t (1 β€ t β€ 10) β the number of test cases.
The first line of each test case should contain two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. The next line should consist of n space separated integers in the range [1, n] β the array A. k lines should follow. The i-th line should contain an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
The intersection of any two subsets has to be empty.
Example
Input
1
4 2
2 1 3
2 2 4
1
2
3
4
Correct
Output
? 1 1
? 1 2
? 1 3
? 1 4
! 4 3
Note
The array A in the example is [1, 2, 3, 4]. The length of the password is 2. The first element of the password is the maximum of A[2], A[4] (since the first subset contains indices 1 and 3, we take maximum over remaining indices). The second element of the password is the maximum of A[1], A[3] (since the second subset contains indices 2, 4).
Do not forget to read the string "Correct" / "Incorrect" after guessing the password.
Submitted Solution:
```
from __future__ import print_function
from sys import stdout
def solve():
N, K = [int(x) for x in input().split()]
S = []
for _ in range(K):
arr = [int(x) for x in input().split()]
S.append(arr[1:])
def ask(arr):
print_arr = ["?", len(arr)] + arr
print(*print_arr)
stdout.flush()
res = int(input())
return res
max_fro, max_to = 1, N+1
GLOBAL_MAX = ask(list(range(max_fro, max_to)))
while max_to - max_fro > 1:
mid = (max_to + max_fro) // 2
res = ask(list(range(max_fro, mid)))
if res == GLOBAL_MAX: # then max is in [fro, mid)
max_to = mid
else:
max_fro = mid # in [mid, to)
max_idx = max_fro
S_max_idx = None
for k in range(K):
if max_idx in S[k]:
S_max_idx = k
break
if S_max_idx == None:
print("!", *[GLOBAL_MAX]*K)
else:
s_set = set(S[S_max_idx])
outside = set(range(1, N)) - s_set
outside_S_max_idx_max = ask(list(outside))
P = [GLOBAL_MAX]*K
P[S_max_idx] = outside_S_max_idx_max
print("!", *P)
stdout.flush()
assert input() == "Correct" # reads "Correct / Incorrect"
T = int(input())
for _ in range(T):
solve()
``` | instruction | 0 | 30,245 | 12 | 60,490 |
No | output | 1 | 30,245 | 12 | 60,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Ayush devised a new scheme to set the password of his lock. The lock has k slots where each slot can hold integers from 1 to n. The password P is a sequence of k integers each in the range [1, n], i-th element of which goes into the i-th slot of the lock.
To set the password of his lock, Ayush comes up with an array A of n integers each in the range [1, n] (not necessarily distinct). He then picks k non-empty mutually disjoint subsets of indices S_1, S_2, ..., S_k (S_i \underset{i β j} β© S_j = β
) and sets his password as P_i = max_{j β S_i} A[j]. In other words, the i-th integer in the password is equal to the maximum over all elements of A whose indices do not belong to S_i.
You are given the subsets of indices chosen by Ayush. You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the maximum of all elements of the array with index in this subset. You can ask no more than 12 queries.
Input
The first line of the input contains a single integer t (1 β€ t β€ 10) β the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. k lines follow. The i-th line contains an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
It is guaranteed that the intersection of any two subsets is empty.
Interaction
To ask a query print a single line:
* In the beginning print "? c " (without quotes) where c (1 β€ c β€ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n].
For each query, you will receive an integer x β the maximum of value in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries (for example one of the indices is greater than n) then you will get x = -1. In this case, you should terminate the program immediately.
When you have guessed the password, print a single line "! " (without quotes), followed by k space-separated integers β the password sequence.
Guessing the password does not count towards the number of queries asked.
After this, you should read a string. If you guess the password correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases. If the guessed password is incorrect, you will receive the string "Incorrect". In this case, you should terminate the program immediately.
The interactor is not adaptive. The array A does not change with queries.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks
To hack the solution use the following test format:
The first line of the input should contain a single integer t (1 β€ t β€ 10) β the number of test cases.
The first line of each test case should contain two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. The next line should consist of n space separated integers in the range [1, n] β the array A. k lines should follow. The i-th line should contain an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
The intersection of any two subsets has to be empty.
Example
Input
1
4 2
2 1 3
2 2 4
1
2
3
4
Correct
Output
? 1 1
? 1 2
? 1 3
? 1 4
! 4 3
Note
The array A in the example is [1, 2, 3, 4]. The length of the password is 2. The first element of the password is the maximum of A[2], A[4] (since the first subset contains indices 1 and 3, we take maximum over remaining indices). The second element of the password is the maximum of A[1], A[3] (since the second subset contains indices 2, 4).
Do not forget to read the string "Correct" / "Incorrect" after guessing the password.
Submitted Solution:
```
import sys
def debug(*args):
#return
global t
print("\033[0;31m", end="", file=sys.stderr)
print(t, *args, file=sys.stderr)
print("\033[0m", end="", file=sys.stderr)
sys.stderr.flush()
def solve(N, K, subsets):
debug(N, K, subsets)
queryCount = 0
def getUnion(i, j):
indices = set()
for k in range(i, j):
indices.update(subsets[k])
return indices
def queryRange(i, j):
assert i < j
debug("Query range:", i, j)
subset = getUnion(i, j)
return query(subset)
def query(subset):
nonlocal queryCount
queryCount += 1
print(
"? " + str(len(subset)) + " " + " ".join(map(str, subset)), file=sys.stdout
)
sys.stdout.flush()
result = input()
while result == "":
result = input()
debug("Query", queryCount, ":", subset, "\tResult:", result)
if result == "-1":
exit('Failed')
return int(result)
mx = query(set(range(1, N + 1)))
password = [mx for i in range(K)]
if K > 1:
# Find subset with the max
lo = 0
hi = K
while hi - lo > 1:
mid = (lo + hi) // 2
segMx = queryRange(lo, mid)
if segMx == mx:
hi = mid
else:
lo = mid
assert hi - lo == 1
# debug("found index with max", lo, subsets[lo])
password[lo] = query(getUnion(0, K) - subsets[lo])
return " ".join(map(str, password))
if __name__ == "__main__":
T = int(input())
for t in range(T):
N, K = [int(x) for x in input().split()]
subsets = [set(int(x) for x in input().split()[1:]) for i in range(K)]
ans = solve(N, K, subsets)
print("! " + ans, file=sys.stdout)
sys.stdout.flush()
verdict = input()
while verdict == "":
verdict = input()
if verdict != "Correct":
exit('Failed')
``` | instruction | 0 | 30,246 | 12 | 60,492 |
No | output | 1 | 30,246 | 12 | 60,493 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Ayush devised a new scheme to set the password of his lock. The lock has k slots where each slot can hold integers from 1 to n. The password P is a sequence of k integers each in the range [1, n], i-th element of which goes into the i-th slot of the lock.
To set the password of his lock, Ayush comes up with an array A of n integers each in the range [1, n] (not necessarily distinct). He then picks k non-empty mutually disjoint subsets of indices S_1, S_2, ..., S_k (S_i \underset{i β j} β© S_j = β
) and sets his password as P_i = max_{j β S_i} A[j]. In other words, the i-th integer in the password is equal to the maximum over all elements of A whose indices do not belong to S_i.
You are given the subsets of indices chosen by Ayush. You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the maximum of all elements of the array with index in this subset. You can ask no more than 12 queries.
Input
The first line of the input contains a single integer t (1 β€ t β€ 10) β the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. k lines follow. The i-th line contains an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
It is guaranteed that the intersection of any two subsets is empty.
Interaction
To ask a query print a single line:
* In the beginning print "? c " (without quotes) where c (1 β€ c β€ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n].
For each query, you will receive an integer x β the maximum of value in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries (for example one of the indices is greater than n) then you will get x = -1. In this case, you should terminate the program immediately.
When you have guessed the password, print a single line "! " (without quotes), followed by k space-separated integers β the password sequence.
Guessing the password does not count towards the number of queries asked.
After this, you should read a string. If you guess the password correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases. If the guessed password is incorrect, you will receive the string "Incorrect". In this case, you should terminate the program immediately.
The interactor is not adaptive. The array A does not change with queries.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks
To hack the solution use the following test format:
The first line of the input should contain a single integer t (1 β€ t β€ 10) β the number of test cases.
The first line of each test case should contain two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. The next line should consist of n space separated integers in the range [1, n] β the array A. k lines should follow. The i-th line should contain an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
The intersection of any two subsets has to be empty.
Example
Input
1
4 2
2 1 3
2 2 4
1
2
3
4
Correct
Output
? 1 1
? 1 2
? 1 3
? 1 4
! 4 3
Note
The array A in the example is [1, 2, 3, 4]. The length of the password is 2. The first element of the password is the maximum of A[2], A[4] (since the first subset contains indices 1 and 3, we take maximum over remaining indices). The second element of the password is the maximum of A[1], A[3] (since the second subset contains indices 2, 4).
Do not forget to read the string "Correct" / "Incorrect" after guessing the password.
Submitted Solution:
```
def help():
n,k = map(int,input().split(" "))
n1 = n
twoD = []
pp = 0
for i in range(k):
arr = list(map(int,input().split(" ")))
twoD.append(arr[1:])
pp += arr[0]
answer = [0]*k
print("?",n,end=" ")
for i in range(1,n+1):
print(i,end=" ")
print()
n = input()
sec_max = 0
if(k==1):
others = [i for i in range(1,n1+1) if (i not in twoD[0])]
print("?",end = " ")
print(len(others),end = " ")
print(*others,sep = " ")
aa = input()
print("!",aa)
input()
return
start = 0
end = k-1
while (start<end):
if(start+1 == end):
others = [i for i in range(1,n1+1) if (i not in twoD[start])]
print("?",end = " ")
print(len(others),end = " ")
print(*others,sep = " ")
answer[start] = input()
others = [i for i in range(1,n1+1) if (i not in twoD[end])]
print("?",end = " ")
print(len(others),end = " ")
print(*others,sep = " ")
answer[end] = input()
break
mid = start + (end - start)//2
pr1 = 0
for i in range(start,mid+1):
pr1 += len(twoD[i])
print("?",pr1,end=" ")
for i in range(start,mid+1):
print(*twoD[i],sep=" ",end=" ")
print()
inp1 = input()
if(inp1 == n):
for i in range(mid+1,end+1):
answer[i] = n
end = mid
else:
for i in range(start,mid+1):
answer[i] = n
end = mid
# pr1 = 0
# for i in range(mid+1,end+1):
# pr1 += len(twoD[i])
# print("?",pr1,end=" ")
# for i in range(mid+1,end+1):
# print(*twoD[i],sep=" ",end=" ")
# print()
# inp2 = input()
# if((inp1 != n and inp2!=n) or (inp1 == n and inp2==n)):
# print("! ",(n+" ")*k)
# input()
# return
# elif(inp1 ==n and inp2 != n):
# for i in range(mid+1,end+1):
# answer[i] = n
# end = mid
# sec_max = max(sec_max,int(inp2))
# else:
# for i in range(start,mid+1):
# answer[i] = n
# start = mid+1
# sec_max = max(sec_max,int(inp1))
for i in range(k):
if(answer[i]==0):
answer[i]=sec_max
print("!",end=" ")
print(*answer)
input()
for _ in range(int(input())):
help()
# import math
# for _ in range(int(input())):
# h,c,t = map(int,input().split(" "))
# mid = c+(h-c)/2
# diff = t - mid
# if(h == t):
# print(1)
# elif(diff <= 0):
# print(2)
# else:
# x = (h-mid)/diff
# if(x == int(x)):
# if(int(x) == 2):
# print(3)
# else:
# print(int(x))
# else:
# if(math.floor(x)%2==1):
# x1 = math.floor(x)
# x2 = x1+2
# else:
# x2 = math.ceil(x)
# x1 = x2 - 2
# val1 = abs (diff - (h-mid)/x1)
# val2 = abs (diff - (h-mid)/x2)
# if(val1<=val2 ):
# print(x1)
# else:
# print(x2)
#(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})|((?:Jan|January|Feb|February|Mar|March|Apr|April|May|Jun|June|Jul|July|Aug|August|Sept|September|Oct|October|Nov|November|Dec|December)[-\s.,]\s?\d{1,2}(th|nd|st)?[-\s.,]\s?\d{2,4})|(\d{1,2}[\s](?:Jan|January|Feb|February|Mar|March|Apr|April|May|Jun|June|Jul|July|Aug|August|Sep|September|Oct|October|Nov|November|Dec|December)[\s.,]\s?\d{4,4})|
#(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})|((?:Jan|January|Feb|February|Mar|March|Apr|April|May|Jun|June|Jul|July|Aug|August|Sept|September|Oct|October|Nov|November|Dec|December)[-\s.,]\s?\d{1,2}(th|nd|st)?[-\s.,]\s?\d{2,4})|(\d{1,2}[\s](?:Jan|January|Feb|February|Mar|March|Apr|April|May|Jun|June|Jul|July|Aug|August|Sep|September|Oct|October|Nov|November|Dec|December)[\s.,]\s?\d{4,4})|(?:Jan|January|Feb|February|Mar|March|Apr|April|May|Jun|June|Jul|July|Aug|August|Sep|September|Oct|October|Nov|November|Dec|December)\s\d{4,4}|(\d{1,2}/)?\d{4,4}
``` | instruction | 0 | 30,247 | 12 | 60,494 |
No | output | 1 | 30,247 | 12 | 60,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Ayush devised a new scheme to set the password of his lock. The lock has k slots where each slot can hold integers from 1 to n. The password P is a sequence of k integers each in the range [1, n], i-th element of which goes into the i-th slot of the lock.
To set the password of his lock, Ayush comes up with an array A of n integers each in the range [1, n] (not necessarily distinct). He then picks k non-empty mutually disjoint subsets of indices S_1, S_2, ..., S_k (S_i \underset{i β j} β© S_j = β
) and sets his password as P_i = max_{j β S_i} A[j]. In other words, the i-th integer in the password is equal to the maximum over all elements of A whose indices do not belong to S_i.
You are given the subsets of indices chosen by Ayush. You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the maximum of all elements of the array with index in this subset. You can ask no more than 12 queries.
Input
The first line of the input contains a single integer t (1 β€ t β€ 10) β the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. k lines follow. The i-th line contains an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
It is guaranteed that the intersection of any two subsets is empty.
Interaction
To ask a query print a single line:
* In the beginning print "? c " (without quotes) where c (1 β€ c β€ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n].
For each query, you will receive an integer x β the maximum of value in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries (for example one of the indices is greater than n) then you will get x = -1. In this case, you should terminate the program immediately.
When you have guessed the password, print a single line "! " (without quotes), followed by k space-separated integers β the password sequence.
Guessing the password does not count towards the number of queries asked.
After this, you should read a string. If you guess the password correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases. If the guessed password is incorrect, you will receive the string "Incorrect". In this case, you should terminate the program immediately.
The interactor is not adaptive. The array A does not change with queries.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks
To hack the solution use the following test format:
The first line of the input should contain a single integer t (1 β€ t β€ 10) β the number of test cases.
The first line of each test case should contain two integers n and k (2 β€ n β€ 1000, 1 β€ k β€ n) β the size of the array and the number of subsets. The next line should consist of n space separated integers in the range [1, n] β the array A. k lines should follow. The i-th line should contain an integer c (1 β€ c < n) β the size of subset S_i, followed by c distinct integers in the range [1, n] β indices from the subset S_i.
The intersection of any two subsets has to be empty.
Example
Input
1
4 2
2 1 3
2 2 4
1
2
3
4
Correct
Output
? 1 1
? 1 2
? 1 3
? 1 4
! 4 3
Note
The array A in the example is [1, 2, 3, 4]. The length of the password is 2. The first element of the password is the maximum of A[2], A[4] (since the first subset contains indices 1 and 3, we take maximum over remaining indices). The second element of the password is the maximum of A[1], A[3] (since the second subset contains indices 2, 4).
Do not forget to read the string "Correct" / "Incorrect" after guessing the password.
Submitted Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 2020/6/3
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
T = int(input())
for ti in range(T):
N, K = map(int, input().split())
exs = []
for i in range(K):
ex = [int(x) for x in input().split()][1:]
exs.append(set(ex))
# find the index of max val
print('? {}'.format(' '.join([str(i) for i in range(1, N+1)])))
maxv = int(input())
lo, hi = 1, N
while lo < hi:
m = (lo + hi) // 2
# max val in [lo, m]
print('? {}'.format(' '.join([str(i) for i in range(lo, m+1)])))
a = int(input())
# maxval in [m+1, hi)
print('? {}'.format(' '.join([str(i) for i in range(m+1, hi+1)])))
b = int(input())
if a >= b:
# max val is in left section
hi = m
else:
# max val is in rght section
lo = m + 1
maxpos = lo
# pass
ans = []
for ex in exs:
if maxpos not in ex:
ans.append(maxv)
else:
# query for this section
print('? {}'.format(' '.join(map(str, [i for i in range(1, N+1) if i not in ex]))))
v = int(input())
ans.append(v)
print('! {}'.format(' '.join(map(str, ans))))
result = input()
``` | instruction | 0 | 30,248 | 12 | 60,496 |
No | output | 1 | 30,248 | 12 | 60,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,249 | 12 | 60,498 |
Tags: constructive algorithms
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
print(*(l[::-1]))
``` | output | 1 | 30,249 | 12 | 60,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,250 | 12 | 60,500 |
Tags: constructive algorithms
Correct Solution:
```
import sys
from typing import List, Union
def rl(int_: bool = True, is_split: bool = True) -> Union[List[str], List[int]]:
if int_:
return [int(w) for w in sys.stdin.readline().split()]
if is_split:
return [w for w in sys.stdin.readline().split()]
return sys.stdin.readline().strip()
for _ in range(rl()[0]):
(n,) = rl()
p = rl(False)
print(" ".join(reversed(p)))
``` | output | 1 | 30,250 | 12 | 60,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,251 | 12 | 60,502 |
Tags: constructive algorithms
Correct Solution:
```
def main():
t = int(input())
for _ in range(t):
n = int(input())
print(' '.join(reversed(input().split())))
main()
``` | output | 1 | 30,251 | 12 | 60,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,252 | 12 | 60,504 |
Tags: constructive algorithms
Correct Solution:
```
from math import ceil
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
a=a[-1::-1]
for i in a:
print(i,end=" ")
print()
``` | output | 1 | 30,252 | 12 | 60,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,253 | 12 | 60,506 |
Tags: constructive algorithms
Correct Solution:
```
def rev(i):
i.reverse()
return i
def print_iterator(it):
for x in it:
print(x,end=' ')
print('')
a=int(input(""))
arno=[]
arar=[]
opar=[]
for i in range(a):
b=int(input(""))
c=input("").split()
d=[]
for e in c:
d.append(int(e))
arno.append(b)
arar.append(d)
for a in arar:
opar.append(rev(a))
for a in opar:
mapi=map(lambda x: x,a)
print_iterator(mapi)
``` | output | 1 | 30,253 | 12 | 60,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,254 | 12 | 60,508 |
Tags: constructive algorithms
Correct Solution:
```
# @oj: codeforces
# @id: hitwanyang
# @email: 296866643@qq.com
# @date: 2020-09-07 17:00
# @url:https://codeforc.es/contest/1405/problem/A
import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string
from decimal import *
# region fastio
BUFSIZE = 8192
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
## 注ζε΅ε₯ζ¬ε·!!!!!!
## ε
ζζθ·―οΌεε代η οΌε«ηζ₯!!!
def main():
t=int(input())
for i in range(t):
n=int(input())
a=list(map(int,input().split()))
a.reverse()
print (" ".join([str(x) for x in a]))
if __name__ == "__main__":
main()
``` | output | 1 | 30,254 | 12 | 60,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,255 | 12 | 60,510 |
Tags: constructive algorithms
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
li=list(map(int,input().split()))
li.reverse()
print(*li)
``` | output | 1 | 30,255 | 12 | 60,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7]. | instruction | 0 | 30,256 | 12 | 60,512 |
Tags: constructive algorithms
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
for i in range(n-1,-1,-1):
print(a[i],end=' ')
print()
``` | output | 1 | 30,256 | 12 | 60,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
t=int(input())
y=[]
u=[]
for i in range(t):
r=int(input())
e=list(map(int,input().split()))
y.append(r)
u.append(e)
def tully(u):
return u
for j in range(t):
e=tully(u[j])
for i in range(y[j]-1,-1,-1):
print(u[j][i],end=" ")
``` | instruction | 0 | 30,257 | 12 | 60,514 |
Yes | output | 1 | 30,257 | 12 | 60,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
arr=list(map(int,input().split()))
print(*arr[::-1])
``` | instruction | 0 | 30,258 | 12 | 60,516 |
Yes | output | 1 | 30,258 | 12 | 60,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value(): return tuple(map(int, input().split())) # multiple values
def arr(): return [int(i) for i in input().split()] # array input
def sarr(): return [int(i) for i in input()] #array from string
def starr(): return [str(x) for x in input().split()] #string array
def inn(): return int(input()) # integer input
def svalue(): return tuple(map(str, input().split())) #multiple string values
def parr(): return [(value()) for i in range(n)] # array of pairs
mo = 1000000007
# ----------------------------CODE------------------------------#
for _ in range(inn()):
n=inn()
a=arr()
a.reverse()
print(*a)
``` | instruction | 0 | 30,259 | 12 | 60,518 |
Yes | output | 1 | 30,259 | 12 | 60,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = input().split()
print(' '.join(arr[::-1]))
``` | instruction | 0 | 30,260 | 12 | 60,520 |
Yes | output | 1 | 30,260 | 12 | 60,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
for _ in range(int(input())):
x=int(input())
l=list(map(int,input().split()))
l.sort()
ans=[]
for i in range(0,x-1,2):
ans.extend([l[i+1],l[i]])
if(x%2):
ans.extend([l[-1]])
print(*ans)
``` | instruction | 0 | 30,261 | 12 | 60,522 |
No | output | 1 | 30,261 | 12 | 60,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
l = len(arr)
if l%2==0:
for i in range(0,l-1,2):
arr[i],arr[i+1] = arr[i+1],arr[i]
print(*(arr))
else:
print(*(arr[l//2:]+arr[:l//2]))
``` | instruction | 0 | 30,262 | 12 | 60,524 |
No | output | 1 | 30,262 | 12 | 60,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
print(input()[::-1])
``` | instruction | 0 | 30,263 | 12 | 60,526 |
No | output | 1 | 30,263 | 12 | 60,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
Let p be any permutation of length n. We define the fingerprint F(p) of p as the sorted array of sums of adjacent elements in p. More formally,
$$$F(p)=sort([p_1+p_2,p_2+p_3,β¦,p_{n-1}+p_n]).$$$
For example, if n=4 and p=[1,4,2,3], then the fingerprint is given by F(p)=sort([1+4,4+2,2+3])=sort([5,6,5])=[5,5,6].
You are given a permutation p of length n. Your task is to find a different permutation p' with the same fingerprint. Two permutations p and p' are considered different if there is some index i such that p_i β p'_i.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 668). Description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 100) β the length of the permutation.
The second line of each test case contains n integers p_1,β¦,p_n (1β€ p_iβ€ n). It is guaranteed that p is a permutation.
Output
For each test case, output n integers p'_1,β¦, p'_n β a permutation such that p'β p and F(p')=F(p).
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
Example
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
Note
In the first test case, F(p)=sort([1+2])=[3].
And F(p')=sort([2+1])=[3].
In the second test case, F(p)=sort([2+1,1+6,6+5,5+4,4+3])=sort([3,7,11,9,7])=[3,7,7,9,11].
And F(p')=sort([1+2,2+5,5+6,6+3,3+4])=sort([3,7,11,9,7])=[3,7,7,9,11].
In the third test case, F(p)=sort([2+4,4+3,3+1,1+5])=sort([6,7,4,6])=[4,6,6,7].
And F(p')=sort([3+1,1+5,5+2,2+4])=sort([4,6,7,6])=[4,6,6,7].
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
p=l[0]
l.remove(p)
l.append(p)
for i in l:
print(i,end=" ")
``` | instruction | 0 | 30,264 | 12 | 60,528 |
No | output | 1 | 30,264 | 12 | 60,529 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,265 | 12 | 60,530 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
import math
tsts = int(input())
for i in range(tsts):
sm = int(input())
inc = math.floor(math.sqrt(sm))
mul = sm//inc
if inc*mul >= sm:
print(inc + mul - 2)
else:
print(inc + mul - 1)
``` | output | 1 | 30,265 | 12 | 60,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,266 | 12 | 60,532 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
import math
for _ in range(int(input())):
n = int(input())
ns = math.ceil(n**(0.5))
print(ns-2 + math.ceil(n/ns))
``` | output | 1 | 30,266 | 12 | 60,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,267 | 12 | 60,534 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):
n = int(input())
if n==1:
print(0)
continue
import math
x=pow(n,1/2)
if x%1==0:
print(int(x+x-2))
else:
x=int(x)
y=x+1
if x*y>=n:
print(int(x+y)-2)
else:
x+=1
print(int(x+y)-2)
``` | output | 1 | 30,267 | 12 | 60,535 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,268 | 12 | 60,536 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
import math
for j in range(int(input())):
n=int(input())
m=math.floor(math.sqrt(n))
ans=m-1
print(ans+math.ceil((n-m)/m))
``` | output | 1 | 30,268 | 12 | 60,537 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,269 | 12 | 60,538 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
import math
def stepcount(n):
if(n == 1):
return 0
# else:
# return stepcount(n//2)(n%2)+1
cc = math.floor(n**0.5)
c = (n-cc*cc)
bonus = 0
if c != 0:
if c<=cc:
bonus = 1
else:
bonus = 2
return 2*cc-2+bonus
t = int(input())
for i in range(t):
print(stepcount(int(input())))
``` | output | 1 | 30,269 | 12 | 60,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,270 | 12 | 60,540 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
import math
t=int(input())
for i in range(t):
n=int(input())
if n==1:
print(0)
else:
a=math.floor(math.sqrt(n))
b=a+1
s1=a-1
s2=b-1
left1=n-a
left2=n-b
s1+=math.ceil(left1/a)
s2+=math.ceil(left2/b)
print(min(s1,s2))
``` | output | 1 | 30,270 | 12 | 60,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,271 | 12 | 60,542 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
from math import *
for t in range(int(input())):
n = int(input())
print(ceil(n / ceil(sqrt(n))) + ceil(sqrt(n)) - 2)
``` | output | 1 | 30,271 | 12 | 60,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244 | instruction | 0 | 30,272 | 12 | 60,544 |
Tags: binary search, constructive algorithms, math
Correct Solution:
```
import sys
# sys.stdin = open('input.txt','r')
read = sys.stdin.readline
import math
def solution(n):
# num = 1
# min_cnt = n // num - 1
# while num <= math.sqrt(n):
# num += 1
# val = num - 1 + n // num - 1
# if n % num != 0:
# val += 1
# if min_cnt > val:
# min_cnt = val
num = int(math.sqrt(n))
cnt = num - 1 + n // num - 1
if n % num != 0:
cnt += 1
return cnt
t = int(read())
for _ in range(t):
print(solution(int(read())))
``` | output | 1 | 30,272 | 12 | 60,545 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
def main():
t = int(input())
for _ in range(t):
n = int(input())
k = n ** 0.5
if k % 1 != 0:
k = int(k + 1)
else:
k = int(k)
r = (n - k) % k; q = (n - k) // k
if r == 0:
cei = q
else:
cei = q + 1
print(cei + k - 1)
main()
``` | instruction | 0 | 30,273 | 12 | 60,546 |
Yes | output | 1 | 30,273 | 12 | 60,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
#New Imports
def solution():
n = int(input())
val = n**0.5
ans = int(2*val-1)
if val == int(val):
ans -= 1
print(ans)
return
def main():
testcases = 1
testcases = int(input())
for _ in range(testcases):
solution()
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 30,274 | 12 | 60,548 |
Yes | output | 1 | 30,274 | 12 | 60,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
import math
for _ in range(int(input())):
n=int(input())
mn=float('inf')
pat=0
mx=1
while mx*mx<=n:
if n%mx==0:
val=mx-1+(n//mx)
if val<mn:
mn=val
pat=mx
else:
val=mx+n//mx
if val<mn:
mn=val
pat=mx
mx+=1
print(mn-1)
``` | instruction | 0 | 30,275 | 12 | 60,550 |
Yes | output | 1 | 30,275 | 12 | 60,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
ans=int(2*((n)**.5))-1
if(int(n**.5)-n**.5==0):
print(ans-1)
else:
print(ans)
``` | instruction | 0 | 30,276 | 12 | 60,552 |
Yes | output | 1 | 30,276 | 12 | 60,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
import math
t=int(input())
for _ in range(t):
# n,m=list(map(int,input().split()))
n=int(input())
def l(a,b):
return a-1+math.ceil((b-a)/(a))
maxi=63246+10
for i in range(1, 63246):
if(l(i,n)<maxi):
maxi=l(i,n)
if(l(i,n)>maxi):
break
if(n==1):
print(0)
else:
print(maxi)
``` | instruction | 0 | 30,277 | 12 | 60,554 |
No | output | 1 | 30,277 | 12 | 60,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
import math
def function(n):
total=0
min1=10**10
if n==1:
return 0
if n==2:
return 1
if n==3:
return 3
for i in range(math.floor(math.sqrt(n)), 0, -1):
c=(i-1)+(math.ceil(n/i)-1)
if c<min1:
min1=c
total+=1
if c>min1:
return (min1)
break
#print(f'total, c: {total}, {c}')
function(3)
if __name__=="__main__":
t=int(input())
for k1 in range(t):
n=int(input())
print(function(n))
#print('----')
``` | instruction | 0 | 30,278 | 12 | 60,556 |
No | output | 1 | 30,278 | 12 | 60,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Initially, you have the array a consisting of one element 1 (a = [1]).
In one move, you can do one of the following things:
* Increase some (single) element of a by 1 (choose some i from 1 to the current length of a and increase a_i by one);
* Append the copy of some (single) element of a to the end of the array (choose some i from 1 to the current length of a and append a_i to the end of the array).
For example, consider the sequence of five moves:
1. You take the first element a_1, append its copy to the end of the array and get a = [1, 1].
2. You take the first element a_1, increase it by 1 and get a = [2, 1].
3. You take the second element a_2, append its copy to the end of the array and get a = [2, 1, 1].
4. You take the first element a_1, append its copy to the end of the array and get a = [2, 1, 1, 2].
5. You take the fourth element a_4, increase it by 1 and get a = [2, 1, 1, 3].
Your task is to find the minimum number of moves required to obtain the array with the sum at least n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 β€ n β€ 10^9) β the lower bound on the sum of the array.
Output
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least n.
Example
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
Submitted Solution:
```
def get(m):return m+(n-1)//(m+1)+1
for _ in range(int(input())):
n=int(input())
r=n+1
l=-1
while l+2<r:
m1=l+(r-l)//3
m2=r-(r-l)//3
n1=get(m1)
n2=get(m2)
if n1>n2:l=m1
else:r=m2
print(get((r+l)//2)-1)
``` | instruction | 0 | 30,279 | 12 | 60,558 |
No | output | 1 | 30,279 | 12 | 60,559 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.