There are **N** houses for sale.
The i-th house costs **A _{i}** dollars to buy.
You have a budget of

What is the maximum number of houses you can buy?

The first line of the input gives the number of test cases, **T**.
**T** test cases follow. Each test case begins with a single line containing the two integers **N** and **B**.
The second line contains **N** integers. The i-th integer is **A _{i}**, the cost of the i-th house.

For each test case, output one line containing `Case #x: y`

, where `x`

is the test case number (starting from 1) and `y`

is
the maximum number of houses you can buy.

Time limit: 15 seconds per test set.

Memory limit: 1GB.

1 <= **T** <= 100.

1 <= **B** <= 10^{5}.

1 <= **A _{i}** <= 1000, for all i.

1 <= **N** <= 100.

1 <= **N** <= 10^{5}.

3 4 100 20 90 40 90 4 50 30 30 10 10 3 300 999 999 999

Case #1: 2 Case #2: 3 Case #3: 0

#### Analysis

We want to buy as many as possible houses. Intuitively, we can keep buying the cheapest house. The
rationale is to save money at each step so we could buy more in the end. One way to implement this
strategy is to sort all the houses by prices from low to high and then buy houses one by one until
we run out of money.

The sorting part has O(**N** log **N**) time complexity and the processing part has
O(**N**) time complexity. Using counting sort could reduce the sorting complexity to
O(**N**) since the range of the prices is [1, 1000]. The overall time complexity is
O(**N**).

Let's prove the correctness of this greedy algorithm. Let the solution produced by the greedy
algorithm be **A** = {a_{1}, a_{2}, ..., a_{k}} and an optimal solution
**O** = {o_{1}, o_{2}, ..., o_{m}}.

If **O** and **A** are the same, we are done with the proof. Let's assume that there is at
least one element o_{j} in **O** that is not present in **A**. Because we always
take the smallest element from the original set, we know that any element that is not in **A**
is greater than or equal to any a_{i} in **A**. We could replace o_{j} with the
absent element in **A** without worsening the solution, because there will always be element in
**A** that is not in **O**. We then increased number of elements in common between **A**
and **O**, hence we can repeat this operation only finite number of times. We could repeat this
process until all the elements in **O** are elements in **A**. Therefore, **A** is as
good as any optimal solution.

```
use rustgym_util::*;
use std::fmt::Write;
use std::io::*;
fn solve(case_no: usize, reader: &mut impl BufRead, writer: &mut impl Write) {
let args: Vec<usize> = reader.parse_vec();
let n = args[0];
let b = args[1] as i32;
let mut houses: Vec<i32> = reader.parse_vec();
houses.sort_unstable();
let mut sum = 0;
let mut res = 0;
for i in 0..n {
if houses[i] + sum <= b {
sum += houses[i];
res += 1;
}
}
writeln!(writer, "Case #{}: {}", case_no, res).unwrap();
}
google_test_gen!(test, "input.txt", "output.txt");
```