message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3. | instruction | 0 | 54,151 | 12 | 108,302 |
Tags: greedy, math
Correct Solution:
```
for i in range(int(input())):
n,m=map(int,input().split())
a=list(map(int,input().split()))
s=0
if(n==1):
print(sum(a))
elif(n==2):
b=a[0::2]
print(sum(b))
else:
p=(n-1)//2
i=m*p
for k in range(m):
s+=a[i]
i+=n-p
print(s)
``` | output | 1 | 54,151 | 12 | 108,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3. | instruction | 0 | 54,152 | 12 | 108,304 |
Tags: greedy, math
Correct Solution:
```
import sys, itertools
tc = int(sys.stdin.readline())
for _ in range(tc):
n, k = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
temp = n // 2 if n % 2 == 0 else n // 2 + 1
interval = n - (temp - 1)
res = 0
for j in range((temp - 1) * k, len(arr), interval):
res += arr[j]
print(res)
``` | output | 1 | 54,152 | 12 | 108,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3. | instruction | 0 | 54,153 | 12 | 108,306 |
Tags: greedy, math
Correct Solution:
```
import sys, math, itertools, collections, copy
input = sys.stdin.readline
def solve():
N, K = map(int, input().split())
arr = [int(x) for x in input().split()]
size = len(arr)
pos = 0
if N & 1:
pos = N // 2
else:
pos = N // 2 - 1
after = N - pos - 1
begin = size - after - 1
step = -(after + 1)
cnt = 0
ans = 0
for i in range(begin, -1, step):
ans += arr[i]
cnt += 1
if cnt >= K:
break
print(ans)
for _ in range(int(input())):
solve()
``` | output | 1 | 54,153 | 12 | 108,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3. | instruction | 0 | 54,154 | 12 | 108,308 |
Tags: greedy, math
Correct Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
l = list(map(int,input().split()))
if n%2==0:
a = (n//2)-1
b = (n-a)*(-1)
s = 0
ab = b
for x in range(k):
#print(l[b])
s+=l[b]
b+=ab
#print(b)
print(s)
else:
a = (n//2)
b = (n-a)*(-1)
s = 0
ab = b
for x in range(k):
s+=l[b]
b+=ab
#print(b)
print(s)
``` | output | 1 | 54,154 | 12 | 108,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3. | instruction | 0 | 54,155 | 12 | 108,310 |
Tags: greedy, math
Correct Solution:
```
for _ in range(int(input())):
n, k = map(int, input().split())
a = [int(i) for i in input().split()]
x = n // 2 + 1
ans = 0
t = 0
for i in range(n * k - x, -1, -x):
if t == k:
break
t += 1
ans += a[i]
print(ans)
``` | output | 1 | 54,155 | 12 | 108,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
import math
def median_idx(n):
return n//2+n%2-1
def run():
t = int(input())
for _ in range(t):
n, k = list(map(int, input().split()))
nk = list(map(int, input().split()))
sz = len(nk)
# print(n,k,nk)
# print(median_idx(n))
midx = median_idx(n)
if midx==0:
total_median = 0
for i in range(k):
# print(nk[i*n:i*n+n])
total_median += nk[i*n]
print(total_median)
continue
total_median = 0
sleft = midx
sright = n - midx
for i in range(1,k+1):
# print(nk[sz-i*sright])
total_median += nk[sz-i*sright]
# print(midx, sleft, sright, nk[i*(sleft)-1:i*(sleft)-1+sleft]+
# nk[sz-i*sright:sz-i*sright+sright])
print(total_median)
if __name__ == '__main__':
run()
``` | instruction | 0 | 54,156 | 12 | 108,312 |
Yes | output | 1 | 54,156 | 12 | 108,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
for _ in range(int(input())):
n,k=map(int, input().split())
l=list(map(int, input().split()))
ans=0
m=(n//2 + 1)
for i in range(m,m*k+1,m):
ans+=l[-i]
print(ans)
``` | instruction | 0 | 54,157 | 12 | 108,314 |
Yes | output | 1 | 54,157 | 12 | 108,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
t = int(input())
while t > 0:
n, k = map(int, input().split())
arr = list(map(int, input().split()))
x = n*k - 1
sum = 0
while k > 0:
x -= int(n/2)
sum += arr[x]
x -= 1
k -= 1
print(sum)
t -= 1
``` | instruction | 0 | 54,158 | 12 | 108,316 |
Yes | output | 1 | 54,158 | 12 | 108,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
for tt in range(int(input())):
n,k=map(int,input().split())
arr=list(map(int,input().split()))
if n==2:
cnt=0
for i in range(0,n*k,2):
cnt+=arr[i]
print(cnt)
continue
mid=n//2+1
end=n*k-mid
cnt=0
for i in range(k):
## print(arr[end])
cnt+=arr[end]
end-=mid
print(cnt)
``` | instruction | 0 | 54,159 | 12 | 108,318 |
Yes | output | 1 | 54,159 | 12 | 108,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n,k = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
l.sort()
ans = 0
c = 0
jump = (n+1)//2-1
temp = 0
if (n%2==1):
temp = 1
for i in range(n*k-n+jump,-1,-n+temp):
ans+=l[i]
c+=1
if (c==k):
break
print(ans)
``` | instruction | 0 | 54,160 | 12 | 108,320 |
No | output | 1 | 54,160 | 12 | 108,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
def ceil(a, b):
return (a + b - 1) // b
for _ in range(int(input())):
n, k = map(int, input().split())
lis = list(map(int, input().split()))
lis = lis[::-1]
mid = ceil(n, 2)
ans = 0
for i in range(mid, n * k, mid+1):
ans += lis[i]
print(ans)
``` | instruction | 0 | 54,161 | 12 | 108,322 |
No | output | 1 | 54,161 | 12 | 108,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n,k = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
l.sort()
ans = 0
c = 0
jump = (n+1)//2-1
for i in range(n*k-n+jump,-1,-n+1):
ans+=l[i]
c+=1
if (c==k):
break
print(ans)
``` | instruction | 0 | 54,162 | 12 | 108,324 |
No | output | 1 | 54,162 | 12 | 108,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median of an array of integers of length n is the number standing on the ⌈ {n/2} ⌉ (rounding up) position in the non-decreasing ordering of its elements. Positions are numbered starting with 1. For example, a median of the array [2, 6, 4, 1, 3, 5] is equal to 3. There exist some other definitions of the median, but in this problem, we will use the described one.
Given two integers n and k and non-decreasing array of nk integers. Divide all numbers into k arrays of size n, such that each number belongs to exactly one array.
You want the sum of medians of all k arrays to be the maximum possible. Find this maximum possible sum.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, k (1 ≤ n, k ≤ 1000).
The second line of the description of each test case contains nk integers a_1, a_2, …, a_{nk} (0 ≤ a_i ≤ 10^9) — given array. It is guaranteed that the array is non-decreasing: a_1 ≤ a_2 ≤ … ≤ a_{nk}.
It is guaranteed that the sum of nk for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print a single integer — the maximum possible sum of medians of all k arrays.
Example
Input
6
2 4
0 24 34 58 62 64 69 78
2 2
27 61 81 91
4 3
2 4 16 18 21 27 36 53 82 91 92 95
3 4
3 11 12 22 33 35 38 67 69 71 94 99
2 1
11 41
3 3
1 1 1 1 1 1 1 1 1
Output
165
108
145
234
11
3
Note
The examples of possible divisions into arrays for all test cases of the first test:
Test case 1: [0, 24], [34, 58], [62, 64], [69, 78]. The medians are 0, 34, 62, 69. Their sum is 165.
Test case 2: [27, 61], [81, 91]. The medians are 27, 81. Their sum is 108.
Test case 3: [2, 91, 92, 95], [4, 36, 53, 82], [16, 18, 21, 27]. The medians are 91, 36, 18. Their sum is 145.
Test case 4: [3, 33, 35], [11, 94, 99], [12, 38, 67], [22, 69, 71]. The medians are 33, 94, 38, 69. Their sum is 234.
Test case 5: [11, 41]. The median is 11. The sum of the only median is 11.
Test case 6: [1, 1, 1], [1, 1, 1], [1, 1, 1]. The medians are 1, 1, 1. Their sum is 3.
Submitted Solution:
```
import math
t = int(input())
for i in range(t):
n, k = map(int, input().split())
arr = list(map(int, input().split()))
b = arr[::-1]
sum2 = 0
if n == 1:
print(sum(b[0:k]))
elif n == 2:
for i in range(0, len(arr), 2):
sum2 += arr[i]
print(sum2)
else:
# k groups of size n
sum1 = 0
i = 0
while k != 0:
a = [arr[i]] + b[0:n - 1][::-1]
#print(a)
mid = math.ceil(len(a) / 2)
#print(a[mid - 1])
sum1 += a[mid - 1]
b = b[n - 1:len(b)]
i += 1
k -= 1
print(sum1)
``` | instruction | 0 | 54,163 | 12 | 108,326 |
No | output | 1 | 54,163 | 12 | 108,327 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,164 | 12 | 108,328 |
Tags: constructive algorithms, greedy
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
def main():
a,b,c=map(int,input().split())
va=sorted(map(int,input().split()))
vb=sorted(map(int,input().split()))
vc=sorted(map(int,input().split()))
sa=sum(va);sb=sum(vb);sc=sum(vc)
s=sa+sb+sc
#case va
a1=0;a2=0
b1=0;b2=0
c1=0;c2=0
if len(vb)>1:
a1+=abs(vb[0]-(sc-vc[0])-sa)+abs(vc[0]-(sb-vb[0]))
c1+=abs(vb[0]-(sa-va[0])-sc)+abs(va[0]-(sb-vb[0]))
else:
a1+=s-2*vb[0]
c1+=s-2*vb[0]
if len(vc)>1:
a2+=abs(vc[0]-(sb-vb[0])-sa)+abs(vb[0]-(sc-vc[0]))
b1+=abs(vc[0]-(sa-va[0]-sb))+abs(va[0]-(sc-vc[0]))
else:
a2+=s-2*vc[0]
b1+=s-2*vc[0]
if len(va)>1:
b2+=abs(va[0]-(sc-vc[0])-sb)+abs(vc[0]-(sa-va[0]))
c2+=abs(va[0]-(sb-vb[0])-sc)+abs(vb[0]-(sa-va[0]))
else:
b2+=s-2*va[0]
c2+=s-2*va[0]
print(max(a1,a2,b1,b2,c1,c2))
main()
``` | output | 1 | 54,164 | 12 | 108,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,165 | 12 | 108,330 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n1, n2, n3 = map(int, input().split())
a = [[int(i) for i in input().split()] for j in range(3)]
ans = sum(sum(i) for i in a)
cur = min(sum(i) for i in a)
for i in range(2):
for j in range(i+1, 3):
cur = min(cur, min(a[i])+min(a[j]))
print(ans-2*cur)
``` | output | 1 | 54,165 | 12 | 108,331 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,166 | 12 | 108,332 |
Tags: constructive algorithms, greedy
Correct Solution:
```
from sys import stdin
input=stdin.readline
def three(a1,a2,a3):
temp=[a1,a2,a3]
ans=0
temp=sorted(temp,key=lambda s:s[0])
c1=sum(temp[1][1:])+sum(temp[2])-temp[0][0]
c2=temp[1][0]-sum(temp[0][1:])
ans=max(ans,abs(c1)+abs(c2))
s=sum(a1)+sum(a2)+sum(a3)
for i in range(0,3):
ans=max(ans,s-2*sum(temp[i]))
return ans
a=input()
l1=sorted(list(map(int,input().strip().split())))
l2=sorted(list(map(int,input().strip().split())))
l3=sorted(list(map(int,input().strip().split())))
print(three(l1,l2,l3))
``` | output | 1 | 54,166 | 12 | 108,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,167 | 12 | 108,334 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n1,n2,n3=[int(i) for i in input().split(' ')]
a=[int(i) for i in input().split(' ')]
b=[int(i) for i in input().split(' ')]
c=[int(i) for i in input().split(' ')]
sa=sum(a)
sb=sum(b)
sc=sum(c)
ma=min(a)
mb=min(b)
mc=min(c)
a1=sa+max(sb+sc-2*mb-2*mc,abs(sb-sc))
b1=sb+max(sa+sc-2*ma-2*mc,abs(sa-sc))
c1=sc+max(sb+sa-2*mb-2*ma,abs(sb-sa))
print(max(a1,max(b1,c1)))
``` | output | 1 | 54,167 | 12 | 108,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,168 | 12 | 108,336 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
input=sys.stdin.readline
def inp():
return int(input())
def st():
return input().rstrip('\n')
def lis():
return list(map(int,input().split()))
def ma():
return map(int,input().split())
t=1
while(t):
t-=1
n,m,k=ma()
a=lis()
b=lis()
c=lis()
x=sum(a)+sum(b)+sum(c)
s,s1,s2=min(a),min(b),min(c)
print(x - 2*min(s+s1,s+s2,s1+s2,sum(a),sum(b),sum(c)))
``` | output | 1 | 54,168 | 12 | 108,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,169 | 12 | 108,338 |
Tags: constructive algorithms, greedy
Correct Solution:
```
na,nb,nc=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
c=[int(x) for x in input().split()]
suma=sum(a)
sumb=sum(b)
sumc=sum(c)
mina=min(a)
minb=min(b)
minc=min(c)
ans=-float('inf')
#Case 1: make sum(a) smallest. move all b and (c except 1) to a, then move all a to c
abc=[suma,sumb,sumc]
abc.sort()
aa,bb,cc=abc
ans=max(ans,-aa+bb+cc)
#Case 2: move all (a except 1 and c except 1) to b. move all (b except 1) to a.
#then move all to c
abc=[mina,minb,minc]
abc.sort()
aa,bb,cc=abc
ans=max(ans,suma+sumb+sumc-aa*2-bb*2)
print(ans)
``` | output | 1 | 54,169 | 12 | 108,339 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,170 | 12 | 108,340 |
Tags: constructive algorithms, greedy
Correct Solution:
```
aa,bb,cc = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
ss = [sum(a),sum(b),sum(c)]
ss.sort()
s = ss[1]+ss[2]-ss[0]
dd = [min(a),min(b),min(c)]
dd.sort()
print(max(s,sum(ss)-2*(dd[0]+dd[1])))
``` | output | 1 | 54,170 | 12 | 108,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20. | instruction | 0 | 54,171 | 12 | 108,342 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n1,n2,n3 = map(int,input().split())
l1,l2,l3 = list(map(int,input().split())),list(map(int,input().split())),list(map(int,input().split()))
s = sum(l1)+sum(l2)+sum(l3)
m1,m2,m3 = max(l1),max(l2),max(l3)
q1,q2,q3 = min(l1),min(l2),min(l3)
print(max(s-2*min(sum(l1),sum(l2),sum(l3)),s-q1-q2-q3+2*max(q1,q2,q3)-sum([q1,q2,q3])))
``` | output | 1 | 54,171 | 12 | 108,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
'''
Aaditya Upadhyay
.......... .uoeeWWeeeu.
.:::::::::::::::::: "?$$$$$$$$$$c
```....:::::::::::::::::`"$$$$$$$$$$e.
..:::::::::::```.::::::::::::::.`"??$$$$$$b
::::::::::::::` .:::::::` ::::::`` ::::::: `"?$
.:::::::::::::``.::::::::` .:::`` ::::::::::::::::.
:::::`.::::::: ::::::::` ::` . `:::::::::::::::::::.
::::` ::::::::`` :::::::` .ue@$$ `:::::::::::::::::::::
::` .:::::::``z, :::::`.e$$$$$$$$$$.`::::::::::::::::::::
:` :::::::``,e$$r`::: $$$$??' `?b_ `::::::::::::::::::
' :::::::` ,?' `?b,_` R$' .,,. `"iu ````:::::::::::::
::::::` < .,. `?e. $eeee$$F???ee,3c ..````::::::::.
:::::: :: R$$$$$$$e4$ $$$$$$$"e 3$$$$$.:. ``:::::::::``:.
`:::::: :::::`F. "?FJd$$$$$$'L~. . .$$$$L`!!~eec``::::::::.
`::::::.```::.""$' $$$$$$$$$.$bKUeiz$$$$$$'!~ $$ `::::::::
``````` ..: 3`beeed $$$$$$$$$e$Ned$$$$$$$$'u@z$ ::: `:::::::
::: ^NeeeP $$$$$$$$$$$$$$$$$$$$$$$$"NNeP ::::::`::::::
.:::: $$$$F $$$$$$$?$$$$$$$$$$$$$$$$ $F .:::::::::::::
: .::: ?$$$$$ $$$$$$$?c$$$$$$$$$$$$$F,e :::::::::::::``
::::,`$$$$$$,)?$X$$$$$$$$$$$?$$$$$ $$ :::::::::::``
::':: "$$$$$$$$$$$$$$$P?" .d$$$$F,$$ :::::::::`
` :::."$$EC""???"?Cz=d"ud$$$$$$".$$$ :::::`:`
`:::.`?$$bu. 4$$$??Le$$$$$P".$$$$ ::```
`::: `?$$Pbeee$$$$$$$P".d$$$$$
`:` `?$eJCCCNd$$$$F.z$$$$$$$ u.
u`?$$$$$$$$$F z$$$$$$$Pu`$$c.
c^bu?R$$$F"ue$$$$$$$$$$ $ $$$$$bc.
e$$ $$e,`"",e$$$$$$$$$$$$$$$ $$$$$$$$$"bc.
.e$$$$ '$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$'d$$$$be.
..e$$$$$EJ,?$$$$$$$$$$$$$$$$$$$$$$$'$$$$$$$"d$$$$$$$$$be
'''
from sys import stdin, stdout
from collections import *
from math import gcd, floor, ceil
def st(): return list(stdin.readline().strip())
def li(): return list(map(int, stdin.readline().split()))
def mp(): return map(int, stdin.readline().split())
def inp(): return int(stdin.readline())
def pr(n): return stdout.write(str(n)+"\n")
mod = 1000000007
INF = float('inf')
def solve():
a, b, c = mp()
x = li()
y = li()
z = li()
aa, bb, cc = min(x), min(y), min(z)
sa, sb, sc = sum(x), sum(y), sum(z)
xx = min(aa+bb, bb+cc, cc+aa)
zz = sum([sa, sb, sc])-2*xx
xx = min(sa, sb, sc)
val = max(zz, sa+sb+sc-2*xx)
pr(val)
for _ in range(1):
solve()
``` | instruction | 0 | 54,172 | 12 | 108,344 |
Yes | output | 1 | 54,172 | 12 | 108,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
n1,n2,n3=map(int,input().split())
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
l3=list(map(int,input().split()))
l1.sort()
l2.sort()
l3.sort()
l=[l1[0],l2[0],l3[0]]
l.sort()
s1=sum(l1)
s2=sum(l2)
s3=sum(l3)
s=s1+s2+s3
ans=max(s-2*(l[0]+l[1]),s-2*s1,s-2*s2,s-2*s3)
print(ans)
``` | instruction | 0 | 54,173 | 12 | 108,346 |
Yes | output | 1 | 54,173 | 12 | 108,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
try:
a,b,c = map(int,input().split())
arr1 = list(map(int,input().split()))
arr2 = list(map(int,input().split()))
arr3 = list(map(int,input().split()))
mn = [min(arr1),min(arr2),min(arr3)]
sm = [sum(arr1), sum(arr2), sum(arr3)]
# print(mn,sm)
tot = sum(sm)
x=min(min((mn[0]+mn[1]),(mn[1]+mn[2])),(mn[0]+mn[2]))
ans=tot-2*x
x=min(sm[0],min(sm[1],sm[2]))
ans=max(ans,tot-2*x)
print(ans)
except:
pass
``` | instruction | 0 | 54,174 | 12 | 108,348 |
Yes | output | 1 | 54,174 | 12 | 108,349 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
#import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=300006, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.height=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val==0:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
elif val>=1:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
def do(self,temp):
if not temp:
return 0
ter=temp
temp.height=self.do(ter.left)+self.do(ter.right)
if temp.height==0:
temp.height+=1
return temp.height
def query(self, xor):
self.temp = self.root
cur=0
i=31
while(i>-1):
val = xor & (1 << i)
if not self.temp:
return cur
if val>=1:
self.opp = self.temp.right
if self.temp.left:
self.temp = self.temp.left
else:
return cur
else:
self.opp=self.temp.left
if self.temp.right:
self.temp = self.temp.right
else:
return cur
if self.temp.height==pow(2,i):
cur+=1<<(i)
self.temp=self.opp
i-=1
return cur
#-------------------------bin trie-------------------------------------------
for ik in range(1):
n,m,k=map(int,input().split())
l=list(map(int,input().split()))
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
l.sort()
l1.sort()
l2.sort()
w=min(l[0]+l1[0],l[0]+l2[0],l1[0]+l2[0],sum(l),sum(l1),sum(l2))
sw=min(l[0],l1[0],l2[0])
s=sum(l)
s1=sum(l1)
s2=sum(l2)
ans=s+s1+s2-2*w
e=0
print(ans+e)
``` | instruction | 0 | 54,175 | 12 | 108,350 |
Yes | output | 1 | 54,175 | 12 | 108,351 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
import sys
input=sys.stdin.readline
def fun(i,j,k):
s1=su[i]-mi[i]
s2=su[j]+su[k]-mi[j]-ma[k]
s2=mi[i]-s2
s1=mi[j]-s1
s1=ma[k]-s1
return abs(s1)+abs(s2)
n1,n2,n3=map(int,input().split())
ar=list(map(int,input().split()))
br=list(map(int,input().split()))
cr=list(map(int,input().split()))
su=[sum(ar),sum(br),sum(cr)]
mi=[min(ar),min(br),min(cr)]
ma=[max(ar),max(br),max(cr)]
ans=0
ans=max(ans,fun(0,1,2))
ans=max(ans,fun(0,2,1))
ans=max(ans,fun(1,2,0))
ans=max(ans,fun(1,0,2))
ans=max(ans,fun(2,1,0))
ans=max(ans,fun(2,0,1))
print(ans)
``` | instruction | 0 | 54,176 | 12 | 108,352 |
No | output | 1 | 54,176 | 12 | 108,353 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
def brate(niz1, niz2, niz3):
niz1.sort()
niz2.sort()
niz3.sort()
suma=sum(niz1)+sum(niz2)+sum(niz3)
if ( niz1[0] <= niz2[0] and niz1[0] <= niz3[0]):
suma-=2*niz1[0]
if ( (sum(niz1)-niz1[0])>niz2[0] or (sum(niz1)-niz1[0])>niz3[0] ):
suma-=2 * min(niz2[0],niz3[0])
else:
suma-= 2 * (sum(niz1)-niz1[0])
elif ( niz2[0] <= niz1[0] and niz2[0] <= niz3[0]):
suma-=2*niz2[0]
if ( (sum(niz2)-niz2[0])>niz1[0] or (sum(niz2)-niz2[0])>niz3[0] ):
suma-= 2 * min(niz1[0],niz3[0])
else:
suma-= 2 * (sum(niz2)-niz2[0])
else:
suma-=2*niz3[0]
if ( (sum(niz3)-niz3[0])>niz2[0] or (sum(niz3)-niz3[0])>niz1[0] ):
suma-= 2 * min(niz1[0],niz2[0])
else:
suma-= 2 * (sum(niz3)-niz3[0])
print(suma)
n=input()
niz1=input().split(" ")
niz2=input().split(" ")
niz3=input().split(" ")
niz1=[int(i) for i in niz1]
niz2=[int(i) for i in niz2]
niz3=[int(i) for i in niz3]
brate(niz1, niz2, niz3)
``` | instruction | 0 | 54,177 | 12 | 108,354 |
No | output | 1 | 54,177 | 12 | 108,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
n1, n2, n3 = map(int, input().split())
my_list = []
for _ in range(3):
my_list.append(list(map(int, input().split())))
l1=[]
for _ in range(3):
l1 += my_list[_]
l1.sort()
minimum = l1[0]
if minimum in my_list[0] and minimum in my_list[1] and minimum in my_list[2]:
min_len = min(n1,n2,n3)
elif minimum not in my_list[0] and minimum in my_list[1] and minimum in my_list[2]:
min_len = min(n2, n3)
elif minimum in my_list[0] and minimum not in my_list[1] and minimum in my_list[2]:
min_len = min(n1, n3)
elif minimum in my_list[0] and minimum in my_list[1] and minimum not in my_list[2]:
min_len = min(n1, n2)
elif minimum not in my_list[0] and minimum not in my_list[1] and minimum in my_list[2]:
min_len = n3
elif minimum not in my_list[0] and minimum in my_list[1] and minimum not in my_list[2]:
min_len = n2
else:
min_len = n1
minus = l1[0:min_len]
plus = l1[min_len:]
print(sum(plus) - sum(minus))
``` | instruction | 0 | 54,178 | 12 | 108,356 |
No | output | 1 | 54,178 | 12 | 108,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number a from the first bag and number b from the second bag. Then, you remove b from the second bag and replace a with a-b in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
Input
The first line of the input contains three space-separated integers n_1, n_2 and n_3 (1 ≤ n_1, n_2, n_3 ≤ 3⋅10^5, 1 ≤ n_1+n_2+n_3 ≤ 3⋅10^5) — the number of numbers in the three bags.
The i-th of the next three lines contain n_i space-separated integers a_{{i,1}}, a_{{i,2}}, ..., a_{{i,{{n_i}}}} (1 ≤ a_{{i,j}} ≤ 10^9) — the numbers in the i-th bag.
Output
Print a single integer — the maximum number which you can achieve in the end.
Examples
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
Note
In the first example input, let us perform the following operations:
[1, 2], [6, 3, 4, 5], [5]
[-5, 2], [3, 4, 5], [5] (Applying an operation to (1, 6))
[-10, 2], [3, 4], [5] (Applying an operation to (-5, 5))
[2], [3, 4], [15] (Applying an operation to (5, -10))
[-1], [4], [15] (Applying an operation to (2, 3))
[-5], [], [15] (Applying an operation to (-1, 4))
[], [], [20] (Applying an operation to (15, -5))
You can verify that you cannot achieve a bigger number. Hence, the answer is 20.
Submitted Solution:
```
try:
a,b,c = map(int,input().split())
arr1 = list(map(int,input().split()))
arr2 = list(map(int,input().split()))
arr3 = list(map(int,input().split()))
mn = [min(arr1),min(arr2),min(arr3)]
sm = [sum(arr1), sum(arr2), sum(arr3)]
print(mn,sm)
tot = sum(sm)
x=min(min((mn[0]+mn[1]),(mn[1]+mn[2])),(mn[0]+mn[2]))
ans=tot-2*x
x=min(sm[0],min(sm[1],sm[2]))
ans=max(ans,tot-2*x)
print(ans)
except:
pass
``` | instruction | 0 | 54,179 | 12 | 108,358 |
No | output | 1 | 54,179 | 12 | 108,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,184 | 12 | 108,368 |
Tags: greedy, number theory
Correct Solution:
```
from sys import stdin
f = stdin
#f = open("be.txt")
n = int(f.read())
from functools import reduce
def is_rel_p(a, b):
a, b = min(a,b), max(a,b)
while b%a != 0:
if a == 0:
break
b = b%a
a, b = min(a,b), max(a,b)
return min(a,b)==1
nums_good = [True for i in range(0, n)]
nums_good[1]=True
for i in range(2, n):
if n % i == 0:
for j in range(i, n,i):
nums_good[j] = False
# print(nums_good, n)
numset = set(filter(lambda x: nums_good[x], list(range(1,n))))
# print(numset)
muled = reduce(lambda a,b: a*b%n, numset)
# print(muled)
while(muled%n!=1):
value = muled%n
numset.remove(value)
muled//=value
print(len(numset))
print(" ".join(map(str, sorted(numset))))
``` | output | 1 | 54,184 | 12 | 108,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,185 | 12 | 108,370 |
Tags: greedy, number theory
Correct Solution:
```
n = int(input())
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
length = 0
product = 1
P = []
for i in range(1, n):
if gcd(i, n) == 1:
product = product * i % n
P.append(i)
length += 1
if product == n-1 and n != 2:
P.pop()
length -= 1
print(length)
print(*P)
``` | output | 1 | 54,185 | 12 | 108,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,186 | 12 | 108,372 |
Tags: greedy, number theory
Correct Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: Jalpaiguri Govt Enggineering College
'''
from os import path
from io import BytesIO, IOBase
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,Counter,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('0')
file = 1
def ceil(a,b):
return (a+b-1)//b
def solve():
# for n in range(1,ii()+1):
n = ii()
p = 1
x = []
for i in range(1,n):
if gcd(i,n)==1:
x.append(i)
p *= i
p %= n
if p!=1:
x.remove(p)
print(len(x))
print(*x)
if __name__ =="__main__":
if(file):
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
``` | output | 1 | 54,186 | 12 | 108,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,187 | 12 | 108,374 |
Tags: greedy, number theory
Correct Solution:
```
from math import gcd
n = int(input())
ans = 1
l = [1]
for i in range(2,n):
if gcd(n,i)==1:
l.append(i)
ans = (ans*i)%n
if ans==1:
print(len(l))
print(*l)
else:
print(len(l)-1)
print(*l[:-1])
``` | output | 1 | 54,187 | 12 | 108,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,188 | 12 | 108,376 |
Tags: greedy, number theory
Correct Solution:
```
import os,sys;from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno();self.buffer = BytesIO();self.writable = "x" in file.mode or "r" not in file.mode;self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:break
ptr = self.buffer.tell();self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE));self.newlines = b.count(b"\n") + (not b);ptr = self.buffer.tell();self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:os.write(self._fd, self.buffer.getvalue());self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file);self.flush = self.buffer.flush;self.writable = self.buffer.writable;self.write = lambda s: self.buffer.write(s.encode("ascii"));self.read = lambda: self.buffer.read().decode("ascii");self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
try:sys.stdin,sys.stdout=open('in.txt','r'),open('out.txt','w')
except:pass
ii1=lambda:int(sys.stdin.readline().strip()) # for interger
is1=lambda:sys.stdin.readline().strip() # for str
iia=lambda:list(map(int,sys.stdin.readline().strip().split())) # for List[int]
isa=lambda:sys.stdin.readline().strip().split() # for List[str]
mod=int(1e9 + 7);from collections import *;from math import *
# abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# sys.setrecursionlimit(500000)
###################### Start Here ######################
# from functools import lru_cache
# from collections import defaultdict as dd
def main():
n = ii1()
ans = []
for i in range(1,n):
if gcd(i,n)==1:
ans.append(i)
flag = True
pro = 1
for i in ans:
pro*=i
pro%=n
if pro == 1:
print(len(ans))
print(*ans)
else:
ans.pop()
print(len(ans))
print(*ans)
if __name__ == '__main__':
main()
``` | output | 1 | 54,188 | 12 | 108,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,189 | 12 | 108,378 |
Tags: greedy, number theory
Correct Solution:
```
import math
n=int(input())
res=[]
p=1
for i in range(1,n):
if math.gcd(n,i)==1:
p=p*i%n
res.append(i)
if p!=1:
res.remove(p)
print(len(res))
print(*res)
``` | output | 1 | 54,189 | 12 | 108,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,190 | 12 | 108,380 |
Tags: greedy, number theory
Correct Solution:
```
import sys
from math import factorial, ceil
def gcd(a, b):
return b if a == 0 else gcd(b%a, a)
def solve():
n = int(input())
l = [i for i in range(1, n) if gcd(i, n) == 1]
x = 1
for i in l:
x = (x * i) % n
if x != 1:
l.remove(x)
print(len(l))
print(*l)
solve()
``` | output | 1 | 54,190 | 12 | 108,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3]. | instruction | 0 | 54,191 | 12 | 108,382 |
Tags: greedy, number theory
Correct Solution:
```
from math import gcd
n=int(input())
ans=[]
p=1
for i in range(1,n):
if gcd(i,n)==1:
ans.append(i)
p=(p*i)%n
if p==1:
print(len(ans))
print(*ans)
else:
print(len(ans)-1)
ans.remove(p)
print(*ans)
``` | output | 1 | 54,191 | 12 | 108,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
Submitted Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
from __future__ import print_function # for PyPy2
# from itertools import permutations
# from functools import cmp_to_key # for adding custom comparator
# from fractions import Fraction
# from collections import *
from sys import stdin
# from bisect import *
# from heapq import *
# from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
import math
n=int(input())
a=[]
p=i=1
while i<n:
if math.gcd(i,n)<2:a+=i,;p=p*i%n
i+=1
if p>1:a.remove(p)
print(len(a),*a)
``` | instruction | 0 | 54,192 | 12 | 108,384 |
Yes | output | 1 | 54,192 | 12 | 108,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
Submitted Solution:
```
import math
n=int(input())
l=[1]
for i in range(2,n+1):
if math.gcd(i,n)==1:
l.append(i)
x=len(l)
f=0
prod=1
def chk(l):
prod=1
hi=0
for i in range(len(l)):
prod*=l[i]
prod=prod%n
if prod==1:
hi=i
return l[:hi+1]
l=chk(l)
print(len(l))
print(*l)
``` | instruction | 0 | 54,193 | 12 | 108,386 |
Yes | output | 1 | 54,193 | 12 | 108,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
Submitted Solution:
```
import math
n = int(input())
ar1=[]
prd = 1
for j in range(1,n):
if math.gcd(j, n) == 1 :
ar1.append(j)
prd = prd *j % n
if prd != 1:
ar1.pop(-1)
print(len(ar1))
print(*ar1)
``` | instruction | 0 | 54,195 | 12 | 108,390 |
Yes | output | 1 | 54,195 | 12 | 108,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
Submitted Solution:
```
n=int(input())
ans=1
for i in range(1,n):
ans=ans*i
k=n+1;
j=2
c=0
ma=0
l=[]
an=[]
while k<=ans:
for i in range(1,n):
if(k%i==0):
c=c+1
l.append(i)
if(c>ma):
ma=c
an=l.copy()
c=0
l.clear()
k=j*n+1
j=j+1
print(ma)
s=""
for i in an:
s=s+str(i)+" "
print(s)
``` | instruction | 0 | 54,196 | 12 | 108,392 |
No | output | 1 | 54,196 | 12 | 108,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
Submitted Solution:
```
# SHRi GANESHA author: Kunal Verma #
import os
import sys
from collections import Counter
from io import BytesIO, IOBase
from math import gcd, inf, sqrt, ceil, floor
def lcm(a, b):
return (a * b) // gcd(a, b)
if False:
mod = 10 ** 9 + 7
fac = [1]
for i in range(1, 2 * 10 ** 5 + 1):
fac.append((fac[-1] * i) % mod)
fac_in = [pow(fac[-1], mod - 2, mod)]
for i in range(2 * 10 ** 5, 0, -1):
fac_in.append((fac_in[-1] * i) % mod)
fac_in.reverse()
def comb(a, b):
if a < b:
return 0
return (fac[a] * fac_in[b] * fac_in[a - b]) % mod
#MAXN = 16000000
#spf = [0 for i in range(MAXN)]
def sieve():
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, ceil(sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
def getFactorization(x):
ret = set()
while (x != 1):
ret.add(spf[x])
x = x // spf[x]
return ret
def printDivisors(n):
i = 2
z = [1, n]
while i <= sqrt(n):
if (n % i == 0):
if (n / i == i):
z.append(i)
else:
z.append(i)
z.append(n // i)
i = i + 1
return z
def create(n, x, f):
pq = len(bin(n)[2:])
if f == 0:
tt = min
else:
tt = max
dp = [[inf] * n for _ in range(pq)]
dp[0] = x
for i in range(1, pq):
for j in range(n - (1 << i) + 1):
dp[i][j] = tt(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))])
return dp
def enquiry(l, r, dp, f):
if l > r:
return inf if not f else -inf
if f == 1:
tt = max
else:
tt = min
pq1 = len(bin(r - l + 1)[2:]) - 1
return tt(dp[pq1][l], dp[pq1][r - (1 << pq1) + 1])
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
x = []
for i in range(2, n + 1):
if prime[i]:
x.append(i)
return x
def main():
for _ in range(1):
n=int(input())
if True:
an=[]
if n%2==1:
for j in range(1,n-1):
if gcd(j,n)==1:
an.append(j)
else:
for j in range(1,n):
if gcd(j,n)==1:
an.append(j)
print(len(an))
print(*an)
# 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 | 54,197 | 12 | 108,394 |
No | output | 1 | 54,197 | 12 | 108,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now you get Baby Ehab's first words: "Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n." Please solve the problem.
A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
The first line should contain a single integer, the length of the longest subsequence.
The second line should contain the elements of the subsequence, in increasing order.
If there are multiple solutions, you can print any.
Examples
Input
5
Output
3
1 2 3
Input
8
Output
4
1 3 5 7
Note
In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
Submitted Solution:
```
def factors(n):
i=2
blanck=[1]
while i**2<=n :
if n%i==0:
blanck.append(i)
n//=i
else:
i+=1
if n>1:
blanck.append(n)
n=1
return blanck
def f(n):
lst=[(n*i)+1 for i in range(1,10*n)]
if n==2 or n==4:
print(1)
return [1]
for i in lst:
x=factors(i)
if len(x)==len(set(x)) and max(x)<=n-1:
print(len(x))
return x
print(0)
return []
print(*f(int(input())))
``` | instruction | 0 | 54,199 | 12 | 108,398 |
No | output | 1 | 54,199 | 12 | 108,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,248 | 12 | 108,496 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
a.sort()
c=0
for i in range(1,n+1):
c+=abs(a[i-1]-i)
print(c)
``` | output | 1 | 54,248 | 12 | 108,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,249 | 12 | 108,498 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
a = list( map(int,input().split()) )
a = sorted(a)
ans = 0
for i in range(n):
ans += abs(i+1 - a[i])
print(ans)
``` | output | 1 | 54,249 | 12 | 108,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,250 | 12 | 108,500 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
arr = sorted(list(map(int, input().split())))
ans = 0
for i in range(n):
ans += abs (arr[i] - i - 1)
print (ans)
``` | output | 1 | 54,250 | 12 | 108,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,251 | 12 | 108,502 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
aList = list(map(int, input().split()))
standard = [i for i in range(1, n+1)]
aList.sort()
total = 0
for i in range(n):
total += abs(standard[i] - aList[i])
print(total)
``` | output | 1 | 54,251 | 12 | 108,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,252 | 12 | 108,504 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n=int(input());a = sorted([int(x) for x in input().split()]);print(sum([abs(a[i]-i-1) for i in range(n)]))
``` | output | 1 | 54,252 | 12 | 108,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,253 | 12 | 108,506 |
Tags: greedy, implementation, sortings
Correct Solution:
```
N = int(input())
A = [int(x) for x in input().split()]
A.sort()
B = [int(x) for x in range(1, N + 1)]
s = 0
for i in range(N):
s += abs(A[i] - B[i])
print(int(s))
``` | output | 1 | 54,253 | 12 | 108,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,254 | 12 | 108,508 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n=int(input())
L=list(map(int,input().split(' ')))
count=0
L=sorted(L)
for i in range(n):
count=count+abs(L[i]-i-1)
print(count)
``` | output | 1 | 54,254 | 12 | 108,509 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.