message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a_1, …, a_n of n non-negative integers.
Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:
* The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened;
* The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
Example
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
Note
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
Submitted Solution:
```
ll=lambda:map(int,input().split())
t=lambda:int(input())
ss=lambda:input()
lx=lambda x:map(int,input().split(x))
from math import log10 ,log2,ceil,factorial as fac,gcd
#from itertools import combinations_with_replacement as cs
#from functools import reduce
#from bisect import bisect_right as br,bisect_left as bl
#from collections import Counter
#from math import inf
for _ in range(t()):
#def f():
n=t()
l=list(ll())
a,b=-1,n
for i in range(n):
if l[i]<i:
break
a=i
for i in range(n-1,-1,-1):
if l[i]<(n-i-1):
break
b=i
if a>=b:
print("yes")
else:
print("no")
#f()
'''
50 5 5 5 10 40
5 5 5
'''
``` | instruction | 0 | 72,634 | 12 | 145,268 |
Yes | output | 1 | 72,634 | 12 | 145,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a_1, …, a_n of n non-negative integers.
Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:
* The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened;
* The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
Example
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
Note
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
Submitted Solution:
```
n = int(input())
for _ in range(n):
b = int(input())
arr = list(map(int, input().split()))
q = -1
p = b + 1
for i in range(b):
if arr[i] < i:
p = i
break
for i in range(b):
if arr[b - 1 - i] < i:
q = b - 1 - i
break
if q < p - 1:
print("Yes")
else:
print("No")
``` | instruction | 0 | 72,635 | 12 | 145,270 |
Yes | output | 1 | 72,635 | 12 | 145,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a_1, …, a_n of n non-negative integers.
Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:
* The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened;
* The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
Example
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
Note
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
Submitted Solution:
```
def g_eq(a1, a2):
for i in range(len(a1)):
if a1[i] < a2[i]:
return False
return True
def sharpen(arr, arr_len):
k = arr_len//2
to_compare = list(range(k)) + [k] + list(range(k)[::-1])
if arr_len % 2 == 0:
to_compare = [to_compare[1:], to_compare[:-1]]
else:
to_compare = [to_compare]
for i in to_compare:
if g_eq(arr, i):
return 'Yes'
return 'No'
t = int(input())
for _ in range(t):
l = int(input())
a = [int(i) for i in input().split()]
print(sharpen(a, l))
``` | instruction | 0 | 72,636 | 12 | 145,272 |
No | output | 1 | 72,636 | 12 | 145,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a_1, …, a_n of n non-negative integers.
Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:
* The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened;
* The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
Example
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
Note
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
Submitted Solution:
```
import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
for _ in range(int(ri())):
n = int(ri())
arr = Ri()
flag = True
# inflag = True
# i = 0
# for i in range(1,len(arr)):
# if arr[i] == arr[i-1]:
# inflag = False
# break
# if inflag:
# for i in range(1,len(arr)):
# if arr[i] < arr[i-1]:
# break
# for i in range(i+1,len(arr)):
# if arr[i] > arr[i-1]:
# inflag = False
# break
# if inflag:
# Yes()
# else:
flag = False
for i in range(n-1,-1,-1):
if n-i-1 > arr[i] or arr[i] < i:
continue
else:
flag = True
break
if flag :
Yes()
else:
# print("fsf")
No()
``` | instruction | 0 | 72,637 | 12 | 145,274 |
No | output | 1 | 72,637 | 12 | 145,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a_1, …, a_n of n non-negative integers.
Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:
* The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened;
* The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
Example
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
Note
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
Submitted Solution:
```
for i in range(int(input())):
n, a = int(input()), list(map(int, input().split()))
ans, ix = 'NO', -1
for j in range(n - 1):
if a[j] >= j:
ans = 'YES'
else:
if a[j - 1] <= a[j]:
ans = 'NO'
else:
ix = j
break
if ix != -1:
for j in range(n - 1, ix - 1, -1):
if a[j] >= n - j + 1:
ans = 'YES'
else:
ans = 'NO'
break
if n == 1:
ans = 'YES'
if n == 2 and a[0] == a[-1] == 0:
ans = 'NO'
print(ans)
``` | instruction | 0 | 72,638 | 12 | 145,276 |
No | output | 1 | 72,638 | 12 | 145,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a_1, …, a_n of n non-negative integers.
Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:
* The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened;
* The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
Example
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
Note
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
Submitted Solution:
```
# import sys
# file = open("test1")
# sys.stdin = file
def ii(): return int(input())
def ai(): return list(map(int, input().split()))
def mi(): return map(int, input().split())
for _ in range(ii()):
n = ii()
s = ai()
min_till_now = -1
max_till_now = 0
i = 0
inc = True
while i < n :
if s[i]>min_till_now:
min_till_now += 1
i += 1
else:
break
j = 1
while j<n:
if s[j-1] > s[j]:
pass
else:
break
j += 1
if j == n or i == n:
print("YES")
else:
max_till_now = s[i-1 if i>0 else 0]
# print(i,"i")
ans = "YES"
while i < n:
if s[i]>= max_till_now:
ans = "NO"
break
max_till_now = s[i]
i += 1
print(ans)
``` | instruction | 0 | 72,639 | 12 | 145,278 |
No | output | 1 | 72,639 | 12 | 145,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,705 | 12 | 145,410 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
total = int(input())
num_l = list(map(int,input().split()))
if total == 1:
print('1 1')
print(-num_l[0])
print('1 1')
print('0')
print('1 1')
print('0')
elif total == 2:
print('1 1')
print(-num_l[0])
print('2 2')
print(-num_l[1])
print('1 1')
print('0')
else:
print('1 '+str(total-1))
mul1 = total - 1
mul1_l = []
for count in range(total-1):
mul1_l.append(mul1*num_l[count])
print(*mul1_l)
print('1 '+str(total))
mul2 = total
mul2_l = []
for count in range(total-1):
mul2_l.append(-mul2*num_l[count])
mul2_l += [0]
print(*mul2_l)
print(str(total)+' '+str(total))
print(-num_l[total-1])
``` | output | 1 | 72,705 | 12 | 145,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,706 | 12 | 145,412 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
import sys
import math,bisect
sys.setrecursionlimit(10 ** 5)
from collections import defaultdict
from itertools import groupby,accumulate
from heapq import heapify,heappop,heappush
from collections import deque,Counter,OrderedDict
def I(): return int(sys.stdin.readline())
def neo(): return map(int, sys.stdin.readline().split())
def Neo(): return list(map(int, sys.stdin.readline().split()))
n = I()
l = Neo()
if n == 1:
s = "1 1\n"+str(-l[0])+"\n1 1\n0\n1 1\n0"
print(s)
else:
a,an = [],[]
for i in range(n):
an.append((-l[i])*n)
b=-(l[0]+an[0])
for i in range(1,n):
a.append(l[i]*(n-1))
print(1,n)
print(*an)
print(1,1)
print(b)
print(2,n)
print(*a)
``` | output | 1 | 72,706 | 12 | 145,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,707 | 12 | 145,414 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
def fun(ai,n):
ii = -ai%n
num = (ii*n)-ii-ai
return num
n = int(input())
a = [int(i) for i in input().split()]
if n==1:
print(1,1)
print(-a[0])
print(1,1)
print(0)
print(1,1)
print(0)
else:
ans1 = []
for i in range (n):
if a[i]%n==0:
ans1.append(-a[i])
a[i]=0
else:
ans1.append(fun(a[i],n))
a[i]+=ans1[-1]
ans2=[]
for i in range (n-1):
ans2.append(-a[i])
print(1,n)
print(*ans1)
print(1,n-1)
print(*ans2)
print(n,n)
print(-a[-1])
``` | output | 1 | 72,707 | 12 | 145,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,708 | 12 | 145,416 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
if n==1:
print('1 1')
print('0')
print('1 1')
print('0')
print('1 1')
print(-a[0])
else:
print('1', n - 1)
b = []
for i in range(n - 1):
x = a[i] % n
y = x * (n - 1)
b.append(y)
a[i] = -(y + a[i])
print(*b)
print(n, n)
print(-a[n - 1])
a[n - 1] = 0
print('1', n)
print(*a)
``` | output | 1 | 72,708 | 12 | 145,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,709 | 12 | 145,418 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
import math
n = int(input())
arr = list(map(int,input().split()))
if n<=3:
for i in range(n):
print(i+1,i+1)
print(-arr[i])
for i in range(3-n):
print(1,1)
print(0)
else:
ans = [[],[],[]]
for i in range(len(arr)-1):
temp = arr[i]%n*(n-1)
ans[0].append(temp)
arr[i]+=temp
for i in range(len(arr)-1):
temp = -arr[i]
ans[1].append(temp)
arr[i]+=temp
ans[1].append(0)
print(1,n-1)
for num in ans[0]:
print(num, end = " ")
print()
print(1,n)
for num in ans[1]:
print(num, end = " ")
print()
print(n,n)
print(-arr[len(arr)-1])
``` | output | 1 | 72,709 | 12 | 145,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,710 | 12 | 145,420 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
# for _ in range(int(input())):
n = int(input())
# n, m = map(int, input().split())
l = list(map(int, input().split()))
# l = [list(map(int, input().split())) for i in range(n)]
if n == 1:
print(1, 1)
print(0)
print(1, 1)
print(0)
print(1, 1)
print(-l[0])
else:
print(1, n)
arr = []
for i in range(n):
arr.append(-l[i]*n)
print(*arr)
arr2 = []
print(1, n-1)
for i in range(n-1):
arr2.append(l[i]*(n-1))
print(*arr2)
print(n, n)
print(l[-1]*(n-1))
# print(1,1)
# print(-l[0])
# l[0] = 0
# print(2, n)
# valarr = []
# for i in range(1, n):
# temp = n-1
# val = (l[i]%n)*temp
# l[i]+=val
# valarr.append(val)
# print(*valarr)
# print(1, n)
# arr = []
# for i in range(n):
# arr.append(-l[i])
# print(*arr)
``` | output | 1 | 72,710 | 12 | 145,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,711 | 12 | 145,422 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
if n == 1:
print('1 1', -a[0], '1 1', '0', '1 1', '0', sep='\n')
exit(0)
print(1, n)
for i in range(n):
print(-a[i] * n, end = ' ')
a[i] -= a[i] * n
print()
print(1, n - 1)
for i in range(n - 1):
print(-a[i], end = ' ')
a[i] = 0
print()
print(2, n)
for i in range(1, n):
print(-a[i], end = ' ')
a[i] = 0
print()
``` | output | 1 | 72,711 | 12 | 145,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6 | instruction | 0 | 72,712 | 12 | 145,424 |
Tags: constructive algorithms, greedy, number theory
Correct Solution:
```
mod = 10**9 + 7
def solve():
n = int(input())
a = list(map(int, input().split()))
if n == 1:
print(1, 1)
print(0)
else:
print(1, n - 1)
for i in range(0, n - 1):
print(a[i] * (n - 1), end = ' ')
a[i] = a[i] * n
print()
print(n, n)
print(-a[n - 1])
a[n - 1] = 0
print(1, n)
for i in range(n):
a[i] = -a[i]
print(*a)
t = 1
while t > 0:
solve()
t -= 1
``` | output | 1 | 72,712 | 12 | 145,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
# template -> FastIntegerInput;
import sys
_ord, inp, num, neg, _Index = lambda x: x, [], 0, False, 0
i, s = 0, sys.stdin.buffer.read()
try:
while True:
if s[i] >= b"0"[0]:num = 10 * num + _ord(s[i]) - 48
elif s[i] == b"-"[0]:neg = True
elif s[i] != b"\r"[0]:
inp.append(-num if neg else num)
num, neg = 0, False
i += 1
except IndexError: pass
if s and s[-1] >= b"0"[0]: inp.append(-num if neg else num)
def fin(size=None):
global _Index
if size==None:
ni=_Index;_Index+=1
return inp[ni]
else:
ni=_Index;_Index+=size
return inp[ni:ni+size]
'''# template -> PyRivalBootstrap;
from types import GeneratorType
def recursive(f, stack=[]):
def wrapped(*args, **kwargs):
if stack: return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to); to = next(to)
else:
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped'''
_T_=1
for _t_ in range(_T_):
n=fin()
a=fin(n)
if n==1:
print(1,1); print(-a[0]); print(1,1); print(0); print(1,1); print(0); break
print(n,n)
print(-a[-1])
a[-1]-=a[-1]
print(1,n-1)
for i in range(n-1):
print(a[i]*(n-1),end=' ')
a[i]+=a[i]*(n-1)
print()
print(1,n)
for i in range(n):
print(-a[i],end=' ')
a[i]-=a[i]
print()
``` | instruction | 0 | 72,713 | 12 | 145,426 |
Yes | output | 1 | 72,713 | 12 | 145,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
n=int(input())
s=list(map(int,input().split()))
if n>1:
print(n,n)
print(n-s[-1]%n)
s[-1]+=n-s[-1]%n
print(1,n-1)
for i in range(n-1):
f=s[i]*(n-1)
print(f,end=' ')
s[i]+=f
print()
print(1,n)
print(*[-i for i in s])
else:
print(1,1);print(-s[0]);print(1,1);print(0);print(1,1);print(0)
``` | instruction | 0 | 72,714 | 12 | 145,428 |
Yes | output | 1 | 72,714 | 12 | 145,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
import sys
# input = sys.stdin.readline
ll = lambda: list(map(int, input().split()))
lls = lambda: list(map(str, input().split()))
fin = lambda: list(map(float, input().split()))
st = lambda: input()
v = lambda: map(int, input().split())
ii = lambda: int(input())
mod = (10 ** 9) + 7
from math import *
# from fractions import *
from datetime import datetime
from collections import *
import math
# print(log(8,3))
x=ii()
l=ll()
if(x<3):
if(x==1):
print(1,1)
l[0]+=1
print(1)
print(1,1)
l[0]+=1
print(1)
print(1,1)
print(-l[0])
else:
print(1, 1)
print(-l[0])
if(l[1]%2):
print(2,2)
print(1)
l[1]+=1
print(2,2)
print(-l[1])
else:
print(2,2)
print(0)
print(2,2)
print(-l[1])
elif(x==3):
print(1,1)
print(-l[0])
print(2,2)
print(-l[1])
print(3,3)
print(-l[2])
else:
#print(l)
print(x,x)
print(-l[-1])
l[-1]=0
print(1,x-1)
sol=[]
for i in range(x-1):
sol.append((x-1)*(((l[i]%x)+x)%x))
l[i]+=sol[i]
print(*sol)
print(1,x)
ans=[]
#print(l)
for i in range(x):
ans.append(-l[i])
print(*ans)
``` | instruction | 0 | 72,715 | 12 | 145,430 |
Yes | output | 1 | 72,715 | 12 | 145,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
from collections import Counter
from typing import *
n, a = int(input()), [int(x) for x in input().split()]
if n == 1:
print("1 1\n0")
print("1 1\n0")
print("1 1\n{}".format(-a[0]))
else:
print("1 {}".format(n - 1))
for i in range(n - 1):
print(a[i] * (n - 1), end=" ")
a[i] *= n
print("")
print("{} {}\n{}".format(n, n, a[n - 1] * (n - 1)))
a[n - 1] *= n
print("1 {}".format(n))
for i in range(n):
print(-a[i], end=" ")
``` | instruction | 0 | 72,716 | 12 | 145,432 |
Yes | output | 1 | 72,716 | 12 | 145,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
n=int(input())
a=[int(i) for i in input().split()]
#1 4 2 4 5
print(1,n-1)
for i in range(0,n-1):
z=(a[i]%n)*(n-1)
a[i]+=z
print(z,end=' ')
print()
print(n,n)
z=a[n-1]%n
if z==0:print(z)
else:print(-z)
a[n-1]=a[n-1]-z
print(1,n)
for i in range(n):
if a[i]<=0:print(-a[i],end=' ')
else:print(-a[i],end=' ')
``` | instruction | 0 | 72,717 | 12 | 145,434 |
No | output | 1 | 72,717 | 12 | 145,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
input = lambda: sys.stdin.buffer.readline().rstrip()
q=int(input())
w=list(map(int,input().split()))
if q==1:
print(1,1)
print(-w[0])
print(1,1)
print(0)
print(1,1)
print(0)
else:
print(1,1)
print(-w[0])
print(2,q)
print(*([0]+[(q-1)*w[i] for i in range(1,q)]))
print(1,q)
print(*([0]+[-(q)*w[i] for i in range(1,q)]))
``` | instruction | 0 | 72,718 | 12 | 145,436 |
No | output | 1 | 72,718 | 12 | 145,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
if n == 1:
print("1 1")
print("0")
print("1 1")
print("0")
print("1 1")
print(-arr[0])
else:
print("1 1")
print(-arr[0])
print("2", n)
a = [arr[i] * (n-1) for i in range(1, n)]
print(*a)
print("1", n)
b = [-arr[i] * n for i in range(n)]
print(*b)
``` | instruction | 0 | 72,719 | 12 | 145,438 |
No | output | 1 | 72,719 | 12 | 145,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n integers.
You want to make all elements of a equal to zero by doing the following operation exactly three times:
* Select a segment, for each number in this segment we can add a multiple of len to it, where len is the length of this segment (added integers can be different).
It can be proven that it is always possible to make all elements of a equal to zero.
Input
The first line contains one integer n (1 ≤ n ≤ 100 000): the number of elements of the array.
The second line contains n elements of an array a separated by spaces: a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9).
Output
The output should contain six lines representing three operations.
For each operation, print two lines:
* The first line contains two integers l, r (1 ≤ l ≤ r ≤ n): the bounds of the selected segment.
* The second line contains r-l+1 integers b_l, b_{l+1}, ..., b_r (-10^{18} ≤ b_i ≤ 10^{18}): the numbers to add to a_l, a_{l+1}, …, a_r, respectively; b_i should be divisible by r - l + 1.
Example
Input
4
1 3 2 4
Output
1 1
-1
3 4
4 2
2 4
-3 -6 -6
Submitted Solution:
```
import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
input = lambda: sys.stdin.buffer.readline().rstrip()
q=int(input())
w=list(map(int,input().split()))
if q==1:
print(1,1)
print(-w[0])
print(1,1)
print(0)
print(1,1)
print(0)
else:
print(1,1)
print(-w[0])
print(2,q)
print(*[(q-1)*w[i] for i in range(q)])
print(1,q)
print(*[-(q)*w[i] for i in range(q)])
``` | instruction | 0 | 72,720 | 12 | 145,440 |
No | output | 1 | 72,720 | 12 | 145,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,757 | 12 | 145,514 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
import math
import sys
#def get_ints():
# return map(int, sys.stdin.readline().strip().split())
def inpu():
return sys.stdin.readline().strip()
T = int(input())
#lets = 'abcdefghijklmnopqrstuvwxyz'
#key = {lets[i]:i for i in range(26)}
n = 0
def use(ans,i):
tb = -1
#print(ans,i)
for i in range(i+1,n):
if ans[i]!=-1:
tb = ans[i]
break
for i in range(i-1,-1,-1):
if ans[i]!=-1:
return max(tb,ans[i])+1
return tb+1
for t in range(T):
n = int(input())
#n,m = map(int,input().split())
a = list(map(int,input().split()))
#b = inpu()
#a = input()
d = False
ans = [-1]*n
r = sorted(range(n),key = lambda i: a[i])
for i in range(n-1,-1,-1):
ans[r[i]] = use(ans,r[i])
#print(ans)
for i in ans:
print(i,end = ' ')
print()
``` | output | 1 | 72,757 | 12 | 145,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,758 | 12 | 145,516 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
itype = int
def inp(): return int(input())
def tinput(): return list(map(itype, input().split(" ")))
cr = []
def solve(a, si):
if(a == []):
return
global cr
root = a.index(max(a))
for i in range(len(a)):
if i != root:
cr[i+si] += 1
solve(a[:root], si)
solve(a[root+1:], root+1+si)
output = []
for tc in range(int(input())):
n = inp()
a = tinput()
cr = [0]*n
solve(a, 0)
output.append(" ".join(list(map(str, cr))))
print('\n'.join(output))
``` | output | 1 | 72,758 | 12 | 145,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,759 | 12 | 145,518 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
import math
def rec(l,l_,s,e,cnt):
if(s>e):
return
elif(s==e):
l_[s]=cnt
return
else:
maxm=l[s]
ind=s
for j in range(s+1,e+1,1):
if(l[j]>maxm):
maxm=l[j]
ind=j
l_[ind]=cnt
rec(l,l_,s,ind-1,cnt+1)
rec(l,l_,ind+1,e,cnt+1)
t=int(input())
for i in range(t):
n=int(input())
l=list(map(int,input().split()))
l_=[0]*n
rec(l,l_,0,n-1,0)
s=""
for elem in l_:
s+=str(elem)+" "
print(s[:-1])
``` | output | 1 | 72,759 | 12 | 145,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,760 | 12 | 145,520 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
T=int(input())
for t in range(T):
n=int(input())
a=list(map(int,input().split()))
l=[0 for i in range(n)]
def f(a,low,high,count):
i=a.index(max(a[low:high+1]))
l[i]=count
if(low!=high):
if(i==low):
f(a,low+1,high,count+1)
elif(i==high):
f(a,low,high-1,count+1)
else:
f(a,low,i-1,count+1)
f(a,i+1,high,count+1)
f(a,0,n-1,0)
print(*l)
``` | output | 1 | 72,760 | 12 | 145,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,761 | 12 | 145,522 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
import sys
class Node:
def __init__(self,val):
self.val = val
self.left = None
self.right = None
def build(arr,dic):
#print(arr)
if len(arr) == 0:
return
tmp = max(arr)
root = Node(tmp)
#print(root.val)
idx = arr.index(tmp)
root.left = build(arr[:idx],dic)
root.right = build(arr[idx+1:],dic)
return root
for _ in range(int(input())):
n = int(input())
arrr = list(map(int,input().split()))
dic = {}
root = build(arrr,dic)
dic = {}
q = [root]
l = 0
arr = [root.val]
while q:
curr = q[0]
if len(q) == len(arr):
for i in arr:
dic[i] = l
l += 1
arr = []
if curr.left:
q.append(curr.left)
arr.append(curr.left.val)
if curr.right:
q.append(curr.right)
arr.append(curr.right.val)
q.pop(0)
for i in range(n):
arrr[i] = dic[arrr[i]]
print(*arrr)
``` | output | 1 | 72,761 | 12 | 145,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,762 | 12 | 145,524 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
def bin_search(ans, halp, a, b):
if len(a)>0:
m = a.index(max(a))
ind = halp.index(max(a))
b[ind] = ans
p = a[:m]
q = a[m+1:]
bin_search(ans+1,halp,p,b)
bin_search(ans+1,halp,q,b)
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = [0 for i in range(n)]
halp = a.copy()
ans = 0
bin_search(ans, halp, a, b)
print(*b)
``` | output | 1 | 72,762 | 12 | 145,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,763 | 12 | 145,526 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
def dfs(permutation):
global newDict, counter
maxa = max(permutation)
if len(permutation) == 1:
newDict.update({maxa: counter})
return
else:
pos = permutation.index(maxa)
dfs([maxa])
counter += 1
if pos != 0:
dfs(permutation[:pos])
if pos + 1 < len(permutation):
dfs(permutation[pos + 1:])
counter -= 1
t = int(input())
for i in range(t):
n = int(input())
arr = list(map(int, input().split()))
counter = 0
newDict = {}
dfs(arr)
for j in arr:
print(newDict[j], end=' ')
``` | output | 1 | 72,763 | 12 | 145,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation — is a sequence of length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2 | instruction | 0 | 72,764 | 12 | 145,528 |
Tags: dfs and similar, divide and conquer, implementation
Correct Solution:
```
def aux(length, values, x):
if length == 0:
return []
elif length == 1:
return [x]
else:
maximum = values.index(max(values))
first = values[:maximum]
last = values[maximum + 1:]
return aux(len(first), first, x + 1) + [x] + aux(len(last), last, x + 1)
def main():
number = int(input())
for i in range(number):
cont = 0
values = []
length_permutation = int(input())
input_values = input().split(" ")
for i in input_values:
values.append(int(i))
result = aux(length_permutation, values, cont)
output = ""
for i in range(len(result)):
output += str(result[i]) + " "
print(output)
if __name__ == '__main__':
main()
``` | output | 1 | 72,764 | 12 | 145,529 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
from math import *
from sys import *
from bisect import *
from collections import *
t=int(stdin.readline())
for _ in range(t):
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
d={}
def fun(low,high,k):
if low>high:
return
mx=0
j=0
for i in range(low,high+1):
if mx<a[i]:
j=i
mx=a[i]
d[mx]=k
fun(low,j-1,k+1)
fun(j+1,high,k+1)
fun(0,n-1,0)
ans=[]
for i in range(n):
ans.append(d[a[i]])
print(*ans)
``` | instruction | 0 | 72,765 | 12 | 145,530 |
Yes | output | 1 | 72,765 | 12 | 145,531 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
# from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,6)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
def pmat(A):
for ele in A:
print(*ele,end="\n")
def rec(i,j,level):
if i>j:
return
if i==j:
d[i+1]=level
return
x=A.index(max(A[i:j+1]))
# print(i,j,x)
if not i<=x<=j:
return
d[x+1]=level
rec(i,x-1,level+1)
rec(x+1,j,level+1)
for _ in range(L()[0]):
n=L()[0]
A=L()
d=[0 for i in range(n+1)]
rec(0,n-1,0)
print(*d[1:])
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
``` | instruction | 0 | 72,766 | 12 | 145,532 |
Yes | output | 1 | 72,766 | 12 | 145,533 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
def aux(element_j, element_k, array_elements, element_c):
if(element_j == element_k):
result[element_j] = element_c
return
indexBiggest = element_j
for index in range(element_j, element_k+1):
if(array_elements[index] > array_elements[indexBiggest]):
indexBiggest = index
result[indexBiggest] = element_c
element_c += 1
if(element_j <= indexBiggest-1):
aux(element_j, indexBiggest-1, array_elements, element_c)
if(element_k >= indexBiggest+1):
aux(indexBiggest+1, element_k, array_elements, element_c)
for index in range(int(input())):
input_n = int(input())
input_a = list(map(int, input().split()))
result = [0 for i in range(input_n)]
aux(0, input_n-1, input_a, 0)
print(*result)
``` | instruction | 0 | 72,767 | 12 | 145,534 |
Yes | output | 1 | 72,767 | 12 | 145,535 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
'''
* Author : Ayushman Chahar #
* About : IT Sophomore #
* Insti : VIT, Vellore #
'''
import os
import sys
from collections import defaultdict
# from itertools import *
# from math import *
# from queue import *
# from heapq import *
# from bisect import *
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")
readint = lambda: int(sys.stdin.readline().rstrip("\r\n"))
readints = lambda: map(int, sys.stdin.readline().rstrip("\r\n").split())
readstr = lambda: sys.stdin.readline().rstrip("\r\n")
readstrs = lambda: map(str, sys.stdin.readline().rstrip("\r\n").split())
readarri = lambda: [int(_) for _ in sys.stdin.readline().rstrip("\r\n").split()]
readarrs = lambda: [str(_) for _ in sys.stdin.readline().rstrip("\r\n").split()]
sys.setrecursionlimit(100 * 100 * 100)
mod = 998244353
MOD = int(1e9) + 7
ans = [0] * 101
idx = defaultdict(int)
def clear_global():
global ans, idx
idx.clear()
ans = [0] * 101
def chaalu(arr, depth, left, right):
if (len(arr) == 0): return
maxx = max(arr)
check = arr.index(maxx)
ans[idx[maxx]] = depth
chaalu(arr[:check], depth + 1, left, left + check - 1)
chaalu(arr[check + 1:], depth + 1, left + check + 1, right)
def solve():
n, ar = readint(), readarri()
for i in range(n): idx[ar[i]] = i
chaalu(ar, 0, 0, n - 1)
print(*ans[0: n])
def main():
t = 1
t = readint()
for _ in range(t):
# print("Case #" + str(_ + 1) + ": ", end="")
solve()
if __name__ == "__main__":
main()
``` | instruction | 0 | 72,768 | 12 | 145,536 |
Yes | output | 1 | 72,768 | 12 | 145,537 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
from array import *
t=int(input())
while t>0:
n=int(input())
t-=1
s=input()
s=s+' '
ar=array('i',range(1,n+3))
inv=array('i',range(1,n+3))
dep=array('i',range(1,n+3))
j=0
#print('s=',s,'s[j]=',s[0])
for i in range(1,n+1):
st=''
while not(s[j]==' '):
#print('s',j,'=',s[j])
st+=s[j]
j+=1
#print('st',i,'=',st)
ar[i]=int(st)
j+=1
ar[n+1]=0
for i in range(1,n+1):
inv[ar[i]]=i
ens=set(range(1,n+1))
i=n-1
dep[inv[n]]=0
dep[inv[n-1]]=1
while i>1:
i-=1
dep[inv[i]]=0
if inv[i]<inv[n]:
for j in range(i+1,n+1):
if ((inv[j]<inv[j+1]) and (inv[j]<inv[n])) or (j==n):
dep[inv[i]]=dep[inv[j]]+1
break
elif inv[i]>inv[n]:
for j in range(i+1,n+1):
if ((inv[j]>inv[j+1]) and (inv[n]<inv[j])) or (j==n):
dep[inv[i]]=dep[inv[j]]+1
break
#for i in range(inv[i],n+1):
# ar[i]=ar[i+1]
# inv[ar[i]]-=1
answer=''
if n==1:
dep[1]=0
for i in range(1,n):
answer+=str(dep[i])
answer+=' '
answer+=str(dep[n])
print(answer)
``` | instruction | 0 | 72,769 | 12 | 145,538 |
No | output | 1 | 72,769 | 12 | 145,539 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
cases = int(input())
for _ in range(cases):
n = int(input())
perm = list(map(int, input().split()))
count = 0
for i in range(n-1):
first = max(perm[i], perm[i+1])
second = min(perm[i], perm[i+1])
while second*2<first:
count+=1
second*=2
print(count)
``` | instruction | 0 | 72,770 | 12 | 145,540 |
No | output | 1 | 72,770 | 12 | 145,541 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
import sys
def read_ints():
return map(int, sys.stdin.readline().split())
def f(seq):
result = [None] * len(seq)
def g(seq, d):
if not seq:
return
mid = seq.index(max(seq))
result[mid] = d
g(seq[:mid], d+1)
g(seq[mid+1:], d+1)
g(seq, 0)
return result
t_n, = read_ints()
for i_t in range(t_n):
n, = read_ints()
a_seq = tuple(a-1 for a in read_ints())
result = f(a_seq)
print(*result)
``` | instruction | 0 | 72,771 | 12 | 145,542 |
No | output | 1 | 72,771 | 12 | 145,543 |
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 length n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] — permutations, and [2, 3, 2], [4, 3, 1], [0] — no.
Polycarp was recently gifted a permutation a[1 ... n] of length n. Polycarp likes trees more than permutations, so he wants to transform permutation a into a rooted binary tree. He transforms an array of different integers into a tree as follows:
* the maximum element of the array becomes the root of the tree;
* all elements to the left of the maximum — form a left subtree (which is built according to the same rules but applied to the left part of the array), but if there are no elements to the left of the maximum, then the root has no left child;
* all elements to the right of the maximum — form a right subtree (which is built according to the same rules but applied to the right side of the array), but if there are no elements to the right of the maximum, then the root has no right child.
For example, if he builds a tree by permutation a=[3, 5, 2, 1, 4], then the root will be the element a_2=5, and the left subtree will be the tree that will be built for the subarray a[1 ... 1] = [3], and the right one — for the subarray a[3 ... 5] = [2, 1, 4]. As a result, the following tree will be built:
<image> The tree corresponding to the permutation a=[3, 5, 2, 1, 4].
Another example: let the permutation be a=[1, 3, 2, 7, 5, 6, 4]. In this case, the tree looks like this:
<image> The tree corresponding to the permutation a=[1, 3, 2, 7, 5, 6, 4].
Let us denote by d_v the depth of the vertex a_v, that is, the number of edges on the path from the root to the vertex numbered a_v. Note that the root depth is zero. Given the permutation a, for each vertex, find the value of d_v.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 100) — the length of the permutation.
This is followed by n numbers a_1, a_2, …, a_n — permutation a.
Output
For each test case, output n values — d_1, d_2, …, d_n.
Example
Input
3
5
3 5 2 1 4
1
1
4
4 3 1 2
Output
1 0 2 3 1
0
0 1 3 2
Submitted Solution:
```
import sys
input=sys.stdin.readline
I = lambda : list(map(int,input().split()))
t,=I()
for _ in range(t):
n,=I()
l=I()
an=[0]*n
for i in range(n):
x=y=0
j=i+1
while j<n:
if l[j]>l[i]:
an[i]+=1
if l[j]==n:
break
j+=1
j=i-1
while j>-1:
if l[j]>l[i]:
an[i]+=1
if l[j]==n:
break
j-=1
print(*an)
``` | instruction | 0 | 72,772 | 12 | 145,544 |
No | output | 1 | 72,772 | 12 | 145,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,854 | 12 | 145,708 |
Tags: brute force, sortings
Correct Solution:
```
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
s = a[0]
for l in range(n):
for r in range(l,n):
out = sorted(a[:l] + a[r+1:], reverse=True)
inside = sorted(a[l:r+1])
temp = sum(a[l:r+1])
for i in range(min(k, len(out), len(inside))):
if out[i] > inside[i]:
temp += out[i] - inside[i]
else:
break
if temp > s:
s = temp
print(s)
main()
``` | output | 1 | 72,854 | 12 | 145,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,855 | 12 | 145,710 |
Tags: brute force, sortings
Correct Solution:
```
n, k = [int(c) for c in input().split()]
a = [int(c) for c in input().split()]
best = -1000001
seq = []
other = []
for l in range(n):
for r in range(l + 1, n + 1):
seq = sorted(a[l:r])
other = a[:l] + a[r:]
other.sort()
other.reverse()
seq_sum = sum(seq)
best = max(best, seq_sum)
for sw in range(0, min(k, len(seq), len(other))):
seq_sum = seq_sum - seq[sw] + other[sw]
best = max(best, seq_sum)
print(best)
# 200 10
# -933 947 859 -503 947 -767 121 469 214 -381 -962 807 59 -702 -873 -747 -233 77 -853 -39 243 902 909 612 -248 238 -511 -897 933 536 732 322 -155 247 340 145 681 -469 -906 -768 -368 -356 -168 -466 -398 -528 -515 968 107 929 178 29 -938 766 -173 -544 128 905 -877 -134 469 214 788 530 984 -738 805 -317 619 -596 -170 799 -276 -53 -211 663 619 -951 -616 -117 -574 774 127 -532 69 210 901 668 517 -354 280 -746 369 -357 696 570 -918 -912 -23 405 -414 -962 504 -390 165 -767 -259 442 -523 38 910 -956 62 -665 -933 947 859 -503 947 -767 121 469 214 -381 -962 807 59 -702 -873 -747 -233 77 -853 -39 243 902 909 612 -248 238 -511 -897 933 536 732 322 -155 247 340 145 681 -469 -906 -768 -368 -356 -168 -466 -398 -528 -515 968 107 929 178 29 -938 766 -173 -544 128 905 -877 -134 469 214 788 530 984 -738 805 -317 619 -596 -170 799 -276 -53 -211 663 619 -951 -616 -117 -574 774 127 -933 947 859 -503 947 -767 121 469 214 -381 -962 807 59 -702 -873 -747 -233 77 -853 -39 243 902 909 612 -248 238 -511 -897 933 536 732 322 -155 247 340 145 681 -469 -906 -768 -368 -356 -168 -466 -398 -528 -515 968 107 929 178 29 -938 766 -173 -544 128 905 -877 -134 469 214 788 530 984 -738 805 -317 619 -596 -170 799 -276 -53 -211 663 619 -951 -616 -117 -574 774 127 -532 69 210 901 668 517 -354 280 -746 369 -357 696 570 -918 -912 -23 405 -414 -962 504 -390 165 -767 -259 442 -523 38 910 -956 62 -665 -933 947 859 -503 947 -767 121 469 214 -381 -962 807 59 -702 -873 -747 -233 77 -853 -39 243 902 909 612 -248 238 -511 -897 933 536 732 322 -155 247 340 145 681 -469 -906 -768 -368 -356 -168 -466 -398 -528 -515 968 107 929 178 29 -938 766 -173 -544 128 905 -877 -134 469 214 788 530 984 -738 805 -317 619 -596 -170 799 -276 -53 -211 663 619 -951 -616 -117 -574 774 127
``` | output | 1 | 72,855 | 12 | 145,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,856 | 12 | 145,712 |
Tags: brute force, sortings
Correct Solution:
```
read_line = lambda: [int(i) for i in input().split()]
n, k = read_line()
x = read_line()
print(max(sum(sorted(x[l:r] + sorted(x[:l] + x[r:])[-k:])[l-r:]) for l in range(n) for r in range(l + 1, n + 1)))
``` | output | 1 | 72,856 | 12 | 145,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,857 | 12 | 145,714 |
Tags: brute force, sortings
Correct Solution:
```
def readln(): return tuple(map(int, input().split()))
n, k = readln()
a = list(readln())
ans = -10**9
for i in range(n):
for j in range(i, n):
x = a[:i] + a[j + 1:]
y = a[i:j + 1]
x.sort()
y.sort()
x.reverse()
for p in range(min(k, min(len(x), len(y)))):
if x[p] > y[p]:
x[p], y[p] = y[p], x[p]
ans = max(ans, sum(y))
print(ans)
``` | output | 1 | 72,857 | 12 | 145,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,858 | 12 | 145,716 |
Tags: brute force, sortings
Correct Solution:
```
def f(a,k):
ans=-float("inf")
for i in range(len(a)+1):
for j in range(i):
mid=a[j:i]
l=a[:j]+a[i:]
# print(mid,l)
l=sorted(l,reverse=True)
mid=sorted(mid)
s=sum(mid)
ans=max(ans,s)
kk=k
while kk:
if l and mid and s-mid[0]+l[0]>s :
s= s-mid[0]+l[0]
l.pop(0)
mid.pop(0)
kk-=1
ans=max(ans,s)
else:
break
return ans
n,k=map(int,input().strip().split())
a=list(map(int,input().strip().split()))
print(f(a,k))
``` | output | 1 | 72,858 | 12 | 145,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,859 | 12 | 145,718 |
Tags: brute force, sortings
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
res = a[0]
for l in range(n):
for r in range(l, n):
inside = sorted(a[l:r+1])
outside = sorted(a[:l] + a[r+1:], reverse=True)
new_res = sum(inside)
for i in range(min(k, len(inside), len(outside))):
if outside[i] > inside[i]:
new_res += outside[i]-inside[i]
else:
break
if new_res > res:
res = new_res
print(res)
``` | output | 1 | 72,859 | 12 | 145,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,860 | 12 | 145,720 |
Tags: brute force, sortings
Correct Solution:
```
n,m=map(int,input().split())
lis=list(map(int,input().split()))
k=-100000000
for l in range(n):
for r in range(l+1,n+1):
k=max(k,sum(sorted(lis[l:r] + sorted(lis[:l]+lis[r:])[-m:])[l-r:]))
print(k)
``` | output | 1 | 72,860 | 12 | 145,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1 | instruction | 0 | 72,861 | 12 | 145,722 |
Tags: brute force, sortings
Correct Solution:
```
def solve(curr,other,k):
t=0
while t<k and t<len(curr) and t<len(other) and other[t]>curr[t]:
t+=1
return t
n,k=map(int,input().split())
arr=list(map(int,input().split()))
maxx=-10**100
for i in range(n):
curr=[]
other=sorted(arr[:i]+arr[i+1:],reverse=True)
for j in range(i,n):
curr.append(arr[j])
curr.sort()
if j<n-1:
del other[other.index(arr[j+1])]
#print(other)
t=min(len(curr),len(other),k)
t=solve(curr,other,k)
maxx=max(maxx,sum(curr)-sum(curr[:t])+sum(other[:t]))
#print(curr,other,sum(curr)-sum(curr[:t])+sum(other[:t]))
#print(maxx)
#print(curr,other)
print(maxx)
``` | output | 1 | 72,861 | 12 | 145,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
from bisect import bisect_left, bisect_right
n, k = map(int, input().split())
t = list(map(int, input().split()))
p = sorted(t)
if p[-1] <= 0:
print(p[-1])
exit(0)
if p[0] >= 0:
print(sum(p))
exit(0)
i = max(0, n - k - 1)
while p[i] < 0: i += 1
q = sum(p[i: ])
if n < k + 2 or p[n - k - 1] <= 0:
print(q)
exit(0)
for l in range(n - k - 2):
r = l + k + 2
u = sorted(t[: l] + t[r: ])
v = sorted(t[l: r])
for i in range(r, n):
q = max(q, sum(sorted(v + u[- min(k, len(u)): ])[- len(v): ]))
u.remove(t[i])
v.insert(bisect_left(v, t[i]), t[i])
q = max(q, sum(sorted(v + u[- min(k, len(u)): ])[- len(v): ]))
print(q)
``` | instruction | 0 | 72,862 | 12 | 145,724 |
Yes | output | 1 | 72,862 | 12 | 145,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
def solve(i, j):
cur_res = sum(a[i:j+1])
a1 = sorted(a[i:j+1])
a2 = sorted(a[:i] + a[j+1:], reverse=True)
for t in range(min(k, len(a1), len(a2))):
m = min(a1)
if a2[t] > m:
cur_res += a2[t] - m
a1[a1.index(m)] = a2[t]
return cur_res
print(max(solve(i, j) for i in range(n) for j in range(i, n)))
``` | instruction | 0 | 72,863 | 12 | 145,726 |
Yes | output | 1 | 72,863 | 12 | 145,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
s = a[0]
for l in range(n):
for r in range(l,n):
out = sorted(a[:l] + a[r+1:], reverse=True)
inside = sorted(a[l:r+1])
temp = sum(a[l:r+1])
for i in range(min(k, len(out), len(inside))):
if out[i] > inside[i]:
temp += out[i] - inside[i]
else:
break
if temp > s:
s = temp
print(s)
``` | instruction | 0 | 72,864 | 12 | 145,728 |
Yes | output | 1 | 72,864 | 12 | 145,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
#!/usr/local/bin/python3
n, k = map(int, input().split())
a = list(map(int, input().split()))
r_sum = a[0]
for l in range(n):
for r in range(l, n):
inside = sorted(a[l:r+1])
outside = sorted(a[:l] + a[r+1:], reverse=True)
t_sum = sum(inside)
for i in range(min(k, len(inside), len(outside))):
if outside[i] > inside[i]:
t_sum += (outside[i] - inside[i])
else:
break
if t_sum > r_sum:
r_sum = t_sum
print(r_sum)
``` | instruction | 0 | 72,865 | 12 | 145,730 |
Yes | output | 1 | 72,865 | 12 | 145,731 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.