Orig Description
Score : 200 points
Problem StatementAkaki, a patissier, can make N kinds of doughnut using only a certain powder called "Okashi no Moto" (literally "material of pastry", simply called Moto below) as ingredient. These doughnuts are called Doughnut 1, Doughnut 2, ..., Doughnut N. In order to make one Doughnut i (1 ≤ i ≤ N), she needs to consume m_i grams of Moto. She cannot make a non-integer number of doughnuts, such as 0.5 doughnuts.
Now, she has X grams of Moto. She decides to make as many doughnuts as possible for a party tonight. However, since the tastes of the guests differ, she will obey the following condition:
For each of the N kinds of doughnuts, make at least one doughnut of that kind.
At most how many doughnuts can be made here? She does not necessarily need to consume all of her Moto. Also, under the constraints of this problem, it is always possible to obey the condition.
Constraints
2 ≤ N ≤ 100
1 ≤ m_i ≤ 1000
m_1 + m_2 + ... + m_N ≤ X ≤ 10^5
All values in input are integers.
InputInput is given from Standard Input in the following format:
N X
m_1
m_2
:
m_N
OutputPrint the maximum number of doughnuts that can be made under the condition.
Sample Input 13 1000
120
100
140
Sample Output 19
She has 1000 grams of Moto and can make three kinds of doughnuts. If she makes one doughnut for each of the three kinds, she consumes 120 + 100 + 140 = 360 grams of Moto. From the 640 grams of Moto that remains here, she can make additional six Doughnuts 2. This is how she can made a total of nine doughnuts, which is the maximum.
Sample Input 24 360
90
90
90
90
Sample Output 24
Making one doughnut for each of the four kinds consumes all of her Moto.
Sample Input 35 3000
150
130
150
130
110
Sample Output 326
Extracted Specification
An integer N (2 ≤ N ≤ 100), representing some quantity or size.
An integer X (N ≤ X ≤ 10^5), representing another quantity.
A list of integers m of size N, where each integer is between 1 and 1000.
### Example Input:
```
3 1000
120
100
140
```
### Function Signature:
Write a function f(N, X, m) that takes in the input.
def f(N: int, X: int, m: List[int]):
'''
N: an integer
X: an integer
m: a list of integers
'''
Test Case Generator
Sure! Below is a test case generator for the given problem statement.
```python
import random
def tcgen():
# Generate the number of doughnut types
N = random.randint(2, 100)
# Generate grams required for each doughnut type
m = [random.randint(1, 1000) for _ in range(N)]
# Ensure the sum of m is less than X and generate X appropriately
sum_m = sum(m)
X = random.randint(sum_m, 100000)
return N, X, m
# Example of generating a test case
N, X, m = tcgen()
print(N)
print(X)
for grams in m:
print(grams)
```
This function `tcgen` will generate random test cases for the given problem statement. Here's a breakdown of how it works:
1. It generates a random integer \( N \) between 2 and 100, inclusive, representing the number of doughnut types.
2. It generates a list \( m \) of size \( N \) where each element is a random integer between 1 and 1000, inclusive, representing the grams of Moto required to make each type of doughnut.
3. It calculates the sum of the \( m \) list to ensure that \( X \) is at least as large as the sum of \( m \) and then generates a random integer \( X \) between the sum of \( m \) and 100000, inclusive.
The generated test case is printed in the required input format.
Extract Arguments
def extract_arguments(fh):
first_line = fh.readline().strip().split()
N = int(first_line[0])
X = int(first_line[1])
m = [int(fh.readline().strip()) for _ in range(N)]
return N, X, m