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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20 | instruction | 0 | 79,222 | 10 | 158,444 |
Tags: binary search, greedy, implementation
Correct Solution:
```
import math
from collections import defaultdict
import sys
#input = sys.stdin.readline
def main():
n, m = map(int, input().split())
k = list(map(int, input().split()))
sales = [(0, 0)] * m
for i in range(m):
a, b = map(int, input().split())
sales[i] = (b, a)
def check(days):
last_sale = {}
for sale in sales:
if sale[1] <= days:
if sale[0] not in last_sale or sale[1] > last_sale[sale[0]]:
last_sale[sale[0]] = sale[1]
date_last_sales = {}
for t, d in last_sale.items():
if d not in date_last_sales:
date_last_sales[d] = [t]
else:
date_last_sales[d].append(t)
balance = 0
required = [0] + k.copy()
end = 0
for d in range(1, days+1):
balance += 1
if d in date_last_sales:
for t in date_last_sales[d]:
if required[t] > 0:
if required[t] > balance:
end += required[t] - balance
balance -= min(required[t], balance)
required[t] = 0
if d == days: # last day
for r in required:
if r > 0:
end += r
return 2*end <= balance
total = sum(k)
hi = 2*total
lo = 1
while lo + 1 < hi:
mid = (lo + hi) // 2
if check(mid):
hi = mid
else:
lo = mid
if check(lo):
print(lo)
else:
print(hi)
if __name__ == '__main__':
main()
``` | output | 1 | 79,222 | 10 | 158,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20 | instruction | 0 | 79,223 | 10 | 158,446 |
Tags: binary search, greedy, implementation
Correct Solution:
```
import sys
def main():
n, m = map(int, input().split())
k = [int(x) for x in input().split()]
d = [[] for _ in range(4 * 10**5 + 1)]
for j in range(m):
dj, tj = map(int, input().split())
d[dj - 1].append(tj - 1)
lo, hi = 0, 4 * 10**5 + 1
while lo < hi:
mi = (hi + lo) // 2
cash = mi
offset = 0
_k = k[:]
for i in reversed(range(mi)):
for j in d[i]:
while cash and _k[j]:
_k[j] -= 1
cash -= 1
if cash == i + 1:
cash -= 2
offset += 1
if 2 * (sum(_k) - offset) <= cash:
hi = mi
else:
lo = mi + 1
print(lo)
input = iter(sys.stdin.read().splitlines()).__next__
if __name__ == "__main__":
main()
``` | output | 1 | 79,223 | 10 | 158,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
Submitted Solution:
```
input=__import__('sys').stdin.readline
def check(x):
last=[0]*(n+1)
for i in tmp:
if i[0]>x:
break
else:
last[i[1]]=i[0]
sal=[0]*(x+1)
for i in range(1,n+1):
sal[last[i]]+=lis[i-1]
c=0
for i in range(1,x+1):
c+=1
if sal[i]>=c:
sal[i]-=c
c=0
else:
c-=sal[i]
sal[i]=0
if sum(sal)*2<=c:
return True
else:
return False
n,m = map(int,input().split())
lis = list(map(int,input().split()))
tmp=[]
for _ in range(m):
a,b = map(int,input().split())
tmp.append([a,b])
tmp.sort()
l=0
r=sum(lis)*2
while l<=r:
mid = l + (r-l)//2
if check(mid):
r = mid-1
else:
l = mid+1
if check(r):
print(r)
elif check(l):
print(l)
else:
print(l+1)
``` | instruction | 0 | 79,224 | 10 | 158,448 |
Yes | output | 1 | 79,224 | 10 | 158,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
# threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
# sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2 ** 30, func=lambda a, b: min(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] > k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
# -----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.count = 0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
self.temp.count += 1
if not val:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
self.temp.count += 1
self.temp.data = pre_xor
def query(self, xor):
self.temp = self.root
for i in range(31, -1, -1):
val = xor & (1 << i)
if not val:
if self.temp.left and self.temp.left.count > 0:
self.temp = self.temp.left
elif self.temp.right:
self.temp = self.temp.right
else:
if self.temp.right and self.temp.right.count > 0:
self.temp = self.temp.right
elif self.temp.left:
self.temp = self.temp.left
self.temp.count -= 1
return xor ^ self.temp.data
# -------------------------bin trie-------------------------------------------
n,m=map(int,input().split())
l=list(map(int,input().split()))
t=[]
for i in range(m):
a,b=map(int,input().split())
t.append((a,b))
t.sort()
def check(x):
now=x
c=sum(l)
cur=0
last=0
ld=defaultdict(int)
for i in range(len(t)):
if t[i][0]<=x:
ld[t[i][1]]=i
for i in range(m):
if ld[t[i][1]]!=i:
continue
if t[i][0]>x:
break
cur+=t[i][0]-last
rt=min(cur,l[t[i][1]-1])
cur-=rt
now-=rt
c-=rt
last=t[i][0]
if now>=2*c:
return True
return False
st=1
end=2*sum(l)
ans=end
while(st<=end):
mid=(st+end)//2
if check(mid)==True:
ans=mid
end=mid-1
else:
st=mid+1
print(ans)
``` | instruction | 0 | 79,225 | 10 | 158,450 |
Yes | output | 1 | 79,225 | 10 | 158,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10)]
pp=[0]*10
def SieveOfEratosthenes(n=10):
p = 2
c=0
while (p * p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
pp[i]+=1
prime[i] = False
p += 1
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=0
while (left <= right):
mid = (right + left)//2
if (arr[mid][0] > key):
right = mid-1
else:
res=mid
left = mid + 1
return res
#---------------------------------running code------------------------------------------
n,m=map(int,input().split())
l=list(map(int,input().split()))
t=[]
for i in range(m):
a,b=map(int,input().split())
t.append((a,b))
t.sort()
def check(x):
now=x
c=sum(l)
cur=0
last=0
ld=defaultdict(int)
for i in range(len(t)):
if t[i][0]<=x:
ld[t[i][1]]=i
for i in range(m):
if ld[t[i][1]]!=i:
continue
if t[i][0]>x:
break
cur+=t[i][0]-last
rt=min(cur,l[t[i][1]-1])
cur-=rt
now-=rt
c-=rt
last=t[i][0]
if now>=2*c:
return True
return False
st=1
end=2*sum(l)
ans=end
while(st<=end):
mid=(st+end)//2
if check(mid)==True:
ans=mid
end=mid-1
else:
st=mid+1
print(ans)
``` | instruction | 0 | 79,226 | 10 | 158,452 |
Yes | output | 1 | 79,226 | 10 | 158,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
Submitted Solution:
```
import sys
from array import array # noqa: F401
from typing import List, Tuple, TypeVar, Generic, Sequence, Union # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
n, m = map(int, input().split())
k = array('i', [0] + list(map(int, input().split())))
sale = sorted((tuple(map(int, input().split())) for _ in range(m)), reverse=True)
total = sum(k)
visited = array('b', [0]) * (n + 1)
ok, ng = total * 2 + 1, total - 1
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
for i in range(1, n + 1):
visited[i] = 0
bought, money = 0, mid
for di, ti in sale:
if di > mid or visited[ti]:
continue
visited[ti] = 1
if money > di:
money = di
x = k[ti] if k[ti] <= money else money
bought += x
money -= x
if 2 * total - bought <= mid:
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
``` | instruction | 0 | 79,227 | 10 | 158,454 |
Yes | output | 1 | 79,227 | 10 | 158,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Ivan plays a computer game that contains some microtransactions to make characters look cooler. Since Ivan wants his character to be really cool, he wants to use some of these microtransactions — and he won't start playing until he gets all of them.
Each day (during the morning) Ivan earns exactly one burle.
There are n types of microtransactions in the game. Each microtransaction costs 2 burles usually and 1 burle if it is on sale. Ivan has to order exactly k_i microtransactions of the i-th type (he orders microtransactions during the evening).
Ivan can order any (possibly zero) number of microtransactions of any types during any day (of course, if he has enough money to do it). If the microtransaction he wants to order is on sale then he can buy it for 1 burle and otherwise he can buy it for 2 burles.
There are also m special offers in the game shop. The j-th offer (d_j, t_j) means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Ivan wants to order all microtransactions as soon as possible. Your task is to calculate the minimum day when he can buy all microtransactions he want and actually start playing.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of types of microtransactions and the number of special offers in the game shop.
The second line of the input contains n integers k_1, k_2, ..., k_n (0 ≤ k_i ≤ 2 ⋅ 10^5), where k_i is the number of copies of microtransaction of the i-th type Ivan has to order. It is guaranteed that sum of all k_i is not less than 1 and not greater than 2 ⋅ 10^5.
The next m lines contain special offers. The j-th of these lines contains the j-th special offer. It is given as a pair of integers (d_j, t_j) (1 ≤ d_j ≤ 2 ⋅ 10^5, 1 ≤ t_j ≤ n) and means that microtransactions of the t_j-th type are on sale during the d_j-th day.
Output
Print one integer — the minimum day when Ivan can order all microtransactions he wants and actually start playing.
Examples
Input
5 6
1 2 0 2 0
2 4
3 3
1 5
1 2
1 5
2 3
Output
8
Input
5 3
4 2 1 3 2
3 5
4 2
2 5
Output
20
Submitted Solution:
```
import sys
input = sys.stdin.readline
def check(num):
new = []
for i in range(n):
new.append(a[i])
i = 0
b = 0
d = 0
while d!=num and new.count(0)!=n:
b += 1
d += 1
while i<len(o) and o[i][0]==d:
m = min(new[o[i][1]-1],b)
b, new[o[i][1]-1] = b - m, new[o[i][1]-1] - m
i += 1
# print (d,i,b,new,num)
s = sum(new)
if s*2>=b:
return True
return False
n,m = map(int,input().split())
a = list(map(int,input().split()))
o = []
for i in range(m):
x,y = map(int,input().split())
o.append((x,y))
o.sort()
low = 1
high = sum(a)*2
while low<high:
mid = (low+high)//2
if check(mid):
high = mid - 1
else:
low = mid + 1
if check(low):
print (low)
else:
print (low+1)
``` | instruction | 0 | 79,228 | 10 | 158,456 |
No | output | 1 | 79,228 | 10 | 158,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alfred wants to buy a toy moose that costs c dollars. The store doesn’t give change, so he must give the store exactly c dollars, no more and no less. He has n coins. To make c dollars from his coins, he follows the following algorithm: let S be the set of coins being used. S is initially empty. Alfred repeatedly adds to S the highest-valued coin he has such that the total value of the coins in S after adding the coin doesn’t exceed c. If there is no such coin, and the value of the coins in S is still less than c, he gives up and goes home. Note that Alfred never removes a coin from S after adding it.
As a programmer, you might be aware that Alfred’s algorithm can fail even when there is a set of coins with value exactly c. For example, if Alfred has one coin worth $3, one coin worth $4, and two coins worth $5, and the moose costs $12, then Alfred will add both of the $5 coins to S and then give up, since adding any other coin would cause the value of the coins in S to exceed $12. Of course, Alfred could instead combine one $3 coin, one $4 coin, and one $5 coin to reach the total.
Bob tried to convince Alfred that his algorithm was flawed, but Alfred didn’t believe him. Now Bob wants to give Alfred some coins (in addition to those that Alfred already has) such that Alfred’s algorithm fails. Bob can give Alfred any number of coins of any denomination (subject to the constraint that each coin must be worth a positive integer number of dollars). There can be multiple coins of a single denomination. He would like to minimize the total value of the coins he gives Alfred. Please find this minimum value. If there is no solution, print "Greed is good". You can assume that the answer, if it exists, is positive. In other words, Alfred's algorithm will work if Bob doesn't give him any coins.
Input
The first line contains c (1 ≤ c ≤ 200 000) — the price Alfred wants to pay. The second line contains n (1 ≤ n ≤ 200 000) — the number of coins Alfred initially has. Then n lines follow, each containing a single integer x (1 ≤ x ≤ c) representing the value of one of Alfred's coins.
Output
If there is a solution, print the minimum possible total value of the coins in a solution. Otherwise, print "Greed is good" (without quotes).
Examples
Input
12
3
5
3
4
Output
5
Input
50
8
1
2
4
8
16
37
37
37
Output
Greed is good
Note
In the first sample, Bob should give Alfred a single coin worth $5. This creates the situation described in the problem statement.
In the second sample, there is no set of coins that will cause Alfred's algorithm to fail.
Submitted Solution:
```
import sys
def main():
c = int(sys.stdin.readline().strip())
n = int(sys.stdin.readline().strip())
S = 0
data = []
m = int(sys.stdin.readline().strip())
data.append(m)
for i in range(n - 1):
m = int(sys.stdin.readline().strip())
if m >= data[0]:
data.insert(0, m)
else:
data.append(m)
for i in data:
S += i
if S == c:
print(data[0])
break
if S > c:
print('Greed is good')
break
if S < c:
print('Greed is good')
if __name__ == '__main__':
main()
``` | instruction | 0 | 79,603 | 10 | 159,206 |
No | output | 1 | 79,603 | 10 | 159,207 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,873 | 10 | 159,746 |
"Correct Solution:
```
while True:
n, m = map(int, input().split())
if n == 0:
break
N, M = zip(*[[x.strip("*") if i == 0 else int(x) for i, x in enumerate(input().split())] for _ in range(n)])
print(sum([M[i] for b in [input() for _ in range(m)] for i, x in enumerate(N) if b.endswith(x)]))
``` | output | 1 | 79,873 | 10 | 159,747 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,874 | 10 | 159,748 |
"Correct Solution:
```
while True:
n, m = map(int, input().split())
if n == 0:break
h = [input().split() for _ in range(n)]
t = [input() for _ in range(m)]
c = 0
for kuji in t:
for atari in h:
for i in range(len(kuji)):
if atari[0][i] != "*" and kuji[i] != atari[0][i]:
break
else:
c += int(atari[1])
break
print(c)
``` | output | 1 | 79,874 | 10 | 159,749 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,875 | 10 | 159,750 |
"Correct Solution:
```
while True:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
tousen = [[] for i in range(n)]
for i in range(n):
tousen[i] = list(input().split())
tousen[i][0] = list(tousen[i][0])
tousen[i][1] = int(tousen[i][1])
ans = 0
for _ in range(m):
s = list(input())
for i in range(n):
flag = True
for j in range(8):
if tousen[i][0][j] != '*' and tousen[i][0][j] != s[j]:
flag = False
break
if flag:
ans += tousen[i][1]
break
print(ans)
``` | output | 1 | 79,875 | 10 | 159,751 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,876 | 10 | 159,752 |
"Correct Solution:
```
import re
while 1:
n,m=map(int,input().split())
if n==0:break
p=[];s=0
for _ in [0]*n:
n,M=input().replace('*','[0-9]').split()
p.append([re.compile(n),int(M)])
for _ in [0]*m:
l=input()
for n,M in p:
if n.search(l):
s+=M;break
print(s)
``` | output | 1 | 79,876 | 10 | 159,753 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,877 | 10 | 159,754 |
"Correct Solution:
```
while True:
n, m = map(int, input().split())
if n == 0:break
lst = []
for _ in range(n):
num, x = input().split()
lst.append((num, int(x)))
ans= 0
for _ in range(m):
b = input()
for num, x in lst:
for i in range(8):
if num[i] == "*" or num[i] == b[i]:continue
else:break
else:
ans += x
break
print(ans)
``` | output | 1 | 79,877 | 10 | 159,755 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,878 | 10 | 159,756 |
"Correct Solution:
```
while 1:
n,m=map(int,input().split())
if all([n==0,m==0]):break
winning=[]
for i in range(n):
ni,mi=map(str,input().split())
nl=8
while ni[0]=="*":
nl-=1
ni=ni[1:]
winning.append([ni,nl,int(mi)])
ans=0
for i in range(m):
num=input()
for ni,nl,mi in winning:
if ni==num[-nl:]:
ans+=mi
break
print(ans)
``` | output | 1 | 79,878 | 10 | 159,757 |
Provide a correct Python 3 solution for this coding contest problem.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050 | instruction | 0 | 79,879 | 10 | 159,758 |
"Correct Solution:
```
def Com(a, b) :
list_a = list(a)
list_b = list(b)
list_a.reverse()
list_b.reverse()
while '*' in list_a :
list_a.remove('*')
ans = True
for i in range(len(list_a)) :
if list_a[i] != list_b[i] :
ans = False
break
return ans
while True :
n, m = map(int, input().split())
if n == 0 and m == 0 :
break
atari = []
money = []
for i in range(n) :
a, b = input().split()
atari.append(a)
money.append(int(b))
cost = 0
for i in range(m) :
s = input()
for j in range(n) :
if Com(atari[j], s) == True :
cost += money[j]
print(cost)
``` | output | 1 | 79,879 | 10 | 159,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have successfully completed your studies and are preparing to move from near Komaba to near Hongo. As I was organizing my house, I found a lot of lottery tickets I bought last year. After confirming the exchange deadline, I have to cash in by tomorrow, but it is troublesome to go to the lottery counter for a small amount of money because I am not ready to move at all. So you decide to find out how much you can win.
The lottery consists of eight digits. The winning number is also composed of 8 digits and a number and'*', and if the lottery you have and the number part match, the winning money will be paid according to the winning number.
For example, if the lottery number you have is "12345678", you will win if the winning number is "******* 8" or "**** 5678", but the winning number is "**". If it is ** 4678 ", you will not win. There can be multiple winning numbers, and the winnings will be paid independently for each. However, the winning numbers are chosen so that one lottery does not win more than one winning number. For example, if there are two winning numbers, "******* 8" and "**** 5678", "12345678" will win both, so such a winning number will be selected. There is no one to be done.
Your job is to write a program that outputs how much winning money you will get for the lottery number you have and the lottery winning number given as input.
Notes on Test Cases
Multiple datasets are given in the above input format. Create a program that outputs each data set in the above output format.
When n is 0, it indicates the end of input.
<!-
Input
The input is given in the following format.
n m
N1 M1
...
Nn Mn
B1
...
Bm
In the first line, the number of winning numbers n (1 ≤ n ≤ 100) and the number of lottery tickets in possession m (1 ≤ m ≤ 1000) are given as integers.
In the next n lines, each line is given a winning number Ni and a winnings Mi (1 ≤ Mi ≤ 1000000). Winnings are integers. The format of the winning number is as described in the question text.
The next m lines will give you the number of the lottery you have.
Output
Output the total amount of winnings.
Examples
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0
Output
1200
438050
Input
3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
Output
1200
Input
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
Output
438050
Submitted Solution:
```
while 1:
n,a,b=map(int,input().split())
if n==a==b==0:break
c=0;d=[1]*(n+1)
for x in range(a):
for i in range(x*b,n+1,a):d[i]=0
print(sum(d))
``` | instruction | 0 | 79,880 | 10 | 159,760 |
No | output | 1 | 79,880 | 10 | 159,761 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,606 | 10 | 161,212 |
"Correct Solution:
```
X = int(input())
print(X//500*1000+(X-X//500*500)//5*5)
``` | output | 1 | 80,606 | 10 | 161,213 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,607 | 10 | 161,214 |
"Correct Solution:
```
x=int(input())
y=x//500
z=(x-y*500)//5
print(1000*y+5*z)
``` | output | 1 | 80,607 | 10 | 161,215 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,608 | 10 | 161,216 |
"Correct Solution:
```
X = int(input())
print(1000*(X//500)+5*((X%500)//5))
``` | output | 1 | 80,608 | 10 | 161,217 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,609 | 10 | 161,218 |
"Correct Solution:
```
X=int(input());t=500;print(X//t*2*t+X%t//5*5)
``` | output | 1 | 80,609 | 10 | 161,219 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,610 | 10 | 161,220 |
"Correct Solution:
```
x=int(input())
a=x//500
x-=a*500
print(a*1000+(x//5)*5)
``` | output | 1 | 80,610 | 10 | 161,221 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,611 | 10 | 161,222 |
"Correct Solution:
```
S=int(input())
A = S//500
a =S%500//5
print(A*1000 + a*5)
``` | output | 1 | 80,611 | 10 | 161,223 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,612 | 10 | 161,224 |
"Correct Solution:
```
x = int(input())
print(x//500 * 1000 + (x%500)//5 * 5)
``` | output | 1 | 80,612 | 10 | 161,225 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000 | instruction | 0 | 80,613 | 10 | 161,226 |
"Correct Solution:
```
x = int(input())
print(1000*(x//500) + 5*((x%500)//5))
``` | output | 1 | 80,613 | 10 | 161,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
x = int(input())
print(x//500*1000+(x%500//5)*5)
``` | instruction | 0 | 80,614 | 10 | 161,228 |
Yes | output | 1 | 80,614 | 10 | 161,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
X=int(input())
x=X//500
y=X%500//5
print(1000*x+5*y)
``` | instruction | 0 | 80,615 | 10 | 161,230 |
Yes | output | 1 | 80,615 | 10 | 161,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
a=int(input())
print((a//500)*1000+((a%500)//5)*5)
``` | instruction | 0 | 80,616 | 10 | 161,232 |
Yes | output | 1 | 80,616 | 10 | 161,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
x = int(input())
print(1000*(x // 500) + 5*(x%500 // 5) )
``` | instruction | 0 | 80,617 | 10 | 161,234 |
Yes | output | 1 | 80,617 | 10 | 161,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
X = int(input())
C = 0
D = 0
if X >= 0 and X <= 10 ** 9:
while True:
if X > 500:
C = X // 500
P = 500 * C
X = X - P
elif X > 5:
D = X // 5
L = 5 * D
X = X - L
else:
break
total = (1000 * C) + (5 * D)
print(str(total))
``` | instruction | 0 | 80,618 | 10 | 161,236 |
No | output | 1 | 80,618 | 10 | 161,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
x=int(input())
a=int(x/500)
b=int((x-500a)/5)
print(a*1000+b*5)
``` | instruction | 0 | 80,619 | 10 | 161,238 |
No | output | 1 | 80,619 | 10 | 161,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
X = input()
a = X // 500
b = X % 500
c = b // 5
print(a * 1000 + c * 5)
``` | instruction | 0 | 80,620 | 10 | 161,240 |
No | output | 1 | 80,620 | 10 | 161,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi loves gold coins. He gains 1000 happiness points for each 500-yen coin he has and gains 5 happiness points for each 5-yen coin he has. (Yen is the currency of Japan.)
Takahashi has X yen. If he exchanges his money so that he will gain the most happiness points, how many happiness points will he earn?
(We assume that there are six kinds of coins available: 500-yen, 100-yen, 50-yen, 10-yen, 5-yen, and 1-yen coins.)
Constraints
* 0 \leq X \leq 10^9
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
Print the maximum number of happiness points that can be earned.
Examples
Input
1024
Output
2020
Input
0
Output
0
Input
1000000000
Output
2000000000
Submitted Solution:
```
X=int(input())
a=int((X/500))*1000
X=X-((X/500)-1)*1000
b=int(X/5)*5
print(a-b)
``` | instruction | 0 | 80,621 | 10 | 161,242 |
No | output | 1 | 80,621 | 10 | 161,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,943 | 10 | 161,886 |
Tags: math
Correct Solution:
```
import sys
import math
from collections import defaultdict,Counter
input=sys.stdin.readline
def print(x):
sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
# m=pow(10,9)+7
t=int(input())
for i in range(t):
s=int(input())
s1=s
c=0
while s>9:
d=s//10
c+=d
s-=(d*10)
s+=d
# print(s)
print(s1+c)
``` | output | 1 | 80,943 | 10 | 161,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,944 | 10 | 161,888 |
Tags: math
Correct Solution:
```
for i in range(int(input())):
n=int(input())
t=0
if n%9==0:
print(n+ n//9 -1)
else:
print(n+(n//9))
``` | output | 1 | 80,944 | 10 | 161,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,945 | 10 | 161,890 |
Tags: math
Correct Solution:
```
a = int(input())
for i in range(a):
b = int(input())
sumi = 0
while True:
if b<10:
sumi = sumi + b
break
else:
part = b//2
cb = part % 10
if 5<=cb<10:
part = part + 10 - cb
elif 1<=cb<5:
part = part - cb
if 5<=part<=10:
part = 10
sumi = sumi + part
b = b-part + part//10
print(sumi)
``` | output | 1 | 80,945 | 10 | 161,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,946 | 10 | 161,892 |
Tags: math
Correct Solution:
```
for i in range(int(input())):
print(int(int(input())//0.9))
``` | output | 1 | 80,946 | 10 | 161,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,947 | 10 | 161,894 |
Tags: math
Correct Solution:
```
import sys
r_input = sys.stdin.readline
if __name__ == '__main__':
T = int(r_input())
for _ in range(T):
N = int(r_input())
total = 0
while True:
div = N // 10
N %= 10
total += div * 10
N += div
if not N // 10:
total += N
break
print(total)
``` | output | 1 | 80,947 | 10 | 161,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,948 | 10 | 161,896 |
Tags: math
Correct Solution:
```
for i in range(int(input())):
n = int(input())
print(n + (n - 1) // 9)
``` | output | 1 | 80,948 | 10 | 161,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,949 | 10 | 161,898 |
Tags: math
Correct Solution:
```
n=int(input())
i = 0
while i<n:
x = int(input())
#print(x/0.9)
sum=x
while x>=0.1:
x = x - (0.9*x)
#print(x)
sum=sum+x
print(int(sum))
i=i+1
``` | output | 1 | 80,949 | 10 | 161,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111 | instruction | 0 | 80,950 | 10 | 161,900 |
Tags: math
Correct Solution:
```
import math
testcase = int(input())
while testcase>0:
n = int(input())
x = n
spend = 0
p=0
while True:
if x<10:
spend+=x
break
spend+= x - (x%10)
cash = math.floor(x/10)
x -= x - (x%10)
x+= cash
print(spend)
testcase-=1
``` | output | 1 | 80,950 | 10 | 161,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
for _ in range(int(input())):
x = int(input())
print(x + (x - 1) // 9)
``` | instruction | 0 | 80,951 | 10 | 161,902 |
Yes | output | 1 | 80,951 | 10 | 161,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=n
res=0
while True:
if len(str(n))<2:
break
r=n//10
res+=r
n=n-10*r+r
print(a+res)
``` | instruction | 0 | 80,952 | 10 | 161,904 |
Yes | output | 1 | 80,952 | 10 | 161,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
t = int(input())
for __ in range(t):
s = int(input())
total = 0
resto = 0
while True:
if s < 10:
total += s
break
if s % 10 == 0:
total += s
s //= 10
s += resto
resto = 0
else:
s -= 1
resto += 1
print(total)
``` | instruction | 0 | 80,953 | 10 | 161,906 |
Yes | output | 1 | 80,953 | 10 | 161,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
for i in range(int(input())):
n = int(input())
ans = 0
while n >= 10:
plus = n // 10
n = n % 10 + plus
ans += plus * 10
ans += n
print(ans)
``` | instruction | 0 | 80,954 | 10 | 161,908 |
Yes | output | 1 | 80,954 | 10 | 161,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
res=0
while(n>10):
n-=10
res+=10
n+=1
print(res)
``` | instruction | 0 | 80,955 | 10 | 161,910 |
No | output | 1 | 80,955 | 10 | 161,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
if n%9==0:
print(n+int(n/10)+1)
else:
print(int(n/0.9))
``` | instruction | 0 | 80,956 | 10 | 161,912 |
No | output | 1 | 80,956 | 10 | 161,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
t = int(input())
for _ in range(t):
print(int(input()) * 10 // 9)
``` | instruction | 0 | 80,957 | 10 | 161,914 |
No | output | 1 | 80,957 | 10 | 161,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mishka wants to buy some food in the nearby shop. Initially, he has s burles on his card.
Mishka can perform the following operation any number of times (possibly, zero): choose some positive integer number 1 ≤ x ≤ s, buy food that costs exactly x burles and obtain ⌊x/10⌋ burles as a cashback (in other words, Mishka spends x burles and obtains ⌊x/10⌋ back). The operation ⌊a/b⌋ means a divided by b rounded down.
It is guaranteed that you can always buy some food that costs x for any possible value of x.
Your task is to say the maximum number of burles Mishka can spend if he buys food optimally.
For example, if Mishka has s=19 burles then the maximum number of burles he can spend is 21. Firstly, he can spend x=10 burles, obtain 1 burle as a cashback. Now he has s=10 burles, so can spend x=10 burles, obtain 1 burle as a cashback and spend it too.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The next t lines describe test cases. Each test case is given on a separate line and consists of one integer s (1 ≤ s ≤ 10^9) — the number of burles Mishka initially has.
Output
For each test case print the answer on it — the maximum number of burles Mishka can spend if he buys food optimally.
Example
Input
6
1
10
19
9876
12345
1000000000
Output
1
11
21
10973
13716
1111111111
Submitted Solution:
```
if __name__ == '__main__':
for _ in range(int(input().strip())):
n = int(input().strip())
if n % 9 == 0:
print(int(n / 0.9) - 1)
else:
print(int(n / 0.9) - 1)
``` | instruction | 0 | 80,958 | 10 | 161,916 |
No | output | 1 | 80,958 | 10 | 161,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an environmental activist at heart but the reality is harsh and you are just a cashier in a cinema. But you can still do something!
You have n tickets to sell. The price of the i-th ticket is p_i. As a teller, you have a possibility to select the order in which the tickets will be sold (i.e. a permutation of the tickets). You know that the cinema participates in two ecological restoration programs applying them to the order you chose:
* The x\% of the price of each the a-th sold ticket (a-th, 2a-th, 3a-th and so on) in the order you chose is aimed for research and spreading of renewable energy sources.
* The y\% of the price of each the b-th sold ticket (b-th, 2b-th, 3b-th and so on) in the order you chose is aimed for pollution abatement.
If the ticket is in both programs then the (x + y) \% are used for environmental activities. Also, it's known that all prices are multiples of 100, so there is no need in any rounding.
For example, if you'd like to sell tickets with prices [400, 100, 300, 200] and the cinema pays 10\% of each 2-nd sold ticket and 20\% of each 3-rd sold ticket, then arranging them in order [100, 200, 300, 400] will lead to contribution equal to 100 ⋅ 0 + 200 ⋅ 0.1 + 300 ⋅ 0.2 + 400 ⋅ 0.1 = 120. But arranging them in order [100, 300, 400, 200] will lead to 100 ⋅ 0 + 300 ⋅ 0.1 + 400 ⋅ 0.2 + 200 ⋅ 0.1 = 130.
Nature can't wait, so you decided to change the order of tickets in such a way, so that the total contribution to programs will reach at least k in minimum number of sold tickets. Or say that it's impossible to do so. In other words, find the minimum number of tickets which are needed to be sold in order to earn at least k.
Input
The first line contains a single integer q (1 ≤ q ≤ 100) — the number of independent queries. Each query consists of 5 lines.
The first line of each query contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of tickets.
The second line contains n integers p_1, p_2, ..., p_n (100 ≤ p_i ≤ 10^9, p_i mod 100 = 0) — the corresponding prices of tickets.
The third line contains two integers x and a (1 ≤ x ≤ 100, x + y ≤ 100, 1 ≤ a ≤ n) — the parameters of the first program.
The fourth line contains two integers y and b (1 ≤ y ≤ 100, x + y ≤ 100, 1 ≤ b ≤ n) — the parameters of the second program.
The fifth line contains single integer k (1 ≤ k ≤ 10^{14}) — the required total contribution.
It's guaranteed that the total number of tickets per test doesn't exceed 2 ⋅ 10^5.
Output
Print q integers — one per query.
For each query, print the minimum number of tickets you need to sell to make the total ecological contribution of at least k if you can sell tickets in any order.
If the total contribution can not be achieved selling all the tickets, print -1.
Example
Input
4
1
100
50 1
49 1
100
8
100 200 100 200 100 200 100 100
10 2
15 3
107
3
1000000000 1000000000 1000000000
50 1
50 1
3000000000
5
200 100 100 100 100
69 5
31 2
90
Output
-1
6
3
4
Note
In the first query the total contribution is equal to 50 + 49 = 99 < 100, so it's impossible to gather enough money.
In the second query you can rearrange tickets in a following way: [100, 100, 200, 200, 100, 200, 100, 100] and the total contribution from the first 6 tickets is equal to 100 ⋅ 0 + 100 ⋅ 0.1 + 200 ⋅ 0.15 + 200 ⋅ 0.1 + 100 ⋅ 0 + 200 ⋅ 0.25 = 10 + 30 + 20 + 50 = 110.
In the third query the full price of each ticket goes to the environmental activities.
In the fourth query you can rearrange tickets as [100, 200, 100, 100, 100] and the total contribution from the first 4 tickets is 100 ⋅ 0 + 200 ⋅ 0.31 + 100 ⋅ 0 + 100 ⋅ 0.31 = 62 + 31 = 93. | instruction | 0 | 81,806 | 10 | 163,612 |
Tags: binary search, greedy
Correct Solution:
```
def gcd(a, b):
if a*b == 0:
return a+b
return gcd(b, a%b)
def f():
n = int(input())
p = list(map(lambda x:int(x)//100, input().split()))
x, a = map(int, input().split())
y, b = map(int, input().split())
k = int(input())
p.sort(reverse = True)
ps = [0]
for i in range(0, n):
ps.append(ps[-1] + p[i])
i = 0
j = n
if x < y:
x, y, a, b = y, x, b, a
m = n
ab = a*b//gcd(a, b)
colab = m//ab
cola = m//a - colab
colb = m//b - colab
res = (ps[colab]*(x+y) + (ps[colab + cola] - ps[colab])*x +
(ps[colab+cola+colb] - ps[cola+colab])*y)
if res < k:
return -1
# print(p, ps, cola, colb, colab, k, res, ps[colab]*(x+y), (ps[colab + cola] - ps[colab])*x, (ps[colab+cola+colb] - ps[colab+cola])*y)
while j - i > 1:
m = (i+j)//2
colab = m//ab
cola = m//a - colab
colb = m//b - colab
res = (ps[colab]*(x+y) + (ps[colab + cola] - ps[colab])*x +
(ps[colab+cola+colb] - ps[cola+colab])*y)
if res >= k:
j = m
else:
i = m
return j
for i in range(int(input())):
print(f())
``` | output | 1 | 81,806 | 10 | 163,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an environmental activist at heart but the reality is harsh and you are just a cashier in a cinema. But you can still do something!
You have n tickets to sell. The price of the i-th ticket is p_i. As a teller, you have a possibility to select the order in which the tickets will be sold (i.e. a permutation of the tickets). You know that the cinema participates in two ecological restoration programs applying them to the order you chose:
* The x\% of the price of each the a-th sold ticket (a-th, 2a-th, 3a-th and so on) in the order you chose is aimed for research and spreading of renewable energy sources.
* The y\% of the price of each the b-th sold ticket (b-th, 2b-th, 3b-th and so on) in the order you chose is aimed for pollution abatement.
If the ticket is in both programs then the (x + y) \% are used for environmental activities. Also, it's known that all prices are multiples of 100, so there is no need in any rounding.
For example, if you'd like to sell tickets with prices [400, 100, 300, 200] and the cinema pays 10\% of each 2-nd sold ticket and 20\% of each 3-rd sold ticket, then arranging them in order [100, 200, 300, 400] will lead to contribution equal to 100 ⋅ 0 + 200 ⋅ 0.1 + 300 ⋅ 0.2 + 400 ⋅ 0.1 = 120. But arranging them in order [100, 300, 400, 200] will lead to 100 ⋅ 0 + 300 ⋅ 0.1 + 400 ⋅ 0.2 + 200 ⋅ 0.1 = 130.
Nature can't wait, so you decided to change the order of tickets in such a way, so that the total contribution to programs will reach at least k in minimum number of sold tickets. Or say that it's impossible to do so. In other words, find the minimum number of tickets which are needed to be sold in order to earn at least k.
Input
The first line contains a single integer q (1 ≤ q ≤ 100) — the number of independent queries. Each query consists of 5 lines.
The first line of each query contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of tickets.
The second line contains n integers p_1, p_2, ..., p_n (100 ≤ p_i ≤ 10^9, p_i mod 100 = 0) — the corresponding prices of tickets.
The third line contains two integers x and a (1 ≤ x ≤ 100, x + y ≤ 100, 1 ≤ a ≤ n) — the parameters of the first program.
The fourth line contains two integers y and b (1 ≤ y ≤ 100, x + y ≤ 100, 1 ≤ b ≤ n) — the parameters of the second program.
The fifth line contains single integer k (1 ≤ k ≤ 10^{14}) — the required total contribution.
It's guaranteed that the total number of tickets per test doesn't exceed 2 ⋅ 10^5.
Output
Print q integers — one per query.
For each query, print the minimum number of tickets you need to sell to make the total ecological contribution of at least k if you can sell tickets in any order.
If the total contribution can not be achieved selling all the tickets, print -1.
Example
Input
4
1
100
50 1
49 1
100
8
100 200 100 200 100 200 100 100
10 2
15 3
107
3
1000000000 1000000000 1000000000
50 1
50 1
3000000000
5
200 100 100 100 100
69 5
31 2
90
Output
-1
6
3
4
Note
In the first query the total contribution is equal to 50 + 49 = 99 < 100, so it's impossible to gather enough money.
In the second query you can rearrange tickets in a following way: [100, 100, 200, 200, 100, 200, 100, 100] and the total contribution from the first 6 tickets is equal to 100 ⋅ 0 + 100 ⋅ 0.1 + 200 ⋅ 0.15 + 200 ⋅ 0.1 + 100 ⋅ 0 + 200 ⋅ 0.25 = 10 + 30 + 20 + 50 = 110.
In the third query the full price of each ticket goes to the environmental activities.
In the fourth query you can rearrange tickets as [100, 200, 100, 100, 100] and the total contribution from the first 4 tickets is 100 ⋅ 0 + 200 ⋅ 0.31 + 100 ⋅ 0 + 100 ⋅ 0.31 = 62 + 31 = 93. | instruction | 0 | 81,807 | 10 | 163,614 |
Tags: binary search, greedy
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from math import gcd
def lcm(x,y):
return x*y//gcd(x,y)
def check(p,x,a,y,b,k,mid):
z,i,su=lcm(a,b),0,0
while i<mid//z:
su+=(p[i]*(x+y))//100
i+=1
j=0
while j<(mid//a)-(mid//z):
su+=(p[i]*x)//100
i+=1
j+=1
j = 0
while j<(mid//b)-(mid//z):
su +=(p[i]*y)//100
i += 1
j += 1
return su>=k
def solve():
n = int(input())
p= sorted(map(int, input().split()),reverse=True)
x, a = map(int, input().split())
y, b = map(int, input().split())
if y>x:
x,a,y,b=y,b,x,a
k = int(input())
lo,hi,ans=1,n,-1
while lo<=hi:
mid=(lo+hi)//2
if check(p,x,a,y,b,k,mid):
ans=mid
hi=mid-1
else:
lo=mid+1
return ans
def main():
for _ in range(int(input())):
print(solve())
# 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")
if __name__ == "__main__":
main()
``` | output | 1 | 81,807 | 10 | 163,615 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.