output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b;
int a[b + 1];
for (int j = 0; j < b; j++) cin >> a[j];
sort(a, a + b);
int mn = 999999;
for (int j = 1; j < b; j++) {
mn = min(a[j] - a[j - 1], mn);
}
cout << mn << endl;
}
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b;
int a[b + 1];
for (int j = 0; j < b; j++) cin >> a[j];
sort(a, a + b);
int mn = 999999;
for (int j = 1; j < b; j++) {
mn = min(a[j] - a[j - 1], mn);
}
cout << mn << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, min;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
min = a[1] - a[0];
for (int j = 1; j < n - 1; j++) {
if (a[j + 1] - a[j] < min) min = a[j + 1] - a[j];
}
cout << min << endl;
}
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, min;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
min = a[1] - a[0];
for (int j = 1; j < n - 1; j++) {
if (a[j + 1] - a[j] < min) min = a[j + 1] - a[j];
}
cout << min << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5;
int n, a[mxN];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int mindiff = a[1] - a[0];
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] < mindiff) mindiff = a[i] - a[i - 1];
}
cout << mindiff << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| ### Prompt
Create a solution in CPP for the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5;
int n, a[mxN];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int mindiff = a[1] - a[0];
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] < mindiff) mindiff = a[i] - a[i - 1];
}
cout << mindiff << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
int mima(vector<int> vec, int f) {
int mi = vec[0], ma = vec[0];
for (int i = 1; i < vec.size(); i += 1) {
mi = min(mi, vec[i]);
ma = max(ma, vec[i]);
}
if (f) {
return ma;
} else {
return mi;
}
}
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i += 1) {
cin >> arr[i];
}
int ans = INT_MAX;
sort(arr.begin(), arr.end());
for (int i = 0; i < n - 1; i += 1) {
if (abs(arr[i] - arr[i + 1]) < ans) {
ans = abs(arr[i] - arr[i + 1]);
}
}
cout << ans << "\n";
}
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
int mima(vector<int> vec, int f) {
int mi = vec[0], ma = vec[0];
for (int i = 1; i < vec.size(); i += 1) {
mi = min(mi, vec[i]);
ma = max(ma, vec[i]);
}
if (f) {
return ma;
} else {
return mi;
}
}
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i += 1) {
cin >> arr[i];
}
int ans = INT_MAX;
sort(arr.begin(), arr.end());
for (int i = 0; i < n - 1; i += 1) {
if (abs(arr[i] - arr[i + 1]) < ans) {
ans = abs(arr[i] - arr[i + 1]);
}
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int max = 100001;
for (int i = 0; i < n - 1; i++) {
int dif = arr[i + 1] - arr[i];
max = min(dif, max);
}
cout << max << endl;
}
}
| ### Prompt
In Cpp, your task is to solve the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int max = 100001;
for (int i = 0; i < n - 1; i++) {
int dif = arr[i + 1] - arr[i];
max = min(dif, max);
}
cout << max << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int Arr[n];
int sub, res;
for (int i = 0; i < n; i++) {
cin >> Arr[i];
}
sort(Arr, Arr + n);
res = INT_MAX;
for (int i = 0; i < n - 1; i++) {
sub = abs(Arr[i + 1] - Arr[i]);
res = min(res, sub);
}
cout << res << endl;
}
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int Arr[n];
int sub, res;
for (int i = 0; i < n; i++) {
cin >> Arr[i];
}
sort(Arr, Arr + n);
res = INT_MAX;
for (int i = 0; i < n - 1; i++) {
sub = abs(Arr[i + 1] - Arr[i]);
res = min(res, sub);
}
cout << res << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100069], inf = 1e18;
int main() {
long long t, rr, i, z;
scanf("%lld", &t);
for (rr = 0; rr < t; rr++) {
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
sort(a + 1, a + n + 1);
z = inf;
for (i = 2; i <= n; i++) {
z = min(z, a[i] - a[i - 1]);
}
printf("%lld\n", z);
}
}
| ### Prompt
Develop a solution in cpp to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, a[100069], inf = 1e18;
int main() {
long long t, rr, i, z;
scanf("%lld", &t);
for (rr = 0; rr < t; rr++) {
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
sort(a + 1, a + n + 1);
z = inf;
for (i = 2; i <= n; i++) {
z = min(z, a[i] - a[i - 1]);
}
printf("%lld\n", z);
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int main() {
std::ios::sync_with_stdio(false);
int t;
int a[maxn];
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int ans = 0x3f3f3f3f;
for (int i = 0; i < n - 1; i++) ans = min(ans, a[i + 1] - a[i]);
printf("%d\n", ans);
}
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int main() {
std::ios::sync_with_stdio(false);
int t;
int a[maxn];
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int ans = 0x3f3f3f3f;
for (int i = 0; i < n - 1; i++) ans = min(ans, a[i + 1] - a[i]);
printf("%d\n", ans);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
v.emplace_back(x);
}
sort(begin(v), end(v));
int res = ~(1 << 31);
for (int i = 1; i < n; ++i) {
res = min(res, abs(v[i] - v[i - 1]));
}
cout << res << "\n";
}
}
| ### Prompt
Please formulate a cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
v.emplace_back(x);
}
sort(begin(v), end(v));
int res = ~(1 << 31);
for (int i = 1; i < n; ++i) {
res = min(res, abs(v[i] - v[i - 1]));
}
cout << res << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b, long long m = 1000000007) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long inverse(long long a, long long m = 1000000007) {
return power(a, m - 2, m);
}
bool isPrime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
vector<int> primes;
void sieve() {
int i, j;
bitset<3200> b;
b.set();
b[0] = b[1] = 0;
for (i = 2; i <= 3180; i++) {
if (b[i] == 1) {
for (j = i * i; j <= 3180; j += i) b[j] = 0;
primes.push_back(i);
}
}
}
bool dist(int n) {
int cnt[10];
memset(cnt, 0, sizeof cnt);
while (n) {
cnt[n % 10]++;
n /= 10;
}
return *max_element(cnt, cnt + 10) == 1;
}
int a[55];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int i;
for (i = 0; i < n; i++) cin >> a[i];
int d = 1e9;
sort(a, a + n);
for (i = 0; i < n - 1; i++) {
d = min(d, abs(a[i + 1] - a[i]));
}
cout << d << '\n';
}
cin.get();
cin.get();
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b, long long m = 1000000007) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long inverse(long long a, long long m = 1000000007) {
return power(a, m - 2, m);
}
bool isPrime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
vector<int> primes;
void sieve() {
int i, j;
bitset<3200> b;
b.set();
b[0] = b[1] = 0;
for (i = 2; i <= 3180; i++) {
if (b[i] == 1) {
for (j = i * i; j <= 3180; j += i) b[j] = 0;
primes.push_back(i);
}
}
}
bool dist(int n) {
int cnt[10];
memset(cnt, 0, sizeof cnt);
while (n) {
cnt[n % 10]++;
n /= 10;
}
return *max_element(cnt, cnt + 10) == 1;
}
int a[55];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int i;
for (i = 0; i < n; i++) cin >> a[i];
int d = 1e9;
sort(a, a + n);
for (i = 0; i < n - 1; i++) {
d = min(d, abs(a[i + 1] - a[i]));
}
cout << d << '\n';
}
cin.get();
cin.get();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, x, y = INT_MAX;
cin >> x;
while (x--) {
set<int> s;
y = INT_MAX;
cin >> n;
vector<long long> v;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
s.insert(k);
}
if (s.size() < n)
cout << 0 << endl;
else {
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i != 0) y = min(v[i] - v[i - 1], y);
}
cout << y << endl;
}
}
return 0;
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, x, y = INT_MAX;
cin >> x;
while (x--) {
set<int> s;
y = INT_MAX;
cin >> n;
vector<long long> v;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
s.insert(k);
}
if (s.size() < n)
cout << 0 << endl;
else {
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i != 0) y = min(v[i] - v[i - 1], y);
}
cout << y << endl;
}
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, i, min = INT_MAX;
cin >> n;
long long int a[n];
;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
;
for (i = 0; i < n - 1; i++)
if (a[i + 1] - a[i] < min) min = a[i + 1] - a[i];
cout << min << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, i, min = INT_MAX;
cin >> n;
long long int a[n];
;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
;
for (i = 0; i < n - 1; i++)
if (a[i + 1] - a[i] < min) min = a[i + 1] - a[i];
cout << min << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int arr[10110];
int main() {
int t;
cin >> t;
while (t) {
int n, mi = 1000000;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 1; i < n; i++) {
if (mi > (arr[i] - arr[i - 1])) {
mi = arr[i] - arr[i - 1];
}
}
cout << mi << "\n";
t--;
}
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int arr[10110];
int main() {
int t;
cin >> t;
while (t) {
int n, mi = 1000000;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 1; i < n; i++) {
if (mi > (arr[i] - arr[i - 1])) {
mi = arr[i] - arr[i - 1];
}
}
cout << mi << "\n";
t--;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
int diff = 1000;
for (int i = 0; i < n - 1; ++i) {
if (arr[i + 1] - arr[i] < diff) {
diff = arr[i + 1] - arr[i];
}
}
cout << diff << "\n";
}
return 0;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
int diff = 1000;
for (int i = 0; i < n - 1; ++i) {
if (arr[i + 1] - arr[i] < diff) {
diff = arr[i + 1] - arr[i];
}
}
cout << diff << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int aa, n;
cin >> aa;
while (aa--) {
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int max = 1000001;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++)
if (abs(a[i] - a[j]) < max) {
max = abs(a[i] - a[j]);
}
}
cout << max << endl;
}
}
| ### Prompt
Generate a Cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int aa, n;
cin >> aa;
while (aa--) {
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int max = 1000001;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++)
if (abs(a[i] - a[j]) < max) {
max = abs(a[i] - a[j]);
}
}
cout << max << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
long long mod(long long n) {
return (n % 1000000007 + 1000000007) % 1000000007;
}
string test = "-------------------";
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int testCase = 1; testCase <= t; ++testCase) {
int n;
cin >> n;
vector<int> vec(n);
for (int i = 0; i < n; ++i) {
cin >> vec[i];
}
sort((vec).begin(), (vec).end());
int diff = 1000000007;
for (int i = 0; i < n - 1; ++i) {
diff = min(diff, abs(vec[i] - vec[i + 1]));
}
cout << diff << "\n";
}
return 0;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
long long mod(long long n) {
return (n % 1000000007 + 1000000007) % 1000000007;
}
string test = "-------------------";
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int testCase = 1; testCase <= t; ++testCase) {
int n;
cin >> n;
vector<int> vec(n);
for (int i = 0; i < n; ++i) {
cin >> vec[i];
}
sort((vec).begin(), (vec).end());
int diff = 1000000007;
for (int i = 0; i < n - 1; ++i) {
diff = min(diff, abs(vec[i] - vec[i + 1]));
}
cout << diff << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int findGCD(long long int arr[], long long int n) {
long long int result = arr[0];
for (int i = 1; i < n; i++) {
result = gcd(arr[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
long long int fact(long long int g) {
long long int ans = 0;
for (long long int i = 1; i * i <= g; ++i) {
if (g % i == 0) {
++ans;
if (i != g / i) {
++ans;
}
}
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ans[n];
for (int i = 0; i < n; i++) {
cin >> ans[i];
}
sort(ans, ans + n);
int flag = 0;
int mini = ans[1] - ans[0];
for (int i = n - 1; i >= 1; i--) {
mini = min(ans[i] - ans[i - 1], mini);
}
cout << mini << endl;
}
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int findGCD(long long int arr[], long long int n) {
long long int result = arr[0];
for (int i = 1; i < n; i++) {
result = gcd(arr[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
long long int fact(long long int g) {
long long int ans = 0;
for (long long int i = 1; i * i <= g; ++i) {
if (g % i == 0) {
++ans;
if (i != g / i) {
++ans;
}
}
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ans[n];
for (int i = 0; i < n; i++) {
cin >> ans[i];
}
sort(ans, ans + n);
int flag = 0;
int mini = ans[1] - ans[0];
for (int i = n - 1; i >= 1; i--) {
mini = min(ans[i] - ans[i - 1], mini);
}
cout << mini << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long i, j, k, t, l, r, n, m, x, y, a, b, c;
cin >> t;
while (t--) {
cin >> n;
unsigned long long arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
unsigned long long ans = INT_MIN;
for (i = 1; i < n; i++) {
ans = min(ans, arr[i] - arr[i - 1]);
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long i, j, k, t, l, r, n, m, x, y, a, b, c;
cin >> t;
while (t--) {
cin >> n;
unsigned long long arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
unsigned long long ans = INT_MIN;
for (i = 1; i < n; i++) {
ans = min(ans, arr[i] - arr[i - 1]);
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int s[1050];
int main() {
int ttc, n, a, b;
cin >> ttc;
for (int i = 0; i < ttc; ++i) {
cin >> n;
int j = 0;
for (; j < n; ++j) {
cin >> s[j];
}
sort(s, s + j);
int minresult = 99999;
for (int k = 1; k < n; ++k) {
minresult = min(minresult, abs(s[k] - s[k - 1]));
}
cout << minresult << endl;
}
return 0;
}
| ### Prompt
Please formulate a Cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int s[1050];
int main() {
int ttc, n, a, b;
cin >> ttc;
for (int i = 0; i < ttc; ++i) {
cin >> n;
int j = 0;
for (; j < n; ++j) {
cin >> s[j];
}
sort(s, s + j);
int minresult = 99999;
for (int k = 1; k < n; ++k) {
minresult = min(minresult, abs(s[k] - s[k - 1]));
}
cout << minresult << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt;
cin >> cnt;
while (cnt--) {
int num;
cin >> num;
int t[1005] = {0};
for (int i = 0; i < num; ++i) {
cin >> t[i];
}
sort(t, t + num);
int min_val = 0x0FFFFFFF;
for (int i = 1; i < num; ++i) {
min_val = min(min_val, t[i] - t[i - 1]);
}
cout << min_val << endl;
}
return 0;
}
| ### Prompt
Generate a cpp solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int cnt;
cin >> cnt;
while (cnt--) {
int num;
cin >> num;
int t[1005] = {0};
for (int i = 0; i < num; ++i) {
cin >> t[i];
}
sort(t, t + num);
int min_val = 0x0FFFFFFF;
for (int i = 1; i < num; ++i) {
min_val = min(min_val, t[i] - t[i - 1]);
}
cout << min_val << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], i, min1 = 10000, s = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n - 1; i++) {
s = abs(a[i + 1] - a[i]);
min1 = min(min1, s);
}
cout << min1 << endl;
}
}
| ### Prompt
Your challenge is to write a CPP solution to the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], i, min1 = 10000, s = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n - 1; i++) {
s = abs(a[i + 1] - a[i]);
min1 = min(min1, s);
}
cout << min1 << endl;
}
}
``` |
#include <bits/stdc++.h>
int main() {
int i, j, t, n, min, a, b, c, k;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d", &n);
int arr[n];
for (j = 0; j < n; j++) scanf("%d", &arr[j]);
min = fabs(arr[0] - arr[1]);
for (j = 0; j < n - 1; j++) {
a = arr[j];
for (k = j + 1; k < n; k++) {
if (fabs(a - arr[k]) < min) min = fabs(a - arr[k]);
}
}
printf("%d\n", min);
}
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
There are n athletes in front of you. Athletes are numbered from 1 to n from left to right. You know the strength of each athlete — the athlete number i has the strength s_i.
You want to split all athletes into two teams. Each team must have at least one athlete, and each athlete must be exactly in one team.
You want the strongest athlete from the first team to differ as little as possible from the weakest athlete from the second team. Formally, you want to split the athletes into two teams A and B so that the value |max(A) - min(B)| is as small as possible, where max(A) is the maximum strength of an athlete from team A, and min(B) is the minimum strength of an athlete from team B.
For example, if n=5 and the strength of the athletes is s=[3, 1, 2, 6, 4], then one of the possible split into teams is:
* first team: A = [1, 2, 4],
* second team: B = [3, 6].
In this case, the value |max(A) - min(B)| will be equal to |4-3|=1. This example illustrates one of the ways of optimal split into two teams.
Print the minimum value |max(A) - min(B)|.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Then t test cases follow.
Each test case consists of two lines.
The first line contains positive integer n (2 ≤ n ≤ 50) — number of athletes.
The second line contains n positive integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 1000), where s_i — is the strength of the i-th athlete. Please note that s values may not be distinct.
Output
For each test case print one integer — the minimum value of |max(A) - min(B)| with the optimal split of all athletes into two teams. Each of the athletes must be a member of exactly one of the two teams.
Example
Input
5
5
3 1 2 6 4
6
2 1 3 2 4 3
4
7 9 3 1
2
1 1000
3
100 150 200
Output
1
0
2
999
50
Note
The first test case was explained in the statement. In the second test case, one of the optimal splits is A=[2, 1], B=[3, 2, 4, 3], so the answer is |2-2|=0.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int i, j, t, n, min, a, b, c, k;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d", &n);
int arr[n];
for (j = 0; j < n; j++) scanf("%d", &arr[j]);
min = fabs(arr[0] - arr[1]);
for (j = 0; j < n - 1; j++) {
a = arr[j];
for (k = j + 1; k < n; k++) {
if (fabs(a - arr[k]) < min) min = fabs(a - arr[k]);
}
}
printf("%d\n", min);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t;
cin >> t;
while (t--) {
ll n, x;
cin >> n >> x;
ll ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
ll ans = 0;
ll num = 0;
for (int i = n - 1; i >= 0; i--) {
++num;
ll ff = num * ar[i];
if (ff >= x) {
++ans;
num = 0;
continue;
}
}
cout << ans << "\n";
}
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t;
cin >> t;
while (t--) {
ll n, x;
cin >> n >> x;
ll ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
ll ans = 0;
ll num = 0;
for (int i = n - 1; i >= 0; i--) {
++num;
ll ff = num * ar[i];
if (ff >= x) {
++ans;
num = 0;
continue;
}
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, x, sum;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int cnt = 0, j = 1;
for (int i = n - 1; i >= 0; i--) {
sum = a[i] * j;
j++;
if (sum >= x) {
sum = 0;
cnt++;
j = 1;
}
}
cout << cnt << endl;
}
return 0;
}
| ### Prompt
Please create a solution in CPP to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, x, sum;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int cnt = 0, j = 1;
for (int i = n - 1; i >= 0; i--) {
sum = a[i] * j;
j++;
if (sum >= x) {
sum = 0;
cnt++;
j = 1;
}
}
cout << cnt << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tests;
cin >> tests;
while (tests--) {
int n, x;
cin >> n >> x;
vector<int> a(n);
for (int& it : a) cin >> it;
sort(a.rbegin(), a.rend());
int ans = 0, last = -1;
for (int i = 0; i < n; i++) {
int len = i - last;
if (len * a[i] < x) continue;
last = i;
ans++;
}
cout << ans << "\n";
}
return 0;
}
| ### Prompt
Please create a solution in cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tests;
cin >> tests;
while (tests--) {
int n, x;
cin >> n >> x;
vector<int> a(n);
for (int& it : a) cin >> it;
sort(a.rbegin(), a.rend());
int ans = 0, last = -1;
for (int i = 0; i < n; i++) {
int len = i - last;
if (len * a[i] < x) continue;
last = i;
ans++;
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int Solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int ans = 0;
for (int i = n, k = 0; i > 0; --i) {
++k;
if (1ll * k * a[i] >= m) {
++ans;
k = 0;
}
}
return ans;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
printf("%d\n", Solve());
}
return 0;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int Solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int ans = 0;
for (int i = n, k = 0; i > 0; --i) {
++k;
if (1ll * k * a[i] >= m) {
++ans;
k = 0;
}
}
return ans;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
printf("%d\n", Solve());
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = (0); (1) > 0 ? i < (t) : i >= (t); i += (1)) {
int n, x;
cin >> n >> x;
vector<int> num(n);
for (auto& j : num) cin >> j;
sort((num).begin(), (num).end());
int cont = 1;
int ans = 0;
for (int j = (n - 1); (-1) > 0 ? j < (0) : j >= (0); j += (-1)) {
if (num[j] * cont >= x)
++ans, cont = 1;
else
++cont;
}
cout << ans << "\n";
}
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = (0); (1) > 0 ? i < (t) : i >= (t); i += (1)) {
int n, x;
cin >> n >> x;
vector<int> num(n);
for (auto& j : num) cin >> j;
sort((num).begin(), (num).end());
int cont = 1;
int ans = 0;
for (int j = (n - 1); (-1) > 0 ? j < (0) : j >= (0); j += (-1)) {
if (num[j] * cont >= x)
++ans, cont = 1;
else
++cont;
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
vector<long long int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<long long int>());
long long int mn = LONG_LONG_MAX;
long long int cnt = 1, c = 0;
for (int i = 0; i < n;) {
long long int s = cnt * v[i];
if (s >= x) {
c++;
cnt = 1;
i++;
} else {
cnt++;
i++;
}
}
cout << c << "\n";
}
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
vector<long long int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<long long int>());
long long int mn = LONG_LONG_MAX;
long long int cnt = 1, c = 0;
for (int i = 0; i < n;) {
long long int s = cnt * v[i];
if (s >= x) {
c++;
cnt = 1;
i++;
} else {
cnt++;
i++;
}
}
cout << c << "\n";
}
}
``` |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MOD = 1e9 + 7;
const int INF32 = 1 << 30;
const long long INF64 = 1LL << 60;
void solve() {
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.rbegin(), a.rend());
long long sum = a[0];
int num = 1;
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (sum < x) {
num++;
sum = a[i + 1] * num;
} else {
ans++;
sum = a[i + 1];
num = 1;
}
}
if (sum >= x) ans++;
cout << ans << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| ### Prompt
Please formulate a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MOD = 1e9 + 7;
const int INF32 = 1 << 30;
const long long INF64 = 1LL << 60;
void solve() {
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.rbegin(), a.rend());
long long sum = a[0];
int num = 1;
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (sum < x) {
num++;
sum = a[i + 1] * num;
} else {
ans++;
sum = a[i + 1];
num = 1;
}
}
if (sum >= x) ans++;
cout << ans << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x, count = 0, sum = 0;
cin >> n >> x;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (x % a[i] == 0)
a[i] = x / a[i];
else
a[i] = x / a[i] + 1;
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] <= n) {
count++;
sum = sum + count / a[i];
count = count % a[i];
} else {
break;
}
}
cout << sum << endl;
}
}
| ### Prompt
Generate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x, count = 0, sum = 0;
cin >> n >> x;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (x % a[i] == 0)
a[i] = x / a[i];
else
a[i] = x / a[i] + 1;
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] <= n) {
count++;
sum = sum + count / a[i];
count = count % a[i];
} else {
break;
}
}
cout << sum << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x, cont = 0, cant = 1;
scanf("%d%d", &n, &x);
int arr[n];
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
for (int i = n - 1; i >= 0; i--) {
if (cant * arr[i] >= x) {
cont++;
cant = 1;
} else
cant++;
}
printf("%d\n", cont);
}
return 0;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x, cont = 0, cant = 1;
scanf("%d%d", &n, &x);
int arr[n];
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
for (int i = n - 1; i >= 0; i--) {
if (cant * arr[i] >= x) {
cont++;
cant = 1;
} else
cant++;
}
printf("%d\n", cont);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long a[N], b[N], p[N];
long long cnt1, cnt2, ans1, ans2, ou, ji, sum, y, d, ans, m, n, i,
t = 0, j, k, l, cnt, x, z, c;
string s;
bool cmp(int a, int b) { return a > b; }
int main() {
cin >> t;
while (t--) {
ans = 0;
cnt = 1;
cin >> n >> x;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
if (a[i] * cnt >= x)
ans++, cnt = 1;
else
cnt++;
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
In CPP, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long a[N], b[N], p[N];
long long cnt1, cnt2, ans1, ans2, ou, ji, sum, y, d, ans, m, n, i,
t = 0, j, k, l, cnt, x, z, c;
string s;
bool cmp(int a, int b) { return a > b; }
int main() {
cin >> t;
while (t--) {
ans = 0;
cnt = 1;
cin >> n >> x;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
if (a[i] * cnt >= x)
ans++, cnt = 1;
else
cnt++;
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> a;
int main() {
ll t;
cin >> t;
while (t--) {
ll n, k;
cin >> n >> k;
ll m = n;
a.clear();
ll cnt = 0;
while (m--) {
ll xx;
cin >> xx;
a.push_back(xx);
}
sort(a.rbegin(), a.rend());
ll s = 0;
for (auto i : a) {
s++;
if (s * i >= k) {
cnt++;
s = 0;
}
}
cout << cnt << '\n';
}
}
| ### Prompt
In Cpp, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> a;
int main() {
ll t;
cin >> t;
while (t--) {
ll n, k;
cin >> n >> k;
ll m = n;
a.clear();
ll cnt = 0;
while (m--) {
ll xx;
cin >> xx;
a.push_back(xx);
}
sort(a.rbegin(), a.rend());
ll s = 0;
for (auto i : a) {
s++;
if (s * i >= k) {
cnt++;
s = 0;
}
}
cout << cnt << '\n';
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool sortcol(vector<int>& v1, vector<int>& v2) { return v1[1] < v2[1]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
long long x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long ans = 0;
int i = n - 1, t, cnt = 1;
while (n > 0 && i >= 0 && n - cnt >= 0) {
if (a[i] * cnt >= x && (n - cnt) >= 0) {
ans++;
n = n - cnt;
i--;
cnt = 1;
} else {
i--;
cnt++;
}
}
cout << ans << endl;
}
}
| ### Prompt
Please formulate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool sortcol(vector<int>& v1, vector<int>& v2) { return v1[1] < v2[1]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
long long x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long ans = 0;
int i = n - 1, t, cnt = 1;
while (n > 0 && i >= 0 && n - cnt >= 0) {
if (a[i] * cnt >= x && (n - cnt) >= 0) {
ans++;
n = n - cnt;
i--;
cnt = 1;
} else {
i--;
cnt++;
}
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long sum = 0, cnt = 0, flag = 0, blb = 0, i, j, mn = LLONG_MAX,
mx = LLONG_MIN, m;
const long long a = 1e9 + 7;
void ts() { cout << "Hello\n"; }
void ss() {
if (blb == 0)
cout << "Yes\n";
else
cout << "No\n";
}
int main() {
int t;
cin >> t;
while (t--) {
flag = 0, cnt = 0, sum = 0, blb = 1;
string str, str1;
long long n, x, y, z, m = 0;
vector<long long> v, v1, v2;
map<long long, long long> mp;
cin >> n >> m;
int ar[n + 10];
for (i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
for (i = n - 1; i >= 0; i--) {
if (ar[i] * blb >= m) {
sum++;
blb = 1;
} else
blb++;
}
cout << sum << endl;
}
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long sum = 0, cnt = 0, flag = 0, blb = 0, i, j, mn = LLONG_MAX,
mx = LLONG_MIN, m;
const long long a = 1e9 + 7;
void ts() { cout << "Hello\n"; }
void ss() {
if (blb == 0)
cout << "Yes\n";
else
cout << "No\n";
}
int main() {
int t;
cin >> t;
while (t--) {
flag = 0, cnt = 0, sum = 0, blb = 1;
string str, str1;
long long n, x, y, z, m = 0;
vector<long long> v, v1, v2;
map<long long, long long> mp;
cin >> n >> m;
int ar[n + 10];
for (i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
for (i = n - 1; i >= 0; i--) {
if (ar[i] * blb >= m) {
sum++;
blb = 1;
} else
blb++;
}
cout << sum << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 1;
void solve() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int ans = 0;
for (int i = n - 1, j = n; i >= 0; i--) {
if (v[i] * (j - i) >= x) ans++, j = i;
}
cout << ans << "\n";
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 1;
void solve() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int ans = 0;
for (int i = n - 1, j = n; i >= 0; i--) {
if (v[i] * (j - i) >= x) ans++, j = i;
}
cout << ans << "\n";
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, ans = 0;
cin >> n;
long long x, t;
cin >> x;
vector<long long> a;
for (int i = 0; i < n; i++) {
cin >> t;
if (t >= x)
ans++;
else
a.push_back(t);
}
if (a.size() < 2) {
cout << ans << endl;
continue;
}
sort(a.begin(), a.end());
vector<long long>::iterator itr = a.begin();
while (1) {
t = ((x - 1) / (*itr)) + 1;
while (t > a.size()) {
a.erase(itr);
if (a.size() == 0) break;
itr = a.begin();
t = ((x - 1) / (*itr)) + 1;
}
if (a.size() == 0) break;
itr++;
for (int i = 1; i < t; i++) {
if (t - i >= ((x - 1) / (*itr)) + 1) {
a.erase(a.begin(), itr);
itr = a.begin();
t = i + ((x - 1) / (*itr)) + 1;
}
itr++;
}
ans++;
a.erase(a.begin(), itr);
if (a.size() == 0) break;
itr = a.begin();
}
cout << ans << endl;
}
return (0);
}
| ### Prompt
Please create a solution in Cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, ans = 0;
cin >> n;
long long x, t;
cin >> x;
vector<long long> a;
for (int i = 0; i < n; i++) {
cin >> t;
if (t >= x)
ans++;
else
a.push_back(t);
}
if (a.size() < 2) {
cout << ans << endl;
continue;
}
sort(a.begin(), a.end());
vector<long long>::iterator itr = a.begin();
while (1) {
t = ((x - 1) / (*itr)) + 1;
while (t > a.size()) {
a.erase(itr);
if (a.size() == 0) break;
itr = a.begin();
t = ((x - 1) / (*itr)) + 1;
}
if (a.size() == 0) break;
itr++;
for (int i = 1; i < t; i++) {
if (t - i >= ((x - 1) / (*itr)) + 1) {
a.erase(a.begin(), itr);
itr = a.begin();
t = i + ((x - 1) / (*itr)) + 1;
}
itr++;
}
ans++;
a.erase(a.begin(), itr);
if (a.size() == 0) break;
itr = a.begin();
}
cout << ans << endl;
}
return (0);
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<long long> dp(n + 1);
for (int i = n - 1; i >= 0; i--) {
long long r = x / a[i] + (x % a[i] ? 1 : 0);
if (i + r <= n) dp[i] = 1 + dp[i + r];
dp[i] = max(dp[i], dp[i + 1]);
}
cout << dp[0] << endl;
}
return 0;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<long long> dp(n + 1);
for (int i = n - 1; i >= 0; i--) {
long long r = x / a[i] + (x % a[i] ? 1 : 0);
if (i + r <= n) dp[i] = 1 + dp[i + r];
dp[i] = max(dp[i], dp[i + 1]);
}
cout << dp[0] << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int t, n, mt[100000], m[100000], ti;
long long int x, a[100000];
int f(int i) {
if (i == n) return 0;
if (i > n) return -1;
if (mt[i] == ti) return m[i];
mt[i] = ti;
int next = ((x + a[i] - 1) / a[i]) - 1, ans;
ans = max(1 + f(i + next + 1), f(i + 1));
m[i] = ans;
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> t;
for (ti = 1; ti <= t; ti++) {
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cout << f(0) << "\n";
}
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int t, n, mt[100000], m[100000], ti;
long long int x, a[100000];
int f(int i) {
if (i == n) return 0;
if (i > n) return -1;
if (mt[i] == ti) return m[i];
mt[i] = ti;
int next = ((x + a[i] - 1) / a[i]) - 1, ans;
ans = max(1 + f(i + next + 1), f(i + 1));
m[i] = ans;
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> t;
for (ti = 1; ti <= t; ti++) {
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cout << f(0) << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> arr(n);
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr.rbegin(), arr.rend());
long long cnt = 0;
long long start = -1;
for (long long i = 0; i < n; i++) {
if ((i - start) * arr[i] >= x) {
cnt++;
start = i;
}
}
cout << cnt << '\n';
return;
}
int32_t main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> arr(n);
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr.rbegin(), arr.rend());
long long cnt = 0;
long long start = -1;
for (long long i = 0; i < n; i++) {
if ((i - start) * arr[i] >= x) {
cnt++;
start = i;
}
}
cout << cnt << '\n';
return;
}
int32_t main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int ans = 0;
int lim = n + 1;
for (int i = n; i; i--) {
if (a[i] >= x)
ans++, lim--;
else {
int t = x / a[i];
if (x % a[i]) t++;
if (lim - i >= t) {
ans++;
lim = i;
}
}
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int ans = 0;
int lim = n + 1;
for (int i = n; i; i--) {
if (a[i] >= x)
ans++, lim--;
else {
int t = x / a[i];
if (x % a[i]) t++;
if (lim - i >= t) {
ans++;
lim = i;
}
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void merge_sort(int i, int j, int a[], int aux[]);
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int team[n], aux[n], temp;
for (int i = 0; i < n; i++) {
cin >> temp;
team[i] = temp;
}
int i;
merge_sort(0, n - 1, team, aux);
int count = 0, ans = 0;
for (i = n - 1; i >= 0; i--) {
count++;
if (team[i] * count >= x) {
ans++;
count = 0;
}
}
cout << ans << "\n";
}
}
void merge_sort(int i, int j, int a[], int aux[]) {
if (j <= i) {
return;
}
int mid = (i + j) / 2;
merge_sort(i, mid, a, aux);
merge_sort(mid + 1, j, a, aux);
int pointer_left = i;
int pointer_right = mid + 1;
int k;
for (k = i; k <= j; k++) {
if (pointer_left == mid + 1) {
aux[k] = a[pointer_right];
pointer_right++;
} else if (pointer_right == j + 1) {
aux[k] = a[pointer_left];
pointer_left++;
} else if (a[pointer_left] < a[pointer_right]) {
aux[k] = a[pointer_left];
pointer_left++;
} else {
aux[k] = a[pointer_right];
pointer_right++;
}
}
for (k = i; k <= j; k++) {
a[k] = aux[k];
}
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void merge_sort(int i, int j, int a[], int aux[]);
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int team[n], aux[n], temp;
for (int i = 0; i < n; i++) {
cin >> temp;
team[i] = temp;
}
int i;
merge_sort(0, n - 1, team, aux);
int count = 0, ans = 0;
for (i = n - 1; i >= 0; i--) {
count++;
if (team[i] * count >= x) {
ans++;
count = 0;
}
}
cout << ans << "\n";
}
}
void merge_sort(int i, int j, int a[], int aux[]) {
if (j <= i) {
return;
}
int mid = (i + j) / 2;
merge_sort(i, mid, a, aux);
merge_sort(mid + 1, j, a, aux);
int pointer_left = i;
int pointer_right = mid + 1;
int k;
for (k = i; k <= j; k++) {
if (pointer_left == mid + 1) {
aux[k] = a[pointer_right];
pointer_right++;
} else if (pointer_right == j + 1) {
aux[k] = a[pointer_left];
pointer_left++;
} else if (a[pointer_left] < a[pointer_right]) {
aux[k] = a[pointer_left];
pointer_left++;
} else {
aux[k] = a[pointer_right];
pointer_right++;
}
}
for (k = i; k <= j; k++) {
a[k] = aux[k];
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n, x, size = 0, ans = 0;
cin >> n >> x;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
for (long long int i = 0; i < n; i++) {
size++;
if (v[i] * size >= x) {
ans++;
size = 0;
}
}
cout << ans << endl;
}
}
| ### Prompt
In Cpp, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n, x, size = 0, ans = 0;
cin >> n >> x;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
for (long long int i = 0; i < n; i++) {
size++;
if (v[i] * size >= x) {
ans++;
size = 0;
}
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long fix = (long long)1e9 + 7;
long long po2(long long a) {
double temp = a;
if (log2(temp) == (long long)log2(temp)) return log2(temp);
return -1;
}
void tc(long long i) { cout << "Case #" << i + 1 << ": "; }
void yes() { cout << "YES" << '\n'; }
void no() { cout << "NO" << '\n'; }
void impb() { cout << "IMPOSSIBLE" << '\n'; }
long long ct() {
long long t;
scanf("%lld", &t);
return t;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long modinv(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long n, k;
const long long N = 5e5 + 5;
list<long long> adj[N];
queue<long long> q;
long long comanc(long long u, long long v, long long parent[]) {
while (u ^ v) {
if (u == 1 || v == 1) return 1;
u = parent[u];
v = parent[v];
}
return u;
}
long long x;
long long bser(long long lo, long long hi, long long arr[]) {
while (lo < hi) {
long long mid = lo + (hi - lo + 1) / 2;
if (arr[mid] >= x) {
hi = mid - 1;
} else {
lo = mid;
}
}
return lo;
}
int32_t main() {
long long t = ct();
for (long long ii = (0); ii < (t); ii++) {
cin >> n >> x;
long long arr[n];
for (long long j = (0); j < (n); j++) {
cin >> arr[j];
}
sort(arr, arr + n);
long long temp = bser(0, n - 1, arr);
long long ans = 0;
ans += (n - 1 - temp);
long long ind = temp + 1;
for (long long k = temp; k >= 0; k--) {
if (arr[k] * (ind - k) >= x) {
ans++;
ind = k;
}
}
cout << ans << '\n';
}
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long fix = (long long)1e9 + 7;
long long po2(long long a) {
double temp = a;
if (log2(temp) == (long long)log2(temp)) return log2(temp);
return -1;
}
void tc(long long i) { cout << "Case #" << i + 1 << ": "; }
void yes() { cout << "YES" << '\n'; }
void no() { cout << "NO" << '\n'; }
void impb() { cout << "IMPOSSIBLE" << '\n'; }
long long ct() {
long long t;
scanf("%lld", &t);
return t;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long modinv(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long n, k;
const long long N = 5e5 + 5;
list<long long> adj[N];
queue<long long> q;
long long comanc(long long u, long long v, long long parent[]) {
while (u ^ v) {
if (u == 1 || v == 1) return 1;
u = parent[u];
v = parent[v];
}
return u;
}
long long x;
long long bser(long long lo, long long hi, long long arr[]) {
while (lo < hi) {
long long mid = lo + (hi - lo + 1) / 2;
if (arr[mid] >= x) {
hi = mid - 1;
} else {
lo = mid;
}
}
return lo;
}
int32_t main() {
long long t = ct();
for (long long ii = (0); ii < (t); ii++) {
cin >> n >> x;
long long arr[n];
for (long long j = (0); j < (n); j++) {
cin >> arr[j];
}
sort(arr, arr + n);
long long temp = bser(0, n - 1, arr);
long long ans = 0;
ans += (n - 1 - temp);
long long ind = temp + 1;
for (long long k = temp; k >= 0; k--) {
if (arr[k] * (ind - k) >= x) {
ans++;
ind = k;
}
}
cout << ans << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x;
scanf("%d", &n), scanf("%d", &x);
int a[n];
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
int ans;
int p = lower_bound(a, a + n, x) - a;
ans = n - p;
for (int i = p - 1, c = 0; i >= 0; --i) {
++c;
if (1LL * c * a[i] >= 1LL * x) {
c = 0;
++ans;
}
}
cout << ans << '\n';
}
return 0;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x;
scanf("%d", &n), scanf("%d", &x);
int a[n];
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
int ans;
int p = lower_bound(a, a + n, x) - a;
ans = n - p;
for (int i = p - 1, c = 0; i >= 0; --i) {
++c;
if (1LL * c * a[i] >= 1LL * x) {
c = 0;
++ans;
}
}
cout << ans << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<long long> adj[1000001];
long long v[1000001] = {0};
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, x, c = 1, d = 0;
cin >> n >> x;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long i = n - 1;
while (i >= 0) {
if (a[i] * c >= x) {
c = 1;
d++;
} else if (a[i] * c < x) {
c++;
}
i--;
}
cout << d << "\n";
}
}
| ### Prompt
Please create a solution in Cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<long long> adj[1000001];
long long v[1000001] = {0};
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, x, c = 1, d = 0;
cin >> n >> x;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long i = n - 1;
while (i >= 0) {
if (a[i] * c >= x) {
c = 1;
d++;
} else if (a[i] * c < x) {
c++;
}
i--;
}
cout << d << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const string nl = "\n";
long long n, k, ans, hld;
deque<long long> a;
void solve() {
cin >> n >> k;
a.resize(n);
for (auto& i : a) {
cin >> i;
}
ans = hld = 0;
sort(a.rbegin(), a.rend());
for (long long i = 0; i < n; ++i) {
++hld;
if (hld * a[i] >= k) {
++ans;
hld = 0;
}
}
cout << ans << nl;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
long long T;
cin >> T;
while (T--) {
solve();
}
}
| ### Prompt
In cpp, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const string nl = "\n";
long long n, k, ans, hld;
deque<long long> a;
void solve() {
cin >> n >> k;
a.resize(n);
for (auto& i : a) {
cin >> i;
}
ans = hld = 0;
sort(a.rbegin(), a.rend());
for (long long i = 0; i < n; ++i) {
++hld;
if (hld * a[i] >= k) {
++ans;
hld = 0;
}
}
cout << ans << nl;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
long long T;
cin >> T;
while (T--) {
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int getBits(long long int num) { return (int)log2(num) + 1; }
vector<int> gV(int n) {
vector<int> v;
int input;
for (int i = 0; i < n; i++) {
cin >> input;
v.push_back(input);
}
return v;
}
int* gA(int n) {
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
return arr;
}
void solve() {
long long int n, x;
cin >> n >> x;
vector<long long int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int teamSize = 0, teams = 0;
sort(v.rbegin(), v.rend());
for (auto i : v) {
teamSize++;
if (i * teamSize >= x) {
teams++;
teamSize = 0;
}
}
cout << teams << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
};
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int getBits(long long int num) { return (int)log2(num) + 1; }
vector<int> gV(int n) {
vector<int> v;
int input;
for (int i = 0; i < n; i++) {
cin >> input;
v.push_back(input);
}
return v;
}
int* gA(int n) {
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
return arr;
}
void solve() {
long long int n, x;
cin >> n >> x;
vector<long long int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int teamSize = 0, teams = 0;
sort(v.rbegin(), v.rend());
for (auto i : v) {
teamSize++;
if (i * teamSize >= x) {
teams++;
teamSize = 0;
}
}
cout << teams << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
};
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x;
cin >> n >> x;
deque<long long> a;
for (long long i = 0; i < n; ++i) {
long long ai;
cin >> ai;
a.push_back(ai);
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
long long la = -1;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (a[i] * (i - la) >= x) {
la = i;
++ans;
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x;
cin >> n >> x;
deque<long long> a;
for (long long i = 0; i < n; ++i) {
long long ai;
cin >> ai;
a.push_back(ai);
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
long long la = -1;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (a[i] * (i - la) >= x) {
la = i;
++ans;
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x;
cin >> n >> x;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
long long ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
long long tmp = (x + a[i] - 1) / a[i];
tmp--;
if (cnt >= tmp) {
cnt -= tmp;
ans++;
} else
cnt++;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
| ### Prompt
In Cpp, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x;
cin >> n >> x;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
long long ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
long long tmp = (x + a[i] - 1) / a[i];
tmp--;
if (cnt >= tmp) {
cnt -= tmp;
ans++;
} else
cnt++;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, o, p;
cin >> k;
while (k--) {
cin >> o >> p;
int a[o];
for (i = 0; i < o; i++) cin >> a[i];
sort(a, a + o);
l = 0;
j = 0;
for (i = o - 1; i >= 0; i--) {
j++;
if (a[i] * j >= p) {
l++;
j = 0;
}
};
cout << l << "\n";
}
}
| ### Prompt
Please formulate a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, o, p;
cin >> k;
while (k--) {
cin >> o >> p;
int a[o];
for (i = 0; i < o; i++) cin >> a[i];
sort(a, a + o);
l = 0;
j = 0;
for (i = o - 1; i >= 0; i--) {
j++;
if (a[i] * j >= p) {
l++;
j = 0;
}
};
cout << l << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k, i, t = 1, ans = 0, s;
cin >> n >> k;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<long long>());
for (i = 0; i < n; i++) {
s = a[i] * t;
if (s >= k) {
ans++;
t = 1;
} else {
t++;
}
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k, i, t = 1, ans = 0, s;
cin >> n >> k;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<long long>());
for (i = 0; i < n; i++) {
s = a[i] * t;
if (s >= k) {
ans++;
t = 1;
} else {
t++;
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,mmx,avx,avx2")
using namespace std;
const int MAXN = (1e5 + 5);
int dp[MAXN];
int x;
vector<int> a;
int n;
int sol(int k) {
if (k > n) {
return -(1 << 30);
;
}
if (k == n) {
return 0;
}
if (dp[k] != 0) {
return dp[k] - 1;
}
int sk = x / a[k];
if (sk * a[k] < x) {
sk++;
}
dp[k] = max(sol(k + 1), 1 + sol(k + sk));
dp[k]++;
return dp[k] - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
int qr;
cin >> qr;
vector<int> ans;
for (; qr > 0; qr--) {
cin >> n >> x;
for (int i = 0; i < n; i++) {
int ap;
cin >> ap;
a.push_back(ap);
dp[i] = 0;
}
sort(a.begin(), a.end());
ans.push_back(sol(0));
a.clear();
}
for (int j : ans) {
cout << j << endl;
}
}
| ### Prompt
Create a solution in cpp for the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,mmx,avx,avx2")
using namespace std;
const int MAXN = (1e5 + 5);
int dp[MAXN];
int x;
vector<int> a;
int n;
int sol(int k) {
if (k > n) {
return -(1 << 30);
;
}
if (k == n) {
return 0;
}
if (dp[k] != 0) {
return dp[k] - 1;
}
int sk = x / a[k];
if (sk * a[k] < x) {
sk++;
}
dp[k] = max(sol(k + 1), 1 + sol(k + sk));
dp[k]++;
return dp[k] - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
int qr;
cin >> qr;
vector<int> ans;
for (; qr > 0; qr--) {
cin >> n >> x;
for (int i = 0; i < n; i++) {
int ap;
cin >> ap;
a.push_back(ap);
dp[i] = 0;
}
sort(a.begin(), a.end());
ans.push_back(sol(0));
a.clear();
}
for (int j : ans) {
cout << j << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, m;
void solve() {
cin >> n >> m;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int count = 0;
k = n;
for (i = n - 1; i >= 0; i--) {
j = (m / a[i]);
if (m % a[i]) j++;
if (i + j - 1 < k) {
count++;
k = i;
}
}
cout << count;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
cin >> T;
long long h = T;
while (T--) {
solve();
cout << endl;
}
return 0;
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, m;
void solve() {
cin >> n >> m;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int count = 0;
k = n;
for (i = n - 1; i >= 0; i--) {
j = (m / a[i]);
if (m % a[i]) j++;
if (i + j - 1 < k) {
count++;
k = i;
}
}
cout << count;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
cin >> T;
long long h = T;
while (T--) {
solve();
cout << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
void Msort(int t[], int L, int R) {
int temp[R - L + 1];
int M = (L + R) / 2;
int k = 0;
int i = L;
int j = M + 1;
while (i <= M && j <= R) {
if (t[i] <= t[j]) {
temp[k] = t[i];
i++;
k++;
} else {
temp[k] = t[j];
j++;
k++;
}
}
while (i <= M) {
temp[k] = t[i];
i++;
k++;
}
for (int z = 0; z < k; z++) {
t[z + L] = temp[z];
}
}
void mergesort(int t[], int L, int R) {
if (L == R)
return;
else {
int M = (L + R) / 2;
mergesort(t, M + 1, R);
mergesort(t, L, M);
Msort(t, L, R);
}
}
int main() {
int t;
scanf("%d", &t);
getchar();
while (t--) {
int n, x, ctr = 0;
scanf("%d %d", &n, &x);
getchar();
int num[100004];
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
}
getchar();
mergesort(num, 0, n - 1);
int j;
for (int i = n - 1; i >= 0; i--) {
if (num[i] >= x) {
ctr++;
} else {
int k = 1;
for (j = i; j >= 0; j--, k++) {
if (num[j] * k >= x) {
ctr++;
break;
}
}
i = j;
}
}
printf("%d\n", ctr);
}
}
| ### Prompt
Develop a solution in cpp to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
void Msort(int t[], int L, int R) {
int temp[R - L + 1];
int M = (L + R) / 2;
int k = 0;
int i = L;
int j = M + 1;
while (i <= M && j <= R) {
if (t[i] <= t[j]) {
temp[k] = t[i];
i++;
k++;
} else {
temp[k] = t[j];
j++;
k++;
}
}
while (i <= M) {
temp[k] = t[i];
i++;
k++;
}
for (int z = 0; z < k; z++) {
t[z + L] = temp[z];
}
}
void mergesort(int t[], int L, int R) {
if (L == R)
return;
else {
int M = (L + R) / 2;
mergesort(t, M + 1, R);
mergesort(t, L, M);
Msort(t, L, R);
}
}
int main() {
int t;
scanf("%d", &t);
getchar();
while (t--) {
int n, x, ctr = 0;
scanf("%d %d", &n, &x);
getchar();
int num[100004];
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
}
getchar();
mergesort(num, 0, n - 1);
int j;
for (int i = n - 1; i >= 0; i--) {
if (num[i] >= x) {
ctr++;
} else {
int k = 1;
for (j = i; j >= 0; j--, k++) {
if (num[j] * k >= x) {
ctr++;
break;
}
}
i = j;
}
}
printf("%d\n", ctr);
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int past = n, ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] * (past - i) >= m) {
past = i;
ans++;
}
}
cout << ans << endl;
}
}
| ### Prompt
Develop a solution in CPP to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int past = n, ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] * (past - i) >= m) {
past = i;
ans++;
}
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long int mod_pow(long long int x, int n) {
if (n == 0) return 1;
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % 100000007;
x = x * x % 100000007;
n >>= 1;
}
return res;
}
vector<long long int> allDivisors(long long int n) {
vector<long long int> v;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
v.emplace_back(i);
else {
v.emplace_back(i);
v.emplace_back(n / i);
}
}
}
return v;
}
bool isPalin(string s) {
for (int i = 0; i < s.size() / 2; i++) {
if (s[i] != s[s.size() - i - 1]) {
return false;
}
}
return true;
}
vector<int> z_algo(string s) {
int n = s.size();
int l = 0, r = 0;
vector<int> z(n);
for (long long int i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (r < n && s[r] == s[r - l]) {
r++;
}
z[i] = r - l;
r--;
} else {
long long int index = i - l;
if (i + z[index] <= r)
z[i] = z[index];
else {
l = i;
while (r < n && s[r] == s[r - l]) {
r++;
}
z[i] = r - l;
r--;
}
}
}
return z;
}
vector<int> z_match(string str, string pat) {
string total = pat + "$" + str;
vector<int> z = z_algo(total);
vector<int> ans;
for (int i = 0; i < z.size(); i++) {
if (z[i] == pat.size()) {
ans.emplace_back(i - 1 - pat.size());
}
}
return ans;
}
vector<int> kmp(string s) {
int n = (int)s.length();
vector<int> pi(n);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return pi;
}
vector<int> kmp_match(string str, string pat) {
string total = pat + "$" + str;
int n = total.size();
vector<int> ans = kmp(total);
vector<int> res;
for (int i = pat.size() + 1; i < n; i++) {
if (ans[i] == pat.size()) {
res.emplace_back(i - 2 * pat.size());
}
}
return res;
}
bool comp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool isPrime(long long int n) {
int skip = 0;
if (n < 2)
return false;
else if (n == 2)
return true;
long long int limit = sqrt(n);
if (n % 2 == 0) return false;
for (int j = 3; j <= limit; j += 2) {
if (n % j == 0) return false;
}
return true;
}
long long int fact(long long int n) {
if (n == 1)
return 1;
else
return n * fact(n - 1);
}
void solve() {
long long int n, x;
cin >> n >> x;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] >= x) {
ans++;
} else {
long long int count = 1;
while (i >= 0) {
if (count * a[i] >= x) {
ans++;
break;
}
i--;
count++;
}
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int mod_pow(long long int x, int n) {
if (n == 0) return 1;
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % 100000007;
x = x * x % 100000007;
n >>= 1;
}
return res;
}
vector<long long int> allDivisors(long long int n) {
vector<long long int> v;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
v.emplace_back(i);
else {
v.emplace_back(i);
v.emplace_back(n / i);
}
}
}
return v;
}
bool isPalin(string s) {
for (int i = 0; i < s.size() / 2; i++) {
if (s[i] != s[s.size() - i - 1]) {
return false;
}
}
return true;
}
vector<int> z_algo(string s) {
int n = s.size();
int l = 0, r = 0;
vector<int> z(n);
for (long long int i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (r < n && s[r] == s[r - l]) {
r++;
}
z[i] = r - l;
r--;
} else {
long long int index = i - l;
if (i + z[index] <= r)
z[i] = z[index];
else {
l = i;
while (r < n && s[r] == s[r - l]) {
r++;
}
z[i] = r - l;
r--;
}
}
}
return z;
}
vector<int> z_match(string str, string pat) {
string total = pat + "$" + str;
vector<int> z = z_algo(total);
vector<int> ans;
for (int i = 0; i < z.size(); i++) {
if (z[i] == pat.size()) {
ans.emplace_back(i - 1 - pat.size());
}
}
return ans;
}
vector<int> kmp(string s) {
int n = (int)s.length();
vector<int> pi(n);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return pi;
}
vector<int> kmp_match(string str, string pat) {
string total = pat + "$" + str;
int n = total.size();
vector<int> ans = kmp(total);
vector<int> res;
for (int i = pat.size() + 1; i < n; i++) {
if (ans[i] == pat.size()) {
res.emplace_back(i - 2 * pat.size());
}
}
return res;
}
bool comp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool isPrime(long long int n) {
int skip = 0;
if (n < 2)
return false;
else if (n == 2)
return true;
long long int limit = sqrt(n);
if (n % 2 == 0) return false;
for (int j = 3; j <= limit; j += 2) {
if (n % j == 0) return false;
}
return true;
}
long long int fact(long long int n) {
if (n == 1)
return 1;
else
return n * fact(n - 1);
}
void solve() {
long long int n, x;
cin >> n >> x;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] >= x) {
ans++;
} else {
long long int count = 1;
while (i >= 0) {
if (count * a[i] >= x) {
ans++;
break;
}
i--;
count++;
}
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
const char nl = '\n';
const int inf = 2e9;
const ll INF = (ll)2e18;
const ll mod = 1e9 + 7;
const int N = 2e6 + 15;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
ll x;
cin >> x;
ll a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
vi dp(2 * n, 0);
for (int i = n - 1; i >= 0; --i) {
int k = (x + a[i] - 1) / a[i];
if (k > n - i) {
dp[i] = dp[i + 1];
} else {
dp[i] = max(dp[i + 1], 1 + dp[i + k]);
}
}
cout << dp[0] << nl;
}
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
const char nl = '\n';
const int inf = 2e9;
const ll INF = (ll)2e18;
const ll mod = 1e9 + 7;
const int N = 2e6 + 15;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
ll x;
cin >> x;
ll a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
vi dp(2 * n, 0);
for (int i = n - 1; i >= 0; --i) {
int k = (x + a[i] - 1) / a[i];
if (k > n - i) {
dp[i] = dp[i + 1];
} else {
dp[i] = max(dp[i + 1], 1 + dp[i + k]);
}
}
cout << dp[0] << nl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> as(n);
for (int i = 0; i < n; i++) {
cin >> as[i];
}
sort(as.begin(), as.end());
int j = n;
int i = n;
int factor = 1;
int ans = 0;
while (j > 0 && i > 0 && factor <= n) {
while (i > 0 && as[i - 1] >= (x + factor - 1) / factor) i--;
int dist = j - i;
int qty = dist / factor;
ans += qty;
j -= factor * qty;
factor++;
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> as(n);
for (int i = 0; i < n; i++) {
cin >> as[i];
}
sort(as.begin(), as.end());
int j = n;
int i = n;
int factor = 1;
int ans = 0;
while (j > 0 && i > 0 && factor <= n) {
while (i > 0 && as[i - 1] >= (x + factor - 1) / factor) i--;
int dist = j - i;
int qty = dist / factor;
ans += qty;
j -= factor * qty;
factor++;
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
void solve() {
long long n, x;
std::cin >> n >> x;
std::vector<long long> a(n);
for (long long i = 0; i < n; i++) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end());
long long res = 0;
long long i = n - 1;
while (i >= 0 && a[i] >= x) {
res++;
i--;
}
while (i >= 0) {
long long j = i;
while (j >= 0 && a[j] * (i - j + 1) < x) {
j--;
}
if (j != -1) {
res++;
}
i = j - 1;
}
std::cout << res << std::endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cout.tie(nullptr);
std::cin.tie(nullptr);
int t{};
std::cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
void solve() {
long long n, x;
std::cin >> n >> x;
std::vector<long long> a(n);
for (long long i = 0; i < n; i++) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end());
long long res = 0;
long long i = n - 1;
while (i >= 0 && a[i] >= x) {
res++;
i--;
}
while (i >= 0) {
long long j = i;
while (j >= 0 && a[j] * (i - j + 1) < x) {
j--;
}
if (j != -1) {
res++;
}
i = j - 1;
}
std::cout << res << std::endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cout.tie(nullptr);
std::cin.tie(nullptr);
int t{};
std::cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t-- > 0) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long m = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
m++;
if (ceil(x / (double)a[i]) <= m) {
ans++;
m = m - ceil(x / (double)a[i]);
}
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t-- > 0) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long m = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
m++;
if (ceil(x / (double)a[i]) <= m) {
ans++;
m = m - ceil(x / (double)a[i]);
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int t, n, x, a[100100];
bool cmp(int a, int b) { return a > b; }
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &x);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n, cmp);
int i = 0, j, sum = 0;
for (j = 0; j < n; j++)
if (a[j] * (j - i + 1) >= x) {
sum++;
i = j + 1;
}
printf("%d\n", sum);
}
return 0;
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int t, n, x, a[100100];
bool cmp(int a, int b) { return a > b; }
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &x);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n, cmp);
int i = 0, j, sum = 0;
for (j = 0; j < n; j++)
if (a[j] * (j - i + 1) >= x) {
sum++;
i = j + 1;
}
printf("%d\n", sum);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long int tt;
vector<long long int> a;
bool check(long long int sz, long long int x) {
if (sz == 0) {
return true;
}
long long int n = a.size();
long long int s = 0;
long long int ans = 0;
for (long long int i = n - 1; i >= 0; i--) {
s++;
long long int x1;
x1 = ceil(x / double(a[i]));
if (s >= x1) {
ans++;
s = s - x1;
}
}
if (ans >= sz) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
a.resize(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long int l = 0, r = n;
long long int ans = 0;
while (l <= r) {
long long int mid = (l + r) / 2;
if (check(mid, x)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans << endl;
}
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int tt;
vector<long long int> a;
bool check(long long int sz, long long int x) {
if (sz == 0) {
return true;
}
long long int n = a.size();
long long int s = 0;
long long int ans = 0;
for (long long int i = n - 1; i >= 0; i--) {
s++;
long long int x1;
x1 = ceil(x / double(a[i]));
if (s >= x1) {
ans++;
s = s - x1;
}
}
if (ans >= sz) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
a.resize(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long int l = 0, r = n;
long long int ans = 0;
while (l <= r) {
long long int mid = (l + r) / 2;
if (check(mid, x)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int t = 1;
scanf("%d", &t);
while (t--) {
int n, k;
scanf("%d %d", &n, &k);
vector<int> a(n);
for (int &i : a) scanf("%d", &i);
sort(a.rbegin(), a.rend());
int cnt = 0, pr = 0, mn = 1e9;
for (int i = 0; i < n; i++) {
if (a[i] >= k) {
cnt++, pr = i + 1;
} else {
mn = min(mn, a[i]);
if (mn * (i - pr + 1) >= k) cnt++, pr = i + 1;
}
}
cout << cnt << endl;
}
return 0;
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int t = 1;
scanf("%d", &t);
while (t--) {
int n, k;
scanf("%d %d", &n, &k);
vector<int> a(n);
for (int &i : a) scanf("%d", &i);
sort(a.rbegin(), a.rend());
int cnt = 0, pr = 0, mn = 1e9;
for (int i = 0; i < n; i++) {
if (a[i] >= k) {
cnt++, pr = i + 1;
} else {
mn = min(mn, a[i]);
if (mn * (i - pr + 1) >= k) cnt++, pr = i + 1;
}
}
cout << cnt << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x, c = 0;
cin >> n >> x;
vector<long long int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
for (int i = n - 1; i >= 0; i--) {
if (v[i] >= x) {
c++;
} else {
long long int k = 1;
while (v[i] * k < x && i >= 0) {
k++;
i--;
v[i] * k;
}
if (v[i] * k >= x && i >= 0) {
c++;
}
}
}
cout << c << endl;
}
}
| ### Prompt
Create a solution in cpp for the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x, c = 0;
cin >> n >> x;
vector<long long int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
for (int i = n - 1; i >= 0; i--) {
if (v[i] >= x) {
c++;
} else {
long long int k = 1;
while (v[i] * k < x && i >= 0) {
k++;
i--;
v[i] * k;
}
if (v[i] * k >= x && i >= 0) {
c++;
}
}
}
cout << c << endl;
}
}
``` |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
void solve() {
int n, x;
std::cin >> n >> x;
std::vector<int> a(n);
for (int i = 0; i < n; i++) std::cin >> a[i];
std::sort(a.rbegin(), a.rend());
int teams = 0;
int i = 0;
while (i < n) {
int size = 1;
while (i < n && x > a[i] * size) {
i++;
size++;
}
if (i < n && x <= a[i] * size) teams++;
i++;
}
std::cout << teams << "\n";
}
int main() {
int t;
std::cin >> t;
while (t--) solve();
return 0;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
void solve() {
int n, x;
std::cin >> n >> x;
std::vector<int> a(n);
for (int i = 0; i < n; i++) std::cin >> a[i];
std::sort(a.rbegin(), a.rend());
int teams = 0;
int i = 0;
while (i < n) {
int size = 1;
while (i < n && x > a[i] * size) {
i++;
size++;
}
if (i < n && x <= a[i] * size) teams++;
i++;
}
std::cout << teams << "\n";
}
int main() {
int t;
std::cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
long long int n, x;
cin >> n >> x;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int ans = 0;
long long int prev = 0;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] >= x)
ans++;
else {
if (arr[i] * (prev + 1) >= x) {
ans++;
prev = 0;
} else
prev++;
}
}
cout << ans << "\n";
}
return 0;
}
| ### Prompt
Please formulate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
long long int n, x;
cin >> n >> x;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int ans = 0;
long long int prev = 0;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] >= x)
ans++;
else {
if (arr[i] * (prev + 1) >= x) {
ans++;
prev = 0;
} else
prev++;
}
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int n;
long long x;
long long a[100005];
int main() {
int test;
scanf("%d", &test);
while (test--) {
scanf("%d%lld", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
long long num = 0;
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
double tt = ceil(((double)x) / a[i]);
if (num + 1 == tt) {
ans++;
num = 0;
} else {
num++;
}
}
printf("%lld\n", ans);
}
return 0;
}
| ### Prompt
Generate a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
long long x;
long long a[100005];
int main() {
int test;
scanf("%d", &test);
while (test--) {
scanf("%d%lld", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
long long num = 0;
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
double tt = ceil(((double)x) / a[i]);
if (num + 1 == tt) {
ans++;
num = 0;
} else {
num++;
}
}
printf("%lld\n", ans);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main(int argv, char *argc[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
long long int n, x, ans = 0;
cin >> n >> x;
vector<long long int> v(n);
for (auto i = 0; i < n; ++i) cin >> v[i];
sort((v).begin(), (v).end(), greater<long long int>());
long long int c = 0, mn = 2e9;
for (long long int i = 0; i < n; ++i) {
++c;
chmin(mn, v[i]);
if (c * mn >= x) {
++ans;
c = 0;
mn = 2e9;
}
}
cout << ans << "\n";
}
return 0;
}
| ### Prompt
In CPP, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main(int argv, char *argc[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
long long int n, x, ans = 0;
cin >> n >> x;
vector<long long int> v(n);
for (auto i = 0; i < n; ++i) cin >> v[i];
sort((v).begin(), (v).end(), greater<long long int>());
long long int c = 0, mn = 2e9;
for (long long int i = 0; i < n; ++i) {
++c;
chmin(mn, v[i]);
if (c * mn >= x) {
++ans;
c = 0;
mn = 2e9;
}
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mxr = 1e5 + 5;
bool cmp(int a, int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> pr(n);
for (int i = 0; i < n; i++) cin >> pr[i];
sort(pr.begin(), pr.end(), cmp);
int tm = 0, mem = 0;
for (int r : pr) {
mem++;
if (mem * r >= x) {
tm++;
mem = 0;
}
}
cout << tm << "\n";
}
return 0;
}
| ### Prompt
Create a solution in CPP for the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mxr = 1e5 + 5;
bool cmp(int a, int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> pr(n);
for (int i = 0; i < n; i++) cin >> pr[i];
sort(pr.begin(), pr.end(), cmp);
int tm = 0, mem = 0;
for (int r : pr) {
mem++;
if (mem * r >= x) {
tm++;
mem = 0;
}
}
cout << tm << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool comparePairs(const std::pair<int, int>& lhs,
const std::pair<int, int>& rhs) {
if (lhs.second < rhs.second) return 1;
return 0;
}
void solve() {
int n, x;
int arr[100000];
std::vector<pair<int, int> > v;
int i;
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (i = 0; i < n; i++) {
int a = (x / arr[i]) + ((x % arr[i] == 0) ? 0 : 1);
if (a <= n - i) {
v.push_back(make_pair(i, i + a - 1));
}
}
if (v.size() == 0) {
cout << 0 << endl;
return;
}
sort(v.begin(), v.end(), comparePairs);
int end = v[0].second, cnt = 1;
for (i = 1; i < v.size(); i++) {
if (v[i].first > end) {
cnt++;
end = v[i].second;
}
}
cout << cnt << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool comparePairs(const std::pair<int, int>& lhs,
const std::pair<int, int>& rhs) {
if (lhs.second < rhs.second) return 1;
return 0;
}
void solve() {
int n, x;
int arr[100000];
std::vector<pair<int, int> > v;
int i;
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (i = 0; i < n; i++) {
int a = (x / arr[i]) + ((x % arr[i] == 0) ? 0 : 1);
if (a <= n - i) {
v.push_back(make_pair(i, i + a - 1));
}
}
if (v.size() == 0) {
cout << 0 << endl;
return;
}
sort(v.begin(), v.end(), comparePairs);
int end = v[0].second, cnt = 1;
for (i = 1; i < v.size(); i++) {
if (v[i].first > end) {
cnt++;
end = v[i].second;
}
}
cout << cnt << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
``` |
#include <bits/stdc++.h>
const int N = 1e5 + 100, M = 1e6 + 100, SQ = sqrt(2e5), LG = 23, base = 2,
second = 1e3 + 100;
const long long mod = 1e9 + 7, MOD = 1e9 + 9, Inf = 9223372036854775807;
const long long INF = 1e9, inf = 1e18, super_inf = ~0ull / 4;
const long double Pi = (22 * 1.0) / (7 * 1.0);
using namespace std;
long long n, x, t, a[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> t;
while (t--) {
cin >> n >> x;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
long long r = n, ans = 0, s = 0;
while (r > 0) {
s++;
if (s * a[r] >= x) s = 0, ans++;
r--;
}
cout << ans << endl;
}
}
| ### Prompt
Generate a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
const int N = 1e5 + 100, M = 1e6 + 100, SQ = sqrt(2e5), LG = 23, base = 2,
second = 1e3 + 100;
const long long mod = 1e9 + 7, MOD = 1e9 + 9, Inf = 9223372036854775807;
const long long INF = 1e9, inf = 1e18, super_inf = ~0ull / 4;
const long double Pi = (22 * 1.0) / (7 * 1.0);
using namespace std;
long long n, x, t, a[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> t;
while (t--) {
cin >> n >> x;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
long long r = n, ans = 0, s = 0;
while (r > 0) {
s++;
if (s * a[r] >= x) s = 0, ans++;
r--;
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int solve() {
long long n, x;
cin >> n >> x;
long long i;
long long a[n], ans = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= x) {
ans++;
}
}
sort(a, a + n);
int cnt = 0;
for (i = n - 1; i >= 0; i--) {
if (a[i] >= x) {
continue;
}
cnt++;
if (a[i] * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << ans << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int solve() {
long long n, x;
cin >> n >> x;
long long i;
long long a[n], ans = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= x) {
ans++;
}
}
sort(a, a + n);
int cnt = 0;
for (i = n - 1; i >= 0; i--) {
if (a[i] >= x) {
continue;
}
cnt++;
if (a[i] * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << ans << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int INF = 0x3f3f3f3f;
long long MOD = 1000000007;
long long binpow(long long a, long long b, long long c = 1e18) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res *= a;
res %= c;
}
a *= a;
a %= c;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> nums(n);
for (long long i = 0; i < n; i++) {
long long a;
cin >> nums[i];
}
sort(nums.begin(), nums.end());
long long ans = 0;
long long currNum = 0;
for (long long i = n - 1; i >= 0; i--) {
long long it = nums[i];
currNum++;
if (it * currNum >= x) {
ans++;
currNum = 0;
}
}
cout << ans << "\n";
}
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int INF = 0x3f3f3f3f;
long long MOD = 1000000007;
long long binpow(long long a, long long b, long long c = 1e18) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res *= a;
res %= c;
}
a *= a;
a %= c;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> nums(n);
for (long long i = 0; i < n; i++) {
long long a;
cin >> nums[i];
}
sort(nums.begin(), nums.end());
long long ans = 0;
long long currNum = 0;
for (long long i = n - 1; i >= 0; i--) {
long long it = nums[i];
currNum++;
if (it * currNum >= x) {
ans++;
currNum = 0;
}
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, y, cnt = 0;
cin >> n >> y;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int k = 0;
for (int i = n - 1; i >= 0; i--) {
k++;
if (k * a[i] >= y) {
cnt++;
k = 0;
}
}
cout << cnt << endl;
}
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, y, cnt = 0;
cin >> n >> y;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int k = 0;
for (int i = n - 1; i >= 0; i--) {
k++;
if (k * a[i] >= y) {
cnt++;
k = 0;
}
}
cout << cnt << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
vector<int> gV(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
int* gA(int n) {
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
return arr;
}
void solve() {
long long int n, x, ans = 0;
cin >> n >> x;
int* arr = new int[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int idx = -1;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] >= x) {
ans++;
} else {
idx = i;
break;
}
}
for (int i = idx; i >= 0; i--) {
int total;
if (idx < 0) break;
if (x % arr[i] == 0) {
total = x / arr[i];
} else {
total = x / arr[i] + 1;
}
if (idx - (total - 1) >= 0) {
if (idx - i + 1 >= total) {
ans++;
i -= (total - 1);
idx -= (total);
} else {
if ((i - (total - 1) >= 0) && (arr[i - (total - 1)] * total >= x)) {
ans++;
i -= (total - 1);
idx -= (total);
}
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
};
return 0;
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> gV(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
int* gA(int n) {
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
return arr;
}
void solve() {
long long int n, x, ans = 0;
cin >> n >> x;
int* arr = new int[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int idx = -1;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] >= x) {
ans++;
} else {
idx = i;
break;
}
}
for (int i = idx; i >= 0; i--) {
int total;
if (idx < 0) break;
if (x % arr[i] == 0) {
total = x / arr[i];
} else {
total = x / arr[i] + 1;
}
if (idx - (total - 1) >= 0) {
if (idx - i + 1 >= total) {
ans++;
i -= (total - 1);
idx -= (total);
} else {
if ((i - (total - 1) >= 0) && (arr[i - (total - 1)] * total >= x)) {
ans++;
i -= (total - 1);
idx -= (total);
}
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
};
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int testcases = 1;
cin >> testcases;
int t = testcases;
while (testcases--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int c = 0;
int idx = lower_bound(a, a + n, x) - a;
c += n - idx;
vector<int> dp(idx, 0);
int ans = 0;
for (int i = idx - 1; i >= 0; i--) {
int req = x / a[i];
if (x % a[i] != 0) req++;
int next = i + req;
if (i + req - 1 >= idx) continue;
dp[i]++;
if (next < idx) dp[i] += dp[next];
ans = max(ans, dp[i]);
}
c += ans;
cout << c << endl;
}
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int testcases = 1;
cin >> testcases;
int t = testcases;
while (testcases--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int c = 0;
int idx = lower_bound(a, a + n, x) - a;
c += n - idx;
vector<int> dp(idx, 0);
int ans = 0;
for (int i = idx - 1; i >= 0; i--) {
int req = x / a[i];
if (x % a[i] != 0) req++;
int next = i + req;
if (i + req - 1 >= idx) continue;
dp[i]++;
if (next < idx) dp[i] += dp[next];
ans = max(ans, dp[i]);
}
c += ans;
cout << c << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
scanf("%d", &(test));
for (int t = 1; t <= test; t++) {
long long int x, n, cnt = 0;
scanf("%lld", &(n)), scanf("%lld", &(x));
long long int a[n + 5];
for (int i = 1; i <= n; i++) scanf("%lld", &(a[i]));
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
long long int tot = 0;
for (int i = 1; i <= n; i++) {
int dif = i - cnt;
long long int val = (a[i] + x - 1) / a[i];
if (dif >= val) {
tot++;
cnt = i;
}
}
cout << tot << endl;
}
return 0;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
scanf("%d", &(test));
for (int t = 1; t <= test; t++) {
long long int x, n, cnt = 0;
scanf("%lld", &(n)), scanf("%lld", &(x));
long long int a[n + 5];
for (int i = 1; i <= n; i++) scanf("%lld", &(a[i]));
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
long long int tot = 0;
for (int i = 1; i <= n; i++) {
int dif = i - cnt;
long long int val = (a[i] + x - 1) / a[i];
if (dif >= val) {
tot++;
cnt = i;
}
}
cout << tot << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long cnt = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
cnt++;
if (arr[i] * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << ans << "\n";
}
return 0;
}
| ### Prompt
Generate a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long cnt = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
cnt++;
if (arr[i] * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
;
sort(a, a + n);
long long cnt = 0, ans = 0;
for (long long i = n - 1; i >= 0; i--) {
cnt++;
if (a[i] * cnt >= x) {
cnt = 0;
ans++;
}
}
cout << ans << "\n";
}
}
| ### Prompt
Please create a solution in Cpp to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
;
sort(a, a + n);
long long cnt = 0, ans = 0;
for (long long i = n - 1; i >= 0; i--) {
cnt++;
if (a[i] * cnt >= x) {
cnt = 0;
ans++;
}
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0;
long long j = n - 1;
while (j >= 0 && a[j] >= x) {
ans++;
j--;
}
for (long long i = j; i >= 0; i--) {
long long c = 1;
while (i >= 0 && c * a[i] < x) {
c++;
i--;
}
if (i > -1 && a[i] * c >= x) ans++;
}
cout << ans << "\n";
}
}
| ### Prompt
Generate a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0;
long long j = n - 1;
while (j >= 0 && a[j] >= x) {
ans++;
j--;
}
for (long long i = j; i >= 0; i--) {
long long c = 1;
while (i >= 0 && c * a[i] < x) {
c++;
i--;
}
if (i > -1 && a[i] * c >= x) ans++;
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(long long &x, long long &y) {
long long temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(long long t) { cout << "Case #" << t << ": "; }
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
bool isPrime(long long x) {
if (x < 2) return false;
for (long long y = 2; y * y <= x; y++)
if (x % y == 0) return false;
return true;
}
long long ceil(long long a, long long b) {
long long aa = (a + b - 1) / b;
return aa;
}
const long long N = 100005;
bool mycmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
void solve(long long t = 0) {
long long n, m;
cin >> n >> m;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort((v).begin(), (v).end());
long long cur = 1e18;
long long no = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
if (cur == 1e18)
cur = v[i];
else
cur = min(cur, v[i]);
no++;
if (cur * no >= m) ans++, no = 0, cur = 1e18;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 0;
cin >> t;
for (long long i = 1; i < t + 1; i++) solve();
auto start1 = high_resolution_clock::now();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(long long &x, long long &y) {
long long temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(long long t) { cout << "Case #" << t << ": "; }
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
bool isPrime(long long x) {
if (x < 2) return false;
for (long long y = 2; y * y <= x; y++)
if (x % y == 0) return false;
return true;
}
long long ceil(long long a, long long b) {
long long aa = (a + b - 1) / b;
return aa;
}
const long long N = 100005;
bool mycmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
void solve(long long t = 0) {
long long n, m;
cin >> n >> m;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort((v).begin(), (v).end());
long long cur = 1e18;
long long no = 0;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
if (cur == 1e18)
cur = v[i];
else
cur = min(cur, v[i]);
no++;
if (cur * no >= m) ans++, no = 0, cur = 1e18;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 0;
cin >> t;
for (long long i = 1; i < t + 1; i++) solve();
auto start1 = high_resolution_clock::now();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, a = 0, e = 0;
cin >> n >> x;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n, greater<int>());
for (int i = 0; i < n; i++) {
e++;
if (e * arr[i] >= x) {
e = 0;
a++;
}
}
cout << a << endl;
}
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, a = 0, e = 0;
cin >> n >> x;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n, greater<int>());
for (int i = 0; i < n; i++) {
e++;
if (e * arr[i] >= x) {
e = 0;
a++;
}
}
cout << a << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool testing = false;
bool stress = false;
bool recursion = false;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
istream &operator>>(istream &is, vector<T> vec) {
for (int i = 0; i < vec.size(); i++) {
cin >> vec[i];
}
return is;
}
template <typename T>
void print(T var) {
cerr << var << " ";
}
template <typename T>
void print(vector<T> vec) {
for (auto itr = vec.begin(); itr != vec.end(); itr++) {
print(*itr);
}
}
template <typename T>
void print(T arr[], ll n) {
for (ll i = 0; i < n; i++) {
print(arr[i]);
}
}
template <typename T>
class Debugger {
void print(T var) { cerr << var << " "; }
void print(vector<T> vec) {
for (auto itr = vec.begin(); itr != vec.end(); itr++) {
print(*itr);
}
}
Debugger operator<<(T var) {
print(var);
return Debugger();
}
};
template <class T>
void arrInput(T arr[], int n) {
for (int i = 0; i < n; i++) {
T el;
cin >> el;
arr[i] = el;
}
}
template <class T>
void arrInput(vector<T> &arr, int n) {
for (int i = 0; i < n; i++) {
T el;
cin >> el;
arr.push_back(el);
}
}
template <class T>
void arrInput(vector<T> &arr) {
for (int i = 0; i < arr.size(); i++) {
T el;
cin >> el;
arr[i] = el;
}
}
void printMap(map<int, float> infected[], int n,
string message = "printing map function") {
if (testing) {
cout << message << " "
<< "new print" << endl
<< endl;
for (int i = 0; i < n; i++) {
cout << endl << "map " << i << " " << endl;
for (auto j = infected[i].begin(); j != infected[i].end(); j++) {
cout << j->first << " " << j->second << endl;
}
}
cout << endl;
}
}
void printArray(int n, int arr[], bool forcePrint = false,
string message = "printing array") {
if (testing) {
cout << message << " ";
}
if (testing || forcePrint)
for (int j = 0; j < n; j++) {
cout << arr[j] << " ";
}
}
void printSet(set<int, greater<int>> arr) {
if (testing) {
for (auto i = arr.begin(); i != arr.end(); i++) {
cout << *i << " ";
}
cout << endl;
}
}
int placeHigh(int arr[], int low, int high) {
int less = low;
for (low; low < high; low++) {
if (arr[low] <= arr[high]) {
swap(arr[less], arr[low]);
less++;
}
}
swap(arr[less], arr[high]);
return less;
}
void quicksort(int arr[], int low, int high) {
if (low < high) {
int pi = placeHigh(arr, low, high);
quicksort(arr, low, pi - 1);
quicksort(arr, pi + 1, high);
}
}
void printValue(string value, string message = "value = ") {
if (testing) cout << message << value << endl;
}
void inputSet(set<int, greater<int>> *mySet, int n) {
for (int i = 0; i < n; i++) {
int el;
cin >> el;
(*mySet).insert(el);
}
}
template <typename T>
long long binarySearch(vector<T> vec, T el) {
long long low = 0, high = vec.size() - 1;
while (low <= high) {
long long mid = low + abs((high - low) / 2);
if (vec[mid] == el) {
return mid;
}
if (el < vec[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}
ll solve() {
int n, x;
cin >> n >> x;
int arr[n];
arrInput(arr, n);
sort(arr, arr + n);
;
int end = n - 1;
ll count = 0;
for (int i = n - 1; i >= 0; i--) {
;
;
;
if ((((end - i) + 1) * arr[i]) >= x) {
end = i - 1;
count++;
}
}
return count;
}
template <typename T>
void resultPrinter(T var) {
cout << var << " ";
}
template <typename T>
void resultPrinter(vector<T> vec) {
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++) {
resultPrinter(vec[i]);
}
}
void resultPrinter(bool var) { cout << (var ? "Yes" : "No"); }
void takeInput() {}
bool test() { return true; }
signed main(int arg, char **args) {
for (long long i = 1; i < arg; i++) {
char ar = *args[i];
if (ar == 'd') {
testing = true;
} else {
if (ar == 's') {
stress = true;
} else {
if (ar == 'r') {
recursion = true;
}
}
}
}
if (recursion) {
takeInput();
return 0;
}
if (stress) {
return test();
} else {
long long t;
cin >> t;
while (t-- > 0) {
resultPrinter(solve());
cout << endl;
}
}
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool testing = false;
bool stress = false;
bool recursion = false;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
istream &operator>>(istream &is, vector<T> vec) {
for (int i = 0; i < vec.size(); i++) {
cin >> vec[i];
}
return is;
}
template <typename T>
void print(T var) {
cerr << var << " ";
}
template <typename T>
void print(vector<T> vec) {
for (auto itr = vec.begin(); itr != vec.end(); itr++) {
print(*itr);
}
}
template <typename T>
void print(T arr[], ll n) {
for (ll i = 0; i < n; i++) {
print(arr[i]);
}
}
template <typename T>
class Debugger {
void print(T var) { cerr << var << " "; }
void print(vector<T> vec) {
for (auto itr = vec.begin(); itr != vec.end(); itr++) {
print(*itr);
}
}
Debugger operator<<(T var) {
print(var);
return Debugger();
}
};
template <class T>
void arrInput(T arr[], int n) {
for (int i = 0; i < n; i++) {
T el;
cin >> el;
arr[i] = el;
}
}
template <class T>
void arrInput(vector<T> &arr, int n) {
for (int i = 0; i < n; i++) {
T el;
cin >> el;
arr.push_back(el);
}
}
template <class T>
void arrInput(vector<T> &arr) {
for (int i = 0; i < arr.size(); i++) {
T el;
cin >> el;
arr[i] = el;
}
}
void printMap(map<int, float> infected[], int n,
string message = "printing map function") {
if (testing) {
cout << message << " "
<< "new print" << endl
<< endl;
for (int i = 0; i < n; i++) {
cout << endl << "map " << i << " " << endl;
for (auto j = infected[i].begin(); j != infected[i].end(); j++) {
cout << j->first << " " << j->second << endl;
}
}
cout << endl;
}
}
void printArray(int n, int arr[], bool forcePrint = false,
string message = "printing array") {
if (testing) {
cout << message << " ";
}
if (testing || forcePrint)
for (int j = 0; j < n; j++) {
cout << arr[j] << " ";
}
}
void printSet(set<int, greater<int>> arr) {
if (testing) {
for (auto i = arr.begin(); i != arr.end(); i++) {
cout << *i << " ";
}
cout << endl;
}
}
int placeHigh(int arr[], int low, int high) {
int less = low;
for (low; low < high; low++) {
if (arr[low] <= arr[high]) {
swap(arr[less], arr[low]);
less++;
}
}
swap(arr[less], arr[high]);
return less;
}
void quicksort(int arr[], int low, int high) {
if (low < high) {
int pi = placeHigh(arr, low, high);
quicksort(arr, low, pi - 1);
quicksort(arr, pi + 1, high);
}
}
void printValue(string value, string message = "value = ") {
if (testing) cout << message << value << endl;
}
void inputSet(set<int, greater<int>> *mySet, int n) {
for (int i = 0; i < n; i++) {
int el;
cin >> el;
(*mySet).insert(el);
}
}
template <typename T>
long long binarySearch(vector<T> vec, T el) {
long long low = 0, high = vec.size() - 1;
while (low <= high) {
long long mid = low + abs((high - low) / 2);
if (vec[mid] == el) {
return mid;
}
if (el < vec[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}
ll solve() {
int n, x;
cin >> n >> x;
int arr[n];
arrInput(arr, n);
sort(arr, arr + n);
;
int end = n - 1;
ll count = 0;
for (int i = n - 1; i >= 0; i--) {
;
;
;
if ((((end - i) + 1) * arr[i]) >= x) {
end = i - 1;
count++;
}
}
return count;
}
template <typename T>
void resultPrinter(T var) {
cout << var << " ";
}
template <typename T>
void resultPrinter(vector<T> vec) {
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++) {
resultPrinter(vec[i]);
}
}
void resultPrinter(bool var) { cout << (var ? "Yes" : "No"); }
void takeInput() {}
bool test() { return true; }
signed main(int arg, char **args) {
for (long long i = 1; i < arg; i++) {
char ar = *args[i];
if (ar == 'd') {
testing = true;
} else {
if (ar == 's') {
stress = true;
} else {
if (ar == 'r') {
recursion = true;
}
}
}
}
if (recursion) {
takeInput();
return 0;
}
if (stress) {
return test();
} else {
long long t;
cin >> t;
while (t-- > 0) {
resultPrinter(solve());
cout << endl;
}
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long ans = 0, skill = 0, len = 1;
for (long long i = n - 1; i >= 0; i--) {
skill = a[i];
if (skill * len >= x) {
ans++;
len = 1;
} else {
len++;
}
}
cout << ans << "\n";
}
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long ans = 0, skill = 0, len = 1;
for (long long i = n - 1; i >= 0; i--) {
skill = a[i];
if (skill * len >= x) {
ans++;
len = 1;
} else {
len++;
}
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int n, x;
void Fun(int l, int r, int& c) {
if (l >= n) return;
int t = ceil(1.0 * x / vec[l]);
if (r - t + 1 >= l) {
++c;
Fun(l + 1, r - t + 1, c);
}
return;
}
void Solve() {
cin >> n >> x;
vec.resize(n);
for (auto& el : vec) cin >> el;
sort(vec.begin(), vec.end(), greater<int>());
int ans = 0, c = 1;
for (auto& el : vec) {
if (el * c >= x) {
++ans;
c = 0;
}
++c;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) Solve();
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int n, x;
void Fun(int l, int r, int& c) {
if (l >= n) return;
int t = ceil(1.0 * x / vec[l]);
if (r - t + 1 >= l) {
++c;
Fun(l + 1, r - t + 1, c);
}
return;
}
void Solve() {
cin >> n >> x;
vec.resize(n);
for (auto& el : vec) cin >> el;
sort(vec.begin(), vec.end(), greater<int>());
int ans = 0, c = 1;
for (auto& el : vec) {
if (el * c >= x) {
++ans;
c = 0;
}
++c;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) Solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
int T, n, x;
int num[100001];
int main() {
cin >> T;
while (T--) {
cin >> n >> x;
for (int i = 0; i < n; ++i) cin >> num[i];
sort(num, num + n);
int ans = 0, cnt = 0;
for (int i = n - 1; i >= 0; i--) {
if (++cnt * num[i] >= x) {
ans++;
cnt = 0;
}
}
cout << ans << '\n';
}
return 0;
}
| ### Prompt
Generate a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int T, n, x;
int num[100001];
int main() {
cin >> T;
while (T--) {
cin >> n >> x;
for (int i = 0; i < n; ++i) cin >> num[i];
sort(num, num + n);
int ans = 0, cnt = 0;
for (int i = n - 1; i >= 0; i--) {
if (++cnt * num[i] >= x) {
ans++;
cnt = 0;
}
}
cout << ans << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll SUM(VI& V) { return accumulate((V).begin(), (V).end(), 0LL); }
ll MIN(VI& V) { return *min_element((V).begin(), (V).end()); }
ll MAX(VI& V) { return *max_element((V).begin(), (V).end()); }
void print_vector(VI& V) {
ll n = V.size();
for (ll i = (0); i < (n); ++i) {
if (i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
using ld = long double;
void no() {
cout << ("NO") << '\n';
exit(0);
}
void yes() {
cout << ("YES") << '\n';
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
void solve() {
ll n, x;
cin >> n >> x;
VI A(n);
for (ll i = (0); i < (n); ++i) cin >> A[i];
sort((A).begin(), (A).end());
stack<ll> st;
for (ll a : A) st.push(a);
ll ans = 0;
ll cnt = 0;
while (!st.empty()) {
ll v = st.top();
st.pop();
cnt++;
if (v * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << (ans) << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
while (N--) solve();
return 0;
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll SUM(VI& V) { return accumulate((V).begin(), (V).end(), 0LL); }
ll MIN(VI& V) { return *min_element((V).begin(), (V).end()); }
ll MAX(VI& V) { return *max_element((V).begin(), (V).end()); }
void print_vector(VI& V) {
ll n = V.size();
for (ll i = (0); i < (n); ++i) {
if (i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
using ld = long double;
void no() {
cout << ("NO") << '\n';
exit(0);
}
void yes() {
cout << ("YES") << '\n';
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
void solve() {
ll n, x;
cin >> n >> x;
VI A(n);
for (ll i = (0); i < (n); ++i) cin >> A[i];
sort((A).begin(), (A).end());
stack<ll> st;
for (ll a : A) st.push(a);
ll ans = 0;
ll cnt = 0;
while (!st.empty()) {
ll v = st.top();
st.pop();
cnt++;
if (v * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << (ans) << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
while (N--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, m, x, y, z, v, d, i, j, k, sum, t, ans, Q;
cin >> t;
while (t--) {
cin >> n >> x;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long cnt = 1, mn = a[n - 1];
ans = 0;
for (i = n - 1; i >= 0; i--) {
mn = min(mn, a[i]);
if (mn * cnt >= x) {
ans++;
cnt = 1;
continue;
}
cnt++;
}
cout << ans << endl;
}
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, m, x, y, z, v, d, i, j, k, sum, t, ans, Q;
cin >> t;
while (t--) {
cin >> n >> x;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long cnt = 1, mn = a[n - 1];
ans = 0;
for (i = n - 1; i >= 0; i--) {
mn = min(mn, a[i]);
if (mn * cnt >= x) {
ans++;
cnt = 1;
continue;
}
cnt++;
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void deb(initializer_list<T> l) {
for (auto& e : l) cout << e << ' ';
cout << endl;
}
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (auto& e : a) cin >> e;
sort(a.begin(), a.end(), greater<long long>());
long long ans = 0;
for (long long i = 0; i < n; ++i) {
long long cnt = 0;
while (i < n) {
++cnt;
if (cnt * a[i] >= x) {
++ans;
break;
}
++i;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| ### Prompt
Develop a solution in cpp to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void deb(initializer_list<T> l) {
for (auto& e : l) cout << e << ' ';
cout << endl;
}
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (auto& e : a) cin >> e;
sort(a.begin(), a.end(), greater<long long>());
long long ans = 0;
for (long long i = 0; i < n; ++i) {
long long cnt = 0;
while (i < n) {
++cnt;
if (cnt * a[i] >= x) {
++ans;
break;
}
++i;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long count = 0, value = 0, prev = n;
for (long long i = n - 1; i >= 0; i--) {
value = a[i];
if (value * (prev - i) >= x) {
prev = i;
count++;
}
}
cout << count << "\n";
}
return 0;
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long count = 0, value = 0, prev = n;
for (long long i = n - 1; i >= 0; i--) {
value = a[i];
if (value * (prev - i) >= x) {
prev = i;
count++;
}
}
cout << count << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long int n, x, pos = 1;
cin >> n >> x;
long int* a = new long int[n];
for (auto i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > x) {
a[i] = 0;
} else {
if (x % a[i] == 0) {
a[i] = x / a[i];
} else {
a[i] = ((x / a[i]) + 1);
}
}
}
sort(a, a + n);
int count = 0;
for (auto i = 0; i < n;) {
if (a[i] <= pos && pos >= 1) {
count++;
i++;
pos = 1;
} else {
i++;
pos++;
}
}
cout << count << endl;
}
return 0;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long int n, x, pos = 1;
cin >> n >> x;
long int* a = new long int[n];
for (auto i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > x) {
a[i] = 0;
} else {
if (x % a[i] == 0) {
a[i] = x / a[i];
} else {
a[i] = ((x / a[i]) + 1);
}
}
}
sort(a, a + n);
int count = 0;
for (auto i = 0; i < n;) {
if (a[i] <= pos && pos >= 1) {
count++;
i++;
pos = 1;
} else {
i++;
pos++;
}
}
cout << count << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 200;
long long a[N];
void solve() {
long long n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
reverse(a + 1, a + 1 + n);
long long mi = 1e9, ans = 0, k = 0;
for (int i = 1; i <= n; i++) {
mi = min(a[i], mi);
k++;
if (k * mi >= x) {
ans++;
k = 0;
mi = 1e9;
}
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 200;
long long a[N];
void solve() {
long long n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
reverse(a + 1, a + 1 + n);
long long mi = 1e9, ans = 0, k = 0;
for (int i = 1; i <= n; i++) {
mi = min(a[i], mi);
k++;
if (k * mi >= x) {
ans++;
k = 0;
mi = 1e9;
}
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long INF = 1e18;
const long long MAXN = 1 << 17;
const long long MOD = 998244353;
const long long LOG = ceil(log(MAXN) / log(2));
const long double EPS = 1e-9;
const int dx[8] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy[8] = {0, -1, 0, 1, 1, -1, 1, -1};
void solve() {
int n, x;
cin >> n >> x;
vector<int> v(n);
for (int &a : v) {
cin >> a;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int ans = 0;
for (int i = 0, l = -1; i < n; ++i) {
if ((i - l) * 1ll * v[i] >= x) {
ans++;
l = i;
}
}
cout << ans << '\n';
}
int main() {
faster();
int T = 1;
cin >> T;
while (T--) {
solve();
}
cerr << "\nTime elapsed " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long INF = 1e18;
const long long MAXN = 1 << 17;
const long long MOD = 998244353;
const long long LOG = ceil(log(MAXN) / log(2));
const long double EPS = 1e-9;
const int dx[8] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy[8] = {0, -1, 0, 1, 1, -1, 1, -1};
void solve() {
int n, x;
cin >> n >> x;
vector<int> v(n);
for (int &a : v) {
cin >> a;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int ans = 0;
for (int i = 0, l = -1; i < n; ++i) {
if ((i - l) * 1ll * v[i] >= x) {
ans++;
l = i;
}
}
cout << ans << '\n';
}
int main() {
faster();
int T = 1;
cin >> T;
while (T--) {
solve();
}
cerr << "\nTime elapsed " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc = 1;
cin >> tc;
while (tc--) {
int n, x;
cin >> n >> x;
int a[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<int>());
int crnt = 1, cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] * crnt >= x) {
cnt++;
crnt = 1;
} else
crnt++;
}
cout << cnt << endl;
}
return 0;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc = 1;
cin >> tc;
while (tc--) {
int n, x;
cin >> n >> x;
int a[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<int>());
int crnt = 1, cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] * crnt >= x) {
cnt++;
crnt = 1;
} else
crnt++;
}
cout << cnt << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int a[100005];
void solve() {
int n;
cin >> n;
int x;
cin >> x;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1, greater<int>());
int sum = 0, ans = 0;
for (int i = 1; i <= n; i++) {
sum++;
if (sum * a[i] >= x) {
sum -= x / a[i] + (x % a[i] != 0);
ans++;
}
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| ### Prompt
Develop a solution in cpp to the problem described below:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int a[100005];
void solve() {
int n;
cin >> n;
int x;
cin >> x;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1, greater<int>());
int sum = 0, ans = 0;
for (int i = 1; i <= n; i++) {
sum++;
if (sum * a[i] >= x) {
sum -= x / a[i] + (x % a[i] != 0);
ans++;
}
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {-1, 1, 0, 0};
long long arr[100000];
long long tree[100001];
int main() {
long long t;
scanf("%lld", &t);
;
while (t--) {
long long n, m;
scanf("%lld %lld", &n, &m);
std::vector<long long> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end(), greater<long long>());
long long last = -1;
long long res = 0;
for (int i = 0; i < n; i++) {
if ((i - last) * vec[i] >= m) {
res++;
last = i;
}
}
cout << res << endl;
}
return 0;
}
| ### Prompt
Generate a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {-1, 1, 0, 0};
long long arr[100000];
long long tree[100001];
int main() {
long long t;
scanf("%lld", &t);
;
while (t--) {
long long n, m;
scanf("%lld %lld", &n, &m);
std::vector<long long> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end(), greater<long long>());
long long last = -1;
long long res = 0;
for (int i = 0; i < n; i++) {
if ((i - last) * vec[i] >= m) {
res++;
last = i;
}
}
cout << res << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
char dir[] = {'D', 'R', 'U', 'L'};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end(), greater<long long>());
long long ctr = 0, j = 1;
for (int i = 0; i < n; i++) {
if (a[i] * j >= x)
++ctr, j = 1;
else
++j;
}
cout << ctr << "\n";
}
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
char dir[] = {'D', 'R', 'U', 'L'};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end(), greater<long long>());
long long ctr = 0, j = 1;
for (int i = 0; i < n; i++) {
if (a[i] * j >= x)
++ctr, j = 1;
else
++j;
}
cout << ctr << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int T, n, x, p, tot, cuenta;
vector<int> a;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> T;
for (int t = (1); t <= (T); t++) {
a.clear();
cin >> n >> x;
for (int i = (1); i <= (n); i++) {
cin >> p;
a.push_back(p);
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
tot = 0;
cuenta = 0;
for (auto n : a) {
cuenta++;
if (cuenta * n >= x) {
cuenta = 0;
tot++;
}
}
cout << tot << "\n";
}
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int T, n, x, p, tot, cuenta;
vector<int> a;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> T;
for (int t = (1); t <= (T); t++) {
a.clear();
cin >> n >> x;
for (int i = (1); i <= (n); i++) {
cin >> p;
a.push_back(p);
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
tot = 0;
cuenta = 0;
for (auto n : a) {
cuenta++;
if (cuenta * n >= x) {
cuenta = 0;
tot++;
}
}
cout << tot << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x;
cin >> n >> x;
vector<int> a(n);
for (int& i : a) cin >> i;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
vector<int> dp(n + 1);
int ans = 0;
for (int i = 0; i < n; ++i) {
int cnt = (x + a[i] - 1) / a[i];
if (cnt > i + 1) continue;
dp[i + 1] = 1 + dp[i + 1 - cnt];
ans = max(ans, dp[i + 1]);
}
cout << ans << '\n';
}
int main() {
int tt;
cin >> tt;
while (tt--) solve();
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
There are n programmers that you want to split into several non-empty teams. The skill of the i-th programmer is a_i. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least x.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
Input
The first line contains the integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5; 1 ≤ x ≤ 10^9) — the number of programmers and the restriction of team skill respectively.
The second line of each test case contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9), where a_i is the skill of the i-th programmer.
The sum of n over all inputs does not exceed 10^5.
Output
For each test case print one integer — the maximum number of teams that you can assemble.
Example
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x;
cin >> n >> x;
vector<int> a(n);
for (int& i : a) cin >> i;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
vector<int> dp(n + 1);
int ans = 0;
for (int i = 0; i < n; ++i) {
int cnt = (x + a[i] - 1) / a[i];
if (cnt > i + 1) continue;
dp[i + 1] = 1 + dp[i + 1 - cnt];
ans = max(ans, dp[i + 1]);
}
cout << ans << '\n';
}
int main() {
int tt;
cin >> tt;
while (tt--) solve();
}
``` |
Subsets and Splits