output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#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
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;
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>
using namespace std;
int main() {
int t;
cin >> t;
while (t) {
int n, x;
cin >> n >> x;
long long int arr[n], count = 0, minimum = -1, teams = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
for (int i = 0; i < n; i++) {
minimum = arr[i];
count++;
if ((minimum * count) >= x) {
teams++;
count = 0;
}
}
cout << teams << endl;
t--;
}
}
| ### 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) {
int n, x;
cin >> n >> x;
long long int arr[n], count = 0, minimum = -1, teams = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
for (int i = 0; i < n; i++) {
minimum = arr[i];
count++;
if ((minimum * count) >= x) {
teams++;
count = 0;
}
}
cout << teams << endl;
t--;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n, x;
cin >> n >> x;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
int count = 0, temp = 1;
for (int i = 0; i < n; i++) {
if (v[i] * temp >= x) {
count++;
temp = 1;
} else
temp++;
}
cout << count << 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 tt;
cin >> tt;
while (tt--) {
int n, x;
cin >> n >> x;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
int count = 0, temp = 1;
for (int i = 0; i < n; i++) {
if (v[i] * temp >= x) {
count++;
temp = 1;
} else
temp++;
}
cout << count << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
const double pi = std::acos(-1);
using namespace std;
const long long int mod = 1000000000 + 7;
long long int power(long long int x, long long int y, long long int md) {
long long int res = 1;
x = x % md;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % md;
y = y >> 1;
x = (x * x) % md;
}
return res;
}
long long int m_mul(long long int a, long long int b) {
a = a % mod;
b = b % mod;
return (a * b + mod) % mod;
}
long long int m_add(long long int a, long long int b) {
a = a % mod;
b = b % mod;
return (a + b + mod) % mod;
}
int main() {
long long int tc;
cin >> tc;
while (tc--) {
long long int n, x;
cin >> n >> x;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<long long int>());
long long int a1 = 1;
long long int k = 0;
for (long long int i = 0; i < n; i++) {
if (arr[i] * a1 >= x) {
a1 = 1;
k++;
} else {
a1++;
}
}
cout << k << '\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>
const double pi = std::acos(-1);
using namespace std;
const long long int mod = 1000000000 + 7;
long long int power(long long int x, long long int y, long long int md) {
long long int res = 1;
x = x % md;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % md;
y = y >> 1;
x = (x * x) % md;
}
return res;
}
long long int m_mul(long long int a, long long int b) {
a = a % mod;
b = b % mod;
return (a * b + mod) % mod;
}
long long int m_add(long long int a, long long int b) {
a = a % mod;
b = b % mod;
return (a + b + mod) % mod;
}
int main() {
long long int tc;
cin >> tc;
while (tc--) {
long long int n, x;
cin >> n >> x;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<long long int>());
long long int a1 = 1;
long long int k = 0;
for (long long int i = 0; i < n; i++) {
if (arr[i] * a1 >= x) {
a1 = 1;
k++;
} else {
a1++;
}
}
cout << k << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, i, j;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
long long ans = 0;
for (i = n - 1; i >= 0; i--) {
if (a[i] >= x) {
ans++;
continue;
}
long long cnt = 1;
while (i >= 0 && cnt * a[i] < x) {
i--;
cnt++;
}
if (i >= 0) ans++;
}
cout << ans << "\n";
}
}
| ### 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;
const double pi = 3.14159265358979323846;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, i, j;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
long long ans = 0;
for (i = n - 1; i >= 0; i--) {
if (a[i] >= x) {
ans++;
continue;
}
long long cnt = 1;
while (i >= 0 && cnt * a[i] < x) {
i--;
cnt++;
}
if (i >= 0) ans++;
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n, x;
cin >> t;
int *answer = new int[t];
for (int u = 0; u < t; u++) {
cin >> n >> x;
int *input = new int[n];
for (int j = 0; j < n; j++) {
cin >> input[j];
}
int team = 0;
int counting = 0;
sort(input, input + n, greater<int>());
for (int i = 0; i < n; i++) {
if (input[i] >= x) {
team++;
}
if (input[i] < x) {
counting++;
long int e = counting * input[i];
if (e >= x) {
team++;
counting = 0;
}
}
}
answer[u] = team;
}
for (int i = 0; i < t; i++) {
cout << answer[i] << "\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;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n, x;
cin >> t;
int *answer = new int[t];
for (int u = 0; u < t; u++) {
cin >> n >> x;
int *input = new int[n];
for (int j = 0; j < n; j++) {
cin >> input[j];
}
int team = 0;
int counting = 0;
sort(input, input + n, greater<int>());
for (int i = 0; i < n; i++) {
if (input[i] >= x) {
team++;
}
if (input[i] < x) {
counting++;
long int e = counting * input[i];
if (e >= x) {
team++;
counting = 0;
}
}
}
answer[u] = team;
}
for (int i = 0; i < t; i++) {
cout << answer[i] << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
long long A(long long x) {
if (x >= 0)
return x;
else
return -x;
}
long long gcd(long long a, long long b) {
if (b > a) {
long long tmp = b;
b = a;
a = tmp;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
unsigned long long popcount(unsigned long long x) {
x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1) + (x & 0x5555555555555555UL);
x = ((x & 0xccccccccccccccccUL) >> 2) + (x & 0x3333333333333333UL);
x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4) + (x & 0x0f0f0f0f0f0f0f0fUL);
x = ((x & 0xff00ff00ff00ff00UL) >> 8) + (x & 0x00ff00ff00ff00ffUL);
x = ((x & 0xffff0000ffff0000UL) >> 16) + (x & 0x0000ffff0000ffffUL);
x = ((x & 0xffffffff00000000UL) >> 32) + (x & 0x00000000ffffffffUL);
return x;
}
int main(void) {
int T;
cin >> T;
for (int query = 0; query < T; query++) {
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>());
int ans = 0;
long long tmp = 0;
for (int i = 0; i < n; i++) {
if (a[i] * (tmp + 1) >= x) {
ans++;
tmp = 0;
} else
tmp++;
}
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 inf = (int)1e9;
long long A(long long x) {
if (x >= 0)
return x;
else
return -x;
}
long long gcd(long long a, long long b) {
if (b > a) {
long long tmp = b;
b = a;
a = tmp;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
unsigned long long popcount(unsigned long long x) {
x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1) + (x & 0x5555555555555555UL);
x = ((x & 0xccccccccccccccccUL) >> 2) + (x & 0x3333333333333333UL);
x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4) + (x & 0x0f0f0f0f0f0f0f0fUL);
x = ((x & 0xff00ff00ff00ff00UL) >> 8) + (x & 0x00ff00ff00ff00ffUL);
x = ((x & 0xffff0000ffff0000UL) >> 16) + (x & 0x0000ffff0000ffffUL);
x = ((x & 0xffffffff00000000UL) >> 32) + (x & 0x00000000ffffffffUL);
return x;
}
int main(void) {
int T;
cin >> T;
for (int query = 0; query < T; query++) {
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>());
int ans = 0;
long long tmp = 0;
for (int i = 0; i < n; i++) {
if (a[i] * (tmp + 1) >= x) {
ans++;
tmp = 0;
} else
tmp++;
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long t, n, x, v[200001];
void solve() {
cin >> n >> x;
for (int i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
reverse(v + 1, v + n + 1);
long long ans = 0;
long long nr = 0;
for (int i = 1; i <= n; i++) {
nr++;
if (nr * v[i] >= x) {
nr = 0;
ans++;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
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;
long long t, n, x, v[200001];
void solve() {
cin >> n >> x;
for (int i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
reverse(v + 1, v + n + 1);
long long ans = 0;
long long nr = 0;
for (int i = 1; i <= n; i++) {
nr++;
if (nr * v[i] >= x) {
nr = 0;
ans++;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long skill[100001];
long long x;
int t;
int n;
long long atSkill(long long i) {
if (i <= n)
return skill[i];
else
return -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n >> x;
for (int i = 0; i < n; ++i) cin >> skill[i];
sort(skill, skill + n);
skill[n] = 0;
for (int i = n - 1; i >= 0; --i) {
long long ileDoNastepnego = skill[i + 1];
long long iluTakich;
if (x % skill[i] == 0)
iluTakich = x / skill[i];
else
iluTakich = 1 + x / skill[i];
long long zTym = 1 + atSkill(i + iluTakich);
skill[i] = max(ileDoNastepnego, zTym);
}
cout << skill[0] << '\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;
long long skill[100001];
long long x;
int t;
int n;
long long atSkill(long long i) {
if (i <= n)
return skill[i];
else
return -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n >> x;
for (int i = 0; i < n; ++i) cin >> skill[i];
sort(skill, skill + n);
skill[n] = 0;
for (int i = n - 1; i >= 0; --i) {
long long ileDoNastepnego = skill[i + 1];
long long iluTakich;
if (x % skill[i] == 0)
iluTakich = x / skill[i];
else
iluTakich = 1 + x / skill[i];
long long zTym = 1 + atSkill(i + iluTakich);
skill[i] = max(ileDoNastepnego, zTym);
}
cout << skill[0] << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void test_case();
long long power(int n, int p);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
test_case();
}
return 0;
}
void test_case() {
int n, x;
cin >> n >> x;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
int teams = 0;
int cnt = 1;
for (int ptr = n - 1; ptr >= 0; ptr--) {
if (arr[ptr] * cnt >= x) {
teams++;
cnt = 1;
} else
cnt++;
}
cout << teams << '\n';
}
long long power(int n, int p) {
long long ans = 1;
if (p == 0) return 1;
long long temp = power(n, p / 2);
if (p % 2 == 0)
ans = (temp * temp) % 1000000007;
else {
ans = (ans * n) % 1000000007;
ans *= (temp * temp) % 1000000007;
}
return ans;
}
| ### 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;
void test_case();
long long power(int n, int p);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
test_case();
}
return 0;
}
void test_case() {
int n, x;
cin >> n >> x;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
int teams = 0;
int cnt = 1;
for (int ptr = n - 1; ptr >= 0; ptr--) {
if (arr[ptr] * cnt >= x) {
teams++;
cnt = 1;
} else
cnt++;
}
cout << teams << '\n';
}
long long power(int n, int p) {
long long ans = 1;
if (p == 0) return 1;
long long temp = power(n, p / 2);
if (p % 2 == 0)
ans = (temp * temp) % 1000000007;
else {
ans = (ans * n) % 1000000007;
ans *= (temp * temp) % 1000000007;
}
return ans;
}
``` |
#include <bits/stdc++.h>
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int sum() { return 0; }
template <typename T, typename... Args>
T sum(T a, Args... args) {
return a + sum(args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
std::vector<long long> v(n);
long long cnt = 0;
for (int i = 0; i < n; ++i) {
cin >> v[i];
if (v[i] >= x) cnt++;
}
sort(v.begin(), v.end(), greater<int>());
long long ans = 0, rem = n - cnt;
long long sz = 1, mn = INT_MAX;
if (rem > 0) {
for (int i = cnt; i < n; ++i) {
mn = v[i];
if (sz * mn >= x) {
cnt++;
sz = 1;
} else {
sz++;
}
}
}
cout << cnt << "\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>
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int sum() { return 0; }
template <typename T, typename... Args>
T sum(T a, Args... args) {
return a + sum(args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
std::vector<long long> v(n);
long long cnt = 0;
for (int i = 0; i < n; ++i) {
cin >> v[i];
if (v[i] >= x) cnt++;
}
sort(v.begin(), v.end(), greater<int>());
long long ans = 0, rem = n - cnt;
long long sz = 1, mn = INT_MAX;
if (rem > 0) {
for (int i = cnt; i < n; ++i) {
mn = v[i];
if (sz * mn >= x) {
cnt++;
sz = 1;
} else {
sz++;
}
}
}
cout << cnt << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int32_t INF32 = 1000000000;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int32_t tests;
cin >> tests;
for (int32_t test = 0; test < tests; test++) {
int32_t count, value;
cin >> count >> value;
int32_t values[count];
for (int32_t i = 0; i < count; i++) {
cin >> values[i];
}
sort(values, values + count);
int32_t min_team_size[count];
int32_t free_count = 0;
for (int32_t i = count - 1; i >= 0; i--) {
free_count++;
min_team_size[i] = (value - 1) / values[i] + 1;
if (min_team_size[i] > free_count) {
min_team_size[i] = INF32;
} else {
free_count -= min_team_size[i];
}
}
sort(min_team_size, min_team_size + count);
int32_t result = 0;
int32_t sum = 0;
for (int32_t i = 0; i < count && sum < count; i++) {
if (min_team_size[i] <= 0) {
continue;
}
if (sum + min_team_size[i] <= count) {
result++;
sum += min_team_size[i];
} else {
break;
}
}
cout << result << "\n";
}
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;
const int32_t INF32 = 1000000000;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int32_t tests;
cin >> tests;
for (int32_t test = 0; test < tests; test++) {
int32_t count, value;
cin >> count >> value;
int32_t values[count];
for (int32_t i = 0; i < count; i++) {
cin >> values[i];
}
sort(values, values + count);
int32_t min_team_size[count];
int32_t free_count = 0;
for (int32_t i = count - 1; i >= 0; i--) {
free_count++;
min_team_size[i] = (value - 1) / values[i] + 1;
if (min_team_size[i] > free_count) {
min_team_size[i] = INF32;
} else {
free_count -= min_team_size[i];
}
}
sort(min_team_size, min_team_size + count);
int32_t result = 0;
int32_t sum = 0;
for (int32_t i = 0; i < count && sum < count; i++) {
if (min_team_size[i] <= 0) {
continue;
}
if (sum + min_team_size[i] <= count) {
result++;
sum += min_team_size[i];
} else {
break;
}
}
cout << result << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test;
cin >> test;
while (test--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long ans = 0;
long long j;
for (int i = 0; i < n; i++) {
long long nax = 0, cnt = 0;
j = i;
while (j < n) {
nax = v[j];
cnt++;
if (cnt * nax >= k) {
ans++;
break;
}
j++;
}
i = j;
}
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>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test;
cin >> test;
while (test--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long ans = 0;
long long j;
for (int i = 0; i < n; i++) {
long long nax = 0, cnt = 0;
j = i;
while (j < n) {
nax = v[j];
cnt++;
if (cnt * nax >= k) {
ans++;
break;
}
j++;
}
i = j;
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
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(), greater<int>());
int ans = 0, cur = 1;
for (auto s : a) {
if (s * cur >= x) {
ans++;
cur = 0;
}
cur++;
}
cout << ans << "\n";
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
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;
void solve() {
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(), greater<int>());
int ans = 0, cur = 1;
for (auto s : a) {
if (s * cur >= x) {
ans++;
cur = 0;
}
cur++;
}
cout << ans << "\n";
return;
}
int 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 main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, t, i, x;
cin >> t;
while (t--) {
long long ans = 0, m = 1;
cin >> n >> x;
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++) {
if ((a[i] * m) >= x) {
m = 0;
ans++;
}
m++;
}
cout << ans << endl;
}
}
| ### 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() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, t, i, x;
cin >> t;
while (t--) {
long long ans = 0, m = 1;
cin >> n >> x;
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++) {
if ((a[i] * m) >= x) {
m = 0;
ans++;
}
m++;
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x, ans = 0;
memset(a, 0, sizeof(a));
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int flag = 0;
int tmpc = 1, tmpa = 1, f = 0;
for (int i = n; i >= 1; i--) {
tmpa = tmpc * a[i];
tmpc++;
if (tmpa >= x) {
tmpc = 1;
tmpa = 1;
ans++;
}
}
printf("%d\n", ans);
}
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 a[100005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x, ans = 0;
memset(a, 0, sizeof(a));
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int flag = 0;
int tmpc = 1, tmpa = 1, f = 0;
for (int i = n; i >= 1; i--) {
tmpa = tmpc * a[i];
tmpc++;
if (tmpa >= x) {
tmpc = 1;
tmpa = 1;
ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 5;
long long a[maxn];
void f() {
int n, t = 0, m = 0;
long long x;
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
for (int i = 0; i < n; i++) {
m++;
if (a[i] * m >= x) {
t++;
m = 0;
}
}
cout << t << endl;
}
int main() {
int t, n;
cin >> t;
for (int q = 0; q < t; q++) {
f();
}
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 maxn = 1000 * 100 + 5;
long long a[maxn];
void f() {
int n, t = 0, m = 0;
long long x;
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
for (int i = 0; i < n; i++) {
m++;
if (a[i] * m >= x) {
t++;
m = 0;
}
}
cout << t << endl;
}
int main() {
int t, n;
cin >> t;
for (int q = 0; q < t; q++) {
f();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int t, n;
long long x, arr[100005];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%lld", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
}
sort(arr, arr + n);
int cant = 0, answer = 0;
;
for (int i = n - 1; i >= 0; i--) {
cant++;
if ((long long)cant * arr[i] >= x) {
cant = 0;
answer++;
}
}
printf("%d\n", answer);
}
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 t, n;
long long x, arr[100005];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%lld", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
}
sort(arr, arr + n);
int cant = 0, answer = 0;
;
for (int i = n - 1; i >= 0; i--) {
cant++;
if ((long long)cant * arr[i] >= x) {
cant = 0;
answer++;
}
}
printf("%d\n", answer);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
int n, x;
cin >> n >> x;
vector<int> v(n, 0);
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = n - 1; i > -1; i--) {
int k = ceil(double(x) / v[i]);
cnt++;
if (cnt >= k) {
ans++;
cnt = 0;
}
}
cout << ans << endl;
}
int main() {
fastio();
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
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;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
int n, x;
cin >> n >> x;
vector<int> v(n, 0);
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = n - 1; i > -1; i--) {
int k = ceil(double(x) / v[i]);
cnt++;
if (cnt >= k) {
ans++;
cnt = 0;
}
}
cout << ans << endl;
}
int main() {
fastio();
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int INF64 = mod * mod + 1;
void solve() {
long long int n, x;
cin >> n >> x;
priority_queue<long long int> pq;
while (n--) {
long long int a;
cin >> a;
pq.push(a);
}
long long int ans = 0, curr = 0, currmin;
while (!pq.empty()) {
if (curr * currmin < x) {
currmin = pq.top();
pq.pop(), curr++;
} else {
ans++;
curr = 0;
}
}
ans += (curr * currmin >= x);
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
cin >> T;
for (long long int i = 1; i <= T; i++) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\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;
long long int mod = 1000000007;
long long int INF64 = mod * mod + 1;
void solve() {
long long int n, x;
cin >> n >> x;
priority_queue<long long int> pq;
while (n--) {
long long int a;
cin >> a;
pq.push(a);
}
long long int ans = 0, curr = 0, currmin;
while (!pq.empty()) {
if (curr * currmin < x) {
currmin = pq.top();
pq.pop(), curr++;
} else {
ans++;
curr = 0;
}
}
ans += (curr * currmin >= x);
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
cin >> T;
for (long long int i = 1; i <= T; i++) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
``` |
#include <bits/stdc++.h>
using namespace std;
void func(long long int arr[], int n, long long int x) {
if (arr[n - 1] * n < x) {
printf("0\n");
return;
}
int dp[n + 1];
for (int i = 0; i <= n; i++) dp[i] = 0;
int ans = INT_MIN;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] >= x) {
dp[i] = 1 + dp[i + 1];
} else {
float a = x;
float b = arr[i];
float c = ceil(a / b);
if (c + i > n) {
dp[i] = 0;
} else {
dp[i] = 1 + dp[i + (int)c];
}
}
}
for (int i = 0; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
printf("\n");
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
long long int x;
cin >> n >> x;
long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
func(arr, n, x);
}
}
| ### 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;
void func(long long int arr[], int n, long long int x) {
if (arr[n - 1] * n < x) {
printf("0\n");
return;
}
int dp[n + 1];
for (int i = 0; i <= n; i++) dp[i] = 0;
int ans = INT_MIN;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] >= x) {
dp[i] = 1 + dp[i + 1];
} else {
float a = x;
float b = arr[i];
float c = ceil(a / b);
if (c + i > n) {
dp[i] = 0;
} else {
dp[i] = 1 + dp[i + (int)c];
}
}
}
for (int i = 0; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
printf("\n");
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
long long int x;
cin >> n >> x;
long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
func(arr, n, x);
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int n, x;
cin >> n >> x;
int num[n];
for (int j = 0; j < n; j++) {
cin >> num[j];
}
sort(num, num + n);
reverse(num, num + n);
int res = 0;
int counter = 0;
int temp_counter = 0;
while (counter < n) {
if (num[counter] >= x) {
res++;
} else {
temp_counter++;
if (num[counter] * temp_counter >= x) {
res++;
temp_counter = 0;
}
}
counter++;
}
cout << res << "\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_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int n, x;
cin >> n >> x;
int num[n];
for (int j = 0; j < n; j++) {
cin >> num[j];
}
sort(num, num + n);
reverse(num, num + n);
int res = 0;
int counter = 0;
int temp_counter = 0;
while (counter < n) {
if (num[counter] >= x) {
res++;
} else {
temp_counter++;
if (num[counter] * temp_counter >= x) {
res++;
temp_counter = 0;
}
}
counter++;
}
cout << res << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x, a, s = 0;
cin >> n >> x;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
if (a >= x)
s++;
else
v.push_back(a);
}
sort(v.begin(), v.end());
int i = v.size() - 1, j = 1;
while (i >= 0) {
if (v[i] * j >= x) {
s++;
j = 1;
i--;
} else
j++, i--;
}
cout << s << 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;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x, a, s = 0;
cin >> n >> x;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
if (a >= x)
s++;
else
v.push_back(a);
}
sort(v.begin(), v.end());
int i = v.size() - 1, j = 1;
while (i >= 0) {
if (v[i] * j >= x) {
s++;
j = 1;
i--;
} else
j++, i--;
}
cout << s << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N];
bool cmp(int a, int b) { return a > b; }
int main() {
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof a);
int n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1, cmp);
int len = 1, res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] * len >= x) {
len = 1;
res++;
} else
len++;
}
cout << res << endl;
}
}
| ### 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 = 100010;
int a[N];
bool cmp(int a, int b) { return a > b; }
int main() {
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof a);
int n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1, cmp);
int len = 1, res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] * len >= x) {
len = 1;
res++;
} else
len++;
}
cout << res << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> v;
int el;
for (int i = 0; i < n; ++i) {
cin >> el;
v.push_back(el);
}
sort(v.begin(), v.end(), greater<int>());
int ans = 0;
int k;
for (k = 0; k < n; ++k) {
if (v[k] >= x)
++ans;
else
break;
}
int m = 1;
for (int i = k; i < n; ++i) {
if (m * v[i] >= x) {
++ans;
m = 0;
}
++m;
}
cout << ans << endl;
}
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--) {
int n, x;
cin >> n >> x;
vector<int> v;
int el;
for (int i = 0; i < n; ++i) {
cin >> el;
v.push_back(el);
}
sort(v.begin(), v.end(), greater<int>());
int ans = 0;
int k;
for (k = 0; k < n; ++k) {
if (v[k] >= x)
++ans;
else
break;
}
int m = 1;
for (int i = k; i < n; ++i) {
if (m * v[i] >= x) {
++ans;
m = 0;
}
++m;
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int T, n, m, a[100005], f[100005];
void u(int &x, int y) {
if (y > x) x = y;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), f[i] = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
if (a[i] >= m)
f[i] = f[i - 1] + 1;
else {
int _ = i + (m - 1) / a[i];
if (_ <= n) u(f[_], f[i - 1] + 1);
u(f[i], f[i - 1]);
}
}
printf("%d\n", f[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, m, a[100005], f[100005];
void u(int &x, int y) {
if (y > x) x = y;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), f[i] = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
if (a[i] >= m)
f[i] = f[i - 1] + 1;
else {
int _ = i + (m - 1) / a[i];
if (_ <= n) u(f[_], f[i - 1] + 1);
u(f[i], f[i - 1]);
}
}
printf("%d\n", f[n]);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int *arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int p = n - 1;
int count = 0;
for (int i = n - 1; i >= 0; i--) {
if ((arr[i] * (p - i + 1)) >= x) {
count++;
p = i - 1;
}
}
cout << count << 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;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int *arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int p = n - 1;
int count = 0;
for (int i = n - 1; i >= 0; i--) {
if ((arr[i] * (p - i + 1)) >= x) {
count++;
p = i - 1;
}
}
cout << count << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, j, i;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int a[n], dp[n];
for (size_t i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
long long int s = ceil((double)x / a[i]);
if (i + s > n)
dp[i] = 0;
else if (i + s == n)
dp[i] = 1;
else
dp[i] = dp[i + s] + 1;
}
cout << *max_element(dp, dp + n) << endl;
}
}
| ### 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() {
long long int t, j, i;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int a[n], dp[n];
for (size_t i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
long long int s = ceil((double)x / a[i]);
if (i + s > n)
dp[i] = 0;
else if (i + s == n)
dp[i] = 1;
else
dp[i] = dp[i + s] + 1;
}
cout << *max_element(dp, dp + n) << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(!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(begin(a), end(a));
int fodder = 0, t = 0;
for (int i = n - 1; i >= 0; i--) {
fodder++;
if (a[i] * fodder >= x) {
int u = (x + a[i] - 1) / a[i];
fodder -= u;
t++;
}
}
cout << t << '\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;
int main() {
ios::sync_with_stdio(!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(begin(a), end(a));
int fodder = 0, t = 0;
for (int i = n - 1; i >= 0; i--) {
fodder++;
if (a[i] * fodder >= x) {
int u = (x + a[i] - 1) / a[i];
fodder -= u;
t++;
}
}
cout << t << '\n';
}
}
``` |
#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() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
cin >> t;
while (t--) {
int n, c = 1, x = 0, k;
cin >> n >> k;
int i;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<long long int>());
long long int mi = 1000000000000;
vector<long long int> v;
for (i = 0; i < n; i++) {
v.push_back(a[i]);
mi = min(a[i], mi);
if (mi * v.size() >= k) {
x++;
mi = 1000000000000;
v.clear();
}
}
cout << x << 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() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
cin >> t;
while (t--) {
int n, c = 1, x = 0, k;
cin >> n >> k;
int i;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<long long int>());
long long int mi = 1000000000000;
vector<long long int> v;
for (i = 0; i < n; i++) {
v.push_back(a[i]);
mi = min(a[i], mi);
if (mi * v.size() >= k) {
x++;
mi = 1000000000000;
v.clear();
}
}
cout << x << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long mod = 1000000007;
vector<long long> p;
inline int getint() {
int num = 0, bj = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == EOF) return EOF;
bj = (c == '-' || bj == -1) ? -1 : 1, c = getchar();
}
while (c >= '0' && c <= '9') num = num * 10 + c - '0', c = getchar();
return num * bj;
}
void init() {}
bool cmp(int x, int y) { return x > y; }
void solve() {
int T;
cin >> T;
while (T--) {
p.clear();
long long n, x;
n = getint();
x = getint();
long long a;
for (int i = 0; i < n; ++i) {
a = getint();
p.push_back(a);
}
sort(p.begin(), p.end(), cmp);
long long len = 0;
int ans = 0;
for (int i = 0; i < p.size(); ++i) {
len++;
if (p[i] * len >= x) {
ans++;
len = 0;
}
}
cout << ans << endl;
}
}
int main() {
init();
solve();
}
| ### 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 warning(disable : 4996)
using namespace std;
const long long mod = 1000000007;
vector<long long> p;
inline int getint() {
int num = 0, bj = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == EOF) return EOF;
bj = (c == '-' || bj == -1) ? -1 : 1, c = getchar();
}
while (c >= '0' && c <= '9') num = num * 10 + c - '0', c = getchar();
return num * bj;
}
void init() {}
bool cmp(int x, int y) { return x > y; }
void solve() {
int T;
cin >> T;
while (T--) {
p.clear();
long long n, x;
n = getint();
x = getint();
long long a;
for (int i = 0; i < n; ++i) {
a = getint();
p.push_back(a);
}
sort(p.begin(), p.end(), cmp);
long long len = 0;
int ans = 0;
for (int i = 0; i < p.size(); ++i) {
len++;
if (p[i] * len >= x) {
ans++;
len = 0;
}
}
cout << ans << endl;
}
}
int main() {
init();
solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, const multiset<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <class S, class T>
ostream &operator<<(ostream &os, const unordered_map<S, T> &v) {
for (auto i : v) os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
template <class T>
bool umin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool umax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const long long N = 2e5 + 1;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> v;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
if (a >= x)
ans++;
else
v.push_back(a);
}
sort(v.begin(), v.end());
long long len = 0;
for (long long i = (long long)v.size() - 1; i >= 0; i--) {
len++;
if (v[i] * len >= x) {
ans++;
len = 0;
}
}
cout << ans << '\n';
}
signed main() {
long long q = 1;
cin >> q;
while (q--) 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;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, const multiset<T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream &operator<<(ostream &os, const map<S, T> &p) {
os << "[";
for (auto &it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <class S, class T>
ostream &operator<<(ostream &os, const unordered_map<S, T> &v) {
for (auto i : v) os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
template <class T>
bool umin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool umax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const long long N = 2e5 + 1;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> v;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
if (a >= x)
ans++;
else
v.push_back(a);
}
sort(v.begin(), v.end());
long long len = 0;
for (long long i = (long long)v.size() - 1; i >= 0; i--) {
len++;
if (v[i] * len >= x) {
ans++;
len = 0;
}
}
cout << ans << '\n';
}
signed main() {
long long q = 1;
cin >> q;
while (q--) solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long tt;
cin >> tt;
for (long long sgg = 0; sgg < tt; ++sgg) {
long long siz;
cin >> siz;
long long skill;
cin >> skill;
long long sad = 0, S = 0, P = 0;
vector<long long> inp(siz);
for (long long i = 0; i < siz; ++i) {
cin >> inp[i];
}
sort(inp.begin(), inp.end());
reverse(inp.begin(), inp.end());
long long ans = 0;
for (long long i = 0; i < siz; ++i) {
if (inp[i] >= skill) {
ans++;
} else {
sad++;
if (inp[i] * sad >= skill) {
sad = 0;
ans++;
}
}
}
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;
int main() {
long long tt;
cin >> tt;
for (long long sgg = 0; sgg < tt; ++sgg) {
long long siz;
cin >> siz;
long long skill;
cin >> skill;
long long sad = 0, S = 0, P = 0;
vector<long long> inp(siz);
for (long long i = 0; i < siz; ++i) {
cin >> inp[i];
}
sort(inp.begin(), inp.end());
reverse(inp.begin(), inp.end());
long long ans = 0;
for (long long i = 0; i < siz; ++i) {
if (inp[i] >= skill) {
ans++;
} else {
sad++;
if (inp[i] * sad >= skill) {
sad = 0;
ans++;
}
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long dp[100008];
long long work(vector<long long> &a, long long &n, long long &x, long long i) {
if (i > n) return -0x3f3f3f3f;
if (i == n) return 0;
if (dp[i] != -1) return dp[i];
if (a[i] >= x) return dp[i] = work(a, n, x, i + 1) + 1;
long long y = x / a[i];
if (x % a[i]) y += 1;
return dp[i] = (work(a, n, x, i + 1) > work(a, n, x, i + y) + 1
? work(a, n, x, i + 1)
: work(a, n, x, i + y) + 1);
}
void solve() {
long long x, n;
cin >> n >> x;
vector<long long> a(n);
{
int n11 = a.size();
for (int i1 = 0; i1 < n11; i1++) cin >> a[i1];
};
sort(a.begin(), a.end());
memset(dp, -1, sizeof(dp));
cout << work(a, n, x, 0) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
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;
long long dp[100008];
long long work(vector<long long> &a, long long &n, long long &x, long long i) {
if (i > n) return -0x3f3f3f3f;
if (i == n) return 0;
if (dp[i] != -1) return dp[i];
if (a[i] >= x) return dp[i] = work(a, n, x, i + 1) + 1;
long long y = x / a[i];
if (x % a[i]) y += 1;
return dp[i] = (work(a, n, x, i + 1) > work(a, n, x, i + y) + 1
? work(a, n, x, i + 1)
: work(a, n, x, i + y) + 1);
}
void solve() {
long long x, n;
cin >> n >> x;
vector<long long> a(n);
{
int n11 = a.size();
for (int i1 = 0; i1 < n11; i1++) cin >> a[i1];
};
sort(a.begin(), a.end());
memset(dp, -1, sizeof(dp));
cout << work(a, n, x, 0) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
int k = 1;
sort(a, a + n, greater<int>());
for (int i = 0; i < n; i++) {
if (a[i] * k >= x) {
ans++;
k = 1;
} else {
++k;
}
}
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;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
int k = 1;
sort(a, a + n, greater<int>());
for (int i = 0; i < n; i++) {
if (a[i] * k >= x) {
ans++;
k = 1;
} else {
++k;
}
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void test() {
int nPers, skillMin;
cin >> nPers >> skillMin;
vector<int> nbPersNeeded;
map<int, int> nPersDisp;
int skill, toFormGroup;
for (int i = 0; i < nPers; i++) {
cin >> skill;
toFormGroup = ceil(double(skillMin) / double(skill));
if (nPersDisp[toFormGroup] == 0) {
nbPersNeeded.push_back(toFormGroup);
}
nPersDisp[toFormGroup]++;
}
sort(nbPersNeeded.begin(), nbPersNeeded.end());
int r = 0;
int nGroup = 0;
for (int i = 0; i < nbPersNeeded.size(); i++) {
if (nbPersNeeded[i] == 0) {
cout << "zero" << endl;
} else {
nGroup += (r + nPersDisp[nbPersNeeded[i]]) / nbPersNeeded[i];
r = (r + nPersDisp[nbPersNeeded[i]]) % nbPersNeeded[i];
}
}
cout << nGroup << endl;
}
int main() {
int nTest;
cin >> nTest;
for (int i = 0; i < nTest; i++) {
test();
}
}
| ### 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;
void test() {
int nPers, skillMin;
cin >> nPers >> skillMin;
vector<int> nbPersNeeded;
map<int, int> nPersDisp;
int skill, toFormGroup;
for (int i = 0; i < nPers; i++) {
cin >> skill;
toFormGroup = ceil(double(skillMin) / double(skill));
if (nPersDisp[toFormGroup] == 0) {
nbPersNeeded.push_back(toFormGroup);
}
nPersDisp[toFormGroup]++;
}
sort(nbPersNeeded.begin(), nbPersNeeded.end());
int r = 0;
int nGroup = 0;
for (int i = 0; i < nbPersNeeded.size(); i++) {
if (nbPersNeeded[i] == 0) {
cout << "zero" << endl;
} else {
nGroup += (r + nPersDisp[nbPersNeeded[i]]) / nbPersNeeded[i];
r = (r + nPersDisp[nbPersNeeded[i]]) % nbPersNeeded[i];
}
}
cout << nGroup << endl;
}
int main() {
int nTest;
cin >> nTest;
for (int i = 0; i < nTest; i++) {
test();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long a, int p, long long int m) {
if (p == 0) return 1;
if (p & 1) {
return ((a % m) * (bigmod(a, p - 1, m))) % m;
} else {
long long tmp = bigmod(a, p / 2, m);
return (tmp * tmp) % m;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int chu;
cin >> chu;
while (chu--) {
long long int n;
cin >> n;
long long int x;
cin >> x;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
long long int ans = 0;
long long int i = 0;
long long int y = 1;
for (i = 0; i < n; i++) {
if (a[i] * y >= x)
ans++, y = 1;
else
y++;
}
cout << ans;
cout << "\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;
long long bigmod(long long a, int p, long long int m) {
if (p == 0) return 1;
if (p & 1) {
return ((a % m) * (bigmod(a, p - 1, m))) % m;
} else {
long long tmp = bigmod(a, p / 2, m);
return (tmp * tmp) % m;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int chu;
cin >> chu;
while (chu--) {
long long int n;
cin >> n;
long long int x;
cin >> x;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
long long int ans = 0;
long long int i = 0;
long long int y = 1;
for (i = 0; i < n; i++) {
if (a[i] * y >= x)
ans++, y = 1;
else
y++;
}
cout << ans;
cout << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, 1};
int dy4[] = {1, -1, 1, -1};
int main() {
int t;
cin >> t;
while (t--) {
long long n, x, c = 1, ans = 0;
cin >> n >> x;
long long a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; i--) {
if ((a[i] * c) >= x)
ans++, c = 1;
else
c++;
}
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;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, 1};
int dy4[] = {1, -1, 1, -1};
int main() {
int t;
cin >> t;
while (t--) {
long long n, x, c = 1, ans = 0;
cin >> n >> x;
long long a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; i--) {
if ((a[i] * c) >= x)
ans++, c = 1;
else
c++;
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long x, unsigned int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int t;
cin >> t;
while (t--) {
long long int n, x, ans = 0;
cin >> n >> x;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int sum = 0;
int i = 0, j = n - 1;
stack<long long int> st;
while (j >= 0) {
st.push(a[j]);
long long int curr = st.top() * st.size();
if (curr >= x) {
ans++;
while (!st.empty()) {
st.pop();
}
}
j--;
}
cout << ans << '\n';
}
}
| ### 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;
long long int power(long long x, unsigned int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int t;
cin >> t;
while (t--) {
long long int n, x, ans = 0;
cin >> n >> x;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int sum = 0;
int i = 0, j = n - 1;
stack<long long int> st;
while (j >= 0) {
st.push(a[j]);
long long int curr = st.top() * st.size();
if (curr >= x) {
ans++;
while (!st.empty()) {
st.pop();
}
}
j--;
}
cout << ans << '\n';
}
}
``` |
#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;
multiset<long long> nums;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
nums.insert(a);
}
long long ans = 0;
long long currNum = 0;
auto it = nums.end();
for (long long i = n - 1; i >= 0; i--) {
currNum++;
it--;
if (*(it)*currNum >= x) {
ans++;
currNum = 0;
}
}
cout << ans << "\n";
}
}
| ### 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 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;
multiset<long long> nums;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
nums.insert(a);
}
long long ans = 0;
long long currNum = 0;
auto it = nums.end();
for (long long i = n - 1; i >= 0; i--) {
currNum++;
it--;
if (*(it)*currNum >= x) {
ans++;
currNum = 0;
}
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long n) {
if (n <= 1) return false;
long long g = sqrt(n);
for (long long i = 2; i <= g; i++)
if (n % i == 0) return false;
return true;
}
long long power(long long base, long long exp) {
long long MOD = LLONG_MAX;
if (exp == 1)
return base;
else {
if (exp % 2 == 0) {
long long base1 = (pow(power(base, exp / 2), 2));
return base1 % MOD;
} else {
long long ans = (base * pow(power(base, (exp - 1) / 2), 2));
return ans % MOD;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long temp, temp1, temp2;
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 i, j;
i = j = n - 1;
long long res = 0;
while (i >= 0) {
if (a[i] * (j - i + 1) >= x) {
j = i - 1;
res++;
}
i--;
}
cout << res << 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;
bool isprime(long long n) {
if (n <= 1) return false;
long long g = sqrt(n);
for (long long i = 2; i <= g; i++)
if (n % i == 0) return false;
return true;
}
long long power(long long base, long long exp) {
long long MOD = LLONG_MAX;
if (exp == 1)
return base;
else {
if (exp % 2 == 0) {
long long base1 = (pow(power(base, exp / 2), 2));
return base1 % MOD;
} else {
long long ans = (base * pow(power(base, (exp - 1) / 2), 2));
return ans % MOD;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long temp, temp1, temp2;
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 i, j;
i = j = n - 1;
long long res = 0;
while (i >= 0) {
if (a[i] * (j - i + 1) >= x) {
j = i - 1;
res++;
}
i--;
}
cout << res << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const int dy[8] = {1, -1, 0, 0, 1, -1, -1, 1};
const char dch[4] = {'R', 'L', 'D', 'U'};
const double PI = 3.141592653589793;
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, k;
long long isi[100005];
long long memo[100005];
long long ceil(long long a, long long b) { return (a - 1) / b + 1; }
int main() {
fasterios();
int testCases;
cin >> testCases;
int tc = 0;
while (++tc <= testCases) {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> isi[i];
sort(isi + 1, isi + 1 + n);
memo[n + 1] = 0;
long long ans = 0;
for (int i = n; i >= 1; i--) {
long long cur = ceil(k, isi[i]);
memo[i] = 0;
if (i + cur - 1 > n) continue;
memo[i] = 1 + memo[i + cur];
ans = max(ans, memo[i]);
}
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 double EPS = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const int dy[8] = {1, -1, 0, 0, 1, -1, -1, 1};
const char dch[4] = {'R', 'L', 'D', 'U'};
const double PI = 3.141592653589793;
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, k;
long long isi[100005];
long long memo[100005];
long long ceil(long long a, long long b) { return (a - 1) / b + 1; }
int main() {
fasterios();
int testCases;
cin >> testCases;
int tc = 0;
while (++tc <= testCases) {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> isi[i];
sort(isi + 1, isi + 1 + n);
memo[n + 1] = 0;
long long ans = 0;
for (int i = n; i >= 1; i--) {
long long cur = ceil(k, isi[i]);
memo[i] = 0;
if (i + cur - 1 > n) continue;
memo[i] = 1 + memo[i + cur];
ans = max(ans, memo[i]);
}
cout << ans << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
const int MOD = 1000000007;
int no_of_bits(long long n) {
int count = 0;
while (n > 0) {
n = n >> 1;
count++;
}
return count;
}
long long gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void printFrequency(vector<int> v) {
unordered_map<int, int> M;
for (int i = 1; i < (int)v.size(); i++) {
if (M.find(v[i]) == M.end()) {
M.insert(make_pair(v[i], 1));
} else {
M[v[i]]++;
}
}
}
void add_self(int &a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
}
void sub_self(int &a, int b) {
a -= b;
if (a < 0) {
a += MOD;
}
}
int search(vector<int> x, int n, int i) {
int l = 0, h = n - 1, mid;
while (l <= h) {
mid = (l + h) / 2;
if (x[mid] < i) {
l = mid + 1;
} else {
h = mid - 1;
}
}
return l;
}
bool check9(string s) {
for (int i = 0; i < (int)s.size(); i++)
if (s[i] != '9') return 0;
return 1;
}
bool comparator(const pair<long long, int> &a, const pair<long long, int> &b) {
if (a.first > b.first)
return 1;
else if (a.first < b.first)
return 0;
else {
if (a.second < b.second)
return 1;
else
return 0;
}
}
const int INF = -2000;
const long long INF_ = 1e13;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long ans = 0, store = n - 1;
for (int i = n - 1; i >= 0; i--) {
if (v[i] * (store - i + 1) >= x) {
ans++;
store = i - 1;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| ### 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;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
const int MOD = 1000000007;
int no_of_bits(long long n) {
int count = 0;
while (n > 0) {
n = n >> 1;
count++;
}
return count;
}
long long gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void printFrequency(vector<int> v) {
unordered_map<int, int> M;
for (int i = 1; i < (int)v.size(); i++) {
if (M.find(v[i]) == M.end()) {
M.insert(make_pair(v[i], 1));
} else {
M[v[i]]++;
}
}
}
void add_self(int &a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
}
void sub_self(int &a, int b) {
a -= b;
if (a < 0) {
a += MOD;
}
}
int search(vector<int> x, int n, int i) {
int l = 0, h = n - 1, mid;
while (l <= h) {
mid = (l + h) / 2;
if (x[mid] < i) {
l = mid + 1;
} else {
h = mid - 1;
}
}
return l;
}
bool check9(string s) {
for (int i = 0; i < (int)s.size(); i++)
if (s[i] != '9') return 0;
return 1;
}
bool comparator(const pair<long long, int> &a, const pair<long long, int> &b) {
if (a.first > b.first)
return 1;
else if (a.first < b.first)
return 0;
else {
if (a.second < b.second)
return 1;
else
return 0;
}
}
const int INF = -2000;
const long long INF_ = 1e13;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long ans = 0, store = n - 1;
for (int i = n - 1; i >= 0; i--) {
if (v[i] * (store - i + 1) >= x) {
ans++;
store = i - 1;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC option("tune=native")
#pragma GCC target("avx,avx2,fma")
const int mod = 1e9 + 7;
void solve() {
int n = 0;
int x = 0;
cin >> n >> x;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
int ans = 0;
int z = 1;
for (int i = 0; i < n; i++) {
if (arr[i] * z >= x) {
ans++;
z = 1;
} else
z++;
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int t = 0;
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;
#pragma GCC optimize("Ofast")
#pragma GCC option("tune=native")
#pragma GCC target("avx,avx2,fma")
const int mod = 1e9 + 7;
void solve() {
int n = 0;
int x = 0;
cin >> n >> x;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
int ans = 0;
int z = 1;
for (int i = 0; i < n; i++) {
if (arr[i] * z >= x) {
ans++;
z = 1;
} else
z++;
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int t = 0;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n, x;
while (t--) {
cin >> n >> x;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int s = 0, j, shu = 1;
for (j = n; j > 0; j--) {
if (a[j] * shu >= x) {
s++;
shu = 1;
} else
shu++;
}
cout << s << endl;
}
}
| ### 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 t;
cin >> t;
int n, x;
while (t--) {
cin >> n >> x;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int s = 0, j, shu = 1;
for (j = n; j > 0; j--) {
if (a[j] * shu >= x) {
s++;
shu = 1;
} else
shu++;
}
cout << s << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
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());
int prev = n;
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
long long mn = a[i];
long long nm = prev - i;
if (mn * nm >= x) {
ans++;
prev = i;
}
}
cout << ans << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| ### 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;
void solve() {
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());
int prev = n;
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
long long mn = a[i];
long long nm = prev - i;
if (mn * nm >= x) {
ans++;
prev = i;
}
}
cout << ans << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void checkpoint1() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
checkpoint1();
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long ans = 0;
map<long long, long long> v;
for (long long i = 0; i < n; i++) {
long long y;
cin >> y;
if (y >= x)
ans++;
else {
y = ceil((long double)x / y);
v[y]++;
}
}
long long op = 0;
for (auto i : v) {
i.second += op;
ans += (i.second / i.first);
op = (i.second % i.first);
}
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;
void checkpoint1() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
checkpoint1();
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long ans = 0;
map<long long, long long> v;
for (long long i = 0; i < n; i++) {
long long y;
cin >> y;
if (y >= x)
ans++;
else {
y = ceil((long double)x / y);
v[y]++;
}
}
long long op = 0;
for (auto i : v) {
i.second += op;
ans += (i.second / i.first);
op = (i.second % i.first);
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, n, t, x, ans, cnt, a[100002];
cin >> t;
while (t--) {
cin >> n >> x;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
ans = cnt = 0;
for (i = n; i > 0; i--) {
++cnt;
if (a[i] * cnt >= x) ++ans, cnt = 0;
}
cout << ans << '\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;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, n, t, x, ans, cnt, a[100002];
cin >> t;
while (t--) {
cin >> n >> x;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
ans = cnt = 0;
for (i = n; i > 0; i--) {
++cnt;
if (a[i] * cnt >= x) ++ans, cnt = 0;
}
cout << ans << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<int> v1;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
v1.push_back(a);
}
sort(v1.begin(), v1.end());
vector<int> v2;
long long team = 0;
for (long long i = n - 1; i >= 0; i--) {
v2.push_back(v1[i]);
long long y = v2.size();
long long w = v2[y - 1];
if (w * y >= x) {
team++;
v2.clear();
}
}
cout << team << 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;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<int> v1;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
v1.push_back(a);
}
sort(v1.begin(), v1.end());
vector<int> v2;
long long team = 0;
for (long long i = n - 1; i >= 0; i--) {
v2.push_back(v1[i]);
long long y = v2.size();
long long w = v2[y - 1];
if (w * y >= x) {
team++;
v2.clear();
}
}
cout << team << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int good(const string &s, char x) {
if (s.length() == 1) return s[0] != x;
int ans = 0, ans2 = 0;
int n = s.size();
for (int i = 0; i < n / 2; i++) {
if (s[i] != x) ans++;
if (s[i + n / 2] != x) ans2++;
}
ans += good(s.substr(n / 2, n / 2), x + 1);
ans2 += good(s.substr(0, n / 2), x + 1);
return min(ans, ans2);
}
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
long long int x;
cin >> x;
vector<long long int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end(), greater<long long int>());
vector<long long int> b(n);
for (int i = 0; i < n; i++) b[i] = ceil((x * 1.0) / (a[i] * 1.0));
int ans = 0, j = 0, i = 0;
while (i < n) {
if (b[i] <= i - j + 1) {
ans++;
j = i + 1;
i++;
} else
i++;
}
cout << ans << endl;
}
}
| ### 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 good(const string &s, char x) {
if (s.length() == 1) return s[0] != x;
int ans = 0, ans2 = 0;
int n = s.size();
for (int i = 0; i < n / 2; i++) {
if (s[i] != x) ans++;
if (s[i + n / 2] != x) ans2++;
}
ans += good(s.substr(n / 2, n / 2), x + 1);
ans2 += good(s.substr(0, n / 2), x + 1);
return min(ans, ans2);
}
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
long long int x;
cin >> x;
vector<long long int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end(), greater<long long int>());
vector<long long int> b(n);
for (int i = 0; i < n; i++) b[i] = ceil((x * 1.0) / (a[i] * 1.0));
int ans = 0, j = 0, i = 0;
while (i < n) {
if (b[i] <= i - j + 1) {
ans++;
j = i + 1;
i++;
} else
i++;
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, x;
cin >> n >> x;
vector<int> v;
for (int i = 0; i < n; i++) {
int y;
cin >> y;
v.push_back(y);
}
sort(v.rbegin(), v.rend());
int p = 0, s = 0, r = 0;
for (int i = 0; i < n; i++) {
p++;
if (p * v[i] >= x) {
s++;
p = 0;
r = 1;
}
}
if (r == 0) {
cout << 0 << endl;
} else
cout << s << endl;
}
}
| ### 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 T;
cin >> T;
while (T--) {
int n, x;
cin >> n >> x;
vector<int> v;
for (int i = 0; i < n; i++) {
int y;
cin >> y;
v.push_back(y);
}
sort(v.rbegin(), v.rend());
int p = 0, s = 0, r = 0;
for (int i = 0; i < n; i++) {
p++;
if (p * v[i] >= x) {
s++;
p = 0;
r = 1;
}
}
if (r == 0) {
cout << 0 << endl;
} else
cout << s << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int q, n, x, br, p;
vector<int> A;
void Ucitaj() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> p;
A.push_back(p);
}
}
void Resi() {
int tv = 0;
br = 0;
sort(A.begin(), A.end());
for (int i = n - 1; i >= 0; i--) {
tv++;
if (tv * A[i] >= x) {
br++;
tv = 0;
}
}
}
void Ispisi() { cout << br << "\n"; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> q;
while (q--) {
Ucitaj();
Resi();
Ispisi();
A.clear();
}
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 q, n, x, br, p;
vector<int> A;
void Ucitaj() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> p;
A.push_back(p);
}
}
void Resi() {
int tv = 0;
br = 0;
sort(A.begin(), A.end());
for (int i = n - 1; i >= 0; i--) {
tv++;
if (tv * A[i] >= x) {
br++;
tv = 0;
}
}
}
void Ispisi() { cout << br << "\n"; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> q;
while (q--) {
Ucitaj();
Resi();
Ispisi();
A.clear();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
const long double PI = 3.141592653589793238463;
int main() {
long long T;
std::cin >> T;
while (T--) {
long long n, x;
std::cin >> n >> x;
long long a[n];
for (long long i = 0; i < (long long)n; i++) std::cin >> a[i];
sort(a, a + n);
long long tot = 0;
long long c = 0;
for (long long i = n - 1; i >= (long long)0; i--) {
c++;
if (c * a[i] >= x) {
tot++;
c = 0;
}
}
std::cout << tot << std::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;
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
const long double PI = 3.141592653589793238463;
int main() {
long long T;
std::cin >> T;
while (T--) {
long long n, x;
std::cin >> n >> x;
long long a[n];
for (long long i = 0; i < (long long)n; i++) std::cin >> a[i];
sort(a, a + n);
long long tot = 0;
long long c = 0;
for (long long i = n - 1; i >= (long long)0; i--) {
c++;
if (c * a[i] >= x) {
tot++;
c = 0;
}
}
std::cout << tot << std::endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int i, a[n], ans = 0, j = 1;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
if (j * a[i] >= x) {
ans++;
j = 1;
} else
j++;
}
cout << ans << "\n";
}
}
| ### 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(void) {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int i, a[n], ans = 0, j = 1;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
if (j * a[i] >= x) {
ans++;
j = 1;
} else
j++;
}
cout << ans << "\n";
}
}
``` |
#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;
cin >> n >> x;
vector<long int> vec(n);
for (int i = 0; i < n; i++) cin >> vec[i];
sort(vec.begin(), vec.end(), greater<int>());
long long int i = 1, j = 0;
long long int ans = 0;
while (j < n) {
while (j < n and vec[j] * i < x) j++, i++;
if (j < n and vec[j] * i >= x) {
ans++;
i = 1;
j++;
}
}
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;
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;
cin >> n >> x;
vector<long int> vec(n);
for (int i = 0; i < n; i++) cin >> vec[i];
sort(vec.begin(), vec.end(), greater<int>());
long long int i = 1, j = 0;
long long int ans = 0;
while (j < n) {
while (j < n and vec[j] * i < x) j++, i++;
if (j < n and vec[j] * i >= x) {
ans++;
i = 1;
j++;
}
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long pow2(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = ((res % 998244353) * (a % 998244353)) % 998244353;
a = ((a % 998244353) * (a % 998244353));
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
cin >> t;
long long tot = t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (long long i = 0; i < (n); ++i) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<int>());
int j = 0;
long long ans = 0;
for (long long i = 0; i < (n); ++i) {
if (v[i] >= x) {
ans++;
j++;
continue;
}
if ((i - j + 1) * v[i] >= x) {
ans++;
j = i + 1;
continue;
}
}
cout << ans << 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 pow2(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = ((res % 998244353) * (a % 998244353)) % 998244353;
a = ((a % 998244353) * (a % 998244353));
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
cin >> t;
long long tot = t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (long long i = 0; i < (n); ++i) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<int>());
int j = 0;
long long ans = 0;
for (long long i = 0; i < (n); ++i) {
if (v[i] >= x) {
ans++;
j++;
continue;
}
if ((i - j + 1) * v[i] >= x) {
ans++;
j = i + 1;
continue;
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
long long ans = 0, left = 0;
for (long long i = 0; i < n; i++) {
left++;
if (v[i] * left >= x) {
ans++;
left = 0;
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
cin >> TESTS;
while (TESTS--) {
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;
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
long long ans = 0, left = 0;
for (long long i = 0; i < n; i++) {
left++;
if (v[i] * left >= x) {
ans++;
left = 0;
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
cin >> TESTS;
while (TESTS--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
long long index = n;
for (int i = 0; i < n; i++) {
if (a[i] >= k) {
sum += n - i;
index = i;
break;
}
}
long long count = 1;
for (long long i = index - 1; i >= 0; i--) {
if (count * a[i] >= k) {
sum += 1;
count = 1;
} else
count++;
}
cout << sum << endl;
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
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, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
long long index = n;
for (int i = 0; i < n; i++) {
if (a[i] >= k) {
sum += n - i;
index = i;
break;
}
}
long long count = 1;
for (long long i = index - 1; i >= 0; i--) {
if (count * a[i] >= k) {
sum += 1;
count = 1;
} else
count++;
}
cout << sum << endl;
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
ios::sync_with_stdio(0);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
int last = n - 1;
int answer = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] * (last - i + 1) >= x) {
answer++;
last = i - 1;
}
}
cout << answer << 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() {
cin.tie(NULL);
ios::sync_with_stdio(0);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
int last = n - 1;
int answer = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] * (last - i + 1) >= x) {
answer++;
last = i - 1;
}
}
cout << answer << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long longinf = 1LL << 60;
const long long mod = 1e9 + 7;
void solve() {
int n;
long long x;
cin >> n >> x;
priority_queue<long long> q;
for (int i = (int)(0); i < (int)(n); i++) {
long long a;
cin >> a;
q.push(a);
}
int ans = 0;
int m = 0;
while (!q.empty()) {
long long cur = q.top();
q.pop();
m++;
if (cur * m >= x) {
ans++;
m = 0;
}
}
cout << ans << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
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;
const int inf = 1e9 + 7;
const long long longinf = 1LL << 60;
const long long mod = 1e9 + 7;
void solve() {
int n;
long long x;
cin >> n >> x;
priority_queue<long long> q;
for (int i = (int)(0); i < (int)(n); i++) {
long long a;
cin >> a;
q.push(a);
}
int ans = 0;
int m = 0;
while (!q.empty()) {
long long cur = q.top();
q.pop();
m++;
if (cur * m >= x) {
ans++;
m = 0;
}
}
cout << ans << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 9;
const long long inf = 1e18 + 18;
const int max6 = 1e6 + 6;
const int modx = 1e9 + 7;
const int mody = 997;
const int base = 137;
int n, first;
int a[max6];
long long f[max6], dd[max6];
int up(int a, int b) {
int res = a / b;
res += b * res < a;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
cin >> n >> first;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) f[i] = dd[i] = 0;
long long gmax = 0;
for (int i = 1; i <= n; ++i) {
int id = min(up(first, a[i]) + i - 1, n + 1);
dd[id] = max(dd[id], f[i - 1] + 1);
gmax = max(gmax, dd[i]);
f[i] = gmax;
}
cout << f[n] << "\n";
}
}
| ### 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 oo = 1e9 + 9;
const long long inf = 1e18 + 18;
const int max6 = 1e6 + 6;
const int modx = 1e9 + 7;
const int mody = 997;
const int base = 137;
int n, first;
int a[max6];
long long f[max6], dd[max6];
int up(int a, int b) {
int res = a / b;
res += b * res < a;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
cin >> n >> first;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) f[i] = dd[i] = 0;
long long gmax = 0;
for (int i = 1; i <= n; ++i) {
int id = min(up(first, a[i]) + i - 1, n + 1);
dd[id] = max(dd[id], f[i - 1] + 1);
gmax = max(gmax, dd[i]);
f[i] = gmax;
}
cout << f[n] << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
pair<long long, long long> p;
map<long long, long long> mp;
set<long long> st;
deque<long long> dq;
priority_queue<long long> pq;
long long mn = INT_MAX, mx = INT_MIN;
long long n, m, tc, i, j, tmp, sum, cn, ans, res, pos, flag, l, x;
string s;
long long a[200007], b[200007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> tc;
while (tc--) {
cn = 0;
res = 0;
cin >> n >> x;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
res++;
if (res * a[i] >= x) {
res = 0;
cn++;
}
}
cout << cn << 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;
vector<long long> v;
pair<long long, long long> p;
map<long long, long long> mp;
set<long long> st;
deque<long long> dq;
priority_queue<long long> pq;
long long mn = INT_MAX, mx = INT_MIN;
long long n, m, tc, i, j, tmp, sum, cn, ans, res, pos, flag, l, x;
string s;
long long a[200007], b[200007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> tc;
while (tc--) {
cn = 0;
res = 0;
cin >> n >> x;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
res++;
if (res * a[i] >= x) {
res = 0;
cn++;
}
}
cout << cn << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void solve() {
long long n;
cin >> n;
;
long long x;
cin >> x;
;
vector<long long> arr(n);
for (long long i = 0; i < (long long)n; i++) {
cin >> arr[i];
};
sort(arr.begin(), arr.end());
long long i = n - 1, count = 0;
while (i >= 0) {
long long j = i;
while (arr[j] * (i - j + 1) < x and j >= 0) j--;
if (j >= 0) count++;
i = j - 1;
}
cout << count;
cout << '\n';
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long 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;
const int mod = 1e9 + 7;
void solve() {
long long n;
cin >> n;
;
long long x;
cin >> x;
;
vector<long long> arr(n);
for (long long i = 0; i < (long long)n; i++) {
cin >> arr[i];
};
sort(arr.begin(), arr.end());
long long i = n - 1, count = 0;
while (i >= 0) {
long long j = i;
while (arr[j] * (i - j + 1) < x and j >= 0) j--;
if (j >= 0) count++;
i = j - 1;
}
cout << count;
cout << '\n';
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
;
while (t--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
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());
vector<int> suf_max(n + 1, 0), dp(n + 1, 0);
for (int i = n - 1; i >= 0; --i) {
int k = (x / a[i]) + ((x % a[i]) != 0);
suf_max[i] = suf_max[i + 1];
if (i + k > n) continue;
dp[i] = suf_max[i + k] + 1;
suf_max[i] = max(suf_max[i + 1], dp[i]);
}
cout << suf_max[0] << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
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() {
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());
vector<int> suf_max(n + 1, 0), dp(n + 1, 0);
for (int i = n - 1; i >= 0; --i) {
int k = (x / a[i]) + ((x % a[i]) != 0);
suf_max[i] = suf_max[i + 1];
if (i + k > n) continue;
dp[i] = suf_max[i + k] + 1;
suf_max[i] = max(suf_max[i + 1], dp[i]);
}
cout << suf_max[0] << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int arr[100007];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int _t = 0; _t < t; ++_t) {
int n, x;
cin >> n >> x;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr, arr + n);
int teams = 0;
int count = 0;
for (int i = n - 1; i >= 0; --i) {
++count;
if (count * arr[i] >= x) {
++teams;
count = 0;
}
}
cout << teams << "\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 arr[100007];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int _t = 0; _t < t; ++_t) {
int n, x;
cin >> n >> x;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr, arr + n);
int teams = 0;
int count = 0;
for (int i = n - 1; i >= 0; --i) {
++count;
if (count * arr[i] >= x) {
++teams;
count = 0;
}
}
cout << teams << "\n";
}
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, ans = 0;
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];
ans = max(ans, dp[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(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
long long n, x, ans = 0;
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];
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void inout() {}
int main() {
fast();
inout();
int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long int np = 1;
long long int teams = 0;
for (long long int j = n - 1; j >= 0; j--) {
if (v[j] >= x)
teams++;
else {
np++;
j--;
while (v[j] * np < x && j >= 0) {
np++;
j--;
}
if (v[j] * np >= x && j >= 0) teams++;
np = 1;
}
}
cout << teams << "\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;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void inout() {}
int main() {
fast();
inout();
int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long int np = 1;
long long int teams = 0;
for (long long int j = n - 1; j >= 0; j--) {
if (v[j] >= x)
teams++;
else {
np++;
j--;
while (v[j] * np < x && j >= 0) {
np++;
j--;
}
if (v[j] * np >= x && j >= 0) teams++;
np = 1;
}
}
cout << teams << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 100000 + 10;
int n, m, ans;
int a[maxn];
void print(int a[], int n, int st = 0) {
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", a[i + st]);
}
printf("\n");
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
}
void doit() {
sort(a, a + n);
ans = 0;
int cnt = 0;
for (int i = n - 1; i >= 0; i--) {
cnt++;
if ((long long)a[i] * cnt >= m) {
ans++;
cnt = 0;
}
}
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
init();
doit();
}
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;
const int inf = 0x3f3f3f3f;
const int maxn = 100000 + 10;
int n, m, ans;
int a[maxn];
void print(int a[], int n, int st = 0) {
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", a[i + st]);
}
printf("\n");
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
}
void doit() {
sort(a, a + n);
ans = 0;
int cnt = 0;
for (int i = n - 1; i >= 0; i--) {
cnt++;
if ((long long)a[i] * cnt >= m) {
ans++;
cnt = 0;
}
}
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
init();
doit();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
long long x;
cin >> n >> x;
long long input[n];
for (int i = 0; i < n; i++) {
cin >> input[i];
}
sort(input, input + n, greater<long long>());
int i = 0, j = 0;
int ans = 0;
long long minima = INT_MAX;
while (j < n) {
minima = input[j];
long long size = j - i + 1;
if (minima * size >= x) {
ans++;
i = j + 1;
}
j++;
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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;
void solve() {
int n;
long long x;
cin >> n >> x;
long long input[n];
for (int i = 0; i < n; i++) {
cin >> input[i];
}
sort(input, input + n, greater<long long>());
int i = 0, j = 0;
int ans = 0;
long long minima = INT_MAX;
while (j < n) {
minima = input[j];
long long size = j - i + 1;
if (minima * size >= x) {
ans++;
i = j + 1;
}
j++;
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x, i, a = 0, s = 0;
cin >> n >> x;
long long A[n];
for (i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
for (i = n - 1; i > -1; i--) {
a++;
if ((A[i] * a) >= x) {
s++;
a = 0;
}
}
cout << s << "\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 main() {
long long t;
cin >> t;
while (t--) {
long long n, x, i, a = 0, s = 0;
cin >> n >> x;
long long A[n];
for (i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
for (i = n - 1; i > -1; i--) {
a++;
if ((A[i] * a) >= x) {
s++;
a = 0;
}
}
cout << s << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int j = 1, teams = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] * j >= x) {
teams++;
j = 0;
}
j++;
}
cout << teams << 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() {
int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int j = 1, teams = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] * j >= x) {
teams++;
j = 0;
}
j++;
}
cout << teams << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x, cnt = 0;
cin >> n >> x;
vector<int> v(n);
vector<int> small;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] >= x)
cnt++;
else
small.push_back(v[i]);
}
sort(small.begin(), small.end());
long long mi = INT_MAX;
int c = 0;
for (int i = small.size() - 1; i >= 0; i--) {
c++;
mi = min(mi, 1LL * small[i]);
if ((mi * c) >= x) {
c = 0;
cnt++;
mi = INT_MAX;
}
}
cout << cnt << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
cin >> T;
while (T--) {
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;
void solve() {
long long n, x, cnt = 0;
cin >> n >> x;
vector<int> v(n);
vector<int> small;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] >= x)
cnt++;
else
small.push_back(v[i]);
}
sort(small.begin(), small.end());
long long mi = INT_MAX;
int c = 0;
for (int i = small.size() - 1; i >= 0; i--) {
c++;
mi = min(mi, 1LL * small[i]);
if ((mi * c) >= x) {
c = 0;
cnt++;
mi = INT_MAX;
}
}
cout << cnt << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
cin >> T;
while (T--) {
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int x[100001];
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x, x + n, greater<int>());
int num = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
if (x[i] * num >= m) {
ans++;
num = 1;
} else {
num++;
}
}
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;
int x[100001];
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x, x + n, greater<int>());
int num = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
if (x[i] * num >= m) {
ans++;
num = 1;
} else {
num++;
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int t, n, x, a[100001], nre, nrc;
int main() {
cin >> t;
for (int tt = 1; tt <= t; tt++) {
cin >> n >> x;
nre = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; i--) {
nrc = 1;
while (a[i] < x / nrc + x % nrc and i >= 1) {
nrc++;
i--;
}
if (a[i] >= x / nrc) nre++;
}
cout << nre << endl;
}
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, a[100001], nre, nrc;
int main() {
cin >> t;
for (int tt = 1; tt <= t; tt++) {
cin >> n >> x;
nre = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; i--) {
nrc = 1;
while (a[i] < x / nrc + x % nrc and i >= 1) {
nrc++;
i--;
}
if (a[i] >= x / nrc) nre++;
}
cout << nre << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int cmp(int a, int b) { return a > b; }
int main() {
int t, n, x, i, tot, cnt;
scanf("%d", &t);
while (t--) {
tot = 0, cnt = 0;
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
cnt++;
if (a[i] * cnt >= x) tot++, cnt = 0;
}
printf("%d\n", tot);
}
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 a[100001];
int cmp(int a, int b) { return a > b; }
int main() {
int t, n, x, i, tot, cnt;
scanf("%d", &t);
while (t--) {
tot = 0, cnt = 0;
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
cnt++;
if (a[i] * cnt >= x) tot++, cnt = 0;
}
printf("%d\n", tot);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long cnt = 1, i = n - 1, team = 0;
while (i >= 0 && v[i] > x) {
++team;
--i;
}
for (; i >= 0; --i) {
if (cnt * v[i] >= x) {
cnt = 0;
++team;
}
++cnt;
}
cout << team << "\n";
}
}
| ### 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() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long cnt = 1, i = n - 1, team = 0;
while (i >= 0 && v[i] > x) {
++team;
--i;
}
for (; i >= 0; --i) {
if (cnt * v[i] >= x) {
cnt = 0;
++team;
}
++cnt;
}
cout << team << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve(long long int arr[], long long int n, long long int x) {
reverse(arr, arr + n);
long long int ans = 0, idx = 0, flag = 0;
for (long long int i = 0; i < n; i++) {
if (arr[i] >= x) {
ans++;
} else {
flag = 1;
idx = i;
break;
}
}
if (flag == 1) {
long long int cnt = 2;
for (long long int i = idx + 1; i < n; i++) {
if (arr[i] * cnt >= x) {
ans++;
cnt = 1;
} else {
cnt++;
}
}
}
cout << ans << "\n";
}
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
solve(arr, n, x);
}
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;
void solve(long long int arr[], long long int n, long long int x) {
reverse(arr, arr + n);
long long int ans = 0, idx = 0, flag = 0;
for (long long int i = 0; i < n; i++) {
if (arr[i] >= x) {
ans++;
} else {
flag = 1;
idx = i;
break;
}
}
if (flag == 1) {
long long int cnt = 2;
for (long long int i = idx + 1; i < n; i++) {
if (arr[i] * cnt >= x) {
ans++;
cnt = 1;
} else {
cnt++;
}
}
}
cout << ans << "\n";
}
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
solve(arr, n, x);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x, i, j, k, c = 0;
cin >> n >> x;
long long ar[n];
for (i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
k = n;
for (i = 0; i < n; i++) {
if (ar[i] >= x) {
if (c == 0) k = i;
c++;
}
}
long long l = 1, p = ar[k - 1];
for (i = k - 1; i >= 0; i--) {
p = ar[i];
if (p * l >= x) {
c++;
l = 1;
} else {
l++;
}
}
cout << c << 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() {
long long t;
cin >> t;
while (t--) {
long long n, x, i, j, k, c = 0;
cin >> n >> x;
long long ar[n];
for (i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
k = n;
for (i = 0; i < n; i++) {
if (ar[i] >= x) {
if (c == 0) k = i;
c++;
}
}
long long l = 1, p = ar[k - 1];
for (i = k - 1; i >= 0; i--) {
p = ar[i];
if (p * l >= x) {
c++;
l = 1;
} else {
l++;
}
}
cout << c << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int t, n, x, i, s, k, a[maxn];
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int main() {
t = read();
while (t > 0) {
--t;
n = read();
x = read();
for (i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
s = k = 0;
while (n > 0) {
++k;
if (a[n] * k >= x) {
k = 0;
++s;
}
--n;
}
printf("%d\n", s);
}
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 maxn = 100005;
int t, n, x, i, s, k, a[maxn];
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int main() {
t = read();
while (t > 0) {
--t;
n = read();
x = read();
for (i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
s = k = 0;
while (n > 0) {
++k;
if (a[n] * k >= x) {
k = 0;
++s;
}
--n;
}
printf("%d\n", s);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long t9p7 = 1000000007;
void soln(long long t) {
long long m, n, k, a, b, c, cnt = 0, ans = 0, mn = LONG_LONG_MAX,
mx = LONG_LONG_MIN;
string str;
cin >> n >> k;
vector<long long> arr(n + 1, 0), dp(n + 1, 0);
for (long long(i) = (0); (i) < (n); (i)++) {
cin >> arr[i];
}
sort((arr).begin(), (arr).end());
mx = 0;
for (long long(i) = (1); (i) < (n + 1); (i)++) {
a = ceil((long double)k / (long double)arr[i]);
a = i + a - 1;
if (dp[i] < dp[i - 1]) dp[i] = dp[i - 1];
if (a <= n) {
dp[a] = max(dp[a], dp[i - 1] + 1);
mx = max(mx, dp[a]);
}
}
cout << mx << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long t = 1;
cin >> t;
while ((t)--) soln(t);
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 long long t9p7 = 1000000007;
void soln(long long t) {
long long m, n, k, a, b, c, cnt = 0, ans = 0, mn = LONG_LONG_MAX,
mx = LONG_LONG_MIN;
string str;
cin >> n >> k;
vector<long long> arr(n + 1, 0), dp(n + 1, 0);
for (long long(i) = (0); (i) < (n); (i)++) {
cin >> arr[i];
}
sort((arr).begin(), (arr).end());
mx = 0;
for (long long(i) = (1); (i) < (n + 1); (i)++) {
a = ceil((long double)k / (long double)arr[i]);
a = i + a - 1;
if (dp[i] < dp[i - 1]) dp[i] = dp[i - 1];
if (a <= n) {
dp[a] = max(dp[a], dp[i - 1] + 1);
mx = max(mx, dp[a]);
}
}
cout << mx << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long t = 1;
cin >> t;
while ((t)--) soln(t);
return 0;
}
``` |
#include <bits/stdc++.h>
const int MAX = 1e6;
using namespace std;
const int alpha = 26;
void solve() {
int n, m;
cin >> n >> m;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.rbegin(), arr.rend());
int size = 0;
int ans = 0;
for (auto &it : arr) {
size++;
if (size * it >= m) {
ans++;
size = 0;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
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>
const int MAX = 1e6;
using namespace std;
const int alpha = 26;
void solve() {
int n, m;
cin >> n >> m;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.rbegin(), arr.rend());
int size = 0;
int ans = 0;
for (auto &it : arr) {
size++;
if (size * it >= m) {
ans++;
size = 0;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, x, temp;
cin >> t;
while (t--) {
cin >> n;
cin >> x;
vector<long long int> vect;
for (long long int i = 0; i < n; i++) {
cin >> temp;
vect.push_back(temp);
}
sort(vect.begin(), vect.end());
long long int counter = 0;
long long int ans = 0;
for (long long int i = n - 1; i >= 0; i--) {
if (vect[i] >= x) {
ans++;
counter = 0;
} else if ((counter + 1) * vect[i] >= x) {
counter = 0;
ans++;
} else {
counter++;
}
}
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() {
long long int t, n, x, temp;
cin >> t;
while (t--) {
cin >> n;
cin >> x;
vector<long long int> vect;
for (long long int i = 0; i < n; i++) {
cin >> temp;
vect.push_back(temp);
}
sort(vect.begin(), vect.end());
long long int counter = 0;
long long int ans = 0;
for (long long int i = n - 1; i >= 0; i--) {
if (vect[i] >= x) {
ans++;
counter = 0;
} else if ((counter + 1) * vect[i] >= x) {
counter = 0;
ans++;
} else {
counter++;
}
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t1;
cin >> t1;
while (t1--) {
long long int n, k, i, t = 0, a, j = 1;
cin >> n >> k;
vector<int> v;
for (i = 0; i < n; i++) {
cin >> a;
if (a >= k)
t++;
else
v.push_back(a);
}
sort(v.rbegin(), v.rend());
for (auto x : v) {
if (x * j >= k) {
t++;
j = 1;
} else {
j++;
}
}
cout << t << 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() {
long long int t1;
cin >> t1;
while (t1--) {
long long int n, k, i, t = 0, a, j = 1;
cin >> n >> k;
vector<int> v;
for (i = 0; i < n; i++) {
cin >> a;
if (a >= k)
t++;
else
v.push_back(a);
}
sort(v.rbegin(), v.rend());
for (auto x : v) {
if (x * j >= k) {
t++;
j = 1;
} else {
j++;
}
}
cout << t << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
template <class S, class T>
istream &operator>>(istream &is, pair<S, T> &p) {
return is >> p.first >> p.second;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << '{' << p.first << "," << p.second << '}';
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) {
is >> t;
}
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '[';
for (int i = 0; i < int(v.size()); ++i)
os << v[i] << (i == int(v.size() - 1) ? ']' : ',');
return os;
}
void Yes(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YES(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T>
bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int inf = 1001001001;
const ll linf = 1001001001001001001;
void solve() {
int n, x;
cin >> n >> x;
vector<int> a(n);
cin >> a;
sort(a.rbegin(), a.rend());
int ans = 0, cnt = 0;
for (int i : a) {
cnt++;
if ((ll)i * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
for (int i = 0; i < int(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;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
template <class S, class T>
istream &operator>>(istream &is, pair<S, T> &p) {
return is >> p.first >> p.second;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << '{' << p.first << "," << p.second << '}';
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) {
is >> t;
}
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '[';
for (int i = 0; i < int(v.size()); ++i)
os << v[i] << (i == int(v.size() - 1) ? ']' : ',');
return os;
}
void Yes(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YES(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T>
bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int inf = 1001001001;
const ll linf = 1001001001001001001;
void solve() {
int n, x;
cin >> n >> x;
vector<int> a(n);
cin >> a;
sort(a.rbegin(), a.rend());
int ans = 0, cnt = 0;
for (int i : a) {
cnt++;
if ((ll)i * cnt >= x) {
ans++;
cnt = 0;
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
for (int i = 0; i < int(t); ++i) solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
long long t;
scanf("%lld", &t);
while (t--) {
long long n, k;
scanf("%lld", &n);
scanf("%lld", &k);
long long a[n];
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
sort(a, a + n);
long long dp[n];
memset(dp, 0, sizeof(dp));
dp[n - 1] = a[n - 1] >= k;
for (long long i = n - 2; i >= 0; i--) {
long long ans = 0;
if (a[i] >= k)
ans = n - i;
else {
long long d = ceil(k * 1.0 / a[i]);
if (i + d - 1 < n) {
ans = 1;
if (i + d < n) ans += dp[i + d];
}
}
dp[i] = max(dp[i + 1], ans);
}
printf("%lld\n", dp[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;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
long long t;
scanf("%lld", &t);
while (t--) {
long long n, k;
scanf("%lld", &n);
scanf("%lld", &k);
long long a[n];
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
sort(a, a + n);
long long dp[n];
memset(dp, 0, sizeof(dp));
dp[n - 1] = a[n - 1] >= k;
for (long long i = n - 2; i >= 0; i--) {
long long ans = 0;
if (a[i] >= k)
ans = n - i;
else {
long long d = ceil(k * 1.0 / a[i]);
if (i + d - 1 < n) {
ans = 1;
if (i + d < n) ans += dp[i + d];
}
}
dp[i] = max(dp[i + 1], ans);
}
printf("%lld\n", dp[0]);
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
long long int n;
long long int x;
cin >> n >> x;
vector<long long int> arr(n, 0);
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
long long int counta = 0;
for (long long int i = n - 1; i >= 0; i--) {
long long int k = 1;
long long int mini = arr[i];
while ((mini * k) < x) {
k++;
i--;
if (i == -1) break;
mini = arr[i];
}
if (i != -1) counta++;
}
cout << counta << "\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;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
long long int n;
long long int x;
cin >> n >> x;
vector<long long int> arr(n, 0);
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
long long int counta = 0;
for (long long int i = n - 1; i >= 0; i--) {
long long int k = 1;
long long int mini = arr[i];
while ((mini * k) < x) {
k++;
i--;
if (i == -1) break;
mini = arr[i];
}
if (i != -1) counta++;
}
cout << counta << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
vector<A> sub(vector<A> v, int from = 0, int to = -1) {
if (to == -1) to = (int)v.size();
return vector<A>(v.begin() + from, v.begin() + to);
}
template <typename A>
string to_string(vector<A> v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int a[100005];
void solve() {
int n, x, ans = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
int i = 0;
for (; i < n; i++) {
if (a[i] >= x)
ans++;
else
break;
}
for (int cnt = 0; i < n; i++) {
cnt++;
if (cnt * a[i] >= x) {
ans++;
cnt = 0;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
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;
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
vector<A> sub(vector<A> v, int from = 0, int to = -1) {
if (to == -1) to = (int)v.size();
return vector<A>(v.begin() + from, v.begin() + to);
}
template <typename A>
string to_string(vector<A> v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int a[100005];
void solve() {
int n, x, ans = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
int i = 0;
for (; i < n; i++) {
if (a[i] >= x)
ans++;
else
break;
}
for (int cnt = 0; i < n; i++) {
cnt++;
if (cnt * a[i] >= x) {
ans++;
cnt = 0;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long int n, x, l = 0, i = 0;
cin >> n >> x;
long int a[n], j = n - 1;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
while (1) {
int sum = 1;
for (j; j >= 0; j--) {
if ((sum * a[j]) >= x) {
l++;
j--;
break;
}
sum++;
}
if (j < 0) break;
}
cout << l << 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 int n, x, l = 0, i = 0;
cin >> n >> x;
long int a[n], j = n - 1;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
while (1) {
int sum = 1;
for (j; j >= 0; j--) {
if ((sum * a[j]) >= x) {
l++;
j--;
break;
}
sum++;
}
if (j < 0) break;
}
cout << l << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, i, j, k, x, p, cnt = 0, fl = 0;
cin >> n >> x;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
cnt++;
if (a[i] * cnt >= x) {
fl++;
cnt = 0;
}
}
cout << fl << 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;
int main() {
int t;
cin >> t;
while (t--) {
int n, i, j, k, x, p, cnt = 0, fl = 0;
cin >> n >> x;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
cnt++;
if (a[i] * cnt >= x) {
fl++;
cnt = 0;
}
}
cout << fl << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> teams(n);
for (auto& i : teams) cin >> i;
sort(teams.begin(), teams.end());
long long ans = 0;
long long now = 0;
for (long long i = n - 1; i >= 0; i--) {
now++;
if (now * teams[i] < x) {
continue;
}
ans++;
now = 0;
}
cout << ans << "\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;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
vector<long long> teams(n);
for (auto& i : teams) cin >> i;
sort(teams.begin(), teams.end());
long long ans = 0;
long long now = 0;
for (long long i = n - 1; i >= 0; i--) {
now++;
if (now * teams[i] < x) {
continue;
}
ans++;
now = 0;
}
cout << ans << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i1 = 0; i1 < t; i1++) {
int n, x;
cin >> n >> x;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n, greater<int>());
int cur = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
if ((arr[i] * cur) >= x) {
ans++;
cur = 0;
}
cur++;
}
cout << ans << endl;
}
}
| ### 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 main() {
int t;
cin >> t;
for (int i1 = 0; i1 < t; i1++) {
int n, x;
cin >> n >> x;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n, greater<int>());
int cur = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
if ((arr[i] * cur) >= x) {
ans++;
cur = 0;
}
cur++;
}
cout << ans << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long n, x, t, a[100001];
int main() {
cin >> t;
while (t--) {
int ans = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long num = 1;
for (int i = n; i > 0; i--) {
if (a[i] * num >= x) {
ans++;
num = 0;
}
num++;
}
cout << ans << "\n";
}
}
| ### 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;
long long n, x, t, a[100001];
int main() {
cin >> t;
while (t--) {
int ans = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long num = 1;
for (int i = n; i > 0; i--) {
if (a[i] * num >= x) {
ans++;
num = 0;
}
num++;
}
cout << ans << "\n";
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)15e6 + 1100;
const int nnn = 664579 + 500;
const int inf = numeric_limits<int>::max() - 1;
const long long INF = 1e18;
long long dx[] = {0, 1, 0, -1};
long long dy[] = {1, 0, -1, 0};
long long dxx[] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dyy[] = {1, 0, -1, 0, 1, -1, 1, -1};
void solve() {
long long n, x;
cin >> n >> x;
long long a[n + 5];
for (int i = 1; i <= (n); i++) cin >> a[i];
long long ans = 0;
long long l = 1, r = n;
bool ok = 0;
long long num = 0;
sort(a + 1, a + n + 1);
while (r >= 1) {
num++;
if (num * a[r] >= x) ans++, num = 0;
r--;
}
cout << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
cin >> T;
long long CT = 0;
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 namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)15e6 + 1100;
const int nnn = 664579 + 500;
const int inf = numeric_limits<int>::max() - 1;
const long long INF = 1e18;
long long dx[] = {0, 1, 0, -1};
long long dy[] = {1, 0, -1, 0};
long long dxx[] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dyy[] = {1, 0, -1, 0, 1, -1, 1, -1};
void solve() {
long long n, x;
cin >> n >> x;
long long a[n + 5];
for (int i = 1; i <= (n); i++) cin >> a[i];
long long ans = 0;
long long l = 1, r = n;
bool ok = 0;
long long num = 0;
sort(a + 1, a + n + 1);
while (r >= 1) {
num++;
if (num * a[r] >= x) ans++, num = 0;
r--;
}
cout << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
cin >> T;
long long CT = 0;
while (T--) {
solve();
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
signed main(void) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int64_t t;
cin >> t;
while (t--) {
int64_t n;
cin >> n;
int64_t x;
cin >> x;
vector<int64_t> v(n);
for (int64_t i = 0; i < n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<int64_t>());
int64_t counter{};
--n;
for (int64_t i = 0; i <= n;) {
int64_t min_skill = v[i];
int64_t company = 0;
while (i <= n && min_skill * company < x) {
min_skill = min(min_skill, v[i]);
++company;
++i;
}
if (company * min_skill < x) {
break;
} else {
counter++;
}
}
cout << counter << '\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;
using namespace std::chrono;
signed main(void) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int64_t t;
cin >> t;
while (t--) {
int64_t n;
cin >> n;
int64_t x;
cin >> x;
vector<int64_t> v(n);
for (int64_t i = 0; i < n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end(), greater<int64_t>());
int64_t counter{};
--n;
for (int64_t i = 0; i <= n;) {
int64_t min_skill = v[i];
int64_t company = 0;
while (i <= n && min_skill * company < x) {
min_skill = min(min_skill, v[i]);
++company;
++i;
}
if (company * min_skill < x) {
break;
} else {
counter++;
}
}
cout << counter << '\n';
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int A[200005];
int main() {
int T;
cin >> T;
for (int k = 0; k < T; k++) {
int N, x;
cin >> N >> x;
for (int i = 0; i < N; i++) cin >> A[i];
sort(A, A + N);
for (int i = 0; i < N / 2; i++) swap(A[i], A[N - i - 1]);
int cnt = 1, sum = A[0], last = 0;
A[N] = -1;
for (int i = 1; i <= N; i++) {
if (sum * (i - last) >= x) {
cnt++;
last = i;
}
sum = A[i];
}
if (sum * (N - last) < x) cnt--;
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 A[200005];
int main() {
int T;
cin >> T;
for (int k = 0; k < T; k++) {
int N, x;
cin >> N >> x;
for (int i = 0; i < N; i++) cin >> A[i];
sort(A, A + N);
for (int i = 0; i < N / 2; i++) swap(A[i], A[N - i - 1]);
int cnt = 1, sum = A[0], last = 0;
A[N] = -1;
for (int i = 1; i <= N; i++) {
if (sum * (i - last) >= x) {
cnt++;
last = i;
}
sum = A[i];
}
if (sum * (N - last) < x) cnt--;
cout << cnt << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end(), greater<long long>());
long long ans = 0, count = 0;
for (long long i = 0; i < n; i++) {
if (v[i] >= k)
ans++;
else {
count++;
if (count * v[i] >= k) ans++, count = 0;
}
}
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;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end(), greater<long long>());
long long ans = 0, count = 0;
for (long long i = 0; i < n; i++) {
if (v[i] >= k)
ans++;
else {
count++;
if (count * v[i] >= k) ans++, count = 0;
}
}
cout << ans << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
int team = 0;
int start = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= x) {
team++;
start = i + 1;
} else {
if (a[i] * (i - start + 1) >= x) {
team++;
start = i + 1;
}
}
}
cout << team << "\n";
}
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 main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
int team = 0;
int start = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= x) {
team++;
start = i + 1;
} else {
if (a[i] * (i - start + 1) >= x) {
team++;
start = i + 1;
}
}
}
cout << team << "\n";
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 50;
int n, first, a[N];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &first);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + 1 + n, greater<int>());
int now = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
++now;
if ((long long)now * a[i] >= first) ++ans, now = 0;
}
printf("%d\n", ans);
}
}
| ### 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 int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 50;
int n, first, a[N];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &first);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + 1 + n, greater<int>());
int now = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
++now;
if ((long long)now * a[i] >= first) ++ans, now = 0;
}
printf("%d\n", ans);
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
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, num = 0;
for (int i = n - 1; i >= 0; i--) {
num++;
if (a[i] * num >= x) {
c++;
num = 0;
}
}
cout << c << "\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 main() {
int t;
cin >> t;
while (t--) {
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, num = 0;
for (int i = n - 1; i >= 0; i--) {
num++;
if (a[i] * num >= x) {
c++;
num = 0;
}
}
cout << c << "\n";
}
return 0;
}
``` |
Subsets and Splits