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.
Buber is a Berland technology company that specializes in waste of investor's money. Recently Buber decided to transfer its infrastructure to a cloud. The company decided to rent CPU cores in the cloud for n consecutive days, which are numbered from 1 to n. Buber requires k CPU cores each day.
The cloud provider offers m tariff plans, the i-th tariff plan is characterized by the following parameters:
* l_i and r_i — the i-th tariff plan is available only on days from l_i to r_i, inclusive,
* c_i — the number of cores per day available for rent on the i-th tariff plan,
* p_i — the price of renting one core per day on the i-th tariff plan.
Buber can arbitrarily share its computing core needs between the tariff plans. Every day Buber can rent an arbitrary number of cores (from 0 to c_i) on each of the available plans. The number of rented cores on a tariff plan can vary arbitrarily from day to day.
Find the minimum amount of money that Buber will pay for its work for n days from 1 to n. If on a day the total number of cores for all available tariff plans is strictly less than k, then this day Buber will have to work on fewer cores (and it rents all the available cores), otherwise Buber rents exactly k cores this day.
Input
The first line of the input contains three integers n, k and m (1 ≤ n,k ≤ 10^6, 1 ≤ m ≤ 2⋅10^5) — the number of days to analyze, the desired daily number of cores, the number of tariff plans.
The following m lines contain descriptions of tariff plans, one description per line. Each line contains four integers l_i, r_i, c_i, p_i (1 ≤ l_i ≤ r_i ≤ n, 1 ≤ c_i, p_i ≤ 10^6), where l_i and r_i are starting and finishing days of the i-th tariff plan, c_i — number of cores, p_i — price of a single core for daily rent on the i-th tariff plan.
Output
Print a single integer number — the minimal amount of money that Buber will pay.
Examples
Input
5 7 3
1 4 5 3
1 3 5 2
2 5 10 1
Output
44
Input
7 13 5
2 3 10 7
3 5 10 10
1 2 10 6
4 5 10 9
3 4 10 8
Output
462
Input
4 100 3
3 3 2 5
1 1 3 2
2 4 4 4
Output
64
Submitted Solution:
```
from collections import defaultdict
from operator import itemgetter
def find_index(list_to_check, index):
left, right = 0, len(list_to_check) - 1
while True:
if left == right:
return left
mid = left + ((right - left) // 2)
if list_to_check[mid] <= index <= list_to_check[mid]:
return mid
if list_to_check[mid] > index:
right = mid
else:
left = mid+1
n, k, m = map(int, input().split())
tarif_plans = []
split_dots = set()
for i in range(m):
l, r, c, p = map(int, input().split())
tarif_plans.append((l, r, c, p))
split_dots.add(l)
split_dots.add(r)
tarif_plans.sort(key=itemgetter(3))
split_dots = sorted(split_dots)
date_ranges_tarif_plans = defaultdict(list)
for l, r, c, p in tarif_plans:
lef = find_index(split_dots, l)
rig = find_index(split_dots, r)
for index, point in enumerate(split_dots[lef:rig+1], lef):
date_ranges_tarif_plans[(split_dots[index], point)].append((c, p))
total_price = 0
for (s, e), available_cores in date_ranges_tarif_plans.items():
cores = k
days_diff = e-s+1
for av_core, price in available_cores:
if av_core > cores:
total_price += days_diff * cores * price
break
else:
total_price += days_diff * av_core * price
cores -= av_core
print(total_price)
``` | instruction | 0 | 59,736 | 10 | 119,472 |
No | output | 1 | 59,736 | 10 | 119,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,023 | 10 | 120,046 |
Tags: dp
Correct Solution:
```
n = int(input())
t, c = [], []
for i in range(n):
tt, cc = list(map(int, input().split()))
t.append(tt)
c.append(cc)
def find(i: int, cnt: int) -> int:
if cnt >= n: return 0
if i == n: return int(1e18)
return min(find(i + 1, cnt), c[i] + find(i + 1, cnt + 1 + t[i]))
f = [int(1e18)] * (n + 1)
f[0] = 0
# f(n) - min price for n goods
# for every ITEM(c, t) do:
# f(i) = f(i - t[i] - 1) + c[i]
for i in range(n):
for j in range(len(f))[::-1]:
f[j] = min(f[j], f[max(0, j - t[i] - 1)] + c[i])
print(f[-1])
# min: (i + 1, cnt) || c + (i + 1, cnt + t + 1)
``` | output | 1 | 60,023 | 10 | 120,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,024 | 10 | 120,048 |
Tags: dp
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n = N()
arr = []
sm = 0
for _ in range(n):
t, c = RL()
sm+=c
arr.append((t+1, c))
dp = [INF]*(n+1)
dp[0] = 0
for t, c in arr:
for i in range(n, -1, -1):
dp[i] = min(dp[i], dp[max(i-t, 0)]+c)
print(dp[-1])
if __name__ == "__main__":
main()
``` | output | 1 | 60,024 | 10 | 120,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,025 | 10 | 120,050 |
Tags: dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n = int(input())
arr = [tuple(map(int,input().split())) for _ in range(n)]
# time ; cost
dp = [10**15]*(n+1)
"""dp[i] gives the price to be paid when requied time is i
where req time is the time needed to steal items"""
dp[n] = 0
for i in arr:
for j in range(1,n+1):
x = max(0,j-i[0]-1)
dp[x] = min(dp[x],dp[j]+i[1])
print(dp[0])
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 60,025 | 10 | 120,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,026 | 10 | 120,052 |
Tags: dp
Correct Solution:
```
def read():
return [int(v) for v in input().split()]
def main():
n = read()[0]
t, c = [], []
for i in range(n):
line = read()
t.append(line[0] + 1)
c.append(line[1])
MAX = 10 ** 15
dp = [MAX] * (n + 1)
dp[0] = 0
for i in range(n):
for j in range(n, -1, -1):
dp[j] = min(dp[j], dp[max(0, j - t[i])] + c[i])
print(dp[n])
if __name__ == '__main__':
main()
``` | output | 1 | 60,026 | 10 | 120,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,027 | 10 | 120,054 |
Tags: dp
Correct Solution:
```
n=int(input())
ar=[float('inf')]*(n+1)
ar[0]=0
for i in range(n):
t,c=map(int,input().split())
for j in range(n-1,-1,-1):
w=min(j+t+1,n)
ar[w]=min(ar[w],ar[j]+c)
print(ar[n])
``` | output | 1 | 60,027 | 10 | 120,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,028 | 10 | 120,056 |
Tags: dp
Correct Solution:
```
inf = float("inf")
n=int(input())
time, val =[0], [0]
ans=[inf for i in range(n+1)]
ans[0]=0
for i in range(n):
timeInp,valInp= [int(x) for x in input().split()]
timeInp+=1#timeInp+=2
time.append(timeInp)
val.append(valInp)
for i in range(1,n+1):
for j in range(n,0,-1):
ans[j]=min(ans[j],ans[max(0,j-time[i])]+val[i])#(manter, pagarval[i] e liberar espaco)
print(ans[n])
``` | output | 1 | 60,028 | 10 | 120,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111 | instruction | 0 | 60,029 | 10 | 120,058 |
Tags: dp
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def knapsack(limit, values, weights):
n = len(weights)
dp = [[0]*(n+1) for i in range(limit+1)]
for i in range(1, limit+1):
for j in range(1, n+1):
if i < weights[j-1]:
dp[i][j] = dp[i][j-1]
else:
dp[i][j] = max(dp[i-weights[j-1]][j-1] + values[j-1], dp[i][j-1])
return dp[limit][n]
from math import inf
for _ in range(int(input()) if not True else 1):
n = int(input())
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
#a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#s = input()
time = [0]*n
vals = [0]*n
for i in range(n):
x, y = map(int, input().split())
time[i] = x + 1
vals[i] = y
dp = [inf]*(n+1)
dp[0] = 0
for i in range(1,n+1):
for j in range(n, 0, -1):
if j >= time[i-1]:
dp[j] = min(dp[j], dp[j-time[i-1]]+vals[i-1])
else:
dp[j] = min(dp[j],vals[i-1])
print(dp[n])
``` | output | 1 | 60,029 | 10 | 120,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111
Submitted Solution:
```
inf = float("inf")
n=int(input())
time, val =[0], [0]
ans=[inf for i in range(n+1)]
ans[0]=0
for i in range(n):
timeInp,valInp= [int(x) for x in input().split()]
timeInp+=1#timeInp+=2
time.append(timeInp)
val.append(valInp)
for i in range(1,n+1):
for j in range(n,0,-1):
ans[j]=min(ans[j],max(0,ans[j-time[i]])+val[i])#(manter, pagarval[i] e liberar espaco)
print(ans[n])
``` | instruction | 0 | 60,030 | 10 | 120,060 |
No | output | 1 | 60,030 | 10 | 120,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111
Submitted Solution:
```
def coun(item):
return item[1]
c=[]
for i in range(int(input())):
a,b=map(int,input().split())
c.append([a,b])
c.sort(key=coun)
flag=False
l=[]
for i in range(len(c)):
if c[i][0]!=0:
flag=True
break
else:
l.append([0,c[i][1]])
if not flag:
i+=1
start=i
ans=0
for j in range(len(c)):
ans+=c[j][1]
while(start<len(c)):
for j in range(c[start][0]):
if len(c)!=start+1:
ans-=c[len(c)-1][1]
c.pop()
else:
if len(l)!=0:
ans-=l[len(l)-1][1]
l.pop()
else:
break
start+=1
print(ans)
``` | instruction | 0 | 60,031 | 10 | 120,062 |
No | output | 1 | 60,031 | 10 | 120,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111
Submitted Solution:
```
n = int(input())
t, c = [], []
for i in range(n):
tt, cc = list(map(int, input().split()))
t.append(tt)
c.append(cc)
def find(i: int, cnt: int) -> int:
if i == n:
if cnt == n: return 0
else: return int(1e9)
return min(find(i + 1, cnt), c[i] + find(i + 1, cnt + 1 + t[i]))
print(find(0, 0))
# min: (i + 1, cnt) || c + (i + 1, cnt + t + 1)
``` | instruction | 0 | 60,032 | 10 | 120,064 |
No | output | 1 | 60,032 | 10 | 120,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob came to a cash & carry store, put n items into his trolley, and went to the checkout counter to pay. Each item is described by its price ci and time ti in seconds that a checkout assistant spends on this item. While the checkout assistant is occupied with some item, Bob can steal some other items from his trolley. To steal one item Bob needs exactly 1 second. What is the minimum amount of money that Bob will have to pay to the checkout assistant? Remember, please, that it is Bob, who determines the order of items for the checkout assistant.
Input
The first input line contains number n (1 ≤ n ≤ 2000). In each of the following n lines each item is described by a pair of numbers ti, ci (0 ≤ ti ≤ 2000, 1 ≤ ci ≤ 109). If ti is 0, Bob won't be able to steal anything, while the checkout assistant is occupied with item i.
Output
Output one number — answer to the problem: what is the minimum amount of money that Bob will have to pay.
Examples
Input
4
2 10
0 20
1 5
1 3
Output
8
Input
3
0 1
0 10
0 100
Output
111
Submitted Solution:
```
n = int(input())
lis = []
for i in range(n):
k, l = map(int, input().split())
lis.append([k, l])
summ = 0
lis.sort(key=lambda x: x[1])
i, j = 0, n - 1
while i <= j:
summ += lis[i][1]
for x in range(lis[i][0]):
j -= 1
if j == i:
break
i += 1
print(summ)
``` | instruction | 0 | 60,033 | 10 | 120,066 |
No | output | 1 | 60,033 | 10 | 120,067 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,479 | 10 | 120,958 |
"Correct Solution:
```
A,B,C,X,Y = map(int,input().split())
print(min(A*X+B*Y,2*C*X+B*max(0,Y-X),2*C*Y+A*max(0,X-Y)))
``` | output | 1 | 60,479 | 10 | 120,959 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,480 | 10 | 120,960 |
"Correct Solution:
```
a,b,c,x,y=map(int,input().split())
m=min(a+b,2*c)
if x>=y:print(m*y+min(a,2*c)*(x-y))
else:print(m*x+min(b,2*c)*(y-x))
``` | output | 1 | 60,480 | 10 | 120,961 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,481 | 10 | 120,962 |
"Correct Solution:
```
A,B,C,X,Y=map(int,input().split())
v=10**10
for i in range(0,max(X,Y)*2+2):
v=min(v,A*max(X-i,0)+B*max(Y-i,0)+C*i*2)
print(v)
``` | output | 1 | 60,481 | 10 | 120,963 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,482 | 10 | 120,964 |
"Correct Solution:
```
a,b,c,x,y=map(int,input().split())
ans=float('inf')
for i in range(10**5+1):
tmp=2*i*c+a*max(x-i,0)+b*max(y-i,0)
ans=min(tmp,ans)
print(ans)
``` | output | 1 | 60,482 | 10 | 120,965 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,483 | 10 | 120,966 |
"Correct Solution:
```
A, B, C, X, Y = map(int, input().split())
print(min(A * X + B * Y, C * 2 * max(X,Y), C * 2 * min(X,Y) + max(A * (X - Y), B * (Y - X))))
``` | output | 1 | 60,483 | 10 | 120,967 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,484 | 10 | 120,968 |
"Correct Solution:
```
a,b,c,x,y = map(int,input().split())
if x>y:
s = c*y*2+(x-y)*a
else:
s = c*x*2+(y-x)*b
print(min((a*x+b*y),(c*max(x,y)*2),s))
``` | output | 1 | 60,484 | 10 | 120,969 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,485 | 10 | 120,970 |
"Correct Solution:
```
A,B,C,X,Y=list(map(int,input().split()))
print(min([i*2*C+max(0,X-i)*A+max(0,Y-i)*B for i in range(10**5+1)]))
``` | output | 1 | 60,485 | 10 | 120,971 |
Provide a correct Python 3 solution for this coding contest problem.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000 | instruction | 0 | 60,486 | 10 | 120,972 |
"Correct Solution:
```
a,b,c,x,y=map(int,input().split())
print(min(max(x,y)*2*c,a*x+b*y,min(x,y)*2*c+a*(x-min(x,y))+(b*(y-min(x,y)))))
``` | output | 1 | 60,486 | 10 | 120,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000
Submitted Solution:
```
A, B, C, X, Y = map(int,input().split())
if X>Y:
print(min(A*X+B*Y, A*(X-Y)+C*Y*2, C*X*2))
if Y>=X:
print(min(A*X+B*Y, B*(Y-X)+C*X*2, C*Y*2))
``` | instruction | 0 | 60,487 | 10 | 120,974 |
Yes | output | 1 | 60,487 | 10 | 120,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000
Submitted Solution:
```
a,b,c,x,y = map(int,input().split())
res = min(a+b,2*c)*min(x,y)
if x > y:
res += min(a,2*c)*(x-y)
else:
res += min(b,2*c)*(y-x)
print(res)
``` | instruction | 0 | 60,488 | 10 | 120,976 |
Yes | output | 1 | 60,488 | 10 | 120,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000
Submitted Solution:
```
a, b, c, x, y = map(int, input().split())
[m,n],[M,N]= sorted([[x,a],[y,b]])
print(min(a*x+b*y,c*2*M,c*2*m+(M-m)*N))
``` | instruction | 0 | 60,489 | 10 | 120,978 |
Yes | output | 1 | 60,489 | 10 | 120,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000
Submitted Solution:
```
a,b,c,x,y = map(int, input().split())
ab = min(a+b,2*c)
a = min(a,2*c)
b = min(b,2*c)
print((x-y)*a+y*ab if x>y else (y-x)*b+x*ab)
``` | instruction | 0 | 60,490 | 10 | 120,980 |
Yes | output | 1 | 60,490 | 10 | 120,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000
Submitted Solution:
```
A, B, C, X, Y=map(int, input().split())
if (A+B)>2*c:
ans=2*C*min(X, Y)
if X>Y:
if A>2*C:
ans+=2*C*(X-Y)
else:
ans+=A*(X-Y)
else:
if B>2*C:
ans+=2*C*(Y-X)
else:
ans+=B*(Y-X)
else:
ans=A*X+B*Y
print(ans)
``` | instruction | 0 | 60,492 | 10 | 120,984 |
No | output | 1 | 60,492 | 10 | 120,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Pizza At", a fast food chain, offers three kinds of pizza: "A-pizza", "B-pizza" and "AB-pizza". A-pizza and B-pizza are completely different pizzas, and AB-pizza is one half of A-pizza and one half of B-pizza combined together. The prices of one A-pizza, B-pizza and AB-pizza are A yen, B yen and C yen (yen is the currency of Japan), respectively.
Nakahashi needs to prepare X A-pizzas and Y B-pizzas for a party tonight. He can only obtain these pizzas by directly buying A-pizzas and B-pizzas, or buying two AB-pizzas and then rearrange them into one A-pizza and one B-pizza. At least how much money does he need for this? It is fine to have more pizzas than necessary by rearranging pizzas.
Constraints
* 1 ≤ A, B, C ≤ 5000
* 1 ≤ X, Y ≤ 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C X Y
Output
Print the minimum amount of money required to prepare X A-pizzas and Y B-pizzas.
Examples
Input
1500 2000 1600 3 2
Output
7900
Input
1500 2000 1900 3 2
Output
8500
Input
1500 2000 500 90000 100000
Output
100000000
Submitted Solution:
```
A,B,C,X,Y = map(int,input().split())
mini=float("inf")
for a in range(0,X+1):
for b in range(0,Y+1):
c_num = max( 2*(X-a), 2*(Y-b) )
P= A*a + B*b + C*c_num
mini=min(mini,P)
print(mini)
``` | instruction | 0 | 60,493 | 10 | 120,986 |
No | output | 1 | 60,493 | 10 | 120,987 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,559 | 10 | 121,118 |
"Correct Solution:
```
# coding: utf-8
# Here your code !
dataCount = int(input())
while dataCount > 0:
employeeSalesList = []
for _ in range(dataCount):
dataList = input().split(" ")
employeeId, price = int(dataList[0]), int(dataList[1]) * int(dataList[2])
found = False
for data in employeeSalesList:
if data[0] == employeeId:
data[1] += price
found = True
if not found:
employeeSalesList.append([employeeId, price])
answerList = [data[0] for data in employeeSalesList if data[1] >= 1000000]
if answerList:
print("\n".join(map(str, answerList)))
else:
print("NA")
dataCount = int(input())
``` | output | 1 | 60,559 | 10 | 121,119 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,560 | 10 | 121,120 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0: break
data = {}
staff = []
for i in range(n):
x, y, z = [int(el) for el in input().split(' ')]
if x in data:
data[x] += y * z
else:
data[x] = y * z
staff.append(x)
if max(data.values()) < 1e6:
print('NA')
else:
for k in staff:
if data[k] >= 1e6:
print(k)
``` | output | 1 | 60,560 | 10 | 121,121 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,561 | 10 | 121,122 |
"Correct Solution:
```
n = int(input())
while n != 0:
earnings = []
for i in range(0,n):
a = str.split(input(),' ')
if i > 0 :
for j in range(0,len(earnings)):
if a[0] == earnings[j][0]:
earnings[j][1] = str(int(earnings[j][1])+(int(a[1])*int(a[2])))
break
if j == len(earnings) - 1:earnings.append([a[0],str(int(a[1])*int(a[2]))])
else:earnings.append([a[0],str(int(a[1])*int(a[2]))])
milionear = []
for i in range(0,len(earnings)):
if int(earnings[i][1]) >= 1e6:
milionear.append(earnings[i][0])
if len(milionear) == 0 : print('NA')
else:
for i in range(0,len(milionear)):
print(milionear[i])
n = int(input())
``` | output | 1 | 60,561 | 10 | 121,123 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,562 | 10 | 121,124 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0:
break
emp = [0] * 4001
used = set()
for i in range(n):
e, p, q = map(int, input().split())
emp[e] += p * q
if 1000000 <= emp[e] and e not in used:
print(e)
used.add(e)
if len(used) == 0:
print("NA")
``` | output | 1 | 60,562 | 10 | 121,125 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,563 | 10 | 121,126 |
"Correct Solution:
```
from collections import Counter
while True:
n = int(input())
if n == 0:
break
counter = Counter()
for _ in [0]*n:
a, b, c = map(int, input().split())
counter[a] += b*c
result = [str(k) for k, v in counter.items() if v >= 1000000] or ["NA"]
print("\n".join(result))
``` | output | 1 | 60,563 | 10 | 121,127 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,564 | 10 | 121,128 |
"Correct Solution:
```
from collections import OrderedDict
while True:
num = int(input())
if not num: break
result = OrderedDict()
for _ in range(num):
x, y, z = [int(el) for el in input().split(' ')]
if x in result:
result[x] += y*z
else:
result[x] = y*z
res = [print(k) for k,v in result.items() if v >= 1e6]
if not res: print('NA')
``` | output | 1 | 60,564 | 10 | 121,129 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,565 | 10 | 121,130 |
"Correct Solution:
```
p = []
q = []
while True:
n = int(input())
m = 0
number = [0] * 4000
if n == 0:
break
else:
for i in range(n):
p.append(i)
q.append(i)
e,p[i],q[i] = [int(s) for s in input().split(' ')]
if number[e] >= 1000000:
break
else:
number[e] = number[e] + p[i] * q[i]
if number[e] >= 1000000:
print(e)
else:
m = m + 1
if m == n:
print('NA')
``` | output | 1 | 60,565 | 10 | 121,131 |
Provide a correct Python 3 solution for this coding contest problem.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013 | instruction | 0 | 60,566 | 10 | 121,132 |
"Correct Solution:
```
while True:
input_n = int(input())
key = 0
if input_n == 0:
break
id_list = [[0 for i in range(2)]for i in range(input_n)]
for i in range(input_n):
id_line = input().split()
for j in id_list:
if j[0] == int(id_line[0]):
j[1] += int(id_line[1]) * int(id_line[2])
uriage = j[1]
break
else:
id_list[i][0] = int(id_line[0])
id_list[i][1] = int(id_line[1]) * int(id_line[2])
uriage = id_list[i][1]
if uriage >= 1000000:
key = 1
for i in id_list:
if key == 0:
print("NA")
break
if i[1] >= 1000000:
print(i[0])
``` | output | 1 | 60,566 | 10 | 121,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
n = int(input())
while n != 0:
score = {}
j = 0
for i in range(n):
e,p,q = list(map(int,input().split()))
if e in score:
score[e]["value"] += p*q
else:
score[e] = {"value":p*q, "index":j}
j += 1
f = {}
for e,v in score.items():
if v["value"] >= 1000000:
f[v["index"]] = e
if len(f)==0:
print("NA")
else:
for w in sorted(f.items(), key = lambda x:x[0]):
print(w[1])
n = int(input())
``` | instruction | 0 | 60,567 | 10 | 121,134 |
Yes | output | 1 | 60,567 | 10 | 121,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
break
workers = {}
workernames = []
greatworkers = 0
for i in range(n):
person, price, number = map(int, input().split())
if person in workers:
workers[person] += price * number
else:
workers[person] = price * number
workernames.append(person)
for worker in workernames:
if workers[worker] >= 1000000:
print(worker)
greatworkers += 1
if greatworkers == 0:
print('NA')
``` | instruction | 0 | 60,568 | 10 | 121,136 |
Yes | output | 1 | 60,568 | 10 | 121,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
break
lst = [0]*4001
elst = []
ans = []
for i in range(n):
e, p, q = map(int, input().split())
if lst[e]:
pass
else:
elst.append(e)
lst[e] = lst[e] + p*q
for i in elst:
if lst[i] >= 1000000:
ans.append(i)
if ans == []:
print('NA')
else:
for i in ans:
print(i)
``` | instruction | 0 | 60,569 | 10 | 121,138 |
Yes | output | 1 | 60,569 | 10 | 121,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
while True:
n = int(input())
if n == 0: break
data = {}
staff = []
for i in range(n):
tmp = list(map(int, input().split(' ')))
if tmp[0] in data:
data[tmp[0]] += tmp[1] * tmp[2]
else:
data[tmp[0]] = tmp[1] * tmp[2]
staff.append(tmp[0])
if max(data.values()) < 1000000:
print('NA')
else:
for k in staff:
if data[k] >= 1000000:
print(k)
``` | instruction | 0 | 60,570 | 10 | 121,140 |
Yes | output | 1 | 60,570 | 10 | 121,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
import sys
input_lines = sys.stdin.readlines()
cnt = 0
dataset = []
for i in input_lines:
if not(' ' in i):
dataset.append([int(i)])
cnt += 1
else:dataset[cnt-1].append(list(map(int, i.split(' '))))
``` | instruction | 0 | 60,571 | 10 | 121,142 |
No | output | 1 | 60,571 | 10 | 121,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
while True:
num=int(input())
if num==0:
break
else:
d={}
for i in range (num):
info=list(map(int,input().split()))
try:
d[info[0]]+=info[1]*info[2]
except:
d[info[0]]=info[1]*info[2]
answer=[]
for i in d.keys():
if d[i] >=1000000:
answer.append(i)
answer=sorted(answer)
if answer==[]:
print("NA")
else:
for i in answer:
print(i)
``` | instruction | 0 | 60,572 | 10 | 121,144 |
No | output | 1 | 60,572 | 10 | 121,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
while 1:
a={};b=0
n=int(input())
if n==0:break
for _ in[0]*n:
e,p,q=map(int,input().split())
a.setdefault(e,0);a[e]+=p*q
for e in a:
if a[e]>=1e6:print(e);b=1
if b:print('NA')
``` | instruction | 0 | 60,573 | 10 | 121,146 |
No | output | 1 | 60,573 | 10 | 121,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.
Input
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
n (the number of data in the list)
i p q
i p q
:
:
i p q
Output
For each dataset, print a list of employee IDs or a text "NA"
Example
Input
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
Output
1001
1003
NA
2013
Submitted Solution:
```
while(True):
n = int(input())
if n==0: break
d = {}
c = 0
l = list()
for _ in range(n):
id_,p,q = map(int,input().split())
if id_ in d:
d[id_] += p*q
else:
d[id_] = p*q
l.append(id_)
for i in d:
if d[i] >= 1000000:
print(i)
c += 1
if c == 0:
print('NA')
``` | instruction | 0 | 60,574 | 10 | 121,148 |
No | output | 1 | 60,574 | 10 | 121,149 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,881 | 10 | 121,762 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
import math
for _ in range(int(input())):
n,W=map(int,input().split())
w=list(map(int,input().split()))
a=[]
s=0
for i in range(n):
if w[i]<=W and w[i]>=math.ceil(W/2):
a=[i+1]
s=w[i]
break;
else:
s+=w[i]
if s>W:
s-=w[i]
else:
a.append(i+1)
if s>=math.ceil(W/2):
break;
if s>=math.ceil(W/2):
print(len(a))
print(*a)
else:
print(-1)
``` | output | 1 | 60,881 | 10 | 121,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,882 | 10 | 121,764 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
t = int(input())
for _ in range(t):
n, W = map(int, input().split())
w = list(map(int, input().split()))
s = 0
c = []
f = False
for i in range(n):
if (W + 1) // 2 <= w[i] <= W:
print(1)
print(i + 1)
f = True
break
elif w[i] < (W + 1) // 2:
s += (w[i])
c.append(i + 1)
if (W + 1) // 2 <= s <= W:
print(len(c))
print(*c)
f = True
break
if not f:
print(-1)
``` | output | 1 | 60,882 | 10 | 121,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,883 | 10 | 121,766 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
from collections import defaultdict
for _ in range(int(input())):
n,w=map(int,input().split())
a=list(map(int,input().split()))
ex = (w + 1) // 2
gg=False
for i in range(n):
if a[i]>=ex and a[i]<=w:
gg=True
print(1)
print(i+1)
break
if gg:
continue
summ=0
ll=[]
ans=False
for i in range(n):
if summ+a[i]<=w:
summ+=a[i]
ll.append(i+1)
if summ>=ex:
ans=True
break
if ans:
print(len(ll))
print(*ll)
else:
print(-1)
``` | output | 1 | 60,883 | 10 | 121,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,884 | 10 | 121,768 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
import sys
import bisect
*data, = map(int, sys.stdin.read().split()[::-1])
def inp():
return data.pop()
output = []
for _ in range(inp()):
n, W = inp(), inp()
*w, = [inp() for _ in range(n)]
lbound = (W + 1) // 2
items = sorted(range(n), key=lambda i: w[i])
if w[items[0]] > W:
output.append('-1')
elif sum(w) < lbound:
output.append('-1')
else:
s = 0
for i in range(n):
if lbound <= w[items[i]] <= W:
output.append('1')
output.append(str(items[i] + 1))
break
else:
for i in range(n):
s += w[items[i]]
if s >= lbound and s <= W:
ans = [v + 1 for v in items[:i + 1]]
output.append(str(len(ans)))
output.append(' '.join(map(str, sorted(ans))))
break
else:
output.append('-1')
print('\n'.join(output))
``` | output | 1 | 60,884 | 10 | 121,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,885 | 10 | 121,770 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
"""
Don't see the standings during the contest!!! You will lose motivation.
"""
# ---------------------------------------------------Import Libraries---------------------------------------------------
import sys
import time
import os
from math import sqrt, log, log2, ceil, log10, gcd, floor, pow, sin, cos, tan, pi, inf, factorial
from copy import copy, deepcopy
from sys import exit, stdin, stdout
from collections import Counter, defaultdict, deque
from itertools import permutations
import heapq
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is r
# ---------------------------------------------------Global Variables---------------------------------------------------
# sys.setrecursionlimit(100000000)
mod = 1000000007
# ---------------------------------------------------Helper Functions---------------------------------------------------
iinp = lambda: int(sys.stdin.readline())
inp = lambda: sys.stdin.readline().strip()
strl = lambda: list(inp().strip().split(" "))
intl = lambda: list(map(int, inp().split(" ")))
mint = lambda: map(int, inp().split())
flol = lambda: list(map(float, inp().split(" ")))
flush = lambda: stdout.flush()
def permute(nums):
def fun(arr, nums, cur, v):
if len(cur) == len(nums):
arr.append(cur.copy())
i = 0
while i < len(nums):
if v[i]:
i += 1
continue
else:
cur.append(nums[i])
v[i] = 1
fun(arr, nums, cur, v)
cur.pop()
v[i] = 0
i += 1
# while i<len(nums) and nums[i]==nums[i-1]:i+=1 # Uncomment for unique permutations
return arr
res = []
nums.sort()
v = [0] * len(nums)
return fun(res, nums, [], v)
def subsets(res, index, arr, cur):
res.append(cur.copy())
for i in range(index, len(arr)):
cur.append(arr[i])
subsets(res, i + 1, arr, cur)
cur.pop()
return res
def sieve(N):
root = int(sqrt(N))
primes = [1] * (N + 1)
primes[0], primes[1] = 0, 0
for i in range(2, root + 1):
if primes[i]:
for j in range(i * i, N + 1, i):
primes[j] = 0
return primes
def bs(arr, l, r, x):
if x < arr[0] or x > arr[len(arr) - 1]:
return -1
while l <= r:
mid = l + (r - l) // 2
if arr[mid] == x:
return mid
elif arr[mid] < x:
l = mid + 1
else:
r = mid - 1
return -1
def isPrime(n):
if n <= 1: return False
if n <= 3: return True
if n % 2 == 0 or n % 3 == 0: return False
p = int(sqrt(n))
for i in range(5, p + 1, 6):
if n % i == 0 or n % (i + 2) == 0:
return False
return True
# -------------------------------------------------------Functions------------------------------------------------------
def solve():
n,w=mint()
arr=intl()
smallsum=0
small=[]
for i in range(n):
if arr[i]>w:
continue
if ceil(w/2)<=arr[i]<=w:
print(1)
print(i+1)
return
if smallsum+arr[i]<=w:
smallsum+=arr[i]
small.append(i+1)
if ceil(w/2)<=smallsum<=w:
print(len(small))
print(*small)
return
print(-1)
# -------------------------------------------------------Main Code------------------------------------------------------
start_time = time.time()
for _ in range(iinp()):
solve()
# print("--- %s seconds ---" % (time.time() - start_time))
``` | output | 1 | 60,885 | 10 | 121,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,886 | 10 | 121,772 |
Tags: constructive algorithms, greedy, sortings
Correct 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=[]
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)):
print(-1)
else:
print(len(a))
print(*a)
``` | output | 1 | 60,886 | 10 | 121,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,887 | 10 | 121,774 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
class Weight:
def __init__(self, w, i):
self.weight = w
self.index =i
def __lt__(self, other):
return self.weight < other.weight
def solve():
n, total = (int(x) for x in input().strip().split())
arr = list(map(lambda x: Weight(x[0], x[1]), zip([int(x) for x in input().strip().split()], range(1, 1 + n))))
lim = total // 2
if total & 1:
lim += 1
arr_gt_eq_lim = list(filter(lambda t: t.weight >= lim and t.weight <= total, arr))
arr_lt_lim = list(filter(lambda t: t.weight < lim, arr))
if len(arr_gt_eq_lim) > 0:
print(1)
print(arr_gt_eq_lim[0].index)
return
index, s = 0, 0
while index < len(arr_lt_lim):
s += arr_lt_lim[index].weight
if s >= lim:
break
index += 1
if index == len(arr_lt_lim):
print(-1)
else:
print(1 + index)
print(' '.join(map(str, map(lambda t: t.index, arr_lt_lim[:1 + index]))))
if __name__ == '__main__':
for _ in range(int(input().strip())):
solve()
``` | output | 1 | 60,887 | 10 | 121,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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. | instruction | 0 | 60,888 | 10 | 121,776 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
t = int(input())
for _ in range(t):
n, w = map(int, input().split())
a = list(map(int, input().split()))
for i in range(n):
if w <= a[i] * 2 <= w * 2:
print(1)
print(i + 1)
break
else:
t = 0
res = []
for i in range(n):
if a[i] * 2 <= w:
t += a[i]
res.append(i + 1)
if w <= t * 2 <= w * 2:
print(len(res))
print(*res)
break
else:
print(-1)
``` | output | 1 | 60,888 | 10 | 121,777 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.