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 are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.
In one move, you can choose two indices i and j (1 ≤ i, j ≤ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 30; 0 ≤ k ≤ n) — the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 30), where b_i is the i-th element of b.
Output
For each test case, print the answer — the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.
Example
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
Note
In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1].
Submitted Solution:
```
t = int(input())
a = list()
b = list()
str = list()
otv = list()
for i in range(t):
str = input().split(' ')
n = int(str[0])
k = int(str[1])
str.clear()
str = input().split(' ')
for i in range(len(str)):
a.append(int(str[i]))
str.clear()
str = input().split(' ')
for i in range(len(str)):
b.append(int(str[i]))
if k == 0:
otv.append(sum(a))
a.clear()
b.clear()
str.clear()
continue
# сортируем, чтобы по легче было менять числа (минимальные в "а" на максимальные в "b")
a.sort()
b.sort(reverse=True)
#проверяем числа (если в б числа меньше, чем в а, то менять смысла нет)
for i in range(k):
if a[i] < b[i]:
a[i], b[i] = b[i], a[i] # swap
else:
break
otv.append(sum(a))
a.clear()
b.clear()
str.clear()
for i in otv:
print(i)
``` | instruction | 0 | 22,192 | 12 | 44,384 |
Yes | output | 1 | 22,192 | 12 | 44,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.
In one move, you can choose two indices i and j (1 ≤ i, j ≤ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 30; 0 ≤ k ≤ n) — the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 30), where b_i is the i-th element of b.
Output
For each test case, print the answer — the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.
Example
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
Note
In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1].
Submitted Solution:
```
def function(n,k,a,b):
a.sort(reverse = True)
b.sort()
temp = n-1
for x in range(n-k,n):
if a[x]<b[temp]:
a[x]=b[temp]
temp = temp-1
print(sum(a))
if __name__ == "__main__":
t = int(input())
for _ in range(t):
n,k = map(int,input().split())
a = list(map(int,input().strip().split(' ')))
b = list(map(int,input().strip().split(' ')))
function(n,k,a,b)
``` | instruction | 0 | 22,193 | 12 | 44,386 |
No | output | 1 | 22,193 | 12 | 44,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.
In one move, you can choose two indices i and j (1 ≤ i, j ≤ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 30; 0 ≤ k ≤ n) — the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 30), where b_i is the i-th element of b.
Output
For each test case, print the answer — the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.
Example
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
Note
In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1].
Submitted Solution:
```
kek = int(input())
for i in range (0,kek):
n,k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
yip = 0
while max(a) <= max(b) and yip < k:
yip+=1
for j in range (0,k):
z = min(a)
a[a.index(min(a))] = max(b)
b[b.index(max(b))] = z
s = 0
for y in range (0,n):
s += a[y]
print(s)
``` | instruction | 0 | 22,194 | 12 | 44,388 |
No | output | 1 | 22,194 | 12 | 44,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.
In one move, you can choose two indices i and j (1 ≤ i, j ≤ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 30; 0 ≤ k ≤ n) — the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 30), where b_i is the i-th element of b.
Output
For each test case, print the answer — the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.
Example
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
Note
In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1].
Submitted Solution:
```
t = int(input())
for i in range(t):
n,k = [int(i) for i in input().split()]
list1 = [int(i) for i in input().split()]
list2 = [int(i) for i in input().split()]
list1.sort()
list2.sort()
if list1[0]>=list2[-1]:
print(sum(list1))
else:
i = 0
try:
while (k!=0) or (all(list1[i] > x for x in list1)):
b = list1[i]
list1[i] = max(list2)
ind=list2.index(max(list2))
list2[ind] = b
print(i,k,list1)
k-=1
i+=1
except:
pass
print(sum(list1))
``` | instruction | 0 | 22,195 | 12 | 44,390 |
No | output | 1 | 22,195 | 12 | 44,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.
In one move, you can choose two indices i and j (1 ≤ i, j ≤ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 30; 0 ≤ k ≤ n) — the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 30), where b_i is the i-th element of b.
Output
For each test case, print the answer — the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.
Example
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
Note
In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1].
Submitted Solution:
```
t=int(input())
while t!=0:
n,k=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
while k!=0:
m1=min(a)
m2=max(b)
a.remove(m1)
b.remove(m2)
a.append(m2)
b.append(m1)
k-=1
print(sum(a))
t-=1
``` | instruction | 0 | 22,196 | 12 | 44,392 |
No | output | 1 | 22,196 | 12 | 44,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,229 | 12 | 44,458 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
for t in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
if len(set(arr))==n:
print("NO")
else:
print("YES")
``` | output | 1 | 22,229 | 12 | 44,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,230 | 12 | 44,460 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
A = set(map(int, input().split()))
print("YES" if len(A) < n else "NO")
``` | output | 1 | 22,230 | 12 | 44,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,231 | 12 | 44,462 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
mod = 10**9+7
import sys
input = sys.stdin.readline
for nt in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
if len(set(a))==n:
print ("NO")
else:
print ("YES")
``` | output | 1 | 22,231 | 12 | 44,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,232 | 12 | 44,464 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
for i in range(int(input())):
int(input())
l = input().split()
print(['YES', 'NO'][len(set(l))==len(l)])
``` | output | 1 | 22,232 | 12 | 44,465 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,233 | 12 | 44,466 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
# d, k = [int(j) for j in input().split()]
n = int(input())
a = [int(j) for j in input().split()]
if len(a) != len(set(a)):
print("yes")
else:
print("no")
``` | output | 1 | 22,233 | 12 | 44,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,234 | 12 | 44,468 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
import math
from sys import *
for _ in range(int(input())):
n=int(stdin.readline())
m=list(map(int,iter(stdin.readline().split())))
dict,f={},0
for i in m:
if i in dict: dict[i]+=1
else: dict[i]=1
for key,values in dict.items():
if values>=2:
f=1
if f==1:
stdout.write(str("yes")+"\n")
else:
stdout.write(str("no") + "\n")
``` | output | 1 | 22,234 | 12 | 44,469 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,235 | 12 | 44,470 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
n, values = int(input()), [int(i) for i in input().split()]
if len(set(values)) < len(values):
print("YES")
else:
print("NO")
``` | output | 1 | 22,235 | 12 | 44,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | instruction | 0 | 22,236 | 12 | 44,472 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
from collections import Counter
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
temp = Counter(arr)
f = 0
for i in arr:
if temp[i] > 1:
f = 1
break
if f == 1:
print('YES')
else:
print('NO')
``` | output | 1 | 22,236 | 12 | 44,473 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
brr = list(map(int, input().split()))
draft = []
for num in brr:
if num not in draft:
draft.append(num)
else:
print("YES")
break
else:
print("NO")
``` | instruction | 0 | 22,237 | 12 | 44,474 |
Yes | output | 1 | 22,237 | 12 | 44,475 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
x=0
ans=0
for i in range(n):
x=a.count(a[i])
if x>1:
ans=1
print("YES")
break
if(ans==0):
print("NO")
``` | instruction | 0 | 22,238 | 12 | 44,476 |
Yes | output | 1 | 22,238 | 12 | 44,477 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
b=[int(i) for i in input().split()]
if len(set(b))<n:
print('YES')
else:
print('NO')
``` | instruction | 0 | 22,239 | 12 | 44,478 |
Yes | output | 1 | 22,239 | 12 | 44,479 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
from sys import *
'''sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w') '''
from collections import defaultdict as dd
from math import *
from bisect import *
#sys.setrecursionlimit(10 ** 8)
def sinp():
return input()
def inp():
return int(sinp())
def minp():
return map(int, sinp().split())
def linp():
return list(minp())
def strl():
return list(sinp())
def pr(x):
print(x)
mod = int(1e9+7)
for _ in range(inp()):
n = inp()
b = linp()
d = dd(int)
for i in b:
d[i] += 1
pr('YES' if len(d) != n else 'NO')
``` | instruction | 0 | 22,240 | 12 | 44,480 |
Yes | output | 1 | 22,240 | 12 | 44,481 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
# Python3 program to find the number of
# subarrays with sum exactly equal to k.
from collections import defaultdict
# Function to find number of subarrays
# with sum exactly equal to k.
def findSubarraySum(arr, n, Sum):
# Dictionary to store number of subarrays
# starting from index zero having
# particular value of sum.
prevSum = defaultdict(lambda: 0)
res = 0
# Sum of elements so far.
currsum = 0
for i in range(0, n):
# Add current element to sum so far.
currsum += arr[i]
# If currsum is equal to desired sum,
# then a new subarray is found. So
# increase count of subarrays.
if currsum == Sum:
res += 1
# currsum exceeds given sum by currsum - sum.
# Find number of subarrays having
# this sum and exclude those subarrays
# from currsum by increasing count by
# same amount.
if (currsum - Sum) in prevSum:
res += prevSum[currsum - Sum]
# Add currsum value to count of
# different values of sum.
prevSum[currsum] += 1
return res
for _ in range(int(input())):
n=int(input())
arr = list(map(int,input().split(" ")))
Sum = sum(arr)
if Sum%2!=0:
print("NO")
continue
if findSubarraySum(arr, n, Sum)>=2:
print("YES")
continue
else:
print("NO")
``` | instruction | 0 | 22,241 | 12 | 44,482 |
No | output | 1 | 22,241 | 12 | 44,483 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
# Python3 program to find the number of
# subarrays with sum exactly equal to k.
from collections import defaultdict
# Function to find number of subarrays
# with sum exactly equal to k.
def findSubarraySum(arr, n, Sum):
# Dictionary to store number of subarrays
# starting from index zero having
# particular value of sum.
prevSum = defaultdict(lambda: 0)
res = 0
# Sum of elements so far.
currsum = 0
for i in range(0, n):
# Add current element to sum so far.
currsum += arr[i]
# If currsum is equal to desired sum,
# then a new subarray is found. So
# increase count of subarrays.
if currsum == Sum:
res += 1
# currsum exceeds given sum by currsum - sum.
# Find number of subarrays having
# this sum and exclude those subarrays
# from currsum by increasing count by
# same amount.
if (currsum - Sum) in prevSum:
res += prevSum[currsum - Sum]
# Add currsum value to count of
# different values of sum.
prevSum[currsum] += 1
return res
for _ in range(int(input())):
n=int(input())
arr = list(map(int,input().split(" ")))
Sum = sum(arr)
if Sum%2!=0:
print("NO")
continue
if findSubarraySum(arr, n, Sum)>=2:
print("YES")
``` | instruction | 0 | 22,242 | 12 | 44,484 |
No | output | 1 | 22,242 | 12 | 44,485 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
def sort(lst):
#i = 0
for i in range(len(lst)):
a = lst[i]
for j in range(i+1,len(lst)):
if lst[j] < a:
a = lst[j]
lst[i], lst[j] = lst[j], lst[i]
return lst
import sys
t = int(sys.stdin.readline())
for j in range(t):
n = int(sys.stdin.readline())
a = list(map(int,sys.stdin.readline().split()))
sorted_a = sorted(a)
for i in range(len(sorted_a)):
if (sorted_a[i] == sorted_a[i + 1]):
print("YES")
break
else:
print("NO")
break
``` | instruction | 0 | 22,243 | 12 | 44,486 |
No | output | 1 | 22,243 | 12 | 44,487 |
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 b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 ≤ i ≤ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 ≤ l_1 ≤ r_1 < l_2 ≤ r_2 ≤ n;
* a_{l_1}+a_{l_1+1}+…+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+…+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 ≤ n ≤ 1000).
The second line of every test case contains n integers b_1,b_2,…,b_n (0 ≤ b_i ≤ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays.
Submitted Solution:
```
def program():
n = int(input())
a = [int(x) for x in input().split()]
for i in a:
if i>n:
print("NO")
print("YES")
if __name__ == "__main__":
number_of_testcases = 1
number_of_testcases = int(input())
for i in range(number_of_testcases):
program()
``` | instruction | 0 | 22,244 | 12 | 44,488 |
No | output | 1 | 22,244 | 12 | 44,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,312 | 12 | 44,624 |
Tags: greedy
Correct Solution:
```
n = int(input())
l1 = [int(x) for x in input().split()]
l2 = [int(x) for x in input().split()]
used = set()
j = len(l1)-1
worst = j
for i in range(len(l2)-1, -1, -1):
if l2[i] in used:
continue
if l2[i] == l1[j]:
j-=1
else:
while l2[i] != l1[j]:
used.add(l1[j])
j-=1
j -= 1
worst = j+1
#print(worst)
print(len(l1) - worst - 1)
``` | output | 1 | 22,312 | 12 | 44,625 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,313 | 12 | 44,626 |
Tags: greedy
Correct Solution:
```
n = int(input())
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
vis, j = set(), n-1
res = j
for i in range(n-1, -1, -1):
if a2[i] in vis:
continue
if a2[i] == a1[j]:
j -= 1
continue
while a2[i] != a1[j]:
vis.add(a1[j])
j -= 1
j -= 1
res = j+1
print(n-res-1)
``` | output | 1 | 22,313 | 12 | 44,627 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,314 | 12 | 44,628 |
Tags: greedy
Correct Solution:
```
import sys
N = int(input())
current = input().split(" ")
real = input().split(" ")
positions = [-1 for i in range(int(2e5))]
for i, val in enumerate(real):
positions[int(val)-1] = i
# print(positions[:N])
last_pos = -1
for i, val in enumerate(current[1:], 1):
# print(val, positions[int(val) - 1] - i)
if positions[int(current[i - 1]) - 1] > positions[int(val) - 1]:
print(N - i)
sys.exit()
# if positions[int(val)-1] - i < 0:
# print(N - i)
# sys.exit()
# elif positions[int(val) - 1] - i > 0:
# if last_pos == -1:
# last_pos = i
# else:
# if last_pos != -1:
# print(N - i)
# sys.exit()
print(0)
``` | output | 1 | 22,314 | 12 | 44,629 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,315 | 12 | 44,630 |
Tags: greedy
Correct Solution:
```
n = int(input())
a, b = list(map(int, input().split())), list(map(int, input().split()))
i = j = 0
while i < n and j < n:
if b[j] == a[i]: i += 1
j += 1
print(n - i)
``` | output | 1 | 22,315 | 12 | 44,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,316 | 12 | 44,632 |
Tags: greedy
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
id = [0] * 3 * 10**6
res = 0
for i in range(n):
id[b[i]] = i
for i in range(n):
a[i] = id[a[i]]
for i in range(1,n):
if a[i] <a[i-1]:
res = n - i
break
print(res)
``` | output | 1 | 22,316 | 12 | 44,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,317 | 12 | 44,634 |
Tags: greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
from math import *
import bisect as bs
n=int(input())
a=[int(x) for x in input().split()]
b= [int(x) for x in input().split()]
d={}
for i in range(n):
d[b[i]]=i
c=0
ans=0
u=[0 for i in range(n)]
for i in range(n):
u[i]=d[a[i]]
#print(u)
for i in range(1,n):
if u[i]<u[i-1]:
ans=n-i
break
print(ans)
``` | output | 1 | 22,317 | 12 | 44,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves. | instruction | 0 | 22,318 | 12 | 44,636 |
Tags: greedy
Correct Solution:
```
u,d,x,n=0,0,0,int(input())
# n = [0 for i in range(n+10)]
f=list(map(int,input().split()))
s=list(map(int,input().split()))
while d<n:
if s[d]!=f[u]:
x+=1
d+=1
else:
d+=1
u+=1
print(x)
``` | output | 1 | 22,318 | 12 | 44,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves.
Submitted Solution:
```
import sys
input = sys.stdin.readline
from math import *
import bisect as bs
n=int(input())
a=[int(x) for x in input().split()]
b= [int(x) for x in input().split()]
d={}
for i in range(n):
d[b[i]]=i
c=0
ans=0
u=[0 for i in range(n)]
for i in range(n):
u[i]=d[a[i]]
for i in range(n):
if u[i]>i:
ans=n-i-1
break
print(ans)
``` | instruction | 0 | 22,319 | 12 | 44,638 |
No | output | 1 | 22,319 | 12 | 44,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves.
Submitted Solution:
```
n = int(input())
l1 = [int(x) for x in input().split()]
l2 = [int(x) for x in input().split()]
used = set()
j = len(l1)-1
answ = 0
for i in range(len(l2)-1, -1, -1):
if l2[i] in used:
continue
while j >= 0 and l1[j] != l2[i]:
used.add(l1[j])
j-=1
answ += 1
if j >= 0 and l1[j] == l2[i]:
j-=1
print(answ)
``` | instruction | 0 | 22,320 | 12 | 44,640 |
No | output | 1 | 22,320 | 12 | 44,641 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Happy PMP is freshman and he is learning about algorithmic problems. He enjoys playing algorithmic games a lot.
One of the seniors gave Happy PMP a nice game. He is given two permutations of numbers 1 through n and is asked to convert the first one to the second. In one move he can remove the last number from the permutation of numbers and inserts it back in an arbitrary position. He can either insert last number between any two consecutive numbers, or he can place it at the beginning of the permutation.
Happy PMP has an algorithm that solves the problem. But it is not fast enough. He wants to know the minimum number of moves to convert the first permutation to the second.
Input
The first line contains a single integer n (1 ≤ n ≤ 2·105) — the quantity of the numbers in the both given permutations.
Next line contains n space-separated integers — the first permutation. Each number between 1 to n will appear in the permutation exactly once.
Next line describe the second permutation in the same format.
Output
Print a single integer denoting the minimum number of moves required to convert the first permutation to the second.
Examples
Input
3
3 2 1
1 2 3
Output
2
Input
5
1 2 3 4 5
1 5 2 3 4
Output
1
Input
5
1 5 2 3 4
1 2 3 4 5
Output
3
Note
In the first sample, he removes number 1 from end of the list and places it at the beginning. After that he takes number 2 and places it between 1 and 3.
In the second sample, he removes number 5 and inserts it after 1.
In the third sample, the sequence of changes are like this:
* 1 5 2 3 4
* 1 4 5 2 3
* 1 3 4 5 2
* 1 2 3 4 5
So he needs three moves.
Submitted Solution:
```
N = int(input())
current = input().split(" ")
real = input().split(" ")
positions = [-1 for i in range(int(2e5))]
for i, val in enumerate(real):
positions[int(val)-1] = i
# print(positions[:N])
last_neg = -1
for i, val in enumerate(current):
if positions[int(val)] - i < 0:
print(N - i-1)
break
# elif positions[int(val)] - i < 0:
# if last_neg == -1:
# las
``` | instruction | 0 | 22,321 | 12 | 44,642 |
No | output | 1 | 22,321 | 12 | 44,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fafa has an array A of n positive integers, the function f(A) is defined as <image>. He wants to do q queries of two types:
* 1 l r x — find the maximum possible value of f(A), if x is to be added to one element in the range [l, r]. You can choose to which element to add x.
* 2 l r x — increase all the elements in the range [l, r] by value x.
Note that queries of type 1 don't affect the array elements.
Input
The first line contains one integer n (3 ≤ n ≤ 105) — the length of the array.
The second line contains n positive integers a1, a2, ..., an (0 < ai ≤ 109) — the array elements.
The third line contains an integer q (1 ≤ q ≤ 105) — the number of queries.
Then q lines follow, line i describes the i-th query and contains four integers ti li ri xi <image>.
It is guaranteed that at least one of the queries is of type 1.
Output
For each query of type 1, print the answer to the query.
Examples
Input
5
1 1 1 1 1
5
1 2 4 1
2 2 3 1
2 4 4 2
2 3 4 1
1 3 3 2
Output
2
8
Input
5
1 2 3 4 5
4
1 2 4 2
2 2 4 1
2 3 4 1
1 2 4 2
Output
6
10
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
m = int(input())
for u in range(1, m, 1):
b = list(map(int, input().split()))
if b[0] == 2:
for j in range(b[1], b[2], 1):
a[j] = a[j] + b[3]
else:
c = 0
for j in range(b[1], b[2], 1):
t = 0
q = a[j]
a[j] = a[j] + b[3]
for i in range(0, n-1, 1):
t = t + abs(a[i]-a[i+1])
if t > c:
c = t
a[j] = q
print(c)
``` | instruction | 0 | 22,580 | 12 | 45,160 |
No | output | 1 | 22,580 | 12 | 45,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fafa has an array A of n positive integers, the function f(A) is defined as <image>. He wants to do q queries of two types:
* 1 l r x — find the maximum possible value of f(A), if x is to be added to one element in the range [l, r]. You can choose to which element to add x.
* 2 l r x — increase all the elements in the range [l, r] by value x.
Note that queries of type 1 don't affect the array elements.
Input
The first line contains one integer n (3 ≤ n ≤ 105) — the length of the array.
The second line contains n positive integers a1, a2, ..., an (0 < ai ≤ 109) — the array elements.
The third line contains an integer q (1 ≤ q ≤ 105) — the number of queries.
Then q lines follow, line i describes the i-th query and contains four integers ti li ri xi <image>.
It is guaranteed that at least one of the queries is of type 1.
Output
For each query of type 1, print the answer to the query.
Examples
Input
5
1 1 1 1 1
5
1 2 4 1
2 2 3 1
2 4 4 2
2 3 4 1
1 3 3 2
Output
2
8
Input
5
1 2 3 4 5
4
1 2 4 2
2 2 4 1
2 3 4 1
1 2 4 2
Output
6
10
Submitted Solution:
```
def query1(array, l, r, x):
f = 0
best_f = -999999999999999999
for i in range(len(array)-1):
a = array[i]-array[i+1]
f += abs(a)
if i>= l-1 and i < r:
if i == 0:
best_f = max(best_f, abs(a+x) - abs(a))
elif j == len(array):
best_f = max(best_f, abs(array[j - 1] - x - array[j]) - abs(array[j - 1] - array[j]))
else:
best_f = max(best_f, abs(a+x) - abs(a) + abs(
array[j - 1] - x - array[j]) - abs(array[j - 1] - array[j]))
print(f + best_f)
def query2(array, l, r, x):
for i in range(l-1,r):
array[i] += x
if __name__ == "__main__":
# a1 = [1,1,1,1,1]
# query1(a1,2,4,1)
# query2(a1,2,3,1)
# query2(a1,4,4,2)
# query2(a1,3,4,1)
# query1(a1,3,3,2)
#
# a2 = [1,2,3,4,5]
# query1(a2,2,4,2)
# query2(a2,2,4,1)
# query2(a2,3,4,1)
# query1(a2,2,4,2)
array_len = int(input())
array = list(map(int,input().split()))
num_queries = int(input())
for j in range(num_queries):
type,l,r,x = list(map(int, input().split()))
if type == 1:
query1(array,l,r,x)
elif type == 2:
query2(array, l, r, x)
``` | instruction | 0 | 22,581 | 12 | 45,162 |
No | output | 1 | 22,581 | 12 | 45,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fafa has an array A of n positive integers, the function f(A) is defined as <image>. He wants to do q queries of two types:
* 1 l r x — find the maximum possible value of f(A), if x is to be added to one element in the range [l, r]. You can choose to which element to add x.
* 2 l r x — increase all the elements in the range [l, r] by value x.
Note that queries of type 1 don't affect the array elements.
Input
The first line contains one integer n (3 ≤ n ≤ 105) — the length of the array.
The second line contains n positive integers a1, a2, ..., an (0 < ai ≤ 109) — the array elements.
The third line contains an integer q (1 ≤ q ≤ 105) — the number of queries.
Then q lines follow, line i describes the i-th query and contains four integers ti li ri xi <image>.
It is guaranteed that at least one of the queries is of type 1.
Output
For each query of type 1, print the answer to the query.
Examples
Input
5
1 1 1 1 1
5
1 2 4 1
2 2 3 1
2 4 4 2
2 3 4 1
1 3 3 2
Output
2
8
Input
5
1 2 3 4 5
4
1 2 4 2
2 2 4 1
2 3 4 1
1 2 4 2
Output
6
10
Submitted Solution:
```
def query1(array, l, r, x):
# compute f(A)
f = 0
for i in range(len(array)-1):
f += abs(array[i]-array[i+1])
# try adding x
best_f = 0
for j in range(l-1,r):
if j == 0:
best_f = max(best_f, abs(array[j] + x - array[j + 1]) - abs(array[j] - array[j + 1]))
elif j == len(array):
best_f = max(best_f, abs(array[j-1]-x-array[j])- abs(array[j-1]-array[j]))
else:
best_f = max(best_f, abs(array[j]+x-array[j+1])-abs(array[j]-array[j+1])+abs(array[j-1]-x-array[j])- abs(array[j-1]-array[j]))
print(f + best_f)
def query2(array, l, r, x):
for i in range(l-1,r):
array[i] += x
if __name__ == "__main__":
# a1 = [1,1,1,1,1]
# query1(a1,2,4,1)
# query2(a1,2,3,1)
# query2(a1,4,4,2)
# query2(a1,3,4,1)
# query1(a1,3,3,2)
#
# a2 = [1,2,3,4,5]
# query1(a2,2,4,2)
# query2(a2,2,4,1)
# query2(a2,3,4,1)
# query1(a2,2,4,2)
array_len = int(input())
array = list(map(int,input().split()))
num_queries = int(input())
for j in range(num_queries):
type,l,r,x = list(map(int, input().split()))
if type == 1:
query1(array,l,r,x)
elif type == 2:
query2(array, l, r, x)
``` | instruction | 0 | 22,582 | 12 | 45,164 |
No | output | 1 | 22,582 | 12 | 45,165 |
Provide a correct Python 3 solution for this coding contest problem.
Given are two integer sequences of N elements each: A_1,...,A_N and B_1,...,B_N. Determine if it is possible to do the following operation at most N-2 times (possibly zero) so that, for every integer i from 1 to N, A_i \leq B_i holds:
* Choose two distinct integers x and y between 1 and N (inclusive), and swap the values of A_x and A_y.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i,B_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
B_1 B_2 ... B_N
Output
If the objective is achievable, print `Yes`; if it is not, print `No`.
Examples
Input
3
1 3 2
1 2 3
Output
Yes
Input
3
1 2 3
2 2 2
Output
No
Input
6
3 1 2 6 3 4
2 2 8 3 4 3
Output
Yes | instruction | 0 | 22,637 | 12 | 45,274 |
"Correct Solution:
```
class Unionfind:
__slots__ = ['parents','sizes']
def __init__(self, n):
self.parents = list(range(n))
self.sizes = [1]*n
def root(self, x):
if self.parents[x] == x:
return x
else:
root_x = self.root(self.parents[x])
self.parents[x] = root_x
return root_x
def unite(self, x, y):
x = self.root(x); y = self.root(y)
if x == y:
return
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.sizes[x] += self.sizes[y]
self.parents[y] = x
def same(self, x, y):
return self.root(x) == self.root(y)
# 集合自体の数 ({1,2}, {3}, {4} : kind -> 3)
def kind(self):
for v in range(N):
self.root(v)
return len(list(set(self.parents)))
# xが属する集合の要素の数 ({1,2,3} : size(2) -> 3)
def size(self, x):
self.sizes[x] = self.sizes[self.root(x)]
return self.sizes[x]
N = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
sA = sorted(enumerate(A), key=lambda x : x[1])
sB = sorted(enumerate(B), key=lambda x : x[1])
# 必要条件
if not all(a <= b for (i, a), (j, b) in zip(sA, sB)):
print("No")
exit()
uf = Unionfind(N)
# i -> j に移動する
for (i, a), (j, b) in zip(sA, sB):
uf.unite(i, j)
# サイクル数が２つ以上なら高々N-2回で理想の列が作れる
if uf.kind() > 1:
print("Yes")
exit()
# 以下サイクル数が１つだがN-2回以下で条件を満たすような例を弾く
# sB[i] >= sA[i+1]のようなiが存在すれば sA[i] と sA[i+1]をスワップする(目標とする列)
# サイクルが２つに分かれるので条件を満たす
if any(sB[i][1] >= sA[i+1][1] for i in range(N-1)):
print("Yes")
exit()
# 任意のiについてsB[i] < sA[i+1]なら sB[i] と sA[i]を対応させるしかない
# AとBをそれぞれソートした列が目標の列となってこれはN-1回かかるので不適
print("No")
``` | output | 1 | 22,637 | 12 | 45,275 |
Provide a correct Python 3 solution for this coding contest problem.
Given are two integer sequences of N elements each: A_1,...,A_N and B_1,...,B_N. Determine if it is possible to do the following operation at most N-2 times (possibly zero) so that, for every integer i from 1 to N, A_i \leq B_i holds:
* Choose two distinct integers x and y between 1 and N (inclusive), and swap the values of A_x and A_y.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i,B_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
B_1 B_2 ... B_N
Output
If the objective is achievable, print `Yes`; if it is not, print `No`.
Examples
Input
3
1 3 2
1 2 3
Output
Yes
Input
3
1 2 3
2 2 2
Output
No
Input
6
3 1 2 6 3 4
2 2 8 3 4 3
Output
Yes | instruction | 0 | 22,638 | 12 | 45,276 |
"Correct Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 18
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
class UnionFind:
def __init__(self, n):
# 負 : 根であることを示す。絶対値はランクを示す
# 非負: 根でないことを示す。値は親を示す
self.table = [-1] * n
self.size = [1] * n
self.group_num = n
def root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.root(self.table[x])
return self.table[x]
def is_same(self, x, y):
return self.root(x) == self.root(y)
def get_size(self, x):
r = self.root(x)
return self.size[r]
def union(self, x, y):
r1 = self.root(x)
r2 = self.root(y)
if r1 == r2:
return
# ランクの取得
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.size[r1] += self.size[r2]
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
self.size[r2] += self.size[r1]
self.group_num -= 1
n = I()
A = LI()
B = LI()
a_sort_index = sorted(range(n), key=lambda x:A[x])
b_sort_index = sorted(range(n), key=lambda x: B[x])
flag = 0
U = UnionFind(n)
for i in range(n):
if A[a_sort_index[i]] > B[b_sort_index[i]]:
print('No')
break
elif i != 0 and A[a_sort_index[i]] <= B[b_sort_index[i - 1]]:
flag = 1
U.union(a_sort_index[i], b_sort_index[i])
else:
if U.group_num == 1 and not flag:
print('No')
else:
print('Yes')
``` | output | 1 | 22,638 | 12 | 45,277 |
Provide a correct Python 3 solution for this coding contest problem.
Given are two integer sequences of N elements each: A_1,...,A_N and B_1,...,B_N. Determine if it is possible to do the following operation at most N-2 times (possibly zero) so that, for every integer i from 1 to N, A_i \leq B_i holds:
* Choose two distinct integers x and y between 1 and N (inclusive), and swap the values of A_x and A_y.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i,B_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
B_1 B_2 ... B_N
Output
If the objective is achievable, print `Yes`; if it is not, print `No`.
Examples
Input
3
1 3 2
1 2 3
Output
Yes
Input
3
1 2 3
2 2 2
Output
No
Input
6
3 1 2 6 3 4
2 2 8 3 4 3
Output
Yes | instruction | 0 | 22,639 | 12 | 45,278 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
a = [int(item) for item in input().split()]
b = [int(item) for item in input().split()]
# Check bi >= ai is possible
a_s = sorted(a)
b_s = sorted(b)
for i, (aa, bb) in enumerate(zip(a_s, b_s)):
if aa > bb:
print("No")
exit()
# Check there are pair such that ai <= ai+1 <= bi
for ai1, bi in zip(a_s[1:], b_s):
if ai1 <= bi:
print("Yes")
exit()
# get ab's cyclic permutation
ba = []
for i, (aa, bb) in enumerate(zip(a, b)):
ba.append((bb, aa))
ba.sort()
a_idx = []
for i, (bb, aa) in enumerate(ba):
a_idx.append((aa, i))
a_idx.sort()
visited = [0] * n
cycle = 0
for i in range(n):
curr = i
if visited[curr] == 1:
continue
cycle += 1
while visited[curr] == 0:
visited[curr] = 1
curr = a_idx[curr][1]
if cycle > 1:
print("Yes")
else:
print("No")
``` | output | 1 | 22,639 | 12 | 45,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,928 | 12 | 45,856 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
def solve(matrix, col, N, M):
if col == M:
'''
for row in matrix:
print(row)
print()
'''
ans = 0
for row in matrix:
if len(row) == 1:
ans += row[0]
else:
ans += max(*row)
return ans
# girar la columna `col` N - 1 veces
if N == 1:
return solve(matrix, col + 1, N, M)
ans = solve(matrix, col + 1, N, M)
for _ in range(N-1):
tmp = matrix[0][col]
for n in range(1, N):
matrix[n-1][col] = matrix[n][col]
matrix[N-1][col] = tmp
local_ans = solve(matrix, col + 1, N, M)
if local_ans > ans:
ans = local_ans
return ans
def main():
T = int(input())
for t in range(T):
N, M = list(map(lambda x: int(x), input().split()))
matrix = []
for n in range(N):
matrix.append(
list(map(lambda x: int(x), input().split()))
)
elements = []
for n in range(N):
for m in range(M):
elements.append((matrix[n][m], m))
elements.sort(reverse=True)
candidates = []
for t in elements:
if t[1] not in candidates:
candidates.append(t[1])
if len(candidates) == N:
break
simplified = []
for n in range(N):
row = []
for m in candidates:
row.append(matrix[n][m])
simplified.append(row)
ans = solve(simplified, 0, N, min(N, M))
print(ans)
main()
``` | output | 1 | 22,928 | 12 | 45,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,929 | 12 | 45,858 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
a=[[int(x) for x in input().split()] for j in range(n)]
x=[[a[i][j] for i in range(n)] for j in range(m)]
x.sort(key=lambda xx:-max(xx))
dp=[[0 for i in range(1<<n)] for j in range(m+1)]
an=0
for i in range(m):
for prev in range(1<<n):
for pres in range(1<<n):
for j in range(n):
ma=0
if prev^pres!=prev+pres:
continue
for st in range(n):
if pres&(1<<st):
ma+=x[i][(st+j)%n]
dp[i+1][pres^prev]=max(dp[i+1][pres^prev],dp[i][prev]+ma)
print(dp[m][(1<<n)-1])
``` | output | 1 | 22,929 | 12 | 45,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,930 | 12 | 45,860 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
def naiveSolve():
return
def main():
t=int(input())
allans=[]
for _ in range(t):
n,m=readIntArr()
grid=[]
for __ in range(n):
grid.append(readIntArr())
columns=[]
for col in range(m):
temp=[grid[i][col] for i in range(n)]
columns.append(temp)
valCol=[] # (value, column)
for i in range(n):
for j in range(m):
valCol.append((grid[i][j],j))
valCol.sort(reverse=True)
# try all possible shifts for top n columns
topCols=set()
for val,col in valCol:
topCols.add(col)
if len(topCols)==n:
break
# try all configurations
m2=len(topCols)
grid2=[[-1 for __ in range(m2)] for ___ in range(n)]
topColsList=list(topCols)
for j in range(m2):
col=topColsList[j]
for i in range(n):
grid2[i][j]=grid[i][col]
ans=-inf
for mask in range(n**m2):
grid3=[[-1 for __ in range(m2)] for ___ in range(n)]
for col in range(m2):
shift=mask%n
for row in range(n):
grid3[row][col]=grid2[(shift+row)%n][col]
mask//=n
tempAns=0
for row in range(n):
maxx=-inf
for col in range(m2):
maxx=max(maxx,grid3[row][col])
tempAns+=maxx
ans=max(ans,tempAns)
allans.append(ans)
multiLineArrayPrint(allans)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
dv=defaultValFactory;da=dimensionArr
if len(da)==1:return [dv() for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(r):
print('? {}'.format(r))
sys.stdout.flush()
return readIntArr()
def answerInteractive(adj,n):
print('!')
for u in range(1,n+1):
for v in adj[u]:
if v>u:
print('{} {}'.format(u,v))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
# MOD=998244353
from math import gcd,floor,ceil
# from math import floor,ceil # for Python2
for _abc in range(1):
main()
``` | output | 1 | 22,930 | 12 | 45,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,931 | 12 | 45,862 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
from random import randint
for _ in range(int(input())):
n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for _ in range(100):
for j in range(m):
x = randint(0, n - 1)
if x:
B = []
for i in range(n):
B.append(A[i][j])
B = B[x:] + B[:x]
for i in range(n):
A[i][j] = B[i]
c = 0
for i in range(n):
c += max(A[i])
ans = max(ans, c)
print(ans)
``` | output | 1 | 22,931 | 12 | 45,863 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,932 | 12 | 45,864 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
def main():
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
l = []; board = []
for i in range(n):
li = list(map(int, input().split()))
board.append(li)
for j in range(m):
l.append((li[j], j))
l.sort(key = lambda x : x[0], reverse = True)
idxs = set()
z = 0
while len(idxs) < min(n, m):
curr = l[z]
idxs.add(curr[1])
z += 1
idxs = list(idxs)
total = 0
for i in range(n ** n):
rotations = []; num = i
for j in range(n - 1, -1, -1):
nj = n ** j
q = num // nj
num -= q * nj
rotations.append(q)
subtotal = 0
#print(board, idxs, rotations)
for k in range(n):
#print([board[(k + rotations[col]) % n][idxs[col]] for col in range(n)])
subtotal += max(board[(k + rotations[col]) % n][idxs[col]] for col in range(min(n, m)))
total = max(total, subtotal)
print(total)
main()
``` | output | 1 | 22,932 | 12 | 45,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,933 | 12 | 45,866 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
for _ in range(N()):
n, m = RL()
arr = []
for _ in range(n): arr.append(RLL())
larr = [list(i) for i in zip(*arr)]
larr.sort(key = lambda a: max(a), reverse=1)
larr = larr[:n]
res = 0
def dfs(lst, pos=0):
nonlocal res
if pos==min(n, len(larr)):
res = max(res, sum(lst))
return
for i in range(n):
nex = lst.copy()
for j in range(n):
nex[(i+j)%n] = max(nex[(i+j)%n], larr[pos][j])
dfs(nex, pos+1)
dfs([0]*n)
print(res)
if __name__ == "__main__":
main()
``` | output | 1 | 22,933 | 12 | 45,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,934 | 12 | 45,868 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
import random
for _ in range(int(input())):
N, M = map(int, input().split())
X = [[int(a) for a in input().split()] for _ in range(N)]
Y = [[X[i][j] for i in range(N)] for j in range(M)]
ma = 0
for t in range(99):
for i in range(M):
a = random.randrange(N)
Y[i] = [Y[i][j-a] for j in range(N)]
ma = max(ma, sum([max([Y[i][j] for i in range(M)]) for j in range(N)]))
print(ma)
``` | output | 1 | 22,934 | 12 | 45,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9. | instruction | 0 | 22,935 | 12 | 45,870 |
Tags: bitmasks, brute force, dp, greedy, sortings
Correct Solution:
```
t = int(input())
def maxsa(A):
ans = 0
#print("asdasd")
for i in range(n):
cur_maxx = 0
for j in range(4):
cur_maxx = max(cur_maxx, A[j][i])
ans+= cur_maxx
return ans
def fu(A):
answer = 0
for j in range(n):
A[0] = A[0][1:] + A[0][:1]
for i in range(n):
A[1] = A[1][1:] + A[1][:1]
for k in range(n):
A[2] = A[2][1:] + A[2][:1]
for l in range(n):
A[3] = A[3][1:] + A[3][:1]
#print(A)
cur_ans = maxsa(A)
answer = max(answer, cur_ans)
return answer
for j in range(t):
n,m = map(int,input().split())
A = [0] * n
inds = [-1,-1,-1,-1]
maxs =[ 0,0,0,0]
for j in range(n):
A[j] = list(map(int,input().split()))
for j in range(m):
cur_maxs = 0
for i in range(n):
cur_maxs = max(cur_maxs, A[i][j])
maxs.append(cur_maxs)
inds.append(j)
ind = 4
#print(cur_maxs)
while ind !=0 and maxs[ind] > maxs[ind-1]:
inds[ind], inds[ind-1] = inds[ind-1] , inds[ind]
maxs[ind], maxs[ind - 1] = maxs[ind - 1], maxs[ind]
ind-=1
maxs.pop()
inds.pop()
#print(maxs)
#print(inds)
S = [0] * 4
for j in range(4):
if inds[j] != -1:
#print(A)
#print(inds[j])
S[j] = [s[inds[j]] for s in A]
#print(S[j])
else:
S[j] = [0] * n
#print(S)
print(fu(S))
``` | output | 1 | 22,935 | 12 | 45,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9.
Submitted Solution:
```
rnd_mod = 1234567890133
rnd_x = 987654321098
def rnd():
global rnd_x
rnd_x = rnd_x**2 % rnd_mod
return (rnd_x>>5) % (1<<20)
def randrange(a):
return rnd() % a
T = int(input())
for _ in range(T):
N, M = map(int, input().split())
X = []
for __ in range(N):
X.append([int(a) for a in input().split()])
Y = [[X[i][j] for i in range(N)] for j in range(M)]
ma = 0
for t in range(577):
for i in range(M):
a = randrange(N)
Y[i] = [Y[i][j-a] for j in range(N)]
ma = max(ma, sum([max([Y[i][j] for i in range(M)]) for j in range(N)]))
print(ma)
``` | instruction | 0 | 22,936 | 12 | 45,872 |
Yes | output | 1 | 22,936 | 12 | 45,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
inf = -float("inf")
for _ in range(int(input())):
n,m = map(int,input().split())
a = [list(map(int,input().split())) for _ in range(n)]
y = 1<<n
dp = [[0]+[inf]*(y-1) for _ in range(m+1)]
for i in range(1,m+1):
for shift in range(n):
for mask1 in range(y):
for mask2 in range(y):
new = mask1^mask2
if new&mask1:
continue
mm,add = 1,0
for x in range(n):
if mm&new:
tt = x+shift
if tt >= n:
tt -= n
add += a[tt][i-1]
mm <<= 1
dp[i][mask2] = max(dp[i][mask2],dp[i-1][mask1]+add)
print(dp[m][y-1])
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | instruction | 0 | 22,937 | 12 | 45,874 |
Yes | output | 1 | 22,937 | 12 | 45,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
for _ in range(N()):
n, m = RL()
arr = []
for _ in range(n): arr.append(RLL())
larr = [list(i) for i in zip(*arr)]
larr.sort(key = lambda a: max(a), reverse=1)
larr = larr[:n]
res = 0
def dfs(lst, pos=0):
nonlocal res
if pos==min(n, len(larr)):
res = max(res, sum(lst))
return
for i in range(n):
now = larr[pos][i:n]+larr[pos][0:i]
nex = [max(now[j], lst[j]) for j in range(n)]
dfs(nex, pos+1)
dfs([0]*n)
print(res)
if __name__ == "__main__":
main()
``` | instruction | 0 | 22,938 | 12 | 45,876 |
Yes | output | 1 | 22,938 | 12 | 45,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9.
Submitted Solution:
```
for _ in range(int(input())):
N, M = map(int, input().split())
X = [[int(a) for a in input().split()] for _ in range(N)]
Y = [[X[i][j] for i in range(N)] for j in range(M)]
ma = 0
dp = [[0] * (1<<N) for _ in range(M+1)]
for j in range(M):
for mask in range(1<<N):
maskpre = mask
while maskpre >= 0:
maskpre &= mask
ma = 0
for k in range(N):
s = 0
for i in range(N):
if (maskpre >> i) & 1 == 0 and (mask >> i) & 1:
s += X[i-k][j]
ma = max(ma, s)
dp[j+1][mask] = max(dp[j+1][mask], dp[j][maskpre] + ma)
maskpre -= 1
print(dp[-1][-1])
``` | instruction | 0 | 22,939 | 12 | 45,878 |
Yes | output | 1 | 22,939 | 12 | 45,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular n × m matrix a. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for i-th row it is equal r_i. What is the maximal possible value of r_1+r_2+…+r_n?
Input
The first line contains an integer t (1 ≤ t ≤ 40), the number of test cases in the input.
The first line of each test case contains integers n and m (1 ≤ n ≤ 4, 1 ≤ m ≤ 100) — the number of rows and the number of columns in the given matrix a.
Each of the following n lines contains m integers, the elements of a (1 ≤ a_{i, j} ≤ 10^5).
Output
Print t integers: answers for all test cases in the order they are given in the input.
Example
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
Note
In the first test case, you can shift the third column down by one, this way there will be r_1 = 5 and r_2 = 7.
In the second case you can don't rotate anything at all, this way there will be r_1 = r_2 = 10 and r_3 = 9.
Submitted Solution:
```
import sys
input=sys.stdin.readline
def solve(n,m,A):
T=list(map(list,zip(*A)))
Ans=T[0][:]
ret=sum(Ans)
for i in range(1,m):
Tmp0=Ans[:]
for j in range(n):
Tmp1=T[i][j:]+T[i][:j]
Tmp2=[0]*n
for k in range(n):
Tmp2[k]=max(Tmp0[k],Tmp1[k])
s=sum(Tmp2)
if s>ret:
ret=s
Ans=Tmp2[:]
return ret
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
A=[list(map(int,input().split())) for _ in range(n)]
print(solve(n,m,A))
``` | instruction | 0 | 22,940 | 12 | 45,880 |
No | output | 1 | 22,940 | 12 | 45,881 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.