message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,259 | 12 | 202,518 |
Tags: binary search, greedy
Correct Solution:
```
from sys import stdin, stdout
from math import *
n,m,a=0,0,[]
def test(k):
global n,m,a
# print([n,m,a])
b=[]
for i in range(n):
b.append(a[i])
if (i==0):
if ((b[i]+k) >= m):
b[i]=0
else:
if (b[i]==b[i-1]):
continue
if (b[i-1]>b[i]):
if (b[i-1]<=(b[i]+k)):
b[i]=b[i-1]
else:
if (b[i]+k>=m) and (b[i-1]<= ((b[i]+k)%m)):
b[i]=b[i-1]
if (b[i-1]>b[i]):
return False
# print(k)
# print(b)
return True
def main():
global n,m,a
n,m=[int(x) for x in stdin.readline().split()]
a=[int(x) for x in stdin.readline().split()]
res=m
l=0
r=m
while(l<=r):
mid=floor((l+r)/2)
if test(mid)==True:
res=min(res,mid)
r=mid-1
else:
l=mid+1
stdout.write(str(res))
return 0
if __name__ == "__main__":
main()
``` | output | 1 | 101,259 | 12 | 202,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,260 | 12 | 202,520 |
Tags: binary search, greedy
Correct Solution:
```
from collections import Counter
from collections import defaultdict
from collections import deque
import math
import sys
input = sys.stdin.readline
import bisect
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().strip().split()))
rls= lambda: list(map(str, input().split()))
def check(k):
p=[]
c=a[0]
prev=0
for i in range(0,n):
x1=a[i]
x2=(a[i]+k)%m
if(x2<x1):
if(x1<=prev<=m-1 or 0<=prev<=x2):
p.append(prev)
continue
else:
prev=a[i]
elif(x2>x1):
if(x1<=prev<=x2):
p.append(prev)
continue
elif(x2<prev):
# print(p,"llll")
return -1
else:
prev=x1
else:
return -1
p.append(prev)
# print(p,mid)
return 1
n,m=rl()
a=list(map(int,input().strip().split()))
if(a==sorted(a)):
print(0)
exit()
l=0
r=m-1
ans=m
while(l<=r):
mid=l+(r-l)//2
if(check(mid)==1):
# print(mid)
ans=min(mid,ans)
r=mid-1
else:
l=mid+1
print(ans)
``` | output | 1 | 101,260 | 12 | 202,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,261 | 12 | 202,522 |
Tags: binary search, greedy
Correct Solution:
```
from sys import stdin
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
si = lambda: input()
msi = lambda: map(int, stdin.readline().split())
lsi = lambda: list(msi())
n,m=li()
a=li()
l,r=0,m
while(l<r):
M=(l+r)//2
ai1=0
for ai in a:
if (m-ai+ai1)%m>M:
if ai<ai1:
l=M+1
break
ai1=ai
else:
r=M
print(l)
``` | output | 1 | 101,261 | 12 | 202,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
n , k = map(int , input().split())
A = list(map(int , input().split()))
l = 0
r = k + 1
ans = k + 1
for _ in range(20):
B = [0] * n
m = (l + r)//2
min1 = 0
fl = 0
#print(m)
for i in range(n):
if A[i] > min1 :
if k - A[i] + min1 <= m:
B[i] = min1
else:
min1 = A[i]
B[i] = A[i]
else:
if min1 - A[i] > m:
fl = 1
break
else:
B[i] = min1
if fl == 0:
#print(B)
for i in range( n -1 ):
if B[i] > B[i + 1]:
break
fl = 1
if fl == 0:
r = m
ans = min(ans , m)
else:
l = m
else:
l = m
print(ans)
``` | instruction | 0 | 101,262 | 12 | 202,524 |
Yes | output | 1 | 101,262 | 12 | 202,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
#!/usr/bin/env python
def check(mid):
# print(f'called check({mid})')
local_a = [0]
for ai in a:
local_a.append(ai)
for i in range(1, n + 1):
if local_a[i] < local_a[i - 1]:
if local_a[i] + mid >= local_a[i - 1]:
local_a[i] = local_a[i - 1]
elif local_a[i] + mid >= m + local_a[i - 1]:
local_a[i] = local_a[i - 1]
if local_a[i] < local_a[i - 1]:
return False
# print(local_a)
return True
n, m = map(int, input().split())
a = list(map(int, input().split()))
low, high = 0, m
while low != high:
mid = (low + high) >> 1
if check(mid):
high = mid
else:
low = mid + 1
print(low)
``` | instruction | 0 | 101,263 | 12 | 202,526 |
Yes | output | 1 | 101,263 | 12 | 202,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
def check(M):
now = 0
for i in range(n):
#print(i, now, mas[i], M, (now - mas[i]) % m)
if (now - mas[i]) % m > M:
if mas[i] > now:
now = mas[i]
else:
return False
return True
n, m = list(map(int, input().split()))
l = -1
r = m
mas = list(map(int, input().split()))
check(3)
while l < r - 1:
M = (l + r) // 2
if check(M):
r = M
else:
l = M
print(r)
``` | instruction | 0 | 101,264 | 12 | 202,528 |
Yes | output | 1 | 101,264 | 12 | 202,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
def discrete_binary_search(func, lo, hi):
"""
Locate the first value x s.t. func(x) = True within [lo, hi]
return hi if not founded
func(hi) will never been execution
"""
while lo < hi:
mi = lo + (hi - lo) // 2
if func(mi):
hi = mi
else:
lo = mi + 1
return lo
# ############################## main
def solve():
n, m = mpint()
arr = tuple(mpint())
def check(x):
""" ans is <= x """
prev = 0
for i in range(n):
if arr[i] > prev:
if m - (arr[i] - prev) > x:
prev = arr[i]
elif prev - arr[i] > x:
return False
return True
return discrete_binary_search(check, 0, m)
def main():
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
# solve()
print(solve())
# for _ in range(itg()):
# print(solve())
DEBUG = 0
URL = 'https://codeforces.com/contest/1169/problem/C'
if __name__ == '__main__':
if DEBUG:
if DEBUG == 2:
main()
exit()
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | instruction | 0 | 101,265 | 12 | 202,530 |
Yes | output | 1 | 101,265 | 12 | 202,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
n , k = map(int , input().split())
A = list(map(int , input().split()))
l = 0
r = k
ans = k
for _ in range(5):
B = [0] * n
m = (l + r)//2
min1 = 0
fl = 0
#print(m)
for i in range(n):
if A[i] > min1 :
if k - A[i] + min1 <= m:
B[i] = min1
else:
min1 = A[i]
B[i] = A[i]
else:
if min1 - A[i] > m:
fl = 1
break
else:
B[i] = min1
if fl == 0:
#print(B)
for i in range( n -1 ):
if B[i] > B[i + 1]:
break
fl = 1
if fl == 0:
r = m
ans = min(ans , m)
else:
l = r
print(ans)
``` | instruction | 0 | 101,266 | 12 | 202,532 |
No | output | 1 | 101,266 | 12 | 202,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
from sys import stdin
# stdin=open('input.txt')
def input():
return stdin.readline().strip()
# from sys import stdout
# stdout=open('input.txt',mode='w+')
# def print1(x, end='\n'):
# stdout.write(str(x) +end)
# a, b = map(int, input().split())
# l = list(map(int, input().split()))
# # CODE BEGINS HERE.................
def solve(beg, end, a, MOD):
if beg + 1 == end:
return end
k = (beg + end)//2
conditions = []
# print(beg, end, k)
for i in range(n):
if k + a[i] < MOD:
conditions.append([(a[i],a[i] + k)])
elif k + a[i] >= MOD:
conditions.append([(a[i], MOD - 1), (0, (a[i] + k) % MOD)])
prev = 0
flag = True
for cond in conditions:
if len(cond) == 2:
if prev <= min(cond[0][0], cond[1][0]):
prev = min(cond[0][0], cond[1][0])
elif prev <= max(cond[0][0], cond[1][0]):
prev = max(cond[0][0], cond[1][0])
elif prev >= cond[0][0] and prev <= cond[0][1]:
prev = prev
elif prev >= cond[1][0] and prev <= cond[1][1]:
prev = prev
else:
flag = False
break
else:
if prev <= cond[0][0]:
prev = cond[0][0]
elif prev >= cond[0][0] and prev <= cond[0][1]:
prev = prev
else:
flag = False
break
if not flag:
return solve(k, end, a, MOD)
else:
if beg == k:
return k
return solve(beg, k, a, MOD)
n, MOD = map(int, input().split())
a = list(map(int, input().split()))
print(solve(-1, MOD, a, MOD))
# # CODE ENDS HERE....................
# stdout.close()
``` | instruction | 0 | 101,267 | 12 | 202,534 |
No | output | 1 | 101,267 | 12 | 202,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
import copy
n, m = map(int, input().split())
a = list(map(int, input().split()))
l = -1
r = 300001
def check(x):
global a
global m
success = True
if (a[0] + x >= m):
a[0] = 0
last = a[0]
for i in range(1, len(a)):
now = a[i]
if (now < last):
now = min(last, now + x)
if (a[i] + x >= m + last):
now = last
if (now < last):
return False
last = now
return True
while (r - l > 1):
mid = (l + r) // 2
if (check(mid)):
r = mid
else:
l = mid
print(r)
``` | instruction | 0 | 101,268 | 12 | 202,536 |
No | output | 1 | 101,268 | 12 | 202,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1.
Submitted Solution:
```
import copy
n, m = map(int, input().split())
a = list(map(int, input().split()))
l = -1
r = 1000000
def check(x):
global a
global m
b = a.copy()
b[0] = max(0, b[0] - x)
success = True
for i in range(1, len(b)):
if (b[i] < b[i - 1]):
b[i] = min(b[i - 1], b[i] + x)
if (a[i] - x < 0 and a[i] - x + m <= b[i-1]):
b[i] = b[i - 1]
if (a[i] - x < 0 and a[i] - x + m > b[i-1]):
b[i] = min(b[i], a[i] - x + m)
if (b[i] > b[i - 1]):
b[i] = max(b[i - 1], b[i] - x)
if (a[i] + x >= m + b[i - 1]):
b[i] = b[i - 1]
if (b[i] < b[i - 1]):
success = False
return success
while (r - l > 1):
mid = (l + r) // 2
if (check(mid)):
r = mid
else:
l = mid
print(r)
``` | instruction | 0 | 101,269 | 12 | 202,538 |
No | output | 1 | 101,269 | 12 | 202,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,364 | 12 | 202,728 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
s = input()
n = int(s.split(' ')[0])
m = int(s.split(' ')[1])
if n < 2:
print(0)
continue
elif n == 2:
print(m)
else:
print(2*m)
``` | output | 1 | 101,364 | 12 | 202,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,365 | 12 | 202,730 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
if n>=3:
print(2*m)
elif n==1:
print(0)
else:
print(m)
``` | output | 1 | 101,365 | 12 | 202,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,366 | 12 | 202,732 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t=int(input())
for z in range(t):
n,m=map(int,input().split())
if n==1:
print(0)
elif n==2:
print(m)
else:
print(2*m)
``` | output | 1 | 101,366 | 12 | 202,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,367 | 12 | 202,734 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
for i in range(int(input())):
n, m = [int(i) for i in input().split()]
if n <= 1:
print(0)
elif n == 2:
print(m)
else:
print(2*m)
``` | output | 1 | 101,367 | 12 | 202,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,368 | 12 | 202,736 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t=int(input())
for _ in range(t):
n,m=[int(n) for n in input().split()]
if n==1:
print("0")
elif n==2:
print(m)
else:
print(m*2)
``` | output | 1 | 101,368 | 12 | 202,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,369 | 12 | 202,738 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
T = int(input())
while T != 0:
T -= 1
n, m = map(int,input().split())
if n == 1:
print('0')
elif n == 2:
print(m)
else:
print(m*2)
``` | output | 1 | 101,369 | 12 | 202,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,370 | 12 | 202,740 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
import sys
input = sys.stdin.readline
def main():
for _ in range(int(input())):
n, m = map(int, input().split())
if n == 1:
print(0)
elif n == 2:
print(m)
else:
print(m * 2)
if __name__ == '__main__':
main()
``` | output | 1 | 101,370 | 12 | 202,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.
In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.
Output
For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.
Example
Input
5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000
Output
0
2
10
1000000000
2000000000
Note
In the first test case of the example, the only possible array is [100] and the answer is obviously 0.
In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.
In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10. | instruction | 0 | 101,371 | 12 | 202,742 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
class SegmentTree:
def __init__(self, data, default=0, func=lambda a,b:gcd(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# ------------------- 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 --------------------
from bisect import bisect_right, bisect_left
from fractions import Fraction
def pre(s):
n = len(s)
pi=[0]*n
for i in range(1,n):
j = pi[i-1]
while j and s[i] != s[j]:
j = pi[j-1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
from math import gcd
def lcm(a,b):return a*b//gcd(a,b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0"*(length - len(y)) + y
for _ in range(int(input())):
#n = int(input())
n, k = map(int, input().split())
#a, b = map(int, input().split())
#x, y = map(int, input().split())
#a = list(map(int, input().split()))
#s = input()
#print("YES" if s else "NO")
a = []
if n == 1:
print(0)
continue
if n == 2:
print(k)
else:
print(2*k)
``` | output | 1 | 101,371 | 12 | 202,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ray lost his array and needs to find it by asking Omkar. Omkar is willing to disclose that the array has the following qualities:
1. The array has n (1 ≤ n ≤ 2 ⋅ 10^5) elements.
2. Every element in the array a_i is an integer in the range 1 ≤ a_i ≤ 10^9.
3. The array is sorted in nondecreasing order.
Ray is allowed to send Omkar a series of queries. A query consists of two integers, l and r such that 1 ≤ l ≤ r ≤ n. Omkar will respond with two integers, x and f. x is the mode of the subarray from index l to index r inclusive. The mode of an array is defined by the number that appears the most frequently. If there are multiple numbers that appear the most number of times, the smallest such number is considered to be the mode. f is the amount of times that x appears in the queried subarray.
The array has k (1 ≤ k ≤ min(25000,n)) distinct elements. However, due to Ray's sins, Omkar will not tell Ray what k is. Ray is allowed to send at most 4k queries.
Help Ray find his lost array.
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5), which equals to the length of the array that you are trying to find.
Interaction
The interaction starts with reading n.
Then you can make one type of query:
* "? \enspace l \enspace r" (1 ≤ l ≤ r ≤ n) where l and r are the bounds of the subarray that you wish to query.
The answer to each query will be in the form "x \enspace f" where x is the mode of the subarray and f is the number of times x appears in the subarray.
* x satisfies (1 ≤ x ≤ 10^9).
* f satisfies (1 ≤ f ≤ r-l+1).
* If you make more than 4k queries or violate the number range in the query, you will get an output "-1."
* If you terminate after receiving the response "-1", you will get the "Wrong answer" verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To output your answer, print:
* "! \enspace a_1 \enspace a_2 \enspace … \enspace a_{n-1} \enspace a_n" which is an exclamation point followed by the array with a space between every element.
And quit after that. This query is not counted towards the 4k queries limit.
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.
Hack Format
To hack, output 1 integer on the first line, n (1 ≤ n ≤ 2 ⋅ 10^5). On the second line output n integers a_1, a_2, …, a_{n-1}, a_n separated by a space such that there are at most 25000 distinct numbers and a_j ≤ a_{j+1} for all j from 1 to n-1.
Example
Input
6
2 2
2 2
3 2
2 1
Output
? 1 6
? 1 3
? 4 6
? 3 4
! 1 2 2 3 3 4
Note
The first query is l=1 and r=6. The mode is 2, and 2 appears 2 times, so x=2 and f=2. Note that 3 also appears two times, but 2 is outputted because 2 is smaller.
The second query is l=1 and r=3. The mode is 2 and 2 appears twice in the subarray with indices [1,3].
The third query is l=4 and r=6. The mode is 3 and 3 appears twice in the subarray with indices [4,6].
The fourth query is l=3 and r=4. The mode is 2, which appears once in the subarray with indices [3,4]. Note that 3 also appears once in that range, but 2 is smaller than 3.
Submitted Solution:
```
print("?, 1 , 6")
``` | instruction | 0 | 101,380 | 12 | 202,760 |
No | output | 1 | 101,380 | 12 | 202,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ray lost his array and needs to find it by asking Omkar. Omkar is willing to disclose that the array has the following qualities:
1. The array has n (1 ≤ n ≤ 2 ⋅ 10^5) elements.
2. Every element in the array a_i is an integer in the range 1 ≤ a_i ≤ 10^9.
3. The array is sorted in nondecreasing order.
Ray is allowed to send Omkar a series of queries. A query consists of two integers, l and r such that 1 ≤ l ≤ r ≤ n. Omkar will respond with two integers, x and f. x is the mode of the subarray from index l to index r inclusive. The mode of an array is defined by the number that appears the most frequently. If there are multiple numbers that appear the most number of times, the smallest such number is considered to be the mode. f is the amount of times that x appears in the queried subarray.
The array has k (1 ≤ k ≤ min(25000,n)) distinct elements. However, due to Ray's sins, Omkar will not tell Ray what k is. Ray is allowed to send at most 4k queries.
Help Ray find his lost array.
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5), which equals to the length of the array that you are trying to find.
Interaction
The interaction starts with reading n.
Then you can make one type of query:
* "? \enspace l \enspace r" (1 ≤ l ≤ r ≤ n) where l and r are the bounds of the subarray that you wish to query.
The answer to each query will be in the form "x \enspace f" where x is the mode of the subarray and f is the number of times x appears in the subarray.
* x satisfies (1 ≤ x ≤ 10^9).
* f satisfies (1 ≤ f ≤ r-l+1).
* If you make more than 4k queries or violate the number range in the query, you will get an output "-1."
* If you terminate after receiving the response "-1", you will get the "Wrong answer" verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To output your answer, print:
* "! \enspace a_1 \enspace a_2 \enspace … \enspace a_{n-1} \enspace a_n" which is an exclamation point followed by the array with a space between every element.
And quit after that. This query is not counted towards the 4k queries limit.
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.
Hack Format
To hack, output 1 integer on the first line, n (1 ≤ n ≤ 2 ⋅ 10^5). On the second line output n integers a_1, a_2, …, a_{n-1}, a_n separated by a space such that there are at most 25000 distinct numbers and a_j ≤ a_{j+1} for all j from 1 to n-1.
Example
Input
6
2 2
2 2
3 2
2 1
Output
? 1 6
? 1 3
? 4 6
? 3 4
! 1 2 2 3 3 4
Note
The first query is l=1 and r=6. The mode is 2, and 2 appears 2 times, so x=2 and f=2. Note that 3 also appears two times, but 2 is outputted because 2 is smaller.
The second query is l=1 and r=3. The mode is 2 and 2 appears twice in the subarray with indices [1,3].
The third query is l=4 and r=6. The mode is 3 and 3 appears twice in the subarray with indices [4,6].
The fourth query is l=3 and r=4. The mode is 2, which appears once in the subarray with indices [3,4]. Note that 3 also appears once in that range, but 2 is smaller than 3.
Submitted Solution:
```
import sys
n = int(input())
res = [0] * (n + 1)
def helper(l, r, x = 0, f = 0):
if x == 0:
print('?', l, r)
sys.stdout.flush()
x, f = [int(i) for i in input().split()]
if f == 1:
res[l] = x
for i in range(l + 1, r + 1):
print('?', i, i)
sys.stdout.flush()
a, b = [int(i) for i in input().split()]
res[i] = a
return 1
if f == r - l + 1:
for i in range(l, r + 1):
res[i] = x
return f
cnt = helper(l, (r + l) // 2)
nstart = (r + l) // 2 + 1
if res[(r + l) // 2] == x:
remain = f - cnt
while remain > 0 and nstart <= r :
res[nstart] = x
nstart += 1
remain -= 1
if nstart <= r:
return helper(nstart, r)
return f
return helper(nstart, r, x, f)
helper(1, n)
print('!', end=' ')
for i in res[1:]:
print(i, end=' ')
print()
``` | instruction | 0 | 101,381 | 12 | 202,762 |
No | output | 1 | 101,381 | 12 | 202,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ray lost his array and needs to find it by asking Omkar. Omkar is willing to disclose that the array has the following qualities:
1. The array has n (1 ≤ n ≤ 2 ⋅ 10^5) elements.
2. Every element in the array a_i is an integer in the range 1 ≤ a_i ≤ 10^9.
3. The array is sorted in nondecreasing order.
Ray is allowed to send Omkar a series of queries. A query consists of two integers, l and r such that 1 ≤ l ≤ r ≤ n. Omkar will respond with two integers, x and f. x is the mode of the subarray from index l to index r inclusive. The mode of an array is defined by the number that appears the most frequently. If there are multiple numbers that appear the most number of times, the smallest such number is considered to be the mode. f is the amount of times that x appears in the queried subarray.
The array has k (1 ≤ k ≤ min(25000,n)) distinct elements. However, due to Ray's sins, Omkar will not tell Ray what k is. Ray is allowed to send at most 4k queries.
Help Ray find his lost array.
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5), which equals to the length of the array that you are trying to find.
Interaction
The interaction starts with reading n.
Then you can make one type of query:
* "? \enspace l \enspace r" (1 ≤ l ≤ r ≤ n) where l and r are the bounds of the subarray that you wish to query.
The answer to each query will be in the form "x \enspace f" where x is the mode of the subarray and f is the number of times x appears in the subarray.
* x satisfies (1 ≤ x ≤ 10^9).
* f satisfies (1 ≤ f ≤ r-l+1).
* If you make more than 4k queries or violate the number range in the query, you will get an output "-1."
* If you terminate after receiving the response "-1", you will get the "Wrong answer" verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To output your answer, print:
* "! \enspace a_1 \enspace a_2 \enspace … \enspace a_{n-1} \enspace a_n" which is an exclamation point followed by the array with a space between every element.
And quit after that. This query is not counted towards the 4k queries limit.
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.
Hack Format
To hack, output 1 integer on the first line, n (1 ≤ n ≤ 2 ⋅ 10^5). On the second line output n integers a_1, a_2, …, a_{n-1}, a_n separated by a space such that there are at most 25000 distinct numbers and a_j ≤ a_{j+1} for all j from 1 to n-1.
Example
Input
6
2 2
2 2
3 2
2 1
Output
? 1 6
? 1 3
? 4 6
? 3 4
! 1 2 2 3 3 4
Note
The first query is l=1 and r=6. The mode is 2, and 2 appears 2 times, so x=2 and f=2. Note that 3 also appears two times, but 2 is outputted because 2 is smaller.
The second query is l=1 and r=3. The mode is 2 and 2 appears twice in the subarray with indices [1,3].
The third query is l=4 and r=6. The mode is 3 and 3 appears twice in the subarray with indices [4,6].
The fourth query is l=3 and r=4. The mode is 2, which appears once in the subarray with indices [3,4]. Note that 3 also appears once in that range, but 2 is smaller than 3.
Submitted Solution:
```
T=int(input())
arr=[]
for _ in range(T):
print('?',_+1,_+1)
a=input().split(' ')
arr.append(a[0])
print('! '+' '.join(arr))
``` | instruction | 0 | 101,382 | 12 | 202,764 |
No | output | 1 | 101,382 | 12 | 202,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ray lost his array and needs to find it by asking Omkar. Omkar is willing to disclose that the array has the following qualities:
1. The array has n (1 ≤ n ≤ 2 ⋅ 10^5) elements.
2. Every element in the array a_i is an integer in the range 1 ≤ a_i ≤ 10^9.
3. The array is sorted in nondecreasing order.
Ray is allowed to send Omkar a series of queries. A query consists of two integers, l and r such that 1 ≤ l ≤ r ≤ n. Omkar will respond with two integers, x and f. x is the mode of the subarray from index l to index r inclusive. The mode of an array is defined by the number that appears the most frequently. If there are multiple numbers that appear the most number of times, the smallest such number is considered to be the mode. f is the amount of times that x appears in the queried subarray.
The array has k (1 ≤ k ≤ min(25000,n)) distinct elements. However, due to Ray's sins, Omkar will not tell Ray what k is. Ray is allowed to send at most 4k queries.
Help Ray find his lost array.
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5), which equals to the length of the array that you are trying to find.
Interaction
The interaction starts with reading n.
Then you can make one type of query:
* "? \enspace l \enspace r" (1 ≤ l ≤ r ≤ n) where l and r are the bounds of the subarray that you wish to query.
The answer to each query will be in the form "x \enspace f" where x is the mode of the subarray and f is the number of times x appears in the subarray.
* x satisfies (1 ≤ x ≤ 10^9).
* f satisfies (1 ≤ f ≤ r-l+1).
* If you make more than 4k queries or violate the number range in the query, you will get an output "-1."
* If you terminate after receiving the response "-1", you will get the "Wrong answer" verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To output your answer, print:
* "! \enspace a_1 \enspace a_2 \enspace … \enspace a_{n-1} \enspace a_n" which is an exclamation point followed by the array with a space between every element.
And quit after that. This query is not counted towards the 4k queries limit.
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.
Hack Format
To hack, output 1 integer on the first line, n (1 ≤ n ≤ 2 ⋅ 10^5). On the second line output n integers a_1, a_2, …, a_{n-1}, a_n separated by a space such that there are at most 25000 distinct numbers and a_j ≤ a_{j+1} for all j from 1 to n-1.
Example
Input
6
2 2
2 2
3 2
2 1
Output
? 1 6
? 1 3
? 4 6
? 3 4
! 1 2 2 3 3 4
Note
The first query is l=1 and r=6. The mode is 2, and 2 appears 2 times, so x=2 and f=2. Note that 3 also appears two times, but 2 is outputted because 2 is smaller.
The second query is l=1 and r=3. The mode is 2 and 2 appears twice in the subarray with indices [1,3].
The third query is l=4 and r=6. The mode is 3 and 3 appears twice in the subarray with indices [4,6].
The fourth query is l=3 and r=4. The mode is 2, which appears once in the subarray with indices [3,4]. Note that 3 also appears once in that range, but 2 is smaller than 3.
Submitted Solution:
```
import sys
n = int(input())
res = [0] * (n + 1)
def helper(l, r, x = 0, f = 0):
print('? ' + l + ' ' + r)
sys.stdout.flush()
if x == 0:
x, f = [int(i) for i in input().split()]
if f == 1:
res[l] = x
for i in range(l + 1, r + 1):
print('? ' + i + ' ' + i)
sys.stdout.flush()
a, b = [int(i) for i in input().split()]
res[i] = a
return 1
if f == r - l + 1:
for i in range(l, r + 1):
res[i] = x
return f
cnt = helper(l, (r + l) // 2)
nstart = (r + l) // 2 + 1
if res[(r + l) // 2] == x:
remain = f - cnt
while remain > 0:
res[nstart] = x
remain -= 1
return helper(nstart, r)
return helper(nstart, r, x, f)
``` | instruction | 0 | 101,383 | 12 | 202,766 |
No | output | 1 | 101,383 | 12 | 202,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,400 | 12 | 202,800 |
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n = input()
n = n + " "
print(n*int(n))
``` | output | 1 | 101,400 | 12 | 202,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,401 | 12 | 202,802 |
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
for i_t in range(t):
n = int(input())
print(*[1]*n)
``` | output | 1 | 101,401 | 12 | 202,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,402 | 12 | 202,804 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n=int(input())
for i in range(n):
a=int(input())
for j in range(a):
print(1,end=" ")
print()
``` | output | 1 | 101,402 | 12 | 202,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,403 | 12 | 202,806 |
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
print(" ".join(['1' for x in range(int(input()))]))
``` | output | 1 | 101,403 | 12 | 202,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,404 | 12 | 202,808 |
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
print('1 '*n)
``` | output | 1 | 101,404 | 12 | 202,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,405 | 12 | 202,810 |
Tags: constructive algorithms, implementation
Correct Solution:
```
for i in range(int(input())):
n=int(input())
s=' '
m=[1 for z in range(n)]
m=list(map(str,m))
print(s.join(m))
``` | output | 1 | 101,405 | 12 | 202,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,406 | 12 | 202,812 |
Tags: constructive algorithms, implementation
Correct Solution:
```
t=int(input())
for you in range(t):
n=int(input())
for i in range(n):
print(1,end=" ")
print()
``` | output | 1 | 101,406 | 12 | 202,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good. | instruction | 0 | 101,407 | 12 | 202,814 |
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
while t:
t-=1
n = int(input())
print(n*"1 ")
``` | output | 1 | 101,407 | 12 | 202,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
t= int(input())
while t:
n = int(input())
arr = [1 for _ in range(n)]
print(*arr)
t-=1
``` | instruction | 0 | 101,408 | 12 | 202,816 |
Yes | output | 1 | 101,408 | 12 | 202,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
for _ in range(int(input())):
a = [1 for x in range(int(input()))]
print(*a)
``` | instruction | 0 | 101,409 | 12 | 202,818 |
Yes | output | 1 | 101,409 | 12 | 202,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
import sys
import os.path
from collections import *
import math
import bisect
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
else:
input = sys.stdin.readline
############## Code starts here ##########################
t = int(input())
while t:
t-=1
n = int(input())
for i in range(n):
print(1,end=" ")
print()
############## Code ends here ############################
``` | instruction | 0 | 101,410 | 12 | 202,820 |
Yes | output | 1 | 101,410 | 12 | 202,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
l = [2] * n
print(*l)
``` | instruction | 0 | 101,411 | 12 | 202,822 |
Yes | output | 1 | 101,411 | 12 | 202,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l=[x for x in range(1,100)]
s=[]
if n==1:
print(24)
continue
if n==2:
print(19,33)
continue
if n==4:
print(7,37,79,49)
continue
for j in range(len(l)):
if sum(l[:j+1])%len(l[:j+1])==0 :
s.append(l[j])
if len(s)==n:
break
print(*s)
``` | instruction | 0 | 101,412 | 12 | 202,824 |
No | output | 1 | 101,412 | 12 | 202,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
for _ in range(int(input())):
print('1'*int(input()))
``` | instruction | 0 | 101,413 | 12 | 202,826 |
No | output | 1 | 101,413 | 12 | 202,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
n = int(input())
for i in range(n):
a = int(input())
ar = []
s = 1
while(a > 0):
ar.append(s)
s += 6
a -= 1
print(*ar)
``` | instruction | 0 | 101,414 | 12 | 202,828 |
No | output | 1 | 101,414 | 12 | 202,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Andre has very specific tastes. Recently he started falling in love with arrays.
Andre calls an nonempty array b good, if sum of its elements is divisible by the length of this array. For example, array [2, 3, 1] is good, as sum of its elements — 6 — is divisible by 3, but array [1, 1, 2, 3] isn't good, as 7 isn't divisible by 4.
Andre calls an array a of length n perfect if the following conditions hold:
* Every nonempty subarray of this array is good.
* For every i (1 ≤ i ≤ n), 1 ≤ a_i ≤ 100.
Given a positive integer n, output any perfect array of length n. We can show that for the given constraints such an array always exists.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first and only line of every test case contains a single integer n (1 ≤ n ≤ 100).
Output
For every test, output any perfect array of length n on a separate line.
Example
Input
3
1
2
4
Output
24
19 33
7 37 79 49
Note
Array [19, 33] is perfect as all 3 its subarrays: [19], [33], [19, 33], have sums divisible by their lengths, and therefore are good.
Submitted Solution:
```
import random
if __name__ == "__main__":
t = int(input())
while t>0:
arr = [i for i in range(1,10) if i%2==1]
arr2 = [i for i in range(1,10) if i%2==0]
n = int(input())
if n==1:
print(24)
elif n==2:
print("19 33")
elif n%2==1:
for i in range(n):
print(random.choice(arr2))
else:
for i in range(n):
print(random.choice(arr))
t-=1
``` | instruction | 0 | 101,415 | 12 | 202,830 |
No | output | 1 | 101,415 | 12 | 202,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,469 | 12 | 202,938 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
if n%2==0:
for i in range(2,n+1,2):
print(i,i-1,end=' ')
else:
print('-1')
``` | output | 1 | 101,469 | 12 | 202,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,470 | 12 | 202,940 |
Tags: implementation, math
Correct Solution:
```
n=int(input());U=[];a=''
if n%2:print(-1)
else:
for i in range(1,n+1,2):
U.append(i+1);U.append(i)
for j in U:
a+=str(j)+' '
print(a)
``` | output | 1 | 101,470 | 12 | 202,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,471 | 12 | 202,942 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
if(n%2==1):
print(-1)
else:
for i in range(1,(n//2)+1):
print(2*i,(2*i)-1,end=' ')
``` | output | 1 | 101,471 | 12 | 202,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,472 | 12 | 202,944 |
Tags: implementation, math
Correct Solution:
```
R = lambda: map(int, input().split())
n = int(input())
if n % 2:
print(-1)
else:
for i in range(1,n+1,2):
print(i+1,i,end=' ')
``` | output | 1 | 101,472 | 12 | 202,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,473 | 12 | 202,946 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
l = []
p = []
if n % 2 == 1:
print(-1)
else:
for i in range(1 , n + 1):
l.append(i)
for i in range(len(l)):
if i % 2 == 0:
p.append(l[i+1])
else:
p.append(l[i-1])
for i in range(len(p)):
print(p[i] , end = ' ')
``` | output | 1 | 101,473 | 12 | 202,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,474 | 12 | 202,948 |
Tags: implementation, math
Correct Solution:
```
from math import ceil, log, floor, sqrt
import math
k = 1
def mod_expo(n, p, m):
"""find (n^p)%m"""
result = 1
while p != 0:
if p%2 == 1:
result = (result * n)%m
p //= 2
n = (n * n)%m
return result
def find_order(n):
if n%2 == 0:
#res = x for x in range(n, 0, -1)
print(*[x for x in range(n, 0, -1)], sep=' ')
else:
print(-1)
t = 1
#t = int(input())
while t:
t = t - 1
k, g = 0, 0
points = []
n = int(input())
#a = input()
#b = input()
#n, p, q, r = map(int, input().split())
#n, m = map(int, input().split())
#print(discover())
# = map(int, input().split())
#a = list(map(int, input().strip().split()))[:2*n]
#w = list(map(int, input().strip().split()))[:k]
#for i in range(3):
# x, y = map(int, input().split())
# points.append((x, y))
# s = input()
#if possible_phone_number(n, a):
# print("YES")
#else:
# print("NO")
find_order(n)
#print(find_mx_teams(n, m))
``` | output | 1 | 101,474 | 12 | 202,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,475 | 12 | 202,950 |
Tags: implementation, math
Correct Solution:
```
#-------------Program-------------
#----KuzlyaevNikita-Codeforces----
#
n=int(input())
if n%2!=0:print(-1)
else:
for i in range(1,n+1,2):
print(i+1,i,end=' ')
``` | output | 1 | 101,475 | 12 | 202,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3 | instruction | 0 | 101,476 | 12 | 202,952 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
if(n%2==1):
print(-1)
else:
L=list(range(1,n+1))
for i in range(0,n,2):
t=L[i]
L[i]=L[i+1]
L[i+1]=t
for i in range(n-1):
print(L[i],end=" ")
print(L[-1])
``` | output | 1 | 101,476 | 12 | 202,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3
Submitted Solution:
```
n = int(input())
if n%2 == 1:
print('-1')
else:
res = ''
for i in range(n,0,-1):
res+=str(i) + ' '
print(res)
``` | instruction | 0 | 101,477 | 12 | 202,954 |
Yes | output | 1 | 101,477 | 12 | 202,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3
Submitted Solution:
```
n=int(input())
if n%2!=0:
l=-1
print(l)
else:
a=2
b=1
s=str(a)+" "+str(b)
for i in range(2,n,2):
s+=" "+str(a+2)+" "+str(b+2)
a+=2
b+=2
print(s)
``` | instruction | 0 | 101,478 | 12 | 202,956 |
Yes | output | 1 | 101,478 | 12 | 202,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Let's denote the i-th element of permutation p as pi. We'll call number n the size of permutation p1, p2, ..., pn.
Nickolas adores permutations. He likes some permutations more than the others. He calls such permutations perfect. A perfect permutation is such permutation p that for any i (1 ≤ i ≤ n) (n is the permutation size) the following equations hold ppi = i and pi ≠ i. Nickolas asks you to print any perfect permutation of size n for the given n.
Input
A single line contains a single integer n (1 ≤ n ≤ 100) — the permutation size.
Output
If a perfect permutation of size n doesn't exist, print a single integer -1. Otherwise print n distinct integers from 1 to n, p1, p2, ..., pn — permutation p, that is perfect. Separate printed numbers by whitespaces.
Examples
Input
1
Output
-1
Input
2
Output
2 1
Input
4
Output
2 1 4 3
Submitted Solution:
```
n=int(input())
if n%2==1:
print(-1)
else:
arr1=[2*int(x) for x in range(1,int((n+2)/2))]
arr2=[x-1 for x in arr1]
for i in range(n//2):
print(arr1[i],end=" ")
print(arr2[i],end=" ")
``` | instruction | 0 | 101,479 | 12 | 202,958 |
Yes | output | 1 | 101,479 | 12 | 202,959 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.