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 a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,288 | 10 | 122,576 |
"Correct Solution:
```
import heapq
n,m=map(int,input().split())
a=list(map(lambda x:int(x)*(-1),input().split()))
heapq.heapify(a)
for i in range(m):
top=heapq.heappop(a)
heapq.heappush(a,(-1)*(-top//2))
print(-sum(a))
``` | output | 1 | 61,288 | 10 | 122,577 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,289 | 10 | 122,578 |
"Correct Solution:
```
import heapq
N, M = map(int, input().split(" "))
A = [-int(_) for _ in input().split(" ")]
heapq.heapify(A)
for i in range(M):
heapq.heappush(A, -(-heapq.heappop(A)// 2))
print(-sum(A))
``` | output | 1 | 61,289 | 10 | 122,579 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000 | instruction | 0 | 61,290 | 10 | 122,580 |
"Correct Solution:
```
import heapq
N,M=map(int,input().split())
A=[-1*int(i) for i in input().split()]
heapq.heapify(A)
for _ in range(M):
a=-1*heapq.heappop(A)
a=a//2
heapq.heappush(A,-1*a)
print(-1*sum(A))
``` | output | 1 | 61,290 | 10 | 122,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
import heapq
n,m=map(int,input().split())
a=list(map(lambda x:-int(x),input().split()))
heapq.heapify(a)
for i in range(m):
x=-heapq.heappop(a)
heapq.heappush(a,-(x//2))
print(-sum(a))
``` | instruction | 0 | 61,291 | 10 | 122,582 |
Yes | output | 1 | 61,291 | 10 | 122,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
import heapq
n,m=map(int, input().split())
a=[-int(j) for j in input().split()]
heapq.heapify(a)
for i in range(m):
v=heapq.heappop(a)
heapq.heappush(a, -(-v//2))
print(-sum(a))
``` | instruction | 0 | 61,292 | 10 | 122,584 |
Yes | output | 1 | 61,292 | 10 | 122,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
N, M = map(int, input().split())
A = list(map(lambda x: -int(x), input().split()))
import heapq
heapq.heapify(A)
for _ in range(M):
heapq.heapreplace(A, -((-A[0]) // 2))
print(-sum(A))
``` | instruction | 0 | 61,293 | 10 | 122,586 |
Yes | output | 1 | 61,293 | 10 | 122,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
from heapq import*;n,m,*a=eval(',-'.join(open(0).read().split()));x=0;a.sort();exec('x=heapreplace(a,-~x//2);'*-m);print(x//-2-sum(a))
``` | instruction | 0 | 61,294 | 10 | 122,588 |
Yes | output | 1 | 61,294 | 10 | 122,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
n, m = map(int, input().split())
a = sorted(list(map(int, input().split())), reverse=True)
ans = sum(a[min(n, m):])
a = a[:min(n, m)]
if len(a) == 1 and n == 1:
print(a[0]//2**m)
elif len(a) == 1:
print(a[0]//2**m+ans)
else:
for i in range(m):
a[0] //= 2
a = sorted(a, reverse=True)
print(ans+sum(a))
``` | instruction | 0 | 61,295 | 10 | 122,590 |
No | output | 1 | 61,295 | 10 | 122,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
import sys
def input(): return sys.stdin.readline().rstrip()
import heapq
N, M = map(int,input().split())
A = list(map(lambda x:int(x) * (-1),input().split()))
heapq.heapify(A)
for i in range(M):
a = heapq.heappop(A)
a *= -1
a /= 2
a *= -1
heapq.heappush(A,a)
price = 0
for a in A:
price += (-1) * a
print(price)
``` | instruction | 0 | 61,296 | 10 | 122,592 |
No | output | 1 | 61,296 | 10 | 122,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
N,M=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
from bisect import insort
while M>0:
a = A.pop(-1)
a /= 2
insort(A,a)
M-=1
ans = 0
for a in A:
ans += int(a)
print(ans)
``` | instruction | 0 | 61,297 | 10 | 122,594 |
No | output | 1 | 61,297 | 10 | 122,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is going to buy N items one by one.
The price of the i-th item he buys is A_i yen (the currency of Japan).
He has M discount tickets, and he can use any number of them when buying an item.
If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.
What is the minimum amount of money required to buy all the items?
Constraints
* All values in input are integers.
* 1 \leq N, M \leq 10^5
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
Output
Print the minimum amount of money required to buy all the items.
Examples
Input
3 3
2 13 8
Output
9
Input
4 4
1 9 3 5
Output
6
Input
1 100000
1000000000
Output
0
Input
10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
9500000000
Submitted Solution:
```
# -*- coding: utf-8 -*-
import numpy as np
import sys
def main():
N, M = map(int, input().split())
arr = np.array(input().split(), dtype='int64')
for i in range(M):
arr[np.argmax(arr)] /= 2
print(np.sum(arr))
if __name__ =='__main__':
main()
``` | instruction | 0 | 61,298 | 10 | 122,596 |
No | output | 1 | 61,298 | 10 | 122,597 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,408 | 10 | 122,816 |
"Correct Solution:
```
m = int(input())
for _ in range(m):
s = int(input())
y = int(input())
n = int(input())
a = 0
for _d in range(n):
t, p, b = map(float, input().split())
tem = 0
ts = s
if t:
for _y in range(y):
ts += int(ts * p)
ts -= b
a = max(a, ts)
else:
tp = 0
for _y in range(y):
tp += int(ts * p)
ts -= b
a = max(a, ts + tp)
print(int(a))
``` | output | 1 | 61,408 | 10 | 122,817 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,409 | 10 | 122,818 |
"Correct Solution:
```
# AOJ 1135: Ohgas' Fortune
# Python3 2018.7.14 bal4u
for cno in range(int(input())):
a0, y, n = int(input()), int(input()), int(input())
ans = 0
for i in range(n):
buf = list(input().split())
k, r, f = int(buf[0]), float(buf[1]), int(buf[2])
a = a0
if k:
for j in range(y):
b = (int)(a*r)
a += b-f
else:
c = 0
for j in range(y):
b = (int)(a*r)
a -= f
c += b
a += c
ans = max(ans, a)
print(ans)
``` | output | 1 | 61,409 | 10 | 122,819 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,410 | 10 | 122,820 |
"Correct Solution:
```
trial = int(input())
for t in range(trial):
money = int(input())
year = int(input())
cond = int(input())
answer = 0
for c in range(cond):
initial = money
bank = [float(n) for n in input().split(" ")]
if bank[0] == 0:
interest = 0
for y in range(year):
interest += int(initial * bank[1])
initial -= bank[2]
else:
#print(interest + initial)
if answer < interest + initial:
answer = int(interest + initial)
else:
for y in range(year):
initial = initial + int(initial * bank[1] )
initial -= bank[2]
else:
#print(initial)
if answer < initial:
answer = int(initial)
else:
print(answer)
``` | output | 1 | 61,410 | 10 | 122,821 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,411 | 10 | 122,822 |
"Correct Solution:
```
def tanri(money, year, ritu, cost):
temp = int(year*(money+cost)*ritu)
temp -= (ritu * cost*year*(year-1))//2
return temp
def tanri_a(m,y,r,c):
temp = m
ans = 0
for _ in range(y):
ans += int(temp*r)
temp -= c
return ans + temp
def hukuri(m, y, r, c):
temp = (m-c/r)*((1+r)**(y-1))
return int(temp)
def hukuri_a(m, y, r, c):
temp = m
for i in range(y):
temp = temp + int(temp*r) - c
return int(temp)
def main(init_money):
year = int(input())
n = int(input())
ans = 0
for _ in range(n):
temp = input().split()
w, ritsu, cost = int(temp[0]), float(temp[1]), int(temp[2])
# if w == 0: temp = tanri(init_money, year, ritsu, cost)
# else: temp = hukuri(init_money, year, ritsu, cost)
if w == 0: temp2 = tanri_a(init_money, year, ritsu, cost)
else: temp2 = hukuri_a(init_money, year, ritsu, cost)
ans = max(ans, temp2)
# print(f"temp: {temp}, temp2: {temp2}, diff: {temp-temp2}")
print(ans)
return
n = int(input())
for _ in range(n):
main(int(input()))
``` | output | 1 | 61,411 | 10 | 122,823 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,412 | 10 | 122,824 |
"Correct Solution:
```
def co(a):
global y,c,d
for _ in range(y):a+=int(a*c)-d
return int(a)
def i(a):
global y,c,d
b=0
for _ in range(y):
b+=int(a*c)
a-=d
return int(a+b)
for _ in range(int(input())):
m=0
a=int(input());y=int(input())
for _ in range(int(input())):
b,c,d=map(float,input().split())
m=max(m,co(a) if b==1 else i(a))
print(m)
``` | output | 1 | 61,412 | 10 | 122,825 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,413 | 10 | 122,826 |
"Correct Solution:
```
def hukuri(y, m, p, t) :
for i in range(y) :
m += int(m * p) - t
return m
def tanri(y, m, p, t) :
risoku = 0
for i in range(y) :
risoku += int(m * p)
m -= t
return m+risoku
M = int(input())
for i in range(M) :
m = int(input())
y = int(input())
N = int(input())
ans = []
for j in range(N) :
s, p, t = input().split()
if s == '0' :
ans.append(tanri(y, m, float(p), int(t)))
elif s == '1' :
ans.append(hukuri(y, m, float(p), int(t)))
print(max(ans))
``` | output | 1 | 61,413 | 10 | 122,827 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,414 | 10 | 122,828 |
"Correct Solution:
```
def tanri(a, y, r, c):
o = 0
for i in range(y):
o += int((a-i*c)*r)
o += a-y*c
return o
def fukuri(a, y, r, c):
o = a
for i in range(y):
o = int(o*(1+r))-c
return o
m = int(input())
for _ in range(m):
a = int(input())
y = int(input())
n = int(input())
b = []
for i in range(n):
t,r,c = input().split()
r = float(r)
c = int(c)
if t == '0':
b.append(tanri(a, y, r, c))
else:
b.append(fukuri(a, y, r, c))
print(max(b))
``` | output | 1 | 61,414 | 10 | 122,829 |
Provide a correct Python 3 solution for this coding contest problem.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397 | instruction | 0 | 61,415 | 10 | 122,830 |
"Correct Solution:
```
m = int(input())
for _ in range(m):
fund = int(input())
year = int(input())
n = int(input())
ans = fund
for i in range(n):
t, rate, fee = map(float, input().split())
if t:
a = fund
b = 0
for j in range(year):
b = int(a*rate)
a = a+b-fee
ans = max(ans, a)
else:
a = fund
b = 0
for j in range(year):
b+= int(a*rate)
a = a-fee
ans = max(ans, a+b)
print(int(ans))
``` | output | 1 | 61,415 | 10 | 122,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397
Submitted Solution:
```
M = int(input())
def tanri(a,y,nenri,tax):
w = 0
for i in range(y):
w += int(a * nenri)
a -= tax
return a+w
def fukuri(a, y, nenri, tax):
for i in range(y):
a += int(a * nenri) - tax
return a
for i in range(M):
A = int(input())
Y = int(input())
N = int(input())
max_ = 0
for i in range(N):
t, nenri, tax = list(map(float,input().split()))
max_ = max(max_, tanri(A,Y,nenri,tax) if t == 0 else fukuri(A,Y,nenri,tax))
print(int(max_))
``` | instruction | 0 | 61,416 | 10 | 122,832 |
Yes | output | 1 | 61,416 | 10 | 122,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397
Submitted Solution:
```
import sys
readline = sys.stdin.readline
for _ in range(int(readline())):
a = int(readline())
y = int(readline())
n = int(readline())
ans = a
for _ in range(n):
t, rate, fee = [f(x) for f, x in zip((int, float, int), readline().split())]
if t == 1:
res = a
for _ in range(y):
res = res + int(res * rate) - fee
else:
res = a
r = 0
for _ in range(y):
r += int(res * rate)
res = res - fee
res += r
ans = max(ans, res)
print(ans)
``` | instruction | 0 | 61,417 | 10 | 122,834 |
Yes | output | 1 | 61,417 | 10 | 122,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Ohgas are a prestigious family based on Hachioji. The head of the family, Mr. Nemochi Ohga, a famous wealthy man, wishes to increase his fortune by depositing his money to an operation company. You are asked to help Mr. Ohga maximize his profit by operating the given money during a specified period.
From a given list of possible operations, you choose an operation to deposit the given fund to. You commit on the single operation throughout the period and deposit all the fund to it. Each operation specifies an annual interest rate, whether the interest is simple or compound, and an annual operation charge. An annual operation charge is a constant not depending on the balance of the fund. The amount of interest is calculated at the end of every year, by multiplying the balance of the fund under operation by the annual interest rate, and then rounding off its fractional part. For compound interest, it is added to the balance of the fund under operation, and thus becomes a subject of interest for the following years. For simple interest, on the other hand, it is saved somewhere else and does not enter the balance of the fund under operation (i.e. it is not a subject of interest in the following years). An operation charge is then subtracted from the balance of the fund under operation. You may assume here that you can always pay the operation charge (i.e. the balance of the fund under operation is never less than the operation charge). The amount of money you obtain after the specified years of operation is called ``the final amount of fund.'' For simple interest, it is the sum of the balance of the fund under operation at the end of the final year, plus the amount of interest accumulated throughout the period. For compound interest, it is simply the balance of the fund under operation at the end of the final year.
Operation companies use C, C++, Java, etc., to perform their calculations, so they pay a special attention to their interest rates. That is, in these companies, an interest rate is always an integral multiple of 0.0001220703125 and between 0.0001220703125 and 0.125 (inclusive). 0.0001220703125 is a decimal representation of 1/8192. Thus, interest rates' being its multiples means that they can be represented with no errors under the double-precision binary representation of floating-point numbers.
For example, if you operate 1000000 JPY for five years with an annual, compound interest rate of 0.03125 (3.125 %) and an annual operation charge of 3000 JPY, the balance changes as follows.
The balance of the fund under operation (at the beginning of year) | Interest| The balance of the fund under operation (at the end of year)
---|---|---
A| B = A × 0.03125 (and rounding off fractions) | A + B - 3000
1000000| 31250| 1028250
1028250| 32132| 1057382
1057382| 33043| 1087425
1087425| 33982| 1118407
1118407| 34950| 1150357
After the five years of operation, the final amount of fund is 1150357 JPY.
If the interest is simple with all other parameters being equal, it looks like:
The balance of the fund under operation (at the beginning of year) | Interest | The balance of the fund under operation (at the end of year) | Cumulative interest
---|---|---|---
A| B = A × 0.03125 (and rounding off fractions)| A - 3000|
1000000| 31250| 997000| 31250
997000| 31156| 994000| 62406
994000| 31062| 991000| 93468
991000| 30968| 988000| 124436
988000| 30875| 985000| 155311
In this case the final amount of fund is the total of the fund under operation, 985000 JPY, and the cumulative interests, 155311 JPY, which is 1140311 JPY.
Input
The input consists of datasets. The entire input looks like:
> the number of datasets (=m)
> 1st dataset
> 2nd dataset
> ...
> m-th dataset
>
The number of datasets, m, is no more than 100. Each dataset is formatted as follows.
> the initial amount of the fund for operation
> the number of years of operation
> the number of available operations (=n)
> operation 1
> operation 2
> ...
> operation n
>
The initial amount of the fund for operation, the number of years of operation, and the number of available operations are all positive integers. The first is no more than 100000000, the second no more than 10, and the third no more than 100.
Each ``operation'' is formatted as follows.
> simple-or-compound annual-interest-rate annual-operation-charge
where simple-or-compound is a single character of either '0' or '1', with '0' indicating simple interest and '1' compound. annual-interest-rate is represented by a decimal fraction and is an integral multiple of 1/8192. annual-operation-charge is an integer not exceeding 100000.
Output
For each dataset, print a line having a decimal integer indicating the final amount of fund for the best operation. The best operation is the one that yields the maximum final amount among the available operations. Each line should not have any character other than this number.
You may assume the final balance never exceeds 1000000000. You may also assume that at least one operation has the final amount of the fund no less than the initial amount of the fund.
Example
Input
4
1000000
5
2
0 0.03125 3000
1 0.03125 3000
6620000
7
2
0 0.0732421875 42307
1 0.0740966796875 40942
39677000
4
4
0 0.0709228515625 30754
1 0.00634765625 26165
0 0.03662109375 79468
0 0.0679931640625 10932
10585000
6
4
1 0.0054931640625 59759
1 0.12353515625 56464
0 0.0496826171875 98193
0 0.0887451171875 78966
Output
1150357
10559683
50796918
20829397
Submitted Solution:
```
def c(a):
global y,r,d
for _ in range(y):a+=int(a*r)-d
return a
def s(a):
global y,r,d
b=0
for _ in range(y):
b+=int(a*r)
a-=d
return a+b
for _ in range(int(input())):
m=0
a=int(input());y=int(input())
for _ in range(int(input())):
b,r,d=map(float,input().split())
m=max(m,c(a) if b==1 else s(a))
print(int(m))
``` | instruction | 0 | 61,418 | 10 | 122,836 |
Yes | output | 1 | 61,418 | 10 | 122,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,792 | 10 | 123,584 |
Tags: brute force
Correct Solution:
```
n,b = map(int,input().split())
t= list(map(int,input().split()))
ans=0
ma=999999999
mi=0
for i in range(n):
if t[i] < ma:
ma = t[i]
elif t[i]>ma:
temp = b//ma
rest= b-(b//ma)*ma
rest+= (temp)*t[i]
ans=max(rest , ans)
print(max(ans,b))
``` | output | 1 | 61,792 | 10 | 123,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,793 | 10 | 123,586 |
Tags: brute force
Correct Solution:
```
str1 = input().split()
n = (int)(str1[0])
b = (int)(str1[1])
str2 = input().split()
for x in range(n):
str2[x] = (int)(str2[x])
minimum = list()
maximum = list()
ans = 0
if(str2 == sorted(str2,reverse=True)):
print (b)
elif (str2 == sorted(str2)):
print (b - ((int)(b/str2[0]) * str2[0]) + ((int)(b/str2[0]) * str2[len(str2) - 1]))
else:
for x in range(n-1):
if(str2[x+1] > str2[x]):
minimum.append(x)
for x in range(n-1):
if(str2[x+1] < str2[x]):
maximum.append(x)
maximum.append(n-1)
for x in minimum:
for y in maximum:
if(x < y):
v1 = b - ((int)(b/str2[x]) * str2[x]) + ((int)(b/str2[x]) * str2[y])
ans = max(v1,ans)
print (ans)
``` | output | 1 | 61,793 | 10 | 123,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,794 | 10 | 123,588 |
Tags: brute force
Correct Solution:
```
n,b=map(int,input().split())
l=list(map(int,input().split()))
l1=[0]*n
c=0
for i in range(n-1,-1,-1):
c=max(c,l[i])
l1[i]=c
ans=b
for i in range(n-1):
if b>=l[i]:
a=b//l[i]
c=b-a*l[i]
ans=max(ans,c+a*l1[i+1])
print(ans)
``` | output | 1 | 61,794 | 10 | 123,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,795 | 10 | 123,590 |
Tags: brute force
Correct Solution:
```
n, b = map(int, input().split())
a = list(map(int, input().split()))
res = 0
for _ in range(0, len(a)):
m = b // a[_]
o = b - m * a[_]
for i in range(_, len(a)):
res = max(m * a[i] + o, res)
print(res)
``` | output | 1 | 61,795 | 10 | 123,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,796 | 10 | 123,592 |
Tags: brute force
Correct Solution:
```
# Don't wait for opportunity. Create it. Unknown
# by : Blue Edge - Create some chaos
n,b=map(int,input().split())
a=list(map(int,input().split()))
c=[]
mini=4000
for x in a[:-1]:
mini=min(x,mini)
c.append(mini)
maxi=0
i=n-2
ans=b
for x in a[-1:0:-1]:
maxi=max(maxi,x)
# print(maxi,c[i])
ans=max(ans,b+max(0,(b//c[i])*(maxi-c[i])))
# print(ans)
i-=1
print(ans)
``` | output | 1 | 61,796 | 10 | 123,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,797 | 10 | 123,594 |
Tags: brute force
Correct Solution:
```
n,b = list(map(int, input().split(" ")))
values,maxi = list(map(int, input().split(" "))),b
for buyday in range(n-1):
dollar = b//values[buyday]
sellprice = max(values[buyday+1:]);
if sellprice > values[buyday]: maxi = max(b%values[buyday] + sellprice*dollar,maxi)
print(maxi)
``` | output | 1 | 61,797 | 10 | 123,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,798 | 10 | 123,596 |
Tags: brute force
Correct Solution:
```
init_money = int(input().split()[1])
prices = [int(k) for k in input().split()]
n = len(prices)
buy_price = prices[0]
sell_price = prices[0]
t_profit = init_money // buy_price * sell_price - (init_money // buy_price * buy_price)
for idx, i in enumerate(prices):
if i <= buy_price and any([k > i for k in prices[idx:]]):
t_buy_price = i
t_sell_price = max(prices[idx:])
p = init_money // t_buy_price * t_sell_price - (init_money // t_buy_price * t_buy_price)
if p > t_profit:
buy_price = t_buy_price
sell_price = t_sell_price
t_profit = p
if buy_price == sell_price:
print(init_money)
else:
buy_dollar = int(init_money / buy_price)
sell_profit = buy_dollar * sell_price
profit = sell_profit - (buy_dollar * buy_price)
print(profit + init_money)
``` | output | 1 | 61,798 | 10 | 123,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15 | instruction | 0 | 61,799 | 10 | 123,598 |
Tags: brute force
Correct Solution:
```
n,b=map(int,input().split())
p=[int(x) for x in input().split()]
if b<min(p) or n==1:
print(b)
else:
q=[]
for i in range (0,n):
if b>p[i] and i!=n-1:
s=max(p[j] for j in range (i+1,n))
if s>=p[i]:
q.append(int(b/p[i])*s+b-int(b/p[i])*p[i])
if q!=[]:
print(max(q))
else:
print(b)
``` | output | 1 | 61,799 | 10 | 123,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
n,b=map(int,input().split())
l=list(map(int,input().split()))
m=0
t=b
for i in range(n-2,-1,-1):
m=max(m,l[i+1])
t=max(t,b//l[i]*m+b%l[i])
print(t)
``` | instruction | 0 | 61,800 | 10 | 123,600 |
Yes | output | 1 | 61,800 | 10 | 123,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
n,b = map(int, input().split())
a = list(map(int, input().split()))
#First approac Naive
# print (max(b//a[i]*a[j] + b%a[i] for j in range(n) for i in range(j+1) ))
#Second approach
x = 0 #max selling
res = b;
for i in range(n-2, -1, -1):
x = max(x, a[i+1])
res = max(res, (b//a[i]*x + b%a[i]) )
print (res)
``` | instruction | 0 | 61,801 | 10 | 123,602 |
Yes | output | 1 | 61,801 | 10 | 123,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
n , b = map(int,input().split())
lis=list(map(int,input().split()))
mon=0
sell=0
ans=[]
for i in range(n):
share = b//lis[i]
mon=b- (b//lis[i])*lis[i]
for j in range(i,n):
sell=lis[j]*share
# print(share,sell,mon)
ans.append(sell+mon)
#print(ans)
print(max(ans))
``` | instruction | 0 | 61,802 | 10 | 123,604 |
Yes | output | 1 | 61,802 | 10 | 123,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 998244353
"""
"""
def solve():
N, B = getInts()
A = getInts()
best = B
for i in range(N):
for j in range(i+1,N):
tmp = B
dollars = tmp//A[i]
rem = tmp%A[i]
dollars *= A[j]
best = max(dollars+rem,best)
return best
#for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time)á
``` | instruction | 0 | 61,803 | 10 | 123,606 |
Yes | output | 1 | 61,803 | 10 | 123,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
n, b = map(int, input().split())
a = list(map(int, input().split()))
d = 0
b1 = 0
if a != sorted(a, reverse=True):
if a[0] == max(a) or a[-1] == min(a):
while a[0] == max(a) or a[-1] == min(a):
for j in a:
if j == max(a) and a[0] == j:
a.remove(j)
if j == min(a) and a[-1] == j:
a.remove(j)
for i in a:
if i == min(a):
d = round(b / i - 0.49)
b1 = b - d * i
a = a[a.index((i)):]
if i == max(a):
b = d * i + b1
print(b)
else:
print(b)
``` | instruction | 0 | 61,804 | 10 | 123,608 |
No | output | 1 | 61,804 | 10 | 123,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
n,b=map(int,input().split())
l=list(map(int,input().split()))
d=0
x,y=-1,-1
for i in range(n-1):
for j in range(1+i,n):
if d<(l[j]-l[i]) or ( d==l[j]-l[i] and (i<x or j>y)):
d=l[j]-l[i]
x,y=i,j
if x!=y:
print(b//l[x]*l[y] +b%l[x] )
else:
print(b)
``` | instruction | 0 | 61,805 | 10 | 123,610 |
No | output | 1 | 61,805 | 10 | 123,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
n,b=map(int,input().split())
a=list(map(int,input().split()))
f=1
for i in range(n-1):
if a[i+1]>a[i]:
f=0
break
if f==1:
print(b)
else:
a1=a[i:]
x=max(a1)
print((b//a[i])*x + b%a[i])
``` | instruction | 0 | 61,806 | 10 | 123,612 |
No | output | 1 | 61,806 | 10 | 123,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Vasya got hold of information on the Martian dollar course in bourles for the next n days. The buying prices and the selling prices for one dollar on day i are the same and are equal to ai. Vasya has b bourles. He can buy a certain number of dollars and then sell it no more than once in n days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day n?
Input
The first line contains two integers n and b (1 ≤ n, b ≤ 2000) — the number of days and the initial number of money in bourles. The next line contains n integers ai (1 ≤ ai ≤ 2000) — the prices of Martian dollars.
Output
Print the single number — which maximal sum of money in bourles can Vasya get by the end of day n.
Examples
Input
2 4
3 7
Output
8
Input
4 10
4 3 2 1
Output
10
Input
4 10
4 2 3 1
Output
15
Submitted Solution:
```
import math
n, b = map(int, input().split())
arr = list(map(int, input().split()))
mm = max(arr)
ans = b
ans2 = [0]
f = 1
for i in arr:
if f == 1:
if i < mm:
temp2 = i
temp = math.floor(b/i)
b -= i*temp
f = 0
if f == 0:
if i > temp2:
b += i*temp
ans2.append(b)
f = 1
print(max(ans, max(ans2)))
``` | instruction | 0 | 61,807 | 10 | 123,614 |
No | output | 1 | 61,807 | 10 | 123,615 |
Provide a correct Python 3 solution for this coding contest problem.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0 | instruction | 0 | 62,062 | 10 | 124,124 |
"Correct Solution:
```
x, y = map(int, input().split())
d = {
3: 100000,
2: 200000,
1: 300000
}
bonus = 400000
print(d.get(x, 0) + d.get(y, 0) + (bonus if x == 1 and y == 1 else 0))
``` | output | 1 | 62,062 | 10 | 124,125 |
Provide a correct Python 3 solution for this coding contest problem.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0 | instruction | 0 | 62,067 | 10 | 124,134 |
"Correct Solution:
```
x,y=map(int,input().split())
list=[300000,200000,100000,0]
if x>4:
x=4
if y>4:
y=4
if x==1 and y==1:
print(2*300000+400000)
else:
print(list[x-1]+list[y-1])
``` | output | 1 | 62,067 | 10 | 124,135 |
Provide a correct Python 3 solution for this coding contest problem.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0 | instruction | 0 | 62,068 | 10 | 124,136 |
"Correct Solution:
```
x,y = input().split()
d = {"1":300000,"2":200000,"3":100000}
if x=="1" and y=="1":
print(d.get(x,0)+d.get(y,0)+400000)
else:
print(d.get(x,0)+d.get(y,0))
``` | output | 1 | 62,068 | 10 | 124,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,391 | 10 | 124,782 |
Tags: data structures, dp, greedy
Correct Solution:
```
from sys import stdin, stdout
import heapq
class MyHeap(object):
def __init__(self, initial=None, key=lambda x:x):
self.key = key
if initial:
self._data = [(key(item), item) for item in initial]
heapq.heapify(self._data)
else:
self._data = []
def push(self, item):
heapq.heappush(self._data, (self.key(item), item))
def pop(self):
return heapq.heappop(self._data)[1]
def print(self):
for hd in self._data:
print(hd)
print('-------------------------------')
def getminnumerofcoins(n, mpa):
res = 0
mpa.sort(key=lambda x: (x[0], -x[1]))
gap = []
cur = 0
for i in range(len(mpa)):
mp = mpa[i]
#print(mp[0])
if mp[0] > cur:
t = [i, mp[0]-cur]
gap.append(t)
#cur = mp[0]
cur += 1
#print(gap)
if len(gap) == 0:
return 0
hp = MyHeap(key=lambda x: x[1])
gp = gap.pop()
lidx = gp[0]
remaing = gp[1]
#print(remaing)
for i in range(lidx, len(mpa)):
ci = [i, mpa[i][1]]
hp.push(ci)
cur = 0
offset = 0
for i in range(len(mpa)):
mp = mpa[i]
need = mp[0] - cur
if need > 0:
for j in range(need):
if (remaing == 0 or len(hp._data) == 0) and len(gap) > 0:
#print(i)
lg = gap.pop()
while len(gap) > 0 and lg[1] - offset <= 0:
lg = gap.pop()
for k in range(lg[0], lidx):
ci = [k, mpa[k][1]]
hp.push(ci)
lidx = lg[0]
remaing = lg[1] - offset
c = hp.pop()
#print(c)
if c[0] == i:
c = hp.pop()
#print(c)
res += c[1]
cur += 1
offset += 1
remaing -= 1
cur += 1
return res
if __name__ == '__main__':
t = int(stdin.readline())
for i in range(t):
n = int(stdin.readline())
mpa = []
for j in range(n):
mp = list(map(int, stdin.readline().split()))
mpa.append(mp)
res = getminnumerofcoins(n, mpa)
stdout.write(str(res) + '\n')
``` | output | 1 | 62,391 | 10 | 124,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,392 | 10 | 124,784 |
Tags: data structures, dp, greedy
Correct Solution:
```
'''
Created on 2019. 9. 21.
@author: kkhh88
'''
#q = int(input())
#x, y = map(int,input().split(' '))
q = int(input())
for _ in range(q):
n = int(input())
lr = []
for i in range(n):
lr.append(list(map(int,input().split(' '))))
lr.sort(key=lambda x:x[1], reverse = True)
lr.sort(key=lambda x:x[0])
cnt = [0]*n
for i in range(n):
if lr[i][0] > i:
if lr[i][0] - i > cnt[lr[i][0]]:
cnt[lr[i][0]] = lr[i][0] - i
i = n - 1
tmp = 0
ans = 0
lst = []
while i >= 0:
if i > 0 and lr[i][0] == lr[i-1][0]:
lst.append(lr[i][1])
i = i - 1
else:
lst.append(lr[i][1])
if cnt[lr[i][0]] > tmp:
lst.sort()
for _ in range(tmp, cnt[lr[i][0]]):
ans = ans + lst.pop(0)
tmp = cnt[lr[i][0]]
i = i - 1
#print (cnt, lr)
print (ans)
``` | output | 1 | 62,392 | 10 | 124,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,393 | 10 | 124,786 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
import heapq as hq
t = int(input())
for _ in range(t):
n = int(input())
vt = [list(map(int,input().split())) for i in range(n)]
vt.sort(reverse=True)
q = []
hq.heapify(q)
ans = 0
cnt = 0
for i in range(n):
hq.heappush(q,vt[i][1])
if vt[i][0] >= n-i+cnt:
ans += hq.heappop(q)
cnt += 1
print(ans)
``` | output | 1 | 62,393 | 10 | 124,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,394 | 10 | 124,788 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
import heapq
def solve(pr, mm):
omm = []
n = len(mm)
for i in range(n + 1):
omm.append([])
for i in range(n):
omm[mm[i]].append(pr[i])
for i in range(n + 1):
omm[i] = sorted(omm[i])
heap = []
c = 0
t = n
p = 0
for i in range(n, -1, -1):
for h in omm[i]:
heapq.heappush(heap, h)
t -= len(omm[i])
mn = max(i - c - t, 0)
c += mn
for j in range(mn):
p += heapq.heappop(heap)
return p
if __name__ == "__main__":
t = int(input().strip())
for i in range(t):
n = int(input().strip())
ms = []
ps = []
for j in range(n):
arr = [int(v) for v in input().strip().split(' ')]
ms.append(arr[0])
ps.append(arr[1])
print(solve(ps, ms))
``` | output | 1 | 62,394 | 10 | 124,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,395 | 10 | 124,790 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
from heapq import heappop, heappush
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
t = int(input())
for _ in range(t):
n = int(input())
mp = []
for i in range(n):
mi, pi = map(int, input().split())
mp.append((mi, pi))
mp.sort()
prices = []
cost = 0
bribed = 0
i = n - 1
while i >= 0:
currM = mp[i][0]
heappush(prices, mp[i][1])
while i >= 1 and mp[i-1][0] == currM:
i -= 1
heappush(prices, mp[i][1])
already = i + bribed
for k in range(max(0, currM - already)):
cost += heappop(prices)
bribed += 1
i -= 1
print(cost)
``` | output | 1 | 62,395 | 10 | 124,791 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,396 | 10 | 124,792 |
Tags: data structures, dp, greedy
Correct Solution:
```
import heapq
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
info = [list(map(int, input().split())) for i in range(n)]
info = sorted(info)
cnt = [0] * n
for i in range(n):
ind = info[i][0]
cnt[ind] += 1
ruiseki_cnt = [0] * (n+1)
for i in range(n):
ruiseki_cnt[i+1] = ruiseki_cnt[i] + cnt[i]
# print(cnt)
# print(ruiseki_cnt)
need = [0] * n
for i in range(1,n):
if cnt[i] != 0 and i > ruiseki_cnt[i]:
need[i] = min(i - ruiseki_cnt[i], i)
# print(need)
info = sorted(info, reverse = True)
#print(info)
num = n - 1
pos = 0
q = []
used_cnt = 0
ans = 0
while True:
if num == -1:
break
while True:
if pos < n and info[pos][0] >= num:
heapq.heappush(q, info[pos][1])
pos += 1
else:
break
if need[num] - used_cnt > 0:
tmp = need[num] - used_cnt
for _ in range(tmp):
ans += heapq.heappop(q)
used_cnt += tmp
num -= 1
print(ans)
``` | output | 1 | 62,396 | 10 | 124,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,397 | 10 | 124,794 |
Tags: data structures, dp, greedy
Correct Solution:
```
import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
from collections import defaultdict
from heapq import heappop, heappush
t = int(input())
ans = [''] * t
for ti in range(t):
n = int(input())
dd: Tp.Dict[int, Tp.List[int]] = defaultdict(list)
costs = [0] * n
for i in range(n):
mi, pi = map(int, input().split())
dd[mi].append(i)
costs[i] = pi
hq = []
for cnt in range(n):
for x in dd[cnt]:
heappush(hq, -costs[x])
if hq:
heappop(hq)
ans[ti] = str(-sum(hq))
sys.stdout.buffer.write(('\n'.join(ans) + '\n').encode('utf-8'))
if __name__ == '__main__':
main()
``` | output | 1 | 62,397 | 10 | 124,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}. | instruction | 0 | 62,398 | 10 | 124,796 |
Tags: data structures, dp, greedy
Correct Solution:
```
import heapq
t = int(input())
for _ in range(t):
n = int(input())
info = [list(map(int, input().split())) for i in range(n)]
info = sorted(info)
cnt = [0] * n
for i in range(n):
ind = info[i][0]
cnt[ind] += 1
ruiseki_cnt = [0] * (n+1)
for i in range(n):
ruiseki_cnt[i+1] = ruiseki_cnt[i] + cnt[i]
# print(cnt)
# print(ruiseki_cnt)
need = [0] * n
for i in range(1,n):
if cnt[i] != 0 and i > ruiseki_cnt[i]:
need[i] = min(i - ruiseki_cnt[i], i)
# print(need)
info = sorted(info, reverse = True)
#print(info)
num = n - 1
pos = 0
q = []
used_cnt = 0
ans = 0
while True:
if num == -1:
break
while True:
if pos < n and info[pos][0] >= num:
heapq.heappush(q, info[pos][1])
pos += 1
else:
break
if need[num] - used_cnt > 0:
tmp = need[num] - used_cnt
for _ in range(tmp):
ans += heapq.heappop(q)
used_cnt += tmp
num -= 1
print(ans)
``` | output | 1 | 62,398 | 10 | 124,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are n voters, and two ways to convince each of them to vote for you. The first way to convince the i-th voter is to pay him p_i coins. The second way is to make m_i other voters vote for you, and the i-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with m_1 = 1, m_2 = 2, m_3 = 2, m_4 = 4, m_5 = 5, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: {5} → {1, 5} → {1, 2, 3, 5} → {1, 2, 3, 4, 5}.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 5000) — the number of voters.
The next n lines contains the description of voters. i-th line contains two integers m_i and p_i (1 ≤ p_i ≤ 10^9, 0 ≤ m_i < n).
It is guaranteed that the sum of all n over all test cases does not exceed 5000.
Output
For each test case print one integer — the minimum number of coins you have to spend so that everyone votes for you.
Example
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
Note
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: {3} → {1, 3} → {1, 2, 3}.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: {1} → {1, 3, 5} → {1, 2, 3, 5} → {1, 2, 3, 5, 6, 7} → {1, 2, 3, 4, 5, 6, 7}.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: {2, 5} → {1, 2, 3, 4, 5} → {1, 2, 3, 4, 5, 6}.
Submitted Solution:
```
import heapq
for _ in range(int(input())):
n = int(input())
voters = []
for i in range(n):
m,p = list(map(int, input().split()))
voters.append((m, -p))
voters.sort()
for i in range(n):
voters[i] = (voters[i][0], -voters[i][1])
ans = 0
costs = []
heapq.heapify(costs)
bought = 0
for i in range(n-1, -1, -1):
buysNeeded = voters[i][0] - i - bought
heapq.heappush(costs, voters[i][1])
while buysNeeded > 0 and len(costs) > 0:
ans += heapq.heappop(costs)
bought += 1
buysNeeded -= 1
print(ans)
``` | instruction | 0 | 62,399 | 10 | 124,798 |
Yes | output | 1 | 62,399 | 10 | 124,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.