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.
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 | 938 | 10 | 1,876 |
Tags: binary search, greedy
Correct Solution:
```
from collections import deque
n = int(input())
for _ in range(n):
m = int(input()) # number tickets
tickets = list(map(int, input().split()))
tickets.sort(reverse=True)
aperc, ajump = map(int, input().split())
bperc, bjump = map(int, input().split())
q = int(input()) # req total
if bperc > aperc:
bperc, aperc = aperc, bperc
ajump, bjump = bjump, ajump
# a is bigger
aperc = aperc/100
bperc = bperc/100
zet = False
ans = -1
sumo = 0
da = deque()
db = deque()
dc = deque()
tc = 0
for i in range(m):
z = i+1
if z % ajump == 0 and z % bjump == 0:
if(len(da) > 0):
xx = da.pop()
dc.appendleft(xx)
if len(db) > 0:
xxx = db.pop()
da.appendleft(xxx)
db.appendleft(tickets[tc])
sumo = sumo + bperc * xx + \
(aperc-bperc)*xxx + bperc*tickets[tc]
else:
da.appendleft(tickets[tc])
sumo = sumo + bperc * xx + aperc*tickets[tc]
elif len(db) > 0:
xx = db.pop()
dc.appendleft(xx)
db.appendleft(tickets[tc])
sumo = sumo + aperc * xx + bperc*tickets[tc]
else:
dc.appendleft(tickets[tc])
sumo = sumo + (aperc+bperc) * tickets[tc]
tc += 1
elif z % ajump == 0:
if len(db) > 0:
xx = db.pop()
da.appendleft(xx)
db.appendleft(tickets[tc])
sumo = sumo + (aperc-bperc) * xx + bperc*tickets[tc]
else:
da.appendleft(tickets[tc])
sumo = sumo + aperc * tickets[tc]
tc += 1
elif z % bjump == 0:
db.appendleft(tickets[tc])
sumo = sumo + bperc * tickets[tc]
tc += 1
else:
pass
# print(f"i:{i}, sum:{sumo}")
# print(da)
# print(db)
# print(dc)
# print(" ")
if(sumo >= q and (not zet)):
zet = True
ans = i+1
break
print(ans)
``` | output | 1 | 938 | 10 | 1,877 |
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 | 939 | 10 | 1,878 |
Tags: binary search, greedy
Correct Solution:
```
import math
def check(l):
global a
global b
global p
global x
global y
global k
s = [0] * l
rec = 0
for i in range(l):
index = i + 1
if (index % a == 0):
s[i] += x
if (index % b == 0):
s[i] += y
s = sorted(s)[::-1]
for i in range(l):
rec += p[i] / 100 * s[i]
return rec >= k
for q in range(int(input())):
n = int(input())
p = list(map(int, input().split()))
x, a = map(int, input().split())
y, b = map(int, input().split())
k = int(input())
p = sorted(p)[::-1]
low = 0
high = n + 1
while low < high:
mid = (low + high) // 2
if check(mid):
high = mid
else:
low = mid + 1
if low > n:
print(-1)
else:
print(low)
# maxp = max(p)
# minp = min(p)
# maxans = maxp * (n // a) * (x / 100) + maxp * (n // b) * (y / 100)
# minans = minp * (n // a) * (x / 100) + minp * (n // b) * (y / 100)
# # print(p, maxans, minans)
# if maxans < k:
# print(-1)
# return
# ans = []
# c = 0
# for i in range(n):
# index = i + 1
# if index % a == 0 or index % b == 0:
# val = p.pop()
# ans.append(val)
# if index % a == 0 and index % b == 0:
# c += val * ((x + y) / 100)
# else:
# if index % b == 0:
# c += val * (y / 100)
# else:
# c += val * (x / 100)
# else:
# val = p.pop(0)
# ans.append(val)
# if c >= k:
# break
# # print(ans, c)
# lcm = int((a * b) / math.gcd(a, b))
# if len(ans) >= lcm and lcm != 1:
# for i in range(lcm-1, len(ans), lcm):
# start = max(i-lcm, 0)
# end = min(i, len(ans))
# index = ans.index(max(ans[:lcm-1]), 0, lcm-1)
# ans[index], ans[i] = ans[i], ans[index]
# c = 0
# for i in range(len(ans)):
# val = ans[i]
# index = i + 1
# if index % a == 0 and index % b == 0:
# c += val * ((x + y) / 100)
# else:
# if index % b == 0:
# c += val * (y / 100)
# if index % a == 0:
# c += val * (x / 100)
# if c >= k:
# ans = ans[:i+1]
# break
# # print(ans, c)
# print(len(ans))
``` | output | 1 | 939 | 10 | 1,879 |
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 | 940 | 10 | 1,880 |
Tags: binary search, greedy
Correct Solution:
```
def gcd(x, y):
if y:
return gcd(y, x % y)
return x
for _ in range(int(input())):
n = int(input())
a = [0] + sorted(map(int, input().split()))[::-1]
for i in range(n):
a[i + 1] += a[i]
p1, x1 = map(int, input().split())
p2, x2 = map(int, input().split())
if p1 < p2:
p1, x1, p2, x2 = p2, x2, p1, x1
g = gcd(x1, x2)
xx = x1 // g * x2
def f(x):
c1 = x // x1
c2 = x // x2
c3 = x // xx
ret = a[c3] * (p1 + p2)
ret += (a[c1] - a[c3]) * p1
ret += (a[c1 + c2 - c3] - a[c1]) * p2
return ret // 100
m = int(input())
lo, hi = 0, n
while lo < hi:
mid = (lo + hi) // 2
if f(mid) < m:
lo = mid + 1
else:
hi = mid
print(-1 if f(lo) < m else lo)
``` | output | 1 | 940 | 10 | 1,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
from sys import stdin,stdout
from math import gcd,sqrt
from collections import deque
input=stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\n')
L=lambda:list(R())
P=lambda x:stdout.write(x)
hg=lambda x,y:((y+x-1)//x)*x
pw=lambda x:1 if x==1 else 1+pw(x//2)
chk=lambda x:chk(x//2) if not x%2 else True if x==1 else False
N=10**10+7
def get_val(a):
sm=0
for i in range(len(a)):
sm+=a[i]*(v[i]//100)
return sm
for _ in range(I()):
n=I()
v=sorted(R(),reverse=True)
x,a=R()
y,b=R()
k=I()
p=[0]*n
for i in range(a-1,n,a):
p[i]+=x
for i in range(b-1,n,b):
p[i]+=y
l=1
r=n
ans=-1
while l<=r:
m=(l+r)//2
if get_val(sorted(p[:m],reverse=True))>=k:
ans=m
r=m-1
else:
l=m+1
print(ans)
``` | instruction | 0 | 941 | 10 | 1,882 |
Yes | output | 1 | 941 | 10 | 1,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
from math import *
def enough(f):
sum=0
for j in range(1,f+1):
if j<=f//(a*b//gcd(a,b)):
sum+=(x+y)*p[j-1]//100
#elif j<=f//(a*b//gcd(a,b))+f//a:
elif j<=f//a:
sum+=x*p[j-1]//100
#elif j<=f//(a*b//gcd(a,b))+f//a+f//b:
elif j<=f//a+f//b-f//(a*b//gcd(a,b)):
sum+=y*p[j-1]//100
if sum>=k:
return True
else:
return False
q=int(input())
for i in range(q):
n=int(input())
p=list(map(int, input().split()))
x,a=map(int,input().split())
y,b=map(int,input().split())
k=int(input())
if x<y:
x,y=y,x
a,b=b,a
p.sort(reverse=True)
if enough(n):
l=0
r=n+1
while r-l>1:
m=(r+l)//2
if enough(m):
r=m
else:
l=m
print(r)
else:
print(-1)
``` | instruction | 0 | 942 | 10 | 1,884 |
Yes | output | 1 | 942 | 10 | 1,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
import math
import sys
sys.setrecursionlimit(1000000)
def lcm(a,b):
return (a * b) // math.gcd(a,b)
def f(prices, x, a, y, b, i):
Nab = i // lcm(a,b) # i = 8, Nab = 1
Na = i // a - Nab # a=3, b=2. Na = 2-1=1
Nb = i // b - Nab # Nb = 4 - 1 = 3
result = 0
result2 = (sum(prices[:Nab]) * (x + y) + sum(prices[Nab:Nab+Na]) * x + sum(prices[Nab+Na:Nab + Na + Nb]) * y) // 100
for i in range(len(prices)):
if (Nab > 0):
result += (x + y) * (prices[i] // 100)
Nab -= 1
elif (Na > 0):
result += x * (prices[i] // 100)
Na -= 1
elif (Nb > 0):
result += y * (prices[i] // 100)
Nb -= 1
if (Nab == 0) and (Na == 0) and (Nb == 0):
break
return result
def BS(left, right):
global prices, x, a, y, b
mid = (left + right) // 2
res = f(prices, x, a, y, b, mid)
if right - left <= 1:
return -1
if res < k:
return BS(mid, right)
elif res >= k:
if f(prices, x, a, y, b, mid - 1) >= k:
return BS(left, mid - 1)
else:
return mid
q = int(input())
results = []
for j in range(q):
n = int(input())
prices = [int(i) for i in input().split()]
prices.sort(reverse=True)
xa = [int(i) for i in input().split()]
yb = [int(i) for i in input().split()]
k = int(input())
mass = [xa,yb]
mass = sorted(mass, key = lambda a: a[0], reverse=True)
x = mass[0][0]
a = mass[0][1]
y = mass[1][0]
b = mass[1][1]
left_b = 0
right_b = n + 1
while (right_b - left_b > 1):
mid = (right_b + left_b) // 2
if (f(prices, x, a, y, b, mid) >= k):
right_b = mid
else:
left_b = mid
if (right_b > n):
results.append(-1)
else:
results.append(right_b)
#Π±ΠΈΠ½Π°ΡΠ½ΡΠΉ ΠΏΠΎΠΈΡΠΊ
'''res = 0
days = 0
result = BS(1, len(prices))
print(result)'''
for q in results:
print(q)
``` | instruction | 0 | 943 | 10 | 1,886 |
Yes | output | 1 | 943 | 10 | 1,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
def line():
return map(int, input().split())
def num():
return int(input())
from itertools import repeat
def gcd(a,b):
if a<b:
a,b = b,a
while b!=0:
t=b
b=a%b
a=t
return a
def lcm(a,b):
return a*b//gcd(a,b)
q = num()
for _ in repeat(None, q):
n = num()
p = sorted(line(), reverse=True)
x,a = line()
y,b = line()
if x>y:
x,a,y,b = y,b,x,a
k = num()
u=lcm(a,b)
def f(i):
ums=i//u
ams,bms = i//a-ums, i//b-ums
return sum(p[:ums])*(x+y)+sum(p[ums:ums+bms])*y+sum(p[ums+bms:ums+bms+ams])*x
def cool(e):
s = 1
ans=-1
while s<=e:
m = (s+e)//2
d = f(m)
if d<k*100:
s=m+1
else:
ans=m
e=m-1
return ans
print(cool(n+1))
``` | instruction | 0 | 944 | 10 | 1,888 |
Yes | output | 1 | 944 | 10 | 1,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
def solve():
n = int(input())
t = list(map(int,input().split()))
x,a = map(int,input().split())
y,b = map(int,input().split())
k = int(input())
if x<y:
aux = x
x = y
y = aux
aux = a
a = b
b = aux
ans = [0]*(n)
for i in range(n):
if (i+1)%a==0:
ans[i] += x
if (i+1)%b==0:
ans[i] += y
t.append(0)
t.sort()
t.reverse()
for i in range(1,n):
t[i]+=t[i-1]
one = two = three = cur = 0
for i in range(n):
cur = 0
if ans[i]==x+y:
one+=1
if ans[i]==x:
two+=1
if ans[i]==y:
three+=1
if one>0:
cur += (t[one-1])*(y+x)//100
if two>0:
cur += (t[two+one-1]-t[one-1])*(x)//100
if three>0:
cur += (t[two+one+three-1]-t[two+one-1])*(y)//100
if cur>=k:
print(i+1)
return
print(-1)
def main():
t = int(input())
for _ in range(t):
solve()
main()
``` | instruction | 0 | 945 | 10 | 1,890 |
No | output | 1 | 945 | 10 | 1,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
q = int(input())
def answer(amount, prices, prog1, prog2, limit):
prices = prices[0].split()
prog1 = prog1[0].split()
prog2 = prog2[0].split()
pries_new = sorted(prices, reverse=True)
prices_high = []
cash = 0
if int(prog1[0]) * (amount // int(prog1[1])) > int(prog2[0]) * (amount // int(prog2[1])):
base = int(amount // int(prog1[1]))
for g in range(1, len(prices) + 1):
if g % int(prog1[1]) == 0:
prices_high.append(pries_new.pop(0))
elif g % int(prog2[1]) == 0:
prices_high.append(pries_new.pop(0))
else:
prices_high.append(pries_new.pop(-1))
take1 = 0
take2 = 0
for h in range(1, amount + 1):
if h % int(prog1[1]) == 0:
cash += int(prog1[0]) * int(prices_high[take1]) // 100
take1 += 1
base -= 1
if h % int(prog2[1]) == 0:
cash += int(prog2[0]) * int(prices_high[take2 + base]) // 100
take2 += 1
if cash >= limit:
return h
return -1
else:
base = int(amount // int(prog2[1]))
for g in range(1, len(prices) + 1):
if g % int(prog2[1]) == 0:
prices_high.append(pries_new.pop(0))
elif g % int(prog1[1]) == 0:
prices_high.append(pries_new.pop(0))
else:
prices_high.append(pries_new.pop(-1))
take1 = 0
take2 = 0
for h in range(1, amount + 1):
if h % int(prog1[1]) == 0:
cash += int(prog1[0]) * int(prices_high[take1]) // 100
base -= 1
take1 +=1
if h % int(prog2[1]) == 0:
cash += int(prog2[0]) * int(prices_high[take2 + base]) // 100
take2 += 1
if cash >= limit:
return h
return -1
for i in range(q):
print(answer(int(input()), [input()], [input()], [input()], int(input())))
``` | instruction | 0 | 946 | 10 | 1,892 |
No | output | 1 | 946 | 10 | 1,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
u = list(map(int, input().split()))
u.sort()
for i in range(n):
u[i] //= 100
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())
sm = 0
ind = n - 1
last_x = -1
last_y = -1
ans = [0] * n
ok = True
for i in range(n):
i1 = i + 1
if i1 % a != 0 and i1 % b != 0:
ans[i] = sm
#print("#", end = ' ')
elif i1 % a != 0:
if last_y == -1:
last_y = ind
sm += u[ind] * y
ind -= 1
elif i1 % b != 0:
if last_y == -1:
if last_x == -1:
last_x = ind
sm += u[ind] * x
ind -= 1
else:
if last_x == -1:
last_x = last_y
sm += u[last_y] * x
sm -= u[last_y] * y
last_y -= 1
sm += u[ind] * y
ind -= 1
else:
if last_x == -1 and last_y == 1:
sm += u[ind] * (x + y)
ind -= 1
elif last_x == -1:
sm += u[last_y] * x
last_y -= 1
sm += u[ind] * y
ind -= 1
elif last_y == -1:
sm += u[last_x] * y
last_x -= 1
sm + u[ind] * x
ind -= 1
else:
sm += u[last_x] * y
last_x -= 1
sm += u[last_y] * x
sm -= u[last_y] * y
last_y -= 1
sm += u[ind] * y
ind -= 1
ans[i] = sm
if sm >= k:
print(i1)
ok = False
break
if ok:
print(-1)
``` | instruction | 0 | 947 | 10 | 1,894 |
No | output | 1 | 947 | 10 | 1,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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.
Submitted Solution:
```
import math
def solve():
n = int(input())
p = list(map(int, input().split()))
x, a = map(int, input().split())
y, b = map(int, input().split())
k = int(input())
# print()
p = sorted(p)
maxp = max(p)
minp = min(p)
maxans = maxp * (n // a) * (x / 100) + maxp * (n // b) * (y / 100)
minans = minp * (n // a) * (x / 100) + minp * (n // b) * (y / 100)
# print(p, maxans, minans)
if maxans < k:
print(-1)
return
ans = []
c = 0
for i in range(n):
index = i + 1
if index % a == 0 or index % b == 0:
val = p.pop()
ans.append(val)
if index % a == 0 and index % b == 0:
c += val * ((x + y) / 100)
else:
if index % b == 0:
c += val * (y / 100)
else:
c += val * (x / 100)
else:
val = p.pop(0)
ans.append(val)
if c >= k:
break
print(ans, c)
lcm = int((a * b) / math.gcd(a, b))
if len(ans) >= lcm and lcm != 1:
for i in range(lcm-1, len(ans), lcm):
start = max(i-lcm, 0)
end = min(i, len(ans))
index = ans.index(max(ans[start:end]), start, end)
ans[index], ans[i] = ans[i], ans[index]
print(ans)
c = 0
for i in range(len(ans)):
val = ans[i]
index = i + 1
if index % a == 0 and index % b == 0:
c += val * ((x + y) / 100)
else:
if index % b == 0:
c += val * (y / 100)
if index % a == 0:
c += val * (x / 100)
if c >= k:
ans = ans[:i+1]
break
print(ans, c)
print(len(ans))
for q in range(int(input())):
# print()
solve()
``` | instruction | 0 | 948 | 10 | 1,896 |
No | output | 1 | 948 | 10 | 1,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 965 | 10 | 1,930 |
Tags: dp, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
n, p, k = map(int, input().strip().split())
A = list(sorted([int(x) for x in input().strip().split()]))
dp = [0] * k
dp[0] = 0
r = 0
for i in range(1, k):
dp[i] = A[i-1] + dp[i-1]
if (dp[i] <= p):
r = i
for i in range(k):
s = dp[i]
j = i+k
while j <= n and s + A[j-1] <= p:
r = max(j,r)
s += A[j-1]
j = j+k
print(r)
``` | output | 1 | 965 | 10 | 1,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 966 | 10 | 1,932 |
Tags: dp, greedy, sortings
Correct Solution:
```
t=int(input())
import sys
input=sys.stdin.readline
while t>0:
t-=1
n,p,k=map(int,input().split())
a=[int(x) for x in input().split()]
a.sort()
dp=[0 for i in range(n+1)]
for i in range(1,n+1):
if i-k>=0:
dp[i]=a[i-1]+dp[i-k]
else:
dp[i]=dp[i-1]+a[i-1]
flag=0
z=0
for i in range(1,n+1):
if dp[i]>p:
pass
else:
z=i
print(z)
``` | output | 1 | 966 | 10 | 1,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 967 | 10 | 1,934 |
Tags: dp, greedy, sortings
Correct Solution:
```
t=int(input())
for _ in range(t):
n,p,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
ans=0
dp=[0]*n
for i in range(n):
if i>=k-1:
dp[i]=a[i]+dp[i-k]
if dp[i]<=p:
ans=i+1
else:
dp[i]=a[i]+dp[i-1]
if dp[i]<=p:
ans=max(ans,i+1)
print(ans)
``` | output | 1 | 967 | 10 | 1,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 968 | 10 | 1,936 |
Tags: dp, greedy, sortings
Correct Solution:
```
from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *
####################################---fast-input-output----#########################################
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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:
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")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
def input(): return stdin.readline().strip()
def fast(): return stdin.readline().strip()
def zzz(): return [int(i) for i in fast().split()]
z, zz = fast, lambda: (map(int, z().split()))
szz, graph, mod, szzz = lambda: sorted(
zz()), {}, 10**9 + 7, lambda: sorted(zzz())
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def output(answer, end='\n'): stdout.write(str(answer) + end)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try
"""
##################################################---START-CODING---###############################################
# num = int(z())
# for _ in range(num):
# n,p,k=zzz()
# arr = szzz()
# dp=[0]*n
# for i in range(k):
# dp[i]=arr[i]+dp[i-1]
# for j in range(k,n):
# dp[j]=(dp[j-k]+arr[j])
# print(bisect(dp,p))
num = int(z())
for _ in range(num):
n, p, k = zzz()
arr = szzz()
dp = [0]*(n+1)
dp[0] = 0
for i in range(1, n+1):
dp[i] = dp[i-1]+arr[i-1]
if i>=k:
dp[i] = dp[i-k]+arr[i-1]
# print(dp)
for i in range(n, -1, -1):
if dp[i]<=p:
print(i)
break
``` | output | 1 | 968 | 10 | 1,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 969 | 10 | 1,938 |
Tags: dp, greedy, sortings
Correct Solution:
```
t = int(input())
for i in range(t):
n, p, k = map(int, input().split())
goods = list(map(int, input().split()))
goods.sort()
if goods[0] > p:
print(0)
continue
elif len(goods) == 1:
print(1)
continue
sums = [[0]]
for i in range(k - 1):
sums.append([sums[-1][0] + goods[i]])
#print(sums)
for i in range(k, n + 1):
sums[i % k].append(sums[i % k][-1] + goods[i - 1])
#print("Sums is", sums)
for i in range(n - 1, -1, -1):
#print("i =", i)
cost = sums[(i + 1) % k][(i + 1) // k]
if cost <= p:
print(i + 1)
break
``` | output | 1 | 969 | 10 | 1,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 970 | 10 | 1,940 |
Tags: dp, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
n, p, k = map(int, input().split())
a = [int(i) for i in input().split()]
a.sort()
prefix_sums = [0]
for a_i in a[:k]:
prefix_sums.append(a_i + prefix_sums[-1])
max_goods = 0
for ind, start_sum in enumerate(prefix_sums):
balance = p - start_sum
local_goods = ind
while ind + k <= n and a[ind + k - 1] <= balance:
balance -= a[ind + k - 1]
ind += k
local_goods += k
if balance >= 0:
max_goods = max(max_goods, local_goods)
print(max_goods)
``` | output | 1 | 970 | 10 | 1,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 971 | 10 | 1,942 |
Tags: dp, greedy, sortings
Correct Solution:
```
T = int(input())
INF = float('inf')
for _ in range(T):
N,P,K = map(int, input().split())
arr = sorted([int(x) for x in input().split()])
dp = [None] * N
if arr[0] > P:
print(0)
continue
else:
dp[0] = P-arr[0]
for i in range(1,N):
a = dp[i-1]
b = dp[i-K] if i-K >= 0 else (P if i-K == -1 else -INF)
dp[i] = max(a,b) - arr[i]
best = 0
for i,x in enumerate(dp):
if x >= 0:
best = i
print(best+1)
``` | output | 1 | 971 | 10 | 1,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5 | instruction | 0 | 972 | 10 | 1,944 |
Tags: dp, greedy, sortings
Correct Solution:
```
def idp(a,dp,i,k):
if (i-k) >= 0:
return min(a[i]+dp[i-1], a[i]+dp[i-k])
else:
return a[i]+dp[i-1]
t = int(input())
for tc in range(t):
n,p,k = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
dp = [0]*n
dp[0] = a[0]
for i in range(0,k-1):
dp[i] = a[i]+dp[i-1]
dp[k-1] = a[k-1]
for i in range(k,n):
dp[i] = idp(a,dp,i,k)
bst = 0
for i in range(n):
if dp[i] <= p:
bst = i+1
print(bst)
``` | output | 1 | 972 | 10 | 1,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
from sys import stdin
from collections import deque
mod = 10**9 + 7
import sys
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
t = int(input())
for _ in range(t):
n,p,k = map(int,input().split())
l = list(map(int,input().split()))
l.sort()
dp = [0]*(n+10)
ans = 0
for i in range(k-1):
dp[i] = l[i] + dp[i-1]
if dp[i]<=p:
ans = i+1
for i in range(k-1,n):
dp[i] = l[i] + dp[i-k]
if dp[i]<=p:
ans = i+1
print(ans)
``` | instruction | 0 | 973 | 10 | 1,946 |
Yes | output | 1 | 973 | 10 | 1,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
t =int(input())
while t!=0:
n,p,k = map(int,input().split())
list1 = list(map(int,input().split()))
list1.sort()
cost = [0]*(n+1)
for i in range(1,n+1):
if i<k:
cost[i] = cost[i-1]+list1[i-1]
else:
cost[i] = cost[i-k]+list1[i-1]
ans=0
for i in range(n+1):
if cost[i]<=p:
ans=i
print(ans)
t-=1
``` | instruction | 0 | 974 | 10 | 1,948 |
Yes | output | 1 | 974 | 10 | 1,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
# in competition approach: timed out
# n rows and p + 1 columns
# dp[i][j] = how many goods vasya can buy from subset a_i - a_n starting with j coins
# better approach
# array of size n
# dp[i] is cheapest cost to buy first i + 1 goods
# base case: for all j in first k -> dp[j] = a_j + a_j-1
# return i + 1 of largest dp[i] <= p
for j in range(int(input())):
n, p, k = [int(x) for x in input().split()]
goods = [int(x) for x in input().split()]
goods.sort()
dp = [0] * n
dp[0] = goods[0]
if dp[0] > p:
print(0)
continue
for i in range(1, k - 1):
dp[i] = goods[i] + dp[i - 1]
for i in range(k - 1, n):
dp[i] = goods[i] + min(dp[i - 1], dp[i - k])
res = 0
for i in range(0, n):
if dp[i] <= p:
res = i + 1
print(res)
``` | instruction | 0 | 975 | 10 | 1,950 |
Yes | output | 1 | 975 | 10 | 1,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
T = int(input())
for _ in range(T):
n, p, k = map(int, input().split())
li = list(map(int, input().split()))
li.sort()
pref = 0
ans = 0
sum = 0
for i in range(k):
sum = pref
if sum > p:
break
cnt = i
for j in range(i+k-1, n, k):
if sum + li[j] <= p:
cnt += k
sum += li[j]
else:
break
pref += li[i]
ans = max(cnt, ans)
print(ans)
``` | instruction | 0 | 976 | 10 | 1,952 |
Yes | output | 1 | 976 | 10 | 1,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
for _ in range(int(input())):
n, p, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
c = [0] * k
co = p
for j in range(k-1, len(a), k):
if a[j] <= co:
co -= a[j]
c[0] += k
else:
break
for i in range(1, k):
co = p
if a[i-1] <= co:
c[i] += i
co -= a[i-1]
else:
continue
for j in range(k+i-1, len(a), k):
if a[j] <= co:
co -= a[j]
c[i] += k
else:
break
print(max(c))
``` | instruction | 0 | 977 | 10 | 1,954 |
No | output | 1 | 977 | 10 | 1,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
import sys
import math
from collections import defaultdict,Counter
import bisect
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
n,p,k=map(int,input().split())
a=list(map(int,input().split()))
pre=[0]*(n+1)
pre[0]=a[0]
for j in range(1,n):
pre[j]=pre[j-1]+a[j]
p1=p
main=0
a.sort()
for kk in range(k):
ans=0
if p>=pre[kk-1]:
p-=pre[kk-1]
ans+=kk
for j in range(k-1+kk,n,k):
if p-a[j]>=0:
ans+=k
p-=a[j]
else:
for jj in range(j-k+1,j):
if p>=a[jj]:
p-=a[jj]
ans+=1
else:
break
break
main=max(main,ans)
p=p1
else:
break
print(main)
``` | instruction | 0 | 978 | 10 | 1,956 |
No | output | 1 | 978 | 10 | 1,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
from collections import defaultdict, Counter
from bisect import bisect, bisect_left
from math import sqrt, gcd, ceil, factorial
from heapq import heapify, heappush, heappop
MOD = 10**9 + 7
inf = float("inf")
ans_ = []
def nin():return int(input())
def ninf():return int(file.readline())
def st():return (input().strip())
def stf():return (file.readline().strip())
def read(): return list(map(int, input().strip().split()))
def readf():return list(map(int, file.readline().strip().split()))
ans_ = []
# file = open("input.txt", "r")
def solve():
for _ in range(nin()):
n,p,k = read(); arr = read()
arr.sort()
pref = [0]*n
pref[0] = arr[0]
ans = 0
for i in range(n):
pref[i] = max(pref[i-1], arr[i]+(pref[i-k] if i >= k else 0))
if pref[i] <= p:
ans = max(ans, i+1)
else:
break
print(ans)
# file.close()
solve()
for i in ans_:print(i)
``` | instruction | 0 | 979 | 10 | 1,958 |
No | output | 1 | 979 | 10 | 1,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of this problem. The only difference is the constraint on k β the number of gifts in the offer. In this version: 2 β€ k β€ n.
Vasya came to the store to buy goods for his friends for the New Year. It turned out that he was very lucky β today the offer "k of goods for the price of one" is held in store.
Using this offer, Vasya can buy exactly k of any goods, paying only for the most expensive of them. Vasya decided to take this opportunity and buy as many goods as possible for his friends with the money he has.
More formally, for each good, its price is determined by a_i β the number of coins it costs. Initially, Vasya has p coins. He wants to buy the maximum number of goods. Vasya can perform one of the following operations as many times as necessary:
* Vasya can buy one good with the index i if he currently has enough coins (i.e p β₯ a_i). After buying this good, the number of Vasya's coins will decrease by a_i, (i.e it becomes p := p - a_i).
* Vasya can buy a good with the index i, and also choose exactly k-1 goods, the price of which does not exceed a_i, if he currently has enough coins (i.e p β₯ a_i). Thus, he buys all these k goods, and his number of coins decreases by a_i (i.e it becomes p := p - a_i).
Please note that each good can be bought no more than once.
For example, if the store now has n=5 goods worth a_1=2, a_2=4, a_3=3, a_4=5, a_5=7, respectively, k=2, and Vasya has 6 coins, then he can buy 3 goods. A good with the index 1 will be bought by Vasya without using the offer and he will pay 2 coins. Goods with the indices 2 and 3 Vasya will buy using the offer and he will pay 4 coins. It can be proved that Vasya can not buy more goods with six coins.
Help Vasya to find out the maximum number of goods he can buy.
Input
The first line contains one integer t (1 β€ t β€ 10^4) β the number of test cases in the test.
The next lines contain a description of t test cases.
The first line of each test case contains three integers n, p, k (2 β€ n β€ 2 β
10^5, 1 β€ p β€ 2β
10^9, 2 β€ k β€ n) β the number of goods in the store, the number of coins Vasya has and the number of goods that can be bought by the price of the most expensive of them.
The second line of each test case contains n integers a_i (1 β€ a_i β€ 10^4) β the prices of goods.
It is guaranteed that the sum of n for all test cases does not exceed 2 β
10^5.
Output
For each test case in a separate line print one integer m β the maximum number of goods that Vasya can buy.
Example
Input
8
5 6 2
2 4 3 5 7
5 11 2
2 4 3 5 7
3 2 3
4 2 6
5 2 3
10 1 3 9 2
2 10000 2
10000 10000
2 9999 2
10000 10000
4 6 4
3 2 3 2
5 5 3
1 2 2 1 2
Output
3
4
1
1
2
0
4
5
Submitted Solution:
```
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def check(x, p):
i = x - 1
while i > -1 and a[i] <= p:
p -= a[i]
if i >= k - 1:
i -= k
else:
i -= 1
return i <= -1
for _ in range(int(input())):
n, p, k = map(int, input().split())
a = sorted(map(int, input().split()))
if check(k, p):
L = k
R = n + 1
else:
L = 0
R = k + 1
while R - L > 1:
mid = (L + R) >> 1
if check(mid, p):
L = mid
else:
R = mid
print(L)
``` | instruction | 0 | 980 | 10 | 1,960 |
No | output | 1 | 980 | 10 | 1,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n, d = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
m = int(input())
print(sum(arr[:m]) if m <= n else sum(arr) - d * (m-n))
``` | instruction | 0 | 1,188 | 10 | 2,376 |
Yes | output | 1 | 1,188 | 10 | 2,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n, d = tuple(map(int, str.split(input())))
a = sorted(map(int, str.split(input())))
m = int(input())
print(sum(a[:min(m, n)]) - max(0, m - n) * d)
``` | instruction | 0 | 1,189 | 10 | 2,378 |
Yes | output | 1 | 1,189 | 10 | 2,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n,d = map(int,input().split())
l = list(map(int,input().split()))
m = int(input())
l.sort()
if(m>=n):
print(sum(l[:n])-(m-n)*d)
else:
print(sum(l[:m]))
``` | instruction | 0 | 1,190 | 10 | 2,380 |
Yes | output | 1 | 1,190 | 10 | 2,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n,d=map(int,input().split())
l=list(map(int,input().split()))
m=int(input())
if n<m:
print(sum(l)-d*(m-n))
else:
l.sort()
print(sum(l[:m]))
``` | instruction | 0 | 1,191 | 10 | 2,382 |
Yes | output | 1 | 1,191 | 10 | 2,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n,d=(int(i) for i in input().split())
l=[int(i) for i in input().split()]
m=int(input())
print(sum(l)-(m-n)*d)
``` | instruction | 0 | 1,192 | 10 | 2,384 |
No | output | 1 | 1,192 | 10 | 2,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n, d = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
m = int(input())
ans = sum(a[:m])
ans -= (m-n)*d
print(ans)
``` | instruction | 0 | 1,193 | 10 | 2,386 |
No | output | 1 | 1,193 | 10 | 2,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n,d=map(int,input().split())
a=list(map(int,input().split()))
m=int(input())
sumi=sum(a)
if n<m:
print(sumi-(m-n)*d)
else:
print(sumi)
``` | instruction | 0 | 1,194 | 10 | 2,388 |
No | output | 1 | 1,194 | 10 | 2,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja owns a restaurant for n people. The restaurant hall has a coat rack with n hooks. Each restaurant visitor can use a hook to hang his clothes on it. Using the i-th hook costs ai rubles. Only one person can hang clothes on one hook.
Tonight Sereja expects m guests in the restaurant. Naturally, each guest wants to hang his clothes on an available hook with minimum price (if there are multiple such hooks, he chooses any of them). However if the moment a guest arrives the rack has no available hooks, Sereja must pay a d ruble fine to the guest.
Help Sereja find out the profit in rubles (possibly negative) that he will get tonight. You can assume that before the guests arrive, all hooks on the rack are available, all guests come at different time, nobody besides the m guests is visiting Sereja's restaurant tonight.
Input
The first line contains two integers n and d (1 β€ n, d β€ 100). The next line contains integers a1, a2, ..., an (1 β€ ai β€ 100). The third line contains integer m (1 β€ m β€ 100).
Output
In a single line print a single integer β the answer to the problem.
Examples
Input
2 1
2 1
2
Output
3
Input
2 1
2 1
10
Output
-5
Note
In the first test both hooks will be used, so Sereja gets 1 + 2 = 3 rubles.
In the second test both hooks will be used but Sereja pays a fine 8 times, so the answer is 3 - 8 = - 5.
Submitted Solution:
```
n, d = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
m = int(input())
ans = 0
for i in a:
ans += i
if n < m:
ans -= (m - n) * d
print(ans);
``` | instruction | 0 | 1,195 | 10 | 2,390 |
No | output | 1 | 1,195 | 10 | 2,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement. | instruction | 0 | 1,285 | 10 | 2,570 |
Tags: geometry
Correct Solution:
```
def get_bounds(points):
if len(points) == 1:
return points[:]
points.sort()
bounds = [points[0], points[1]]
for xi, yi in points[2:]:
while len(bounds) > 1 and not is_convex(bounds, xi, yi):
del bounds[-1]
bounds.append((xi, yi))
return bounds
def is_convex(bounds, x2, y2):
x1, y1 = bounds[-1]
x0, y0 = bounds[-2]
return (x1 - x0) * (y2 - y1) < (y1 - y0) * (x2 - x1)
def read_data():
n, p, q = map(int, input().split())
ABs = []
for i in range(n):
a, b = map(int, input().split())
ABs.append((a, b))
return n, p, q, ABs
def solve(n, p, q, ABs):
'''
min sum(ds)
s.t. sum(ds[i] * As[i]) >= p and sum(ds[i] * Bs[i]) >= q
'''
bounds = get_bounds(ABs)
a0, b0 = bounds[0]
if len(bounds) == 1:
return max(p/a0, q/b0)
record = float('Inf')
for a1, b1 in bounds[1:]:
steps = min(max(p/a0, q/b0), max(p/a1, q/b1))
den = a0 * b1 - b0 * a1
if den != 0:
r0 = (b1 * p - a1 * q)/den
r1 = - (b0 * p - a0 * q)/den
if r0 > 0 and r1 > 0:
steps = min(steps, r0 + r1)
a0 = a1
b0 = b1
record = min(record, steps)
return record
n, p, q, ABs = read_data()
print(solve(n, p, q, ABs))
``` | output | 1 | 1,285 | 10 | 2,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement. | instruction | 0 | 1,286 | 10 | 2,572 |
Tags: geometry
Correct Solution:
```
from fractions import Fraction
def higher(x1, y1, x2, y2):
if x1 == 0:
if x2 == 0:
return
def min_days(p, q, pr):
ma = max(a for a, b in pr)
mb = max(b for a, b in pr)
pr.sort(key=lambda t: (t[0], -t[1]))
ch = [(0, mb)]
for a, b in pr:
if a == ch[-1][0]:
continue
while (
len(ch) >= 2
and ((b-ch[-2][1])*(ch[-1][0]-ch[-2][0])
>= (a-ch[-2][0])*(ch[-1][1]-ch[-2][1]))
):
ch.pop()
ch.append((a, b))
ch.append((ma, 0))
a1, b1 = None, None
for a2, b2 in ch:
if a1 is not None:
d = (a2-a1)*q + (b1-b2)*p
s = Fraction(b1*p-a1*q, d)
if 0 <= s <= 1:
return Fraction(d, a2*b1 - a1*b2)
a1, b1 = a2, b2
if __name__ == '__main__':
n, p, q = map(int, input().split())
pr = []
for _ in range(n):
a, b = map(int, input().split())
pr.append((a, b))
print("{:.7f}".format(float(min_days(p, q, pr))))
``` | output | 1 | 1,286 | 10 | 2,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement. | instruction | 0 | 1,287 | 10 | 2,574 |
Tags: geometry
Correct Solution:
```
def get_bounds(points):
if len(points) == 1:
return points[:]
points.sort()
bounds = [points[0], points[1]]
for xi, yi in points[2:]:
while len(bounds) > 1 and not is_convex(bounds, xi, yi):
del bounds[-1]
bounds.append((xi, yi))
return bounds
def is_convex(bounds, x2, y2):
x1, y1 = bounds[-1]
x0, y0 = bounds[-2]
return (x1 - x0) * (y2 - y1) < (y1 - y0) * (x2 - x1)
def read_data():
n, p, q = map(int, input().split())
ABs = []
for i in range(n):
a, b = map(int, input().split())
ABs.append((a, b))
return n, p, q, ABs
def solve(n, p, q, ABs):
'''
min sum(ds)
s.t. sum(ds[i] * As[i]) >= p and sum(ds[i] * Bs[i]) >= q
'''
bounds = get_bounds(ABs)
a0, b0 = bounds[0]
if len(bounds) == 1:
return max(p/a0, q/b0)
record = float('Inf')
for a1, b1 in bounds[1:]:
steps = min(max(p/a0, q/b0), max(p/a1, q/b1))
den = a0 * b1 - b0 * a1
if den != 0:
r0 = (b1 * p - a1 * q)/den
r1 = - (b0 * p - a0 * q)/den
if r0 > 0 and r1 > 0:
steps = min(steps, r0 + r1)
a0 = a1
b0 = b1
record = min(record, steps)
return record
n, p, q, ABs = read_data()
print(solve(n, p, q, ABs))
# Made By Mostafa_Khaled
``` | output | 1 | 1,287 | 10 | 2,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
Submitted Solution:
```
__author__ = 'Utena'
import operator
def v(x,y):#calculate the time when given a1,b1,a2,b2
return(((x[0]-y[0])*q-(x[1]-y[1])*p)/(x[0]*y[1]-x[1]*y[0]))
n,p,q=map(int,input().split())
s=[list(map(int,input().split()))for i in range(n)]
s1=[]
s=sorted(s,key=operator.itemgetter(0,1),reverse=0)
s2=[]
if len(s)==1:
print(min(p/s[0][0],q/s[0][1]))
exit(0)
for j in range(n-1):
if s[j][0]<s[j+1][0]:
s1.append(s[j])
s1.append(s[-1])#get the max b
if len(s1)==1:
print(max(p/s1[0][0],q/s1[0][1]))
exit(0)
s1=sorted(s1,key=operator.itemgetter(1,0),reverse=0)
for j in range(len(s1)-1):
if s1[j][1]<s1[j+1][1]:
s2.append(s[j])
s2.append(s[-1])#get the max a
s=[[0,0]]
s2=sorted(s2,key=operator.itemgetter(1),reverse=1)
for k in range(len(s2)):
if s2[k][0]>s[-1][0]:s.append(s2[k])
s.remove(s[0])
if len(s)==1:
print(max(p/s[0][0],q/s[0][1]))
elif len(s)==2:
print(v(s[0],s[1]))
else:
temp=[s[0],s[1]]
for a in s[2:]:
t=v(temp[0],temp[1])
t1=v(a,temp[0])
t2=v(a,temp[1])
if min(t,t1,t2)==t1:temp[1]=a
elif min(t,t1,t2)==t2:temp[0]=a
else:continue
print(v(temp[0],temp[1]))
``` | instruction | 0 | 1,288 | 10 | 2,576 |
No | output | 1 | 1,288 | 10 | 2,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
Submitted Solution:
```
OP_DECIMAL_PLACES = 10
ZERO = 1/OP_DECIMAL_PLACES
class Feasible(Exception):
pass
class Infeasible(Exception):
pass
class Unbounded(Exception):
pass
class LinearProgramming():
def __init__(self, rows, columns, c, Ab, auxiliary=False):
self.__rows = rows
self.__columns = columns
self.__op_matrix_len = rows
c = list(map(lambda x: -x, c))
self.__make_tableau(c, Ab)
self.__add_operation_matrix()
# Set b values to positive
if(auxiliary):
# logging.info("AUXILIARY")
neg_entries = self.__get_b_negative_entries_index()
for i in neg_entries:
self.__tableau[i] = list(map(lambda x: -x, self.__tableau[i]))
basis = [-1]*self.__rows
for i in range(1, self.__rows+1):
for index,val in enumerate(self.__tableau[i][self.__op_matrix_len:-1]):
if (val == 1):
just_zeroes = 0
for k in range(self.__rows+1):
if(self.__tableau[k][index+self.__op_matrix_len] != 0):
just_zeroes += 1
if(just_zeroes == 1):
basis[i-1] = index+self.__op_matrix_len
if (not any(x == -1 for x in basis)):
self.__basis = basis
else:
self.__basis = self.__make_canonical_tableau()
# Initialization for auxiliary tableau
if (auxiliary):
for index,base in enumerate(self.__basis):
self.__tableau[0][base] = 1
for index,base in enumerate(self.__basis):
self.__do_pivoting(index+1, base)
# logging.info("ROWS %i COLS %i"%(rows, columns))
# logging.info("Tableau")
# logging.info(pformat(self.__tableau, width=250))
# logging.info("Basis")
# logging.info(pformat(self.__basis, width = 250))
# logging.info("LP created")
def solve(self):
# Auxiliary LP
neg_entries = self.__get_b_negative_entries_index()
if (len(neg_entries) > 0):
# logging.info("Auxiliary LP")
message = self.__solve_aux_lp()
if(message['status'] == "Infeasible"):
return message
# logging.info("Feasible Aux LP")
try:
while(True):
col = self.__get_first_c_negative_entry()
row = self.__choose_new_basis_at_col(col)
self.__do_pivoting(row, col)
except Feasible:
# logging.info("Feasible")
message = {
"status": "Feasible",
"optimal_value":self.__get_optimal_value(),
"solution": self.__get_feasible_solution(),
"certificate": self.__get_optimal_certificate(),
"basis": self.__get_basis()
}
except Unbounded as e:
col = e.args[0]
# logging.info("Unbounded")
message = {
"status": "Unbounded",
"optimal_value":self.__get_optimal_value(),
"solution": self.__get_feasible_solution(),
"certificate": self.__get_unbounded_certificate(col),
"basis": self.__get_basis()
}
finally:
return message
def __solve_aux_lp(self):
aux_lp = self.__make_auxiliary_tableau()
message = aux_lp.solve()
if(message['status'] == "Feasible"):
if(message['optimal_value'] == 0):
aux_basis = message['basis']
for index, base in enumerate(aux_basis):
if(self.__is_variable_from_original_problem(base)):
self.__do_pivoting(index+1, base)
elif (message['optimal_value'] < 0):
message = {
"status": "Infeasible",
"certificate": message['certificate']
}
return message
def __make_tableau(self, c, Ab):
self.__tableau = c + [0]
self.__tableau = [self.__tableau] + Ab
def __add_operation_matrix(self):
zeroes = [0]*self.__rows
self.__tableau[0] = zeroes + self.__tableau[0]
for i in range(self.__op_matrix_len):
self.__tableau[i+1] = zeroes + self.__tableau[i+1]
self.__tableau[i+1][i] = 1
def __make_canonical_tableau(self):
zeroes = [0]*self.__rows
self.__tableau[0] = self.__tableau[0][:-1] + zeroes +self.__tableau[0][-1:]
for i in range(self.__rows):
zeroes = [0]*self.__rows
zeroes[i] = 1
self.__tableau[i+1] = self.__tableau[i+1][:-1] + zeroes +self.__tableau[i+1][-1:]
basis = [i for i in range(self.__op_matrix_len+self.__columns, self.__op_matrix_len*2+self.__columns)]
return basis
def __make_auxiliary_tableau(self):
rows = self.__rows
columns = self.__columns + self.__rows
c = [0]*columns
c = list(map(lambda x: -x, c))
Ab = [self.__tableau[i][self.__op_matrix_len:] for i in range(1, self.__rows+1)]
auxiliary = True
lp = LinearProgramming(rows, columns, c, Ab, auxiliary)
return lp
def __do_pivoting(self, row, column):
# logging.info("Pivoting at %i %i"%(row, column))
self.__basis[row-1] = column
multiplier = 1/self.__tableau[row][column]
self.__tableau[row] = list(map(lambda x: round(x*multiplier, OP_DECIMAL_PLACES), self.__tableau[row]))
for index in (i for j in (range(row), range(row+1, self.__rows+1)) for i in j):
multiplier = -self.__tableau[index][column]
line_multiplier = list(map(lambda x: x*multiplier, self.__tableau[row]))
self.__tableau[index] = list(map(lambda x,y: round(x+y,OP_DECIMAL_PLACES), self.__tableau[index], line_multiplier))
self.__tableau[index] = list(map(lambda x: 0 if (abs(x) < ZERO) else x, self.__tableau[index]))
# logging.info("Tableau")
# logging.info(pformat(self.__tableau, width=250))
# logging.info("Basis")
# logging.info(pformat(self.__basis, width = 250))
def __get_first_c_negative_entry(self):
try:
# logging.info("Choosing c negative entry")
col = self.__op_matrix_len + self.__tableau[0][self.__op_matrix_len:-1].index(next(filter(lambda x: x<0, self.__tableau[0][self.__op_matrix_len:-1])))
# logging.info(col)
return col
except StopIteration:
raise Feasible()
def __get_b_negative_entries_index(self):
neg_entries = []
for i in range(1, self.__rows+1):
if(self.__tableau[i][-1] < 0):
neg_entries.append(i)
return neg_entries
def __choose_new_basis_at_col(self, col):
# logging.info("Chosing new basis")
index = -1
value = float("inf")
for i in range(1,self.__rows+1):
if (self.__tableau[i][col] > 0):
temp = self.__tableau[i][-1]/self.__tableau[i][col]
# logging.info(temp)
if(temp < value):
value = temp
index = i
# logging.info("Chosen:")
# logging.info(index)
# logging.info(value)
if(index == -1):
raise Unbounded(col)
else:
# logging.info(index)
return index
def __get_optimal_value(self):
return self.__tableau[0][-1]
def __get_optimal_certificate(self):
return self.__tableau[0][:self.__op_matrix_len]
def __get_feasible_solution(self):
solution = [0]*self.__columns
for index, base in enumerate(self.__basis):
if(self.__is_variable_from_original_problem(base)):
solution[base-self.__op_matrix_len] = self.__tableau[index+1][-1]
return solution
def __get_unbounded_certificate(self, col):
solution = [0]*self.__columns
if(self.__is_variable_from_original_problem(col)):
solution[col-self.__op_matrix_len] = 1
for index, base in enumerate(self.__basis):
if(self.__is_variable_from_original_problem(base)):
solution[col-self.__op_matrix_len] = -self.__tableau[index+1][col]
return solution
def __is_variable_from_original_problem(self, basis):
return(basis >= self.__op_matrix_len and basis < self.__op_matrix_len+self.__columns)
def __get_basis(self):
return self.__basis
if (__name__ == '__main__'):
b = list(map(int, input().split()))
columns = b[0]
b = b[1:]
rows = 2
At = [list(map(int, input().split())) for row in range(columns)]
Ab = [[-At[i][j] for i in range(columns)] for j in range(rows)]
for i in range(len(b)):
Ab[i] = Ab[i]+[-b[i]]
c = [-1]*columns
lp = LinearProgramming(rows, columns, c, Ab)
print(rows, columns, c, Ab)
message = lp.solve()
if(message['status'] == "Feasible"):
print("%.15f"%-message["optimal_value"])
if(message['status'] == "Unbounded"):
print("%.15f"%-message["optimal_value"])
``` | instruction | 0 | 1,289 | 10 | 2,578 |
No | output | 1 | 1,289 | 10 | 2,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
Submitted Solution:
```
import sys
jobs, xp, money = map(int, input().split())
vecs = []
maxsum = 0
for i in range(jobs):
x, m = map(int, input().split())
x *= money
m *= xp # ?
vecs.append((x, m))
if x+m > maxsum:
maxsum = x+m
maxvec = (x, m)
target = xp * money
mindays = target / min(maxvec)
for vec in vecs:
if vec[0] <= maxvec[0] and vec[1] <= maxvec[1]:
continue
try:
j = (target*(vec[0]-vec[1])) / (maxvec[1]* vec[0] - vec[1]*maxvec[0])
k = j*((maxvec[1]-maxvec[0])/(vec[0]-vec[1]))
mindays = min(mindays, j+k)
except:
pass
print(mindays)
``` | instruction | 0 | 1,290 | 10 | 2,580 |
No | output | 1 | 1,290 | 10 | 2,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
Submitted Solution:
```
__author__ = 'Utena'
import operator
def v(x,y):#calculate the time when given a1,b1,a2,b2
if (x[0]/x[1]<=p/q) and (y[0]/y[1]<=p/q) or (x[0]/x[1]>=p/q) and (y[0]/y[1]>=p/q):return min(max(p/x[0],q/x[1]),max(p/y[0],q/y[1]))
else:return (((x[0]-y[0])*q-(x[1]-y[1])*p)/(x[0]*y[1]-x[1]*y[0]))
n,p,q=map(int,input().split())
s=[list(map(int,input().split()))for i in range(n)]
s1=[]
s=sorted(s,key=operator.itemgetter(0,1),reverse=0)
s2=[]
if len(s)==1:
print(max(p/s[0][0],q/s[0][1]))
exit(0)
for j in range(n-1):
if s[j][0]<s[j+1][0]:
s1.append(s[j])
s1.append(s[-1])#get the max b
if len(s1)==1:
print(max(p/s1[0][0],q/s1[0][1]))
exit(0)
s1=sorted(s1,key=operator.itemgetter(1,0),reverse=0)
for j in range(len(s1)-1):
if s1[j][1]<s1[j+1][1]:
s2.append(s1[j])
s2.append(s1[-1])#get the max a
s=[[0,0]]
s2=sorted(s2,key=operator.itemgetter(1),reverse=1)
for k in range(len(s2)):
if s2[k][0]>s[-1][0]:s.append(s2[k])
s.remove(s[0])
if len(s)==1:
print(max(p/s[0][0],q/s[0][1]))
elif len(s)==2:
print(v(s[0],s[1]))
else:
temp=[s[0],s[1]]
for a in s[2:]:
t=v(temp[0],temp[1])
t1=v(a,temp[0])
t2=v(a,temp[1])
if min(t,t1,t2)==t1:temp[1]=a
elif min(t,t1,t2)==t2:temp[0]=a
else:continue
print(v(temp[0],temp[1]))
``` | instruction | 0 | 1,291 | 10 | 2,582 |
No | output | 1 | 1,291 | 10 | 2,583 |
Provide a correct Python 3 solution for this coding contest problem.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day. | instruction | 0 | 1,412 | 10 | 2,824 |
"Correct Solution:
```
n, p, m = input().split()
n = int(n)
p = int(p)
m = int(m)
ans = 0
curb = 0
curd = 1
for i in range(0, n):
#print(curb)
tday, tplus = input().split()
tday = int(tday)
tplus = int(tplus)
if curb < 0:
ans += (tday - curd)
curb -= p * (tday - curd)
elif curb - p * (tday - curd) < 0:
curb -= p * (tday - curd)
x = -curb
xx = x // p
if xx * p < x:
xx += 1
x = xx
ans += x
else:
curb -= p * (tday - curd)
curd = tday
#print(curb)
curb += tplus
tday = m + 1
if curb < 0:
ans += (tday - curd)
curb -= p * (tday - curd)
elif curb - p * (tday - curd) < 0:
curb -= p * (tday - curd)
x = -curb
xx = x // p
if xx * p < x:
xx += 1
x = xx
ans += x
print(ans)
``` | output | 1 | 1,412 | 10 | 2,825 |
Provide a correct Python 3 solution for this coding contest problem.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day. | instruction | 0 | 1,413 | 10 | 2,826 |
"Correct Solution:
```
n,p,m=map(int,input().split())
flag,t_neg,t_in,d,tot=0,0,0,1,0
for i in range (n):
ini_d=d
if flag==1:
tot+=(t-p)
if tot<0:
t_neg+=1
d,t=map(int,input().split())
if flag==0:
t_neg=(d-ini_d)
tot=t_neg*-p
flag=1
else:
tot+=(((d-1)-ini_d)*-p)
if tot<0:
if tot<=(((d-1)-ini_d)*-p):
t_neg+=(d-1)-ini_d
else:
x=int(-tot%p)
y=int(-tot/p)
if x!=0:
t_neg+=(y+1)
else:
t_neg+=y
ini_d=d
tot+=(t-p)
if tot<0:
t_neg+=1
tot+=(((m)-ini_d)*-p)
if tot<0:
if tot<=(((m)-ini_d)*-p):
t_neg+=(m)-ini_d
else:
x=int(-tot%p)
y=int(-tot/p)
if x!=0:
t_neg+=(y+1)
else:
t_neg+=y
print (t_neg)
``` | output | 1 | 1,413 | 10 | 2,827 |
Provide a correct Python 3 solution for this coding contest problem.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day. | instruction | 0 | 1,414 | 10 | 2,828 |
"Correct Solution:
```
n, p, m = map(int, input().split())
lastd = 0
acc = 0
output = 0
neg = 0
for i in range(n):
d, t = map(int, input().split())
acc += (d-lastd-1)*-p
if(acc<0):
output += acc//-p -neg
neg = acc//-p
if(acc%p!=0):
output += 1
neg += 1
acc += t-p
if(acc<0):
output += 1
neg = acc//-p
if(acc%p!=0):
neg += 1
else:
neg = 0
lastd = d
if(d<m):
acc += (m-d)*-p
if(acc<0):
output += acc//-p -neg
if(acc%p!=0): output += 1
print(output)
``` | output | 1 | 1,414 | 10 | 2,829 |
Provide a correct Python 3 solution for this coding contest problem.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day. | instruction | 0 | 1,415 | 10 | 2,830 |
"Correct Solution:
```
rd = lambda: map(int, input().split())
n, p, m = rd()
q, l, r = 0, 0, 0
for i in range(n):
d, t = rd()
c = d - q - 1
r += max(min(c - l // p, c), 0)
l -= p * (c + 1) - t
r += l < 0
q = d
c = m - q
print(r + max(min(c - l // p, c), 0))
``` | output | 1 | 1,415 | 10 | 2,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day.
Submitted Solution:
```
n, p, m = map(int, input().split())
lastd = 0
acc = 0
output = 0
neg = 0
for i in range(n):
d, t = map(int, input().split())
acc += (d-lastd-1)*-p
if(acc<0):
output += acc//-p -neg
neg = acc//-p
if(acc%p!=0):
output += 1
neg += 1
acc += t-p
if(acc<0):
output += 1
neg = acc//-p
if(acc%p!=0):
output += 1
neg += 1
else:
neg = 0
lastd = d
if(d<m):
acc += (m-d)*-p
if(acc<0):
output += acc//-p -neg
if(acc%p!=0): output += 1
print(output)
``` | instruction | 0 | 1,416 | 10 | 2,832 |
No | output | 1 | 1,416 | 10 | 2,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 21 21:25:18 2018
@author: Asus
"""
n,p,m = map(int,input().split())
day = [i for i in range(n)]
topup = [i for i in range(n)]
for i in range(n):
day[i],topup[i] = map(int, input().split())
balance = [i for i in range(m)]
for i in range(m):
balance[i] = (i)*(-1*p)
for i in range(n):
for j in range(day[i],m):
balance[j] += topup[i]
ans = 0
for i in range(m):
if(balance[i] < 0):
ans += 1
print(ans)
``` | instruction | 0 | 1,417 | 10 | 2,834 |
No | output | 1 | 1,417 | 10 | 2,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day.
Submitted Solution:
```
n, p, m = map(int, input().split())
lastd = 0
acc = 0
output = 0
neg = 0
for i in range(n):
d, t = map(int, input().split())
acc += (d-lastd-1)*-p
if(acc<0):
output += acc//-p -neg
neg = acc//-p
if(acc%p!=0):
output += 1
neg += 1
acc += t-p
if(acc<0):
output += 1
neg = acc//-p
else:
neg = 0
lastd = d
if(d<m):
acc += (m-d)*-p
if(acc<0):
output += acc//-p -neg
if(acc%p!=0): output += 1
print(output)
``` | instruction | 0 | 1,418 | 10 | 2,836 |
No | output | 1 | 1,418 | 10 | 2,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A sum of p rubles is charged from Arkady's mobile phone account every day in the morning. Among the following m days, there are n days when Arkady will top up the account: in the day di he will deposit ti rubles on his mobile phone account. Arkady will always top up the account before the daily payment will be done. There will be no other payments nor tops up in the following m days.
Determine the number of days starting from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment (i. e. in evening). Initially the account's balance is zero rubles.
Input
The first line contains three integers n, p and m (1 β€ n β€ 100 000, 1 β€ p β€ 109, 1 β€ m β€ 109, n β€ m) β the number of days Arkady will top up the account, the amount of the daily payment, and the number of days you should check.
The i-th of the following n lines contains two integers di and ti (1 β€ di β€ m, 1 β€ ti β€ 109) β the index of the day when Arkady will make the i-th top up, and the amount he will deposit on this day. It is guaranteed that the indices of the days are distinct and are given in increasing order, i. e. di > di - 1 for all i from 2 to n.
Output
Print the number of days from the 1-st to the m-th such that the account will have a negative amount on it after the daily payment.
Examples
Input
3 6 7
2 13
4 20
7 9
Output
3
Input
5 4 100
10 70
15 76
21 12
30 100
67 85
Output
26
Note
In the first example the balance will change as following (remember, initially the balance is zero):
1. in the first day 6 rubles will be charged, the balance in the evening will be equal to - 6;
2. in the second day Arkady will deposit 13 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 1;
3. in the third day 6 rubles will be charged, the balance in the evening will be equal to - 5;
4. in the fourth day Arkady will deposit 20 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 9;
5. in the fifth day 6 rubles will be charged, the balance in the evening will be equal to 3;
6. in the sixth day 6 rubles will be charged, the balance in the evening will be equal to - 3;
7. in the seventh day Arkady will deposit 9 rubles, then 6 rubles will be charged, the balance in the evening will be equal to 0.
Thus, in the end of the first, third and sixth days the balance will be negative in the end of the day.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 21 21:25:18 2018
@author: Asus
"""
n,p,m = map(int,input().split())
day = [i for i in range(n)]
topup = [i for i in range(n)]
balance = [i for i in range(m)]
ans = 0
for i in range(n):
day[i],topup[i] = map(int, input().split())
for j in range(day[i]-1,m):
balance[j] += topup[i]
for i in range(m):
balance[i] += (i)*(-1*p)
if(balance[i] < 0):
ans += 1
print(ans)
``` | instruction | 0 | 1,419 | 10 | 2,838 |
No | output | 1 | 1,419 | 10 | 2,839 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.