message stringlengths 2 30.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 237 109k | cluster float64 10 10 | __index_level_0__ int64 474 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
import math
for _ in range(int(input())):
n,w=map(int,input().split())
l=list(map(int,input().split()))
f=0
s=0
t=[]
for i in range(n):
if l[i]>=math.ceil(w/2) and l[i]<=w:
t=[i+1]
s=l[i]
break
else:
s+=l[i]
if s>w:
s-=l[i]
else:
t.append(i+1)
if s>=math.ceil(w/2):
break
if s>=math.ceil(w/2):
print(len(t))
print(*t)
else:
print(-1)
``` | instruction | 0 | 60,889 | 10 | 121,778 |
Yes | output | 1 | 60,889 | 10 | 121,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
from math import ceil
for T in range(int(input())):
n,s=map(int,input().split())
w=list(map(int,input().split()))
w=[[w[i],i+1] for i in range(n)]
w.sort(key=lambda x:x[0])
s1=0
a=[]
flag=False
for i in range(n-1,-1,-1):
val=w[i][0]
s1+=val
a.append(w[i][1])
if(s1>s):
a.pop()
s1-=val
if(s1 >= ceil(s/2) and s1 <= s):
flag=True
break
if(flag==False):
print(-1)
else:
print(len(a))
print(*a)
``` | instruction | 0 | 60,890 | 10 | 121,780 |
Yes | output | 1 | 60,890 | 10 | 121,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
# Author Name: Ajay Meena
# Codeforce : https://codeforces.com/profile/majay1638
# import inbuilt standard input output
import sys
import math
from sys import stdin, stdout
# //Most Frequently Used Number Theory Concepts
def sieve(N):
primeNumbers = [True]*(N+1)
primeNumbers[0] = False
primeNumbers[1] = False
i = 2
while i*i <= N:
j = i
if primeNumbers[j]:
while j*i <= N:
primeNumbers[j*i] = False
j += 1
i += 1
return primeNumbers
def getPrime(N):
primes = sieve(N)
result = []
for i in range(len(primes)):
if primes[i]:
result.append(i)
return result
def factor(N):
factors = []
i = 1
while i*i <= N:
if N % i == 0:
factors.append(i)
if i != N//i:
factors.append(N//i)
i += 1
return sorted(factors)
def gcd(a, b):
if a < b:
return gcd(b, a)
if b == 0:
return a
return gcd(b, a % b)
def extendedGcd(a, b):
if a < b:
return extendedGcd(b, a)
if b == 0:
return [a, 1, 0]
res = extendedGcd(b, a % b)
x = res[2]
y = res[1]-(math.floor(a/b)*res[2])
res[1] = x
res[2] = y
return res
def iterativeModularFunc(a, b, c):
res = 1
while b > 0:
if b & 1:
res = (res*a) % c
a = (a*a) % c
b = b//2
return res
# // Taking Input Format Helper Function
def get_ints_in_variables():
return map(int, sys.stdin.readline().strip().split())
def get_int(): return int(input())
def get_ints_in_list(): return list(
map(int, sys.stdin.readline().strip().split()))
def get_list_of_list(n): return [list(
map(int, sys.stdin.readline().strip().split())) for _ in range(n)]
def get_string(): return sys.stdin.readline().strip()
def Solution(arr, n, w):
res = []
s = 0
idx = 0
flag = 0
for j in range(n):
if arr[j] <= w:
if s+arr[j] > w and 2*arr[j] < w:
continue
else:
if 2*arr[j] >= w:
idx = j+1
flag = 1
break
res.append(j+1)
s += arr[j]
if flag:
print(1)
print(idx)
else:
if len(res) > 0 and s <= w and 2*s >= w:
print(len(res))
for v in res:
print(v, end=" ")
print()
else:
print(-1)
def main():
# //Write Your Code Here
for _ in range(get_int()):
n, w = get_ints_in_variables()
arr = get_ints_in_list()
Solution(arr, n, w)
# calling main Function
if __name__ == "__main__":
main()
``` | instruction | 0 | 60,891 | 10 | 121,782 |
Yes | output | 1 | 60,891 | 10 | 121,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
import math
for i in range(int(input())):
n,w=map(int,input().split())
d=list(map(int,input().split()))
index=[]
bagw=0
for i in range(n):
if d[i] <=w and d[i]>=math.ceil(w/2) :
index=[i+1]
bagw=d[i]
break
elif bagw+d[i]<=w:
index.append(i+1)
bagw+=d[i]
if bagw >= math.ceil(w/2):
print(len(index))
print(*index)
else:
print("-1")
``` | instruction | 0 | 60,892 | 10 | 121,784 |
Yes | output | 1 | 60,892 | 10 | 121,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
''' ===============================
-- @uthor : Kaleab Asfaw
-- Handle : kaleabasfaw2010
-- Bio : High-School Student
==============================='''
# Fast IO
import sys
import os
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")
# Others
# from math import floor, ceil, gcd
# from decimal import Decimal as d
mod = 10**9+7
def lcm(x, y): return (x * y) / (gcd(x, y))
def fact(x, mod=mod):
ans = 1
for i in range(1, x+1): ans = (ans * i) % mod
return ans
def arr2D(n, m, default=0): return [[default for j in range(m)] for i in range(n)]
def arr3D(n, m, r, default=0): return [[[default for k in range(r)] for j in range(m)] for i in range(n)]
def sortDictV(x): return {k: v for k, v in sorted(x.items(), key = lambda item : item[1])}
class DSU:
def __init__(self, length): self.length = length; self.parent = [-1] * self.length # O(log(n))
def getParent(self, node, start): # O(log(n))
if node >= self.length: return False
if self.parent[node] < 0:
if start != node: self.parent[start] = node
return node
return self.getParent(self.parent[node], start)
def union(self, node1, node2): # O(log(n))
parent1 = self.getParent(node1, node1); parent2 = self.getParent(node2, node2)
if parent1 == parent2: return False
elif self.parent[parent1] <= self.parent[parent2]: self.parent[parent1] += self.parent[parent2]; self.parent[parent2] = parent1
else: self.parent[parent2] += self.parent[parent1]; self.parent[parent1] = parent2
return True
def getCount(self, node): return -self.parent[self.getParent(node, node)] # O(log(n))
def solve(n, w, lst):
for i in range(n):
if lst[i] >= (w+2-1)//2 and lst[i] <= w:
print(1)
print(i+1)
return
lst = sorted(lst)
summ = 0
for i in range(n):
summ += lst[i]
if summ >= (w+2-1)//2 and summ <= w:
print(i+1)
for j in range(1, i+1):
print(j, end=" ")
return
print(-1)
for _ in range(int(input())): # Multicase
n, w = list(map(int, input().split()))
lst = list(map(int, input().split()))
solve(n, w, lst)
``` | instruction | 0 | 60,893 | 10 | 121,786 |
No | output | 1 | 60,893 | 10 | 121,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
'''
|\_/|
| @ @ Woof!
| <> _
| _/\------____ ((| |))
| `--' |
____|_ ___| |___.'
/_/_____/____/_______|
I am here to gaurd this code, woof!
'''
from sys import stdin, stdout
from math import ceil, floor, sqrt, log, log2, log10
from collections import Counter
input = stdin.readline
def solve():
pass
t = int(input())
# t = 1
for _ in range(t):
# n = int(input())
n, w = map(int, input().split())
# s = input()
# t = input()
arr = list(map(int, input().split()))
items = []
for i in range(n):
items.append([arr[i], i + 1])
items.sort()
total = 0
output = []
for i in range(n-1, -1, -1):
if total + items[i][0] <= w:
total += items[i][0]
output.append(items[i][1])
output.sort()
if len(output) > 0 and total >= w//2:
print(len(output))
print(*output)
else:
print(-1)
``` | instruction | 0 | 60,894 | 10 | 121,788 |
No | output | 1 | 60,894 | 10 | 121,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict
import math
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")
# n, k = map(int, input().split(" "))
# l = list(map(int, input().split(" ")))
for _ in range(int(input())):
n, k = map(int, input().split(" "))
l = list(map(int, input().split(" ")))
l.sort()
r = k//2 + k%2
z = []
for i in range(n):
if r<=l[i]<=k:
z.append(l[i])
break
if z:
print(1)
print(*z)
else:
z = []
s = 0
for i in range(n):
if s >= r:
break
z.append(l[i])
s+=l[i]
if r <= s <=k:
print(len(z))
print(*z)
else:
print(-1)
``` | instruction | 0 | 60,895 | 10 | 121,790 |
No | output | 1 | 60,895 | 10 | 121,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half.
Submitted Solution:
```
for _ in range(int(input())):
n, w = map(int, input().split())
weights = list(map(int, input().split()))
kek = int(round(w / 2))
ans = []
bag = 0
for i in range(n):
if weights[i] <= w:
ans.append(i + 1)
bag += weights[i]
if bag >= kek:
break
else:
continue
if ans != []:
print(len(ans))
print(" ".join(str(i) for i in ans))
else:
print(-1)
``` | instruction | 0 | 60,896 | 10 | 121,792 |
No | output | 1 | 60,896 | 10 | 121,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,897 | 10 | 121,794 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
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")
##########################################################
T = int(input())
for _ in range(T):
n, m = map(int, input().split())
k = list(map(int, input().split()))
c = list(map(int, input().split()))
j = 0
s = 0
k.sort(reverse=True)
for i in range(n):
if j <= k[i] - 1:
s += c[j]
j += 1
else:
s += c[k[i] - 1]
print(s)
``` | output | 1 | 60,897 | 10 | 121,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,898 | 10 | 121,796 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
from collections import Counter
t = int(input())
while t > 0:
t -= 1
n, m = (int(i) for i in input().split())
p = [int(i) for i in input().split()]
k = [int(i) for i in input().split()]
c = ans = 0
for i in sorted(p, reverse=True):
if c < i:
ans += k[c]
c += 1
else:
ans += k[i-1]
print(ans)
``` | output | 1 | 60,898 | 10 | 121,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,899 | 10 | 121,798 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int, input().split())
k=sorted(list(map(int ,input().split())),reverse=True)
c=list(map(int, input().split()))
x=0
y=0
i=0
while(i<n and y+1<k[i] and y<m):
x+=c[y]
y+=1
i+=1
while(i<n):
x+=c[k[i]-1]
i+=1
print(x)
``` | output | 1 | 60,899 | 10 | 121,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,900 | 10 | 121,800 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
from sys import stdin
stdin.readline
def mp(): return list(map(int, stdin.readline().strip().split()))
def it():return int(stdin.readline().strip())
for _ in range(it()):
n,m=mp()
c=sorted(mp(),reverse=True)
k=mp()
i,t=0,0
ans=0
while i<n and t<m:
if k[c[i]-1]<=k[t]:
ans+=k[c[i]-1]
i+=1
else:
ans+=k[t]
t+=1
i+=1
if t>=m:
j=i
while j<=n:
ans+=k[c[j]-1]
j+=1
break
print(ans)
``` | output | 1 | 60,900 | 10 | 121,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,901 | 10 | 121,802 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
from math import inf
def main():
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
ks = [int(x) for x in input().split()]
cs = [0] + [int(x) for x in input().split()]
ks.sort(reverse=True)
min_sum = 0
cur_present = 1
for i, k in enumerate(ks):
den = cs[k]
pod = cs[cur_present] if cur_present <= m else inf
if den > pod:
cur_present += 1
min_sum += pod
else:
min_sum += den
print(min_sum)
if __name__ == '__main__':
main()
``` | output | 1 | 60,901 | 10 | 121,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,902 | 10 | 121,804 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
t=int(input())
for _ in range(t):
n,m=list(map(int,input().split(" ")))
friends=list(map(int,input().split(" ")))
presents=list(map(int,input().split(" ")))
preoccupied={}
for x in presents:
preoccupied[x]=False
friends.sort(reverse=True)
res=0
i=0
for x in friends:
if x>i+1:
res+=presents[i]
i+=1
else:
res+=presents[x-1]
print(res)
``` | output | 1 | 60,902 | 10 | 121,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,903 | 10 | 121,806 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
guest=list(map(int,input().split()));guest.sort(reverse=True)
gift=list(map(int,input().split()))
ans=0;j=0
for i in guest:
if j<i:ans+=gift[j];j+=1
else:ans+=gift[i-1]
print(ans)
``` | output | 1 | 60,903 | 10 | 121,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | instruction | 0 | 60,904 | 10 | 121,808 |
Tags: binary search, dp, greedy, sortings, two pointers
Correct Solution:
```
for _ in range(int(input())):
n,x=map(int,input().split())
k=list(map(int,input().split()))
l=list(map(int,input().split()))
cost=[]
for e in k:
cost.append(l[e-1])
cost.sort(reverse=True)
i=0
for e,f in enumerate(cost):
if(f>l[i]):
cost[e]=l[i]
i+=1
print(sum(cost))
``` | output | 1 | 60,904 | 10 | 121,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
for _ in range(int(input())):
n, m = map(int, input().split())
ks = [int(x)-1 for x in input().split()]
cs = [int(x) for x in input().split()]
ks.sort(reverse=True)
t = 0
for i, k in enumerate(ks):
t += cs[min(i, k)]
print(t)
``` | instruction | 0 | 60,905 | 10 | 121,810 |
Yes | output | 1 | 60,905 | 10 | 121,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
for _ in range(int(input())):
n,m = map(int, input().split())
s = sorted(list(map(int, input().split())), reverse=True)
p = list(map(int, input().split()))
ans = 0
for i in range(n):
if i+1 < s[i]:
ans += p[i]
else:
ans += p[s[i]-1]
print(ans)
``` | instruction | 0 | 60,906 | 10 | 121,812 |
Yes | output | 1 | 60,906 | 10 | 121,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
f=list(map(int,input().split()))
g=list(map(int,input().split()))
x=[1]*m
f=sorted(f,reverse=True)
s=0
t=sorted(g)
j=0
for i in f:
if g[i-1] <=t[j]:
s+=g[i-1]
else:
s+=t[j]
j+=1
print(s)
``` | instruction | 0 | 60,907 | 10 | 121,814 |
Yes | output | 1 | 60,907 | 10 | 121,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
import heapq
import sys
def input():
return sys.stdin.readline().rstrip()
def sol():
#start coding here...
#print("Hello CodeForces!")
n, m = map(int, input().split())
idxa = list(map(int, input().split()))
cost = list(map(int, input().split()))
idxa.sort()
lpos = 0
ans = 0
for i in range(n - 1, -1, -1):
idx = idxa[i] - 1
if lpos <= idx:
ans += cost[lpos]
lpos += 1
else:
ans += cost[idx]
print(ans)
return
def main():
testcase = int(input())
for i in range(testcase):
sol()
if __name__ == "__main__":
main()
``` | instruction | 0 | 60,908 | 10 | 121,816 |
Yes | output | 1 | 60,908 | 10 | 121,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
import sys
from collections import defaultdict
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
k = sorted([int(x) for x in input().split()], reverse = True)
c = [int(x) for x in input().split()]
visited = [0] * m
count = k.count(1)
s = c[0] * count
n -= count
for i in range(n):
if i > k[i]:
break
s += c[i]
else:
print(s)
exit()
while i < n:
s += c[k[i] - 1]
i += 1
print(s)
``` | instruction | 0 | 60,909 | 10 | 121,818 |
No | output | 1 | 60,909 | 10 | 121,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
for _ in range (int(input("t = "))):
n,m = map(int,input().split())
k_num = list(map(int,input().split()))
k_num = sorted(k_num , reverse=True)
price_gift = list(map(int,input().split()))
res = 0 ; j = 0
for i in k_num :
if j < i : res+= price_gift[j];j+=1
else : res+= price_gift[i-1]
print(res)
``` | instruction | 0 | 60,910 | 10 | 121,820 |
No | output | 1 | 60,910 | 10 | 121,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
def minAmount(n, m, C, K):
C.sort()
dp = dict()
def Amount(k, c):
if k >= n:
return 0
if c >= m:
return 0
x = (k, c)
if x in dp:
return dp[x]
dp[x] = min(
C[K[k]-1] + Amount(k+1, c),
C[c] + Amount(k+1, c+1)
)
return dp[x]
return Amount(0, 0)
if __name__ == "__main__":
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
K = list(map(int, input().split()))
C = list(map(int, input().split()))
print(minAmount(n, m, C, K))
``` | instruction | 0 | 60,911 | 10 | 121,822 |
No | output | 1 | 60,911 | 10 | 121,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend.
Submitted Solution:
```
# https://codeforces.com/contest/1470/problem/A
tests = int(input())
for i in range(tests):
n, m = input().split(' ')
friends=list(input().split(' '))
gifts = list(input().split(' '))
#gifts_taken=[]
#for i in range(int(m)):
# gifts_taken.append(0)
friends.sort(reverse=True)
sum=0
current=0
for each in friends:
min=9999999999999999999999
if(current<int(m)):
min = int(gifts[current])
current += 1
if(min>int(gifts[int(each)-1])):
min=int(gifts[int(each)-1])
sum+=min
print(sum)
''' for j in range(int(each)):
if(gifts_taken[j]==0 and ok==False):
ok=True
gifts_taken[j]=1
sum+=int(gifts[j])
'''
``` | instruction | 0 | 60,912 | 10 | 121,824 |
No | output | 1 | 60,912 | 10 | 121,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,969 | 10 | 121,938 |
Tags: implementation
Correct Solution:
```
I=lambda:map(int,input().split())
n,m=I()
a=list(I())
def g(f):
global a,n
t=a[:]
i,s=0,0
while i<n:
i+=1
j=t.index(f(t))
s+=t[j]
if t[j]>1:
t[j]-=1
else:
t.pop(j)
return s
print(g(max),g(min))
``` | output | 1 | 60,969 | 10 | 121,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,970 | 10 | 121,940 |
Tags: implementation
Correct Solution:
```
#from collections import Counter
import heapq
#n = int(input())
n,m = map(int,input().split())
l = list(map(int,input().split()))
#k = int(input())
t = [-i for i in l]
min1 = 0
max1 = 0
heapq.heapify(l)
heapq.heapify(t)
for i in range(n):
x = heapq.heappop(l)
y = heapq.heappop(t)
min1 += x
max1 += abs(y)
if x != 1:
heapq.heappush(l,x-1)
if y != -1:
heapq.heappush(t,y+1)
print(max1,min1)
``` | output | 1 | 60,970 | 10 | 121,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,971 | 10 | 121,942 |
Tags: implementation
Correct Solution:
```
import copy
a, b = map(int, input().split(" "))
a1 = a
inp = list(map(int, input().split()))
lst = copy.deepcopy(inp)
i = ans = cnt = 0
ans1 = 0
lst.sort()
inp.sort()
# min datvla
while i < len(lst):
while lst[i] != 0:
if cnt == a:
break
ans += lst[i]
lst[i] -= 1
cnt += 1
i += 1
# max datvla
while a != 0:
inp.sort(reverse=True)
ans1 += inp[0]
inp[0] -= 1
a -= 1
print(ans1, ans)
``` | output | 1 | 60,971 | 10 | 121,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,972 | 10 | 121,944 |
Tags: implementation
Correct Solution:
```
import copy
a, b = map(int, input().split(" "))
a1 = a
inp = list(map(int, input().split()))
lst = copy.deepcopy(inp)
i = ans = cnt = 0
ans1 = cnt1 = 0
j = j1 = 0
lst.sort()
inp.sort()
# min datvla
while i < len(lst):
while lst[i] != 0:
if cnt == a:
break
ans += lst[i]
lst[i] -= 1
cnt += 1
i += 1
# max datvla
inp.sort(reverse=True)
lst1 = list()
while a != 0:
if inp[len(inp)-1] == 0:
break
while inp[j] != 0:
lst1.append(inp[j])
inp[j] -= 1
j += 1
a -= 1
lst1.sort(reverse=True)
while a1 != 0:
ans1 += lst1[j1]
j1 += 1
a1 -= 1
print(ans1, ans)
``` | output | 1 | 60,972 | 10 | 121,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,973 | 10 | 121,946 |
Tags: implementation
Correct Solution:
```
import sys
def maxT(n, tickets):
total = 0
for i in range(len(tickets) - 1, -1, -1):
if n == 0:
break
ele = tickets[i]
sold = min(n, ele)
n -= sold
total += i * sold
return total
def binFormula(k):
"""calculates from 1 to k"""
return ((k) * (k + 1)) / 2
def minT(n, tickets):
total = 0
for i in range(0, len(tickets), 1):
if n == 0:
break
ele = tickets[i]
total += binFormula(ele)
n -= ele
if n < 0:
total -= binFormula(abs(n))
break
return int(total)
def readinput():
n, m = map(int, sys.stdin.readline().rstrip().split(" "))
planeTickets = list(map(int, sys.stdin.readline().rstrip().split(" ")))
planeTickets.sort()
counter = [0 for _ in range(planeTickets[-1] + 1)]
c = 0
for i in range(0, len(planeTickets)):
nextEle = planeTickets[i]
while nextEle >= c:
counter[c] += len(planeTickets) - i
c += 1
return [(maxT(n, counter), minT(n, planeTickets))]
for x, y in readinput():
print(x, y)
``` | output | 1 | 60,973 | 10 | 121,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,974 | 10 | 121,948 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
arr=[int(i) for i in input().split()]
brr=[int(i) for i in arr]
n1=n
n2=n
a,b=0,0
while(n1!=0):
a=a+max(arr)
arr[arr.index(max(arr))]= max(arr)-1
n1=n1-1
while(n2!=0):
b=b+min(brr)
brr[brr.index(min(brr))]= min(brr)-1
if brr[brr.index(min(brr))]==0:
brr.remove(brr[brr.index(min(brr))])
n2=n2-1
print(a,b)
``` | output | 1 | 60,974 | 10 | 121,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,975 | 10 | 121,950 |
Tags: implementation
Correct Solution:
```
nm = input().split()
n, m = int(nm[0]), int(nm[1])
f = 0
l = m-1
mx = 0
mn = 0
arr = list(map(int, input().split()))
arr.sort()
gg = [i for i in arr]
nn = n
while n:
mx += arr[l]
arr[l] -= 1
arr.sort()
n -= 1
while nn:
mn += gg[f]
gg[f] -= 1
gg.sort()
if 0 in gg:gg.remove(0)
nn -= 1
print(mx, mn)
``` | output | 1 | 60,975 | 10 | 121,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | instruction | 0 | 60,976 | 10 | 121,952 |
Tags: implementation
Correct Solution:
```
import heapq
n,m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = a[:]
# find min
heapq.heapify(b)
c = 0
p_min = 0
while b and c<n:
v = heapq.heappop(b)
p_min+=v
if v>1:
heapq.heappush(b,v-1)
c+=1
# find max
heapq._heapify_max(a)
c = 0
p_max = 0
while a and c<n:
v = heapq.heappop(a)
p_max+=v
if v>1:
heapq.heappush(a,v-1)
heapq._heapify_max(a)
c+=1
print(p_max,p_min)
``` | output | 1 | 60,976 | 10 | 121,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
passengers, planes = tuple(map(int, input().split()))
passengers1 = passengers
empty_seats = list(map(int, input().split()))
empty_seats1 = empty_seats[:]
empty_seats.sort()
total_revenue = 0
j=0
for i in range(passengers):
if empty_seats[j]<1:
j+=1
total_revenue+=empty_seats[j]
empty_seats[j]-=1
max_profit = 0
for i in range(passengers1):
empty_seats1.sort()
max_profit += empty_seats1[-1]
empty_seats1[-1]-=1
print (max_profit, total_revenue)
``` | instruction | 0 | 60,977 | 10 | 121,954 |
Yes | output | 1 | 60,977 | 10 | 121,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
def maxprice(arr,n):
s=0
while n!=0:
arr.sort(reverse=True)
s=s+arr[0]
arr[0]=arr[0]-1
n-=1
return(s)
def minprice(arr,n):
s=0
x=0
while n!=0:
arr.sort()
if arr[x]==0:
x+=1
continue
else:
s=s+arr[x]
arr[x]=arr[x]-1
n-=1
return(s)
n,m=map(int,input().split())
arr=[int(x) for x in input().split()]
arr1=arr.copy() #copy of initial array
#print(arr1)
maxans=maxprice(arr,n)
#print(maxans)
minans=minprice(arr1,n)
#print(minans)
print(maxans,minans)
``` | instruction | 0 | 60,978 | 10 | 121,956 |
Yes | output | 1 | 60,978 | 10 | 121,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
n,m = map(int,input().split())
t = list(map(int,input().split()))
f=[]
for k in t:
f.append(k)
p=0
for i in range(n):
p+=max(t)
t[t.index(max(t))]-=1
u=0
q=0
f.sort()
for j in range(m):
if u<n:
if u+f[j]<=n:
q+=f[j]*(f[j]+1)//2
u+=f[j]
elif u+f[j]>n:
for k in range(n-u):
q+=f[j]
f[j]-=1
break
else:
break
print(p,q)
``` | instruction | 0 | 60,979 | 10 | 121,958 |
Yes | output | 1 | 60,979 | 10 | 121,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
n,m = map(int,input().split())
l = list(map(int,input().split()))
min =0
max =0
temp = sorted(l)
for i in range(n):
if len(l) >0:
l.sort(reverse = True)
max += l[0]
l[0] -= 1
if 0 in l:
l.remove(0)
min += temp[0]
temp[0] -= 1
if 0 in temp:
temp.remove(0)
temp.sort()
print(max,min)
``` | instruction | 0 | 60,980 | 10 | 121,960 |
Yes | output | 1 | 60,980 | 10 | 121,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
n,m=map(int,input().split())
list1=list(map(int,input().split()))
list1.sort()
countmin=n
minn=0
countmax=n
maxx=0
i=0
while countmin and i<len(list1):
# 1 1 2
if countmin>=list1[i]:
minn+=(list1[i]*(list1[i]+1))//2
countmin-=list1[i]
else:
total = (list1[i] * (list1[i] + 1)) // 2
first_nums = list1[i] - countmin
first_sums = (first_nums * (first_nums + 1)) // 2
minn += total - first_sums
countmin -= list1[i]
i+=1
list1.sort(reverse=True)
i=0
while countmax:
if i==len(list1):
i=0
maxx+=list1[i]
list1[i]-=1
countmax-=1
i+=1
print(maxx,minn)
``` | instruction | 0 | 60,981 | 10 | 121,962 |
No | output | 1 | 60,981 | 10 | 121,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
n,m = map(int,input().split())
l = list(map(int,input().split()))
high = 0
low = 0
# l = l.sort(reverse = True)
for i in range(n):
high = high + max(l)
a = l.index(max(l))
l[a] = max(l) - 1
for i in range(n):
low = low + min(l)
a = l.index(min(l))
l[a] = min(l) + 1
print(high,low)
``` | instruction | 0 | 60,982 | 10 | 121,964 |
No | output | 1 | 60,982 | 10 | 121,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
n,m=map(int,input().split())
seats=list(map(int,input().split()))
def min_sum(seats):
seats=sorted(seats)
min_sum=0
temp=0
for i in range(len(seats)):
while seats[i]>0:
if temp<n:
min_sum+=seats[i]
temp+=1
seats[i]=seats[i]-1
else:
break
if temp>=n:
break
return min_sum
def max_sum(seats):
seats=sorted(seats,reverse=True)
max_sum=0
temp=0
i=0
while True:
if i>0 and i<m-1:
while seats[i]>=seats[i+1] and seats[i]>=seats[i-1] and temp<n:
max_sum+=seats[i]
temp+=1
seats[i]=seats[i]-1
if temp>=n:
break
if seats[i-1]>seats[i]:
i=i-1
elif seats[i+1]>seats[i]:
i+=1
elif i==0:
while seats[i]>=seats[i+1] and temp<n:
max_sum+=seats[i]
temp+=1
seats[i]=seats[i]-1
if temp>=n:
break
else:
i+=1
else:
while seats[i]>=seats[i-1] and temp<n:
max_sum+=seats[i]
temp+=1
seats[i]=seats[i]-1
if temp>=n:
break
else:
i=i-1
return max_sum
if len(seats)==1:
temp=0
for i in range(m):
temp+=seats[0]
seats[0]=seats[0]-1
print(temp)
else:
print("{} {}".format(max_sum(seats),min_sum(seats)))
``` | instruction | 0 | 60,983 | 10 | 121,966 |
No | output | 1 | 60,983 | 10 | 121,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane.
Submitted Solution:
```
import copy
a, b = map(int, input().split(" "))
inp = list(map(int, input().split()))
lst = copy.deepcopy(inp)
i = ans = cnt = 0
ans1 = cnt1 = 0
j = -1
lst.sort()
inp.sort()
# min datvla
while i < len(lst):
while lst[i] != 0:
if cnt == a:
break
ans += lst[i]
lst[i] -= 1
cnt += 1
i += 1
# max datvla
inp.sort(reverse=True)
while True:
if cnt1 == a:
break
idx = (j + 1) % len(inp)
ans1 += inp[idx]
inp[idx] -= 1
cnt1 += 1
j += 1
print(ans1, ans)
``` | instruction | 0 | 60,984 | 10 | 121,968 |
No | output | 1 | 60,984 | 10 | 121,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
"""
Author : co_devil Chirag Garg
Institute : JIIT
"""
from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
# from bisect import bisect_left,bisect_right
# from decimal import *,threading
from fractions import Fraction
"""from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
else:
from builtins import str as __str__
str = lambda x=b'': x if type(x) is bytes else __str__(x).encode()
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._buffer = BytesIO()
self._fd = file.fileno()
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):
return self._buffer.read() if self._buffer.tell() else os.read(self._fd, os.fstat(self._fd).st_size)
def readline(self):
while self.newlines == 0:
b, ptr = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE)), self._buffer.tell()
self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
self.newlines += b.count(b'\n') + (not b)
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)
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b'\r\n')
def print(*args, **kwargs):
sep, file = kwargs.pop('sep', b' '), kwargs.pop('file', sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop('end', b'\n'))
if kwargs.pop('flush', False):
file.flush()
"""
def ii(): return int(input())
def si(): return str(input())
def mi(): return map(int, input().split())
def li(): return list(mi())
def fii(): return int(stdin.readline())
def fsi(): return str(stdin.readline())
def fmi(): return map(int, stdin.readline().split())
def fli(): return list(fmi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
'z': 25}
mod = 1000000007
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def getKey(item): return item[0]
def sort2(l): return sorted(l, key=getKey)
def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo(x): return (x and (not (x & (x - 1))))
def decimalToBinary(n): return bin(n).replace("0b", "")
def ntl(n): return [int(i) for i in str(n)]
def powerMod(x, y, p):
res = 1
x %= p
while y > 0:
if y & 1:
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
# For getting input from input.txt file
# sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000
def dfs(v, c):
if visited[v]:
if col[v] != c:
print('-1')
exit()
return
col[v] = c
visited[v] = 1
for i in graph[v]:
dfs(i, c ^ 1)
def bfs(d, v):
q = []
q.append(v)
visited[v] = 1
while len(q) != 0:
x = q[0]
q.pop(0)
for i in d[x]:
if visited[i] != 1:
visited[i] = 1
q.append(i)
print(x)
def make_graph(e):
d = {}
for i in range(e):
x, y = mi()
if x not in d.keys():
d[x] = [y]
else:
d[x].append(y)
if y not in d.keys():
d[y] = [x]
else:
d[y].append(x)
return d
def gr2(n):
d = {}
for i in range(n):
x, y = mi()
if x not in d.keys():
d[x] = [y]
else:
d[x].append(y)
return d
def connected_components(graph):
seen = set()
def dfs(v):
vs = set([v])
component = []
while vs:
v = vs.pop()
seen.add(v)
vs |= set(graph[v]) - seen
component.append(v)
return component
ans = []
for v in graph:
if v not in seen:
d = dfs(v)
ans.append(d)
return ans
def primeFactors(n):
s = set()
while n % 2 == 0:
s.add(2)
n = n // 2
for i in range(3, int(sqrt(n)) + 1, 2):
while n % i == 0:
s.add(i)
n = n // i
if n > 2:
s.add(n)
return s
def find_all(a_str, sub):
start = 0
while True:
start = a_str.find(sub, start)
if start == -1: return
yield start
start += len(sub)
def Prime(x):
if x<2:
return False
for i in range(2,int(sqrt(x))+1):
if x%i==0:
return False
return True
n=ii()
if Prime(n):
print(1)
elif n%2==0:
print(2)
elif Prime(n-2):
print(2)
else:
print(3)
``` | instruction | 0 | 61,157 | 10 | 122,314 |
Yes | output | 1 | 61,157 | 10 | 122,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
import math
n = int(input())
def esPrimo(n):
for a in range(2,int(math.sqrt(n))):
if n%a == 0:
return False
return True
if esPrimo(n):
print(1)
elif n%2==0 or esPrimo(n-2):
print(2)
else:
print(3)
``` | instruction | 0 | 61,159 | 10 | 122,318 |
No | output | 1 | 61,159 | 10 | 122,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
n=int(input())
if n%2==0:
print(2)
else:
print(3)
``` | instruction | 0 | 61,160 | 10 | 122,320 |
No | output | 1 | 61,160 | 10 | 122,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
a=[0,0,1,1,2,1,2,1,2,2,2,1,2,1,2,2,2,1,2,2,2,2,2,1,2,2,2,3,2,1,2,1,2]
n=int(input())
for i in range(n,1,-1):
if i!=n-1:
for j in range(2,int(i**0.5) + 2):
if i%j==0:
break
elif j==int(i**0.5) + 1:
exit(print(1+a[n-i]))
#exit(print(n-i))
exit(print(a[n]))
``` | instruction | 0 | 61,161 | 10 | 122,322 |
No | output | 1 | 61,161 | 10 | 122,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
import math as mt
import sys,string
input=sys.stdin.readline
#print=sys.stdout.write
import random
from heapq import heappush,heapify,heappop
L=lambda : list(map(int,input().split()))
Ls=lambda : list(input().split())
M=lambda : map(int,input().split())
I=lambda :int(input())
def isPrime(n):
if(n<=2):
return False
for i in range(2,int(mt.sqrt(n))+1):
if(n%i==0):
return False
return True
n=I()
if(isPrime(n)):
print(1)
else:
if(n%2==0):
print(2)
elif(isPrime(n-2)):
print(2)
else:
print(3)
``` | instruction | 0 | 61,162 | 10 | 122,324 |
No | output | 1 | 61,162 | 10 | 122,325 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,283 | 10 | 122,566 |
"Correct Solution:
```
n,m=[int(j) for j in input().split()]
a=[-int(j) for j in input().split()]
import heapq
heapq.heapify(a)
for i in range(m):
p=heapq.heappop(a)
p=(-p)//2
heapq.heappush(a,-p)
print(-sum(a))
``` | output | 1 | 61,283 | 10 | 122,567 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,284 | 10 | 122,568 |
"Correct Solution:
```
from heapq import heapify,heappop,heappush
N,M=map(int,input().split())
A=list(map(lambda x:-int(x),input().split()))
heapify(A)
for i in range(M):
heappush(A,-(-heappop(A)//2))
print(-sum(A))
``` | output | 1 | 61,284 | 10 | 122,569 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,285 | 10 | 122,570 |
"Correct Solution:
```
import heapq
n, m = map(int, input().split())
a = [-int(i) for i in input().split()]
heapq.heapify(a)
for _ in range(m):
heapq.heappushpop(a, -(-a[0] // 2))
print(-sum(a))
``` | output | 1 | 61,285 | 10 | 122,571 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,286 | 10 | 122,572 |
"Correct Solution:
```
from heapq import*;N,M,*A=map(lambda x:-int(x),open(0).read().split());heapify(A)
for _ in range(-M):heappush(A,0-heappop(A)//-2)
print(-sum(A))
``` | output | 1 | 61,286 | 10 | 122,573 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,287 | 10 | 122,574 |
"Correct Solution:
```
from heapq import*;n,m,*a=eval(',-'.join(open(0).read().split()));x=0;a.sort();exec('x=heappushpop(a,-~x//2);'*-~-m);print(-x-sum(a))
``` | output | 1 | 61,287 | 10 | 122,575 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.