problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p03208 | #include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define P pair<int, int>
#define mod 1000000007
#define S second
#define F first
#define int long long
using namespace std;
int x[100000];
signed main() {
int a, b, ans = INT_MAX;
cin >> a >> b;
f(i, a) { cin >> x[i]; }
sort(x, x + a);
for... | #include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define P pair<int, int>
#define mod 1000000007
#define S second
#define F first
#define int long long
using namespace std;
int x[100000];
signed main() {
int a, b, ans = INT_MAX;
cin >> a >> b;
f(i, a) { cin >> x[i]; }
sort(x, x + a);
for... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,713 | 1,001,714 | u259210975 | cpp |
p03208 | #include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define P pair<int, int>
#define mod 1000000007
#define S second
#define F first
#define int long long
using namespace std;
int x[100000];
signed main() {
int a, b, ans = INT_MAX;
cin >> a >> b;
f(i, a) { cin >> x[i]; }
sort(x, x + a);
for... | #include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define P pair<int, int>
#define mod 1000000007
#define S second
#define F first
#define int long long
using namespace std;
int x[100000];
signed main() {
int a, b, ans = INT_MAX;
cin >> a >> b;
f(i, a) { cin >> x[i]; }
sort(x, x + a);
for... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,001,715 | 1,001,714 | u259210975 | cpp |
p03208 | #include <algorithm>
#include <stdio.h>
typedef long long ll;
using namespace std;
int main(void) {
ll i, j, k, a, b, c, n, ans = 1e9;
scanf("%lld%lld", &n, &k);
ll h[n];
for (i = 0; i < n; ++i)
scanf("%lld", &h[i]);
sort(h, h + n);
for (i = 0; i < n - k; ++i)
if (ans > h[i + k] - h[i])
ans =... | #include <algorithm>
#include <stdio.h>
typedef long long ll;
using namespace std;
int main(void) {
ll i, j, k, a, b, c, n, ans = 1e9;
scanf("%lld%lld", &n, &k);
ll h[n];
for (i = 0; i < n; ++i)
scanf("%lld", &h[i]);
sort(h, h + n);
for (i = 0; i <= n - k; ++i)
if (ans > h[i + k - 1] - h[i])
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"misc.off_by_one",
"assignment.change"
] | 1,001,718 | 1,001,717 | u440920318 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
int k;
int min;
cin >> n >> k;
vector<int> tree(n);
for (int i = 0; i < n; i++) {
cin >> tree[i];
}
sort(tree.begin(), tree.end());
min = tree[k - 1] - tree[0];
for (int j = 0; j < n - k; j++) {
if (min > tree[k - 1 - j] -... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
int k;
int min;
cin >> n >> k;
vector<int> tree(n);
for (int i = 0; i < n; i++) {
cin >> tree[i];
}
sort(tree.begin(), tree.end());
min = tree[k - 1] - tree[0];
for (int j = 0; j < n - k + 1; j++) {
if (min > (tree[k - 1 +... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,001,727 | 1,001,728 | u887066391 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
int *h, *l;
cin >> N >> K;
h = new int[N];
l = new int[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
for (int i = K - 1; i < N; i++) {
l[i] = h[i] - h[i - 2];
}
sort(l + K - 1, l + N);
cout << l[K -... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
int *h, *l;
cin >> N >> K;
h = new int[N];
l = new int[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
for (int i = K - 1; i < N; i++) {
l[i] = h[i] - h[i - K + 1];
}
sort(l + K - 1, l + N);
cout << l... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,001,729 | 1,001,730 | u056863173 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#de... | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#de... | [
"expression.operation.binary.remove"
] | 1,001,735 | 1,001,736 | u759266806 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int k;
cin >> N >> k;
vector<int> h(N, 0);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
int min = 1000000000;
for (int i = 0; i < N - k - 1; i++) {
if (h[k + i - 1] - h[i] < min)
min = h[k + i - 1] - h[... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int k;
cin >> N >> k;
vector<int> h(N, 0);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
int min = 1000000000;
for (int i = 0; i < N - k + 1; i++) {
if (h[k + i - 1] - h[i] < min)
min = h[k + i - 1] - h[... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,760 | 1,001,761 | u531531196 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int k;
cin >> N >> k;
vector<int> h(N, 0);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
long int min = 1000000000;
for (int i = 0; i < N - k - 1; i++) {
if (h[k + i - 1] - h[i] < min)
min = h[k + i - 1]... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int k;
cin >> N >> k;
vector<int> h(N, 0);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
int min = 1000000000;
for (int i = 0; i < N - k + 1; i++) {
if (h[k + i - 1] - h[i] < min)
min = h[k + i - 1] - h[... | [
"variable_declaration.type.narrow.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,762 | 1,001,761 | u531531196 | cpp |
p03208 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <random>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int N, K;
int main() {
cin >> N >> K;
vector<ll> h(N);
for (int i = 0; i < N; i++)
cin >> h.at(i);
sort(h.begin(), ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <random>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int N, K;
int main() {
cin >> N >> K;
vector<ll> h(N);
for (int i = 0; i < N; i++)
cin >> h.at(i);
sort(h.begin(), ... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,001,765 | 1,001,766 | u012298376 | cpp |
p03208 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <random>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int N, K;
int main() {
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h.at(i);
sort(h.begin(),... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <random>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int N, K;
int main() {
cin >> N >> K;
vector<ll> h(N);
for (int i = 0; i < N; i++)
cin >> h.at(i);
sort(h.begin(), ... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,001,767 | 1,001,766 | u012298376 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define nl '\n'
#define INF 2147483647
#define si(i) scanf("%d", &i)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int n, k, ans = INF;
int hgt[100005];
int main() {
... | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define nl '\n'
#define INF 2147483647
#define si(i) scanf("%d", &i)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int n, k, ans = INF;
int hgt[100005];
int main() {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,770 | 1,001,771 | u659781897 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
#define N 100005
const int inf = 1e9 + 5;
int main() {
int a[N], n, k;
int mn = inf;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n - k; i++... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
#define N 100005
const int inf = 1e9 + 5;
int main() {
int a[N], n, k;
int mn = inf;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n - k + 1;... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,772 | 1,001,773 | u326099815 | cpp |
p03208 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
using namespace std;
//////////////////////////////////... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
using namespace std;
//////////////////////////////////... | [
"expression.operation.binary.add"
] | 1,001,784 | 1,001,785 | u259396003 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#define rg register
using namespace std;
template <typename T> inline void in(T &a) {
T ch = getchar(), f = 1;
for (a = 0; !isdigit(ch); ch = getchar())
ch == '-' ? f = -1 : f = f;
for (; isdigit(c... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#define rg register
using namespace std;
template <typename T> inline void in(T &a) {
T ch = getchar(), f = 1;
for (a = 0; !isdigit(ch); ch = getchar())
ch == '-' ? f = -1 : f = f;
for (; isdigit(c... | [
"variable_declaration.value.change"
] | 1,001,797 | 1,001,798 | u231826562 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
int a[100000];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n == k) {
cout << a[n - 1] - a[0];
return 0;
}
int min = 1000000000;
for (int i = 0; i < n - k; i++) {
... | #include <algorithm>
#include <iostream>
using namespace std;
int a[100000];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n == k) {
cout << a[n - 1] - a[0];
return 0;
}
int min = 1000000000;
for (int i = 0; i <= n - k; i++) {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,803 | 1,001,804 | u495514186 | cpp |
p03208 | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int p[100005], a[100005];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
sort(p, p + n);
for (int i = 0; i < n - k; i++) {
a[i] = p[k - 1 + i] - p[i];
}
sort(a, a + n - k);
co... | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int p[100005], a[100005];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
sort(p, p + n);
for (int i = 0; i <= n - k; i++) {
a[i] = p[k - 1 + i] - p[i];
}
sort(a, a + n - k + 1);... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,805 | 1,001,806 | u808738521 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
int min_h = 1e8;
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h, h + n);
for (int i = 0; i < n - k; i++) {
min_h = min(h[i + k - 1] - h[i], min_h);
}
cout << min_h << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
int min_h = 1e18;
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h, h + n);
for (int i = 0; i < n - k + 1; i++) {
min_h = min(h[i + k - 1] - h[i], min_h);
}
cout << min_h << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,810 | 1,001,809 | u398211442 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <functional>
#include <iomanip>
#include <iterator>
#include <math.h>
#include <numeric>
#include <queue>
#include <stack>
#include <string.h>
//#inclu... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <functional>
#include <iomanip>
#include <iterator>
#include <math.h>
#include <numeric>
#include <queue>
#include <stack>
#include <string.h>
//#inclu... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,816 | 1,001,817 | u775013393 | cpp |
p03208 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; --i)
#define yesno(flg) \
if (flg) { \
cout << "YES" << endl; ... | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; --i)
#define yesno(flg) \
if (flg) { \
cout << "YES" << endl; ... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,001,848 | 1,001,849 | u591824072 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
const int INF32 = 1000000010;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<int> h;
for (int i = 0; i < N; i++) {
int t;
cin >> t;
h.push_back(t);
}
sort(h... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
const int INF32 = 1000000010;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<int> h;
for (int i = 0; i < N; i++) {
int t;
cin >> t;
h.push_back(t);
}
sort(h... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,850 | 1,001,851 | u028516426 | cpp |
p03208 | /*
for (int i = 0; i < N; ++i){}
// 各桁の和を計算する関数
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
sort(a, a + N, greater<int>()); // a[0:N] を大きい順にソート
int num[110] = {0}; // バケット
for (int i = 0; i < N; ++i) {
num[d[i]]++; // d[i] が ... | /*
for (int i = 0; i < N; ++i){}
// 各桁の和を計算する関数
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
sort(a, a + N, greater<int>()); // a[0:N] を大きい順にソート
int num[110] = {0}; // バケット
for (int i = 0; i < N; ++i) {
num[d[i]]++; // d[i] が ... | [
"expression.operation.binary.add"
] | 1,001,862 | 1,001,863 | u757738907 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[100001];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int minn = 1e9;
for (int i = 0; i < n - k; i++) {
int d = a[i + k - 1] - a[i];
if (d < minn) {
... | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[100001];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int minn = 1e9;
for (int i = 0; i < n - k + 1; i++) {
int d = a[i + k - 1] - a[i];
if (d < minn) {... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,864 | 1,001,865 | u737168568 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[10001];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int minn = 1e9;
for (int i = 0; i < n - k; i++) {
int d = a[i + k - 1] - a[i];
if (d < minn) {
... | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[100001];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int minn = 1e9;
for (int i = 0; i < n - k + 1; i++) {
int d = a[i + k - 1] - a[i];
if (d < minn) {... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,866 | 1,001,865 | u737168568 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int n, k;
int d[100005];
int main(void) {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> d[i];
sort(d, d + n);
reverse(d, d + n);
int ans = 2e9;
for (int i = 0; i < n - k; i++)
ans = min(ans, d[i] - d[i + k - 1]);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, k;
int d[100005];
int main(void) {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> d[i];
sort(d, d + n);
reverse(d, d + n);
int ans = 2e9;
for (int i = 0; i <= n - k; i++)
ans = min(ans, d[i] - d[i + k - 1]);
cout << ans << endl;
return 0;
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,867 | 1,001,868 | u319282133 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, start, end) for (int i = start; i < end; i++)
#define all(x) (x).begin(), (x).end()
#de... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, start, end) for (int i = start; i < end; i++)
#define all(x) (x).begin(), (x).end()
#de... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"assignment.change"
] | 1,001,877 | 1,001,878 | u934073187 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, K, dif, min = 2000000000;
cin >> N >> K;
int h[100000];
for (int i = 0; i < N; i++)
cin >> h[i];
// 降順ソート
sort(h, h + N, greater<int>());
// 差
for (int i = 0; i < N; i++) {
dif = h[i] - h[i + K - 1];
if ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, K, dif, min = 2000000000;
cin >> N >> K;
int h[100000];
for (int i = 0; i < N; i++)
cin >> h[i];
// 降順ソート
sort(h, h + N, greater<int>());
// 差
for (int i = 0; i + K - 1 < N; i++) {
dif = h[i] - h[i + K - 1];... | [
"control_flow.loop.for.condition.change"
] | 1,001,879 | 1,001,880 | u960997735 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
vector<ll> a;
vector<ll> p;
ll rec(ll n, ll x) {
if (n == 0) {
if (x <= 0)
return 0;
else
return 1;
}
if (x == 1)
return 1;
else if (x < 2 + a[n - 1])
return rec(n - 1, x - 1);
else if (... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
vector<ll> a;
vector<ll> p;
ll rec(ll n, ll x) {
if (n == 0) {
if (x <= 0)
return 0;
else
return 1;
}
if (x == 1)
return 0;
else if (x < 2 + a[n - 1])
return rec(n - 1, x - 1);
else if (... | [
"literal.number.change",
"function.return_value.change"
] | 1,001,915 | 1,001,916 | u568501780 | cpp |
p03209 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,001,917 | 1,001,918 | u190018920 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
const ll MOD = 1e9 + 7;
V<ll> len, pat;
ll rec(ll n, ll x) {
if (n == 0) {
if (x == 1)
return 1;
else
return 0... | #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
const ll MOD = 1e9 + 7;
V<ll> len, pat;
ll rec(ll n, ll x) {
if (n == 0) {
if (x == 1)
return 1;
else
return 0... | [
"expression.operation.binary.add"
] | 1,001,925 | 1,001,926 | u651235280 | cpp |
p03209 | #include <bits/stdc++.h>
#define lli long long
#define rep0(i, j) for (int i = 0; i < j; i++)
#define rep1(i, j) for (int i = 1; i <= j; i++)
#define all(a) a.begin(), a.end()
using namespace std;
void dfs(lli ed, lli num, vector<map<lli, lli>> &vec) {
lli n = 1;
for (auto e : vec[num]) {
if (n == ed)
n+... | #include <bits/stdc++.h>
#define lli long long
#define rep0(i, j) for (int i = 0; i < j; i++)
#define rep1(i, j) for (int i = 1; i <= j; i++)
#define all(a) a.begin(), a.end()
using namespace std;
void dfs(lli ed, lli num, vector<map<lli, lli>> &vec) {
lli n = 1;
for (auto e : vec[num]) {
if (n == ed)
n+... | [
"variable_declaration.type.change"
] | 1,001,936 | 1,001,937 | u950603962 | cpp |
p03209 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
typedef long long ll;
using namespace std;
void solve() {
ll n, x, l = 0, r, ans = 0;
cin >> n >> x;
vector<ll> y(n + 1), sum(n + 1);
y[0] = 1;
sum[0] = 1;
for (int ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
typedef long long ll;
using namespace std;
void solve() {
ll n, x, l = 0, r, ans = 0;
cin >> n >> x;
x--;
vector<ll> y(n + 1), sum(n + 1);
y[0] = 1;
sum[0] = 1;
fo... | [
"expression.unary.arithmetic.add",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,978 | 1,001,979 | u489302942 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define inv(n, a) \
for (int i = 0; i < n; i++) \
cin >> a[i]
#define MOD 1000000007
#define INF 1e7
#define LIN... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define inv(n, a) \
for (int i = 0; i < n; i++) \
cin >> a[i]
#define MOD 1000000007
#define INF 1e7
#define LIN... | [
"control_flow.return.add"
] | 1,002,010 | 1,002,011 | u532086793 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
vector<ll> a;
vector<ll> p;
ll solve(ll n, ll x) {
if (n == 0 && x == 1) {
return 1;
}
if (x == 1) {
return 0;
} else if (1 <= x && x <= 1 + ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
vector<ll> a;
vector<ll> p;
ll solve(ll n, ll x) {
if (n == 0 && x >= 1) {
return 1;
}
if (x <= 1) {
return 0;
} else if (1 <= x && x <= 1 + ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,002,037 | 1,002,040 | u024191315 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
std::vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
sort(v.begin(), v.end());
int ans = 1e9 + 7;
for (int i = 0; i + K < N; i++)
ans = min(ans, v[i + K] - v[i]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
std::vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
sort(v.begin(), v.end());
int ans = 1e9 + 7;
for (int i = 0; i + K - 1 < N; i++)
ans = min(ans, v[i + K - 1] - v[i]);
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"assignment.change"
] | 1,001,884 | 1,001,885 | u942774736 | cpp |
p03208 | #include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include ... | #include <algorithm>
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"assignment.change"
] | 1,001,886 | 1,001,887 | u422592877 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
usin... | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
usin... | [
"assignment.change"
] | 1,001,890 | 1,001,891 | u294531924 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
signed main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (auto &x : a)
cin >> x;
sort(a.begin(), a.end());
int ans = 1e9;
for (int i = 0; i < n - k + 1; ++i) {
ans = min(ans, a[i + k] - a[i]);
}
cout << ans << endl;
}... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
signed main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (auto &x : a)
cin >> x;
sort(a.begin(), a.end());
int ans = 1e9;
for (int i = 0; i < n - k + 1; ++i) {
ans = min(ans, a[i + k - 1] - a[i]);
}
cout << ans << end... | [
"assignment.change"
] | 1,001,892 | 1,001,893 | u705918648 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
signed main() {
int k, n;
cin >> k >> n;
vector<int> a(n);
for (auto &x : a)
cin >> x;
sort(a.begin(), a.end());
int ans = 1e9;
for (int i = 0; i < n - k + 1; ++i) {
ans = min(ans, a[i + k] - a[i]);
}
cout << ans << endl;
}... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
signed main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (auto &x : a)
cin >> x;
sort(a.begin(), a.end());
int ans = 1e9;
for (int i = 0; i < n - k + 1; ++i) {
ans = min(ans, a[i + k - 1] - a[i]);
}
cout << ans << end... | [
"expression.operation.binary.remove",
"assignment.change"
] | 1,001,894 | 1,001,893 | u705918648 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 200000
int main() ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 200000
int main() ... | [
"literal.string.change",
"call.arguments.change",
"call.arguments.add"
] | 1,001,895 | 1,001,896 | u510611356 | cpp |
p03209 | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,002,043 | 1,002,044 | u224756887 | cpp |
p03209 | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,002,047 | 1,002,048 | u224756887 | cpp |
p03209 | #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
// @@ !! LIM(debug)
// --> f:<< debug
// ---- inserted function << from util.cc
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
r... | #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
// @@ !! LIM(debug)
// --> f:<< debug
// ---- inserted function << from util.cc
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
r... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,002,070 | 1,002,071 | u588093355 | cpp |
p03209 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = ... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,002,114 | 1,002,115 | u835805357 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
const int mod = 1000000007;
vector<ll> b(110), a(110);
ll dfs(ll n, ll x) {
if (n == 0) {
if (x <= 0)
return 0;
else
1;
} else if (x > a[n - 1] + 1)... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
const int mod = 1000000007;
vector<ll> b(110), a(110);
ll dfs(ll n, ll x) {
if (n == 0) {
if (x <= 0)
return 0;
else
return 1;
} else if (x > a[n - ... | [
"control_flow.return.add"
] | 1,002,437 | 1,002,438 | u239409893 | cpp |
p03209 | #include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define ll long long
#define re register
#define mp make_pair
typedef pair<int, int> pii;
inline int gi() {
int su... | #include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define ll long long
#define re register
#define mp make_pair
typedef pair<int, int> pii;
inline int gi() {
int su... | [
"control_flow.loop.condition.change"
] | 1,002,441 | 1,002,442 | u810464778 | cpp |
p03209 | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
vector<ll> ps;
vector<ll> as;
ll f(ll n, ll x) {
if (n == 0) {
return x < 0 ? 0 : 1;
} else if (x <= 1 + as[n - 1]) {
return f(n - 1, x - 1);
} else {
return ps[n - 1] + 1 + f(n - 1, x - 2 - as[n - 1]);
}
}
int main(... | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
vector<ll> ps;
vector<ll> as;
ll f(ll n, ll x) {
if (n == 0) {
return x <= 0 ? 0 : 1;
} else if (x <= 1 + as[n - 1]) {
return f(n - 1, x - 1);
} else {
return ps[n - 1] + 1 + f(n - 1, x - 2 - as[n - 1]);
}
}
int main... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,002,447 | 1,002,448 | u231541008 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> l(0, 0), p(0, 0);
ll cal(ll x, ll n) {
if (n == 0)
return (x ? 1 : 0);
else if (x <= 1 + l.at(n - 1))
return cal(x - 1, n - 1);
else
return p.at(n - 1) + 1 + cal(x - 2 - l.at(n - 1), n - 1);
}
int main() {
ll N, i, X;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> l(0, 0), p(0, 0);
ll cal(ll x, ll n) {
if (n == 0)
return (x > 0 ? 1 : 0);
else if (x <= 1 + l.at(n - 1))
return cal(x - 1, n - 1);
else
return p.at(n - 1) + 1 + cal(x - 2 - l.at(n - 1), n - 1);
}
int main() {
ll N, i,... | [
"control_flow.branch.if.condition.change"
] | 1,002,487 | 1,002,488 | u211109468 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> l(0, 0), p(0, 0);
ll cal(ll x, ll n) {
if (n == 0)
return (x ? 1 : 0);
else if (x <= 2 + l.at(n - 1))
return cal(x - 1, n - 1);
else
return p.at(n - 1) + 1 + cal(x - 2 - l.at(n - 1), n - 1);
}
int main() {
ll N, i, X;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> l(0, 0), p(0, 0);
ll cal(ll x, ll n) {
if (n == 0)
return (x > 0 ? 1 : 0);
else if (x <= 1 + l.at(n - 1))
return cal(x - 1, n - 1);
else
return p.at(n - 1) + 1 + cal(x - 2 - l.at(n - 1), n - 1);
}
int main() {
ll N, i,... | [
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 1,002,489 | 1,002,488 | u211109468 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> l(0, 0), p(0, 0);
ll cal(ll x, ll n) {
if (n == 0)
return (x ? 0 : 1);
else if (x <= 2 + l.at(n - 1))
return cal(x - 1, n - 1);
else
return p.at(n - 1) + 1 + cal(x - 2 - l.at(n - 1), n - 1);
}
int main() {
ll N, i, X;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> l(0, 0), p(0, 0);
ll cal(ll x, ll n) {
if (n == 0)
return (x > 0 ? 1 : 0);
else if (x <= 1 + l.at(n - 1))
return cal(x - 1, n - 1);
else
return p.at(n - 1) + 1 + cal(x - 2 - l.at(n - 1), n - 1);
}
int main() {
ll N, i,... | [
"function.return_value.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,002,490 | 1,002,488 | u211109468 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int64_t X;
cin >> X;
int64_t sum = 0;
while (X > 0) {
if (X <= pow(2, N + 1) - 2) {
--N;
--X;
} else if (X == pow(2, N + 1) - 1) {
sum = int64_t(pow(2, N));
break;
} else if (X == pow(2, N + 2) ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int64_t X;
cin >> X;
int64_t sum = 0;
while (X > 0) {
if (X <= pow(2, N + 1) - 2) {
--N;
--X;
} else if (X == pow(2, N + 1) - 1) {
sum += int64_t(pow(2, N));
break;
} else if (X == pow(2, N + 2)... | [
"assignment.value.change"
] | 1,002,506 | 1,002,507 | u304862095 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
main() {
int i, n, k, h[9 << 14], m = 1e9, x;
cin >> n >> k;
for (i = n; i--;)
cin >> h[i];
sort(h, h + n);
for (i = n - k + 1; i--; m = m > x ? x : m)
x = h[i + k - 1] - h[i];
cout << x;
}
| #include <algorithm>
#include <iostream>
using namespace std;
main() {
int i, n, k, h[9 << 14], m = 1e9, x;
cin >> n >> k;
for (i = n; i--;)
cin >> h[i];
sort(h, h + n);
for (i = n - k + 1; i--; m = m > x ? x : m)
x = h[i + k - 1] - h[i];
cout << m;
}
| [
"identifier.change",
"io.output.change"
] | 1,002,526 | 1,002,527 | u653187094 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define forx(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
bool com(pair<int, int> &s, pair<int, int> &t) {
if (s.first == t.first)
return s.second > t.second;
return s.first < t.first;
}
int main() ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define forx(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
bool com(pair<int, int> &s, pair<int, int> &t) {
if (s.first == t.first)
return s.second > t.second;
return s.first < t.first;
}
int main() ... | [
"expression.unary.arithmetic.add"
] | 1,002,536 | 1,002,537 | u604231488 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
int ans = 1000000;
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h, h + n);
for (int i = 0; i <= n - k + 1; i++) {
ans = min(ans, h[k - 1 + i] - h[i]);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
int ans = 2e9;
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h, h + n);
for (int i = 0; i < n - k + 1; i++) {
ans = min(ans, h[k - 1 + i] - h[i]);
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,548 | 1,002,547 | u633967774 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
long long int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,559 | 1,002,560 | u293599059 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,561 | 1,002,560 | u293599059 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 1,002,562 | 1,002,560 | u293599059 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
long long int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
long long int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,559 | 1,002,563 | u293599059 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
long long int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,561 | 1,002,563 | u293599059 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int min = 10 ... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
long long int N, K;
cin >> N >> K;
vector<long long int> v;
long long int tree;
for (int i = 0; i < N; i++) {
cin >> tree;
v.push_back(tree);
}
sort(v.begin(), v.end());
long long int... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 1,002,562 | 1,002,563 | u293599059 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, k[100005], ans = 999999;
cin >> n >> a;
for (int i = 0; i < n; ++i)
cin >> k[i];
sort(k, k + n);
for (int i = 0; i < n - a; ++i) {
ans = min(ans, k[i + a - 1] - k[i]);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, k[100005], ans = 99999999999;
cin >> n >> a;
for (int i = 0; i < n; ++i)
cin >> k[i];
sort(k, k + n);
for (int i = 0; i <= n - a; ++i) {
ans = min(ans, k[i + a - 1] - k[i]);
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,568 | 1,002,567 | u539402331 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h.begin(), h.end());
int mind = 1000000001;
for (int i = 0; i < n - 2; i++) {
// cout << h[i+k-1] << " " << h[i] ... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h.begin(), h.end());
int mind = 1000000001;
for (int i = 0; i < n - k + 1; i++) {
// cout << h[i+k-1] << " " << h... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one"
] | 1,002,583 | 1,002,584 | u239023686 | cpp |
p03208 | #include <algorithm>
#include <chrono>
#include <climits>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#defin... | #include <algorithm>
#include <chrono>
#include <climits>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#defin... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,585 | 1,002,586 | u492373312 | cpp |
p03208 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define ALL(x) (x).begin(), (x).end()
#defi... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define ALL(x) (x).begin(), (x).end()
#defi... | [
"expression.operation.binary.add"
] | 1,002,591 | 1,002,592 | u890870565 | cpp |
p03208 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define ALL(x) (x).begin(), (x).end()
#defi... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define reps(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; --i)
#define ALL(x) (x).begin(), (x).end()
#defi... | [
"expression.operation.binary.add",
"assignment.change"
] | 1,002,593 | 1,002,592 | u890870565 | cpp |
p03208 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define rep(N) for (int i = 0; i < N; ++i)
#define Rep(a, b) for (int i = a; i < b; ++i)
#define For(i, N) for (int i = 0; i < N; ++i)
#define all(v) v.begin(), v.end()
#define rev(v) v.rbegin(), v.rend()
#define makei(N) ... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define rep(N) for (int i = 0; i < N; ++i)
#define Rep(a, b) for (int i = a; i < b; ++i)
#define For(i, N) for (int i = 0; i < N; ++i)
#define all(v) v.begin(), v.end()
#define rev(v) v.rbegin(), v.rend()
#define makei(N) ... | [
"expression.unary.arithmetic.add",
"expression.operation.binary.remove"
] | 1,002,597 | 1,002,598 | u698760125 | cpp |
p03208 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define rep(N) for (int i = 0; i < N; ++i)
#define Rep(a, b) for (int i = a; i < b; ++i)
#define For(i, N) for (int i = 0; i < N; ++i)
#define all(v) v.begin(), v.end()
#define rev(v) v.rbegin(), v.rend()
#define makei(N) ... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define rep(N) for (int i = 0; i < N; ++i)
#define Rep(a, b) for (int i = a; i < b; ++i)
#define For(i, N) for (int i = 0; i < N; ++i)
#define all(v) v.begin(), v.end()
#define rev(v) v.rbegin(), v.rend()
#define makei(N) ... | [
"expression.unary.arithmetic.add"
] | 1,002,599 | 1,002,598 | u698760125 | cpp |
p03208 | #include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h.begin(), h.end(), greater<int>());
int ans = 1000000;
for (int i = 0; i < k ... | #include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h.begin(), h.end(), greater<int>());
int ans = 1000000000;
for (int i = 0; i <... | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,002,630 | 1,002,631 | u330689597 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
// long int h[1000000];
cin >> N >> K;
int ans = 1000000;
int a;
vector<long int> h;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
h.push_back(x);
}
sort(h.begin(), h.end());
for (int ... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
// long int h[1000000];
cin >> N >> K;
int ans = 1000000000;
int a;
vector<long int> h;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
h.push_back(x);
}
sort(h.begin(), h.end());
for (i... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,002,648 | 1,002,647 | u537837642 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
main() {
int n, k;
cin >> n >> k;
long long int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
long long int min = 1000000000000;
for (int i = 0; i < n - k; i++) {
if (min > (h[k + i - 1] - h[i])) {
min = h... | #include <algorithm>
#include <iostream>
using namespace std;
main() {
int n, k;
cin >> n >> k;
long long int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
long long int min = 1000000000000;
for (int i = 0; i < n - k + 1; i++) {
if (min > (h[k + i - 1] - h[i])) {
min... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,002,664 | 1,002,665 | u048128931 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
main() {
int n, k;
cin >> n >> k;
long long int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
long long int min = 1000000000000;
for (int i = 0; i < n - k; i++) {
if (min > (h[k + i - 2] - h[i])) {
min = h... | #include <algorithm>
#include <iostream>
using namespace std;
main() {
int n, k;
cin >> n >> k;
long long int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
long long int min = 1000000000000;
for (int i = 0; i < n - k + 1; i++) {
if (min > (h[k + i - 1] - h[i])) {
min... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 1,002,666 | 1,002,665 | u048128931 | cpp |
p03208 | #include <algorithm>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int N, K;
int h[1000000];
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N, greater<int>());
int dif[1000000];
for (int i = 0; i < N - K; i++) {
dif[i] = h[0 + i] - h[K - ... | #include <algorithm>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int N, K;
int h[100000];
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N, greater<int>());
int dif[1000000];
for (int i = 0; i < N - K + 1; i++) {
dif[i] = h[0 + i] - h[K... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,002,685 | 1,002,686 | u865014539 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
#define INF 2 << 30
int main() {
int ans = INF, n, k, h[100005];
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
sort(h, h +... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
#define INF 2 << 29
int main() {
int ans = INF, n, k, h[100005];
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
sort(h, h +... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 1,002,708 | 1,002,709 | u604928622 | cpp |
p03208 | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf... | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf... | [
"variable_declaration.type.change"
] | 1,002,721 | 1,002,722 | u079330987 | cpp |
p03208 | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf... | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf... | [
"expression.operation.binary.add"
] | 1,002,721 | 1,002,723 | u079330987 | cpp |
p03208 | #include <algorithm>
#include <stdio.h>
using namespace std;
long long h[100000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i;
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
long long ans = 99999999;
sort(h, h + n);
for (i = 0; i + k - 1 < n; i++) {
ans = ans < (h[i + k - 1] - h[i]) ? a... | #include <algorithm>
#include <stdio.h>
using namespace std;
long long h[100000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i;
for (i = 0; i < n; i++) {
scanf("%lld", &h[i]);
}
long long ans = 9223372036854775807;
sort(h, h + n);
for (i = 0; i + k - 1 < n; i++) {
ans = ans < (h[i + k - 1... | [
"literal.string.change",
"call.arguments.change",
"literal.number.change",
"variable_declaration.value.change"
] | 1,002,727 | 1,002,725 | u651965992 | cpp |
p03208 | #include <algorithm>
#include <stdio.h>
using namespace std;
long long h[100000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i;
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
long long ans = 99999999;
sort(h, h + n);
/*for(i=0;i<n;i++)
{
printf("%lld\n",h[i]);
}*/
for (i = 0; i +... | #include <algorithm>
#include <stdio.h>
using namespace std;
long long h[100000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i;
for (i = 0; i < n; i++) {
scanf("%lld", &h[i]);
}
long long ans = 9223372036854775807;
sort(h, h + n);
for (i = 0; i + k - 1 < n; i++) {
ans = ans < (h[i + k - 1... | [
"literal.string.change",
"call.arguments.change",
"literal.number.change",
"variable_declaration.value.change"
] | 1,002,728 | 1,002,725 | u651965992 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int min = 2147483647;... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int min = 2147483647;... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,002,731 | 1,002,732 | u217218591 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int min = 1000000000;... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int min = 2147483647;... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,002,733 | 1,002,732 | u217218591 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> ... | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,002,744 | 1,002,745 | u327242197 | cpp |
p03208 | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int n, sum = 0, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int ans = 1e16;
for (int i = 0; i < n - x; i++) {
ans = min(ans, a[i + x - 1] - a[i]);
}
cout << ans <... | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int n, sum = 0, x;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int ans = 1e16;
for (int i = 0; i <= n - x; i++) {
ans = min(ans, a[i + x - 1] - a[i]);
}
cout << ans ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,002,746 | 1,002,747 | u777468981 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> hs;
for (int i = 0; i < N; i++) {
int h;
cin >> h;
hs.push_back(h);
}
sort(hs.begin(), hs.end());
int ans = 1e+9 + 1;
;
for (int i = 0; i <= N - K; i++) {
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> hs;
for (int i = 0; i < N; i++) {
int h;
cin >> h;
hs.push_back(h);
}
sort(hs.begin(), hs.end());
int ans = 1e+9 + 1;
;
for (int i = 0; i <= N - K; i++) {
... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,002,752 | 1,002,753 | u559765551 | cpp |
p03208 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[100000];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int b[100000];
for (int i = 0; i < n; i++) {
b[i] = a[i + k - 1] - a[i];
}
int ans = 10000... | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int b[100000];
for (int i = 0; i < n; i++) {
b[i] = a[i + k - 1] - a[i];
}
int ans = 1000000000... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change"
] | 1,002,754 | 1,002,755 | u179970156 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int main() {
int i, N, K, h[100000], dif;
long long min = 1000000000;
scanf("%d %d", &N, &K);
for (i = 0; i < N; i++) {
scanf("%d", &h[i]);
}
sort(h, h + N);
for (i = 0; i < N; i++) {
dif = h[i + K - 1] - h[i];
... | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int main() {
int i, N, K, h[100000], dif;
long long min = 1000000000;
scanf("%d %d", &N, &K);
for (i = 0; i < N; i++) {
scanf("%d", &h[i]);
}
sort(h, h + N);
for (i = 0; i < N - K + 1; i++) {
dif = h[i + K - 1] - h[... | [
"control_flow.loop.for.condition.change"
] | 1,002,758 | 1,002,759 | u958128735 | cpp |
p03209 | // だーれだ？
// qqqqqqHHMqqqqqHf!(:;jHmmkf``(:;jkqqqqqqqqqmMH#HMqqK_````````````````(kqqqqqqHMMM
// qqqqqqHHmqqqqH=` :;;jkqH=?~..;;jqqqqqqqqqmM#HM#MHH!````
// ```````..-``dqWbWkRqHMMM qqqqqqMHmqqqK!``.;;;dqH:
// ```.?TUqqHmqqqqmHHHM4Mqkt..```` ..JgHHW@P`.HHkqHHHqM#NN
// qqqqqmHMmqHTYWHgHmmgHR...``` :;Jkq9qqqqqgMH#1dHk$...-... | // だーれだ？
// qqqqqqHHMqqqqqHf!(:;jHmmkf``(:;jkqqqqqqqqqmMH#HMqqK_````````````````(kqqqqqqHMMM
// qqqqqqHHmqqqqH=` :;;jkqH=?~..;;jqqqqqqqqqmM#HM#MHH!````
// ```````..-``dqWbWkRqHMMM qqqqqqMHmqqqK!``.;;;dqH:
// ```.?TUqqHmqqqqmHHHM4Mqkt..```` ..JgHHW@P`.HHkqHHHqM#NN
// qqqqqmHMmqHTYWHgHmmgHR...``` :;Jkq9qqqqqgMH#1dHk$...-... | [
"control_flow.branch.if.condition.change"
] | 1,002,792 | 1,002,793 | u394919721 | cpp |
p03209 | /**
* @author torith
* @date 2019-02-03
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll power(ll a, ll r) {
ll sum = 1;
while (r > 0) {
if ((r & 1) == 1) {
sum *= a;
}
a *= a;
r >>= 1;
}
return sum;
}
ll solve(ll N, ll X) {
ll len_n_1 = 4 * power(2, N - ... | /**
* @author torith
* @date 2019-02-03
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll power(ll a, ll r) {
ll sum = 1;
while (r > 0) {
if ((r & 1) == 1) {
sum *= a;
}
a *= a;
r >>= 1;
}
return sum;
}
ll solve(ll N, ll X) {
ll len_n_1 = 4 * power(2, N - ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,002,823 | 1,002,824 | u278446060 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
long long n, x;
// レベルiバーガーの厚さ Ai
vector<long long> A;
// レベルiバーガーに含まれるパティの総数 Pi
vector<long long> P;
// レベルnnバーガーの下からxx層に含まれるパティの枚数 f(nn, xx)
long long f(long long nn, long long xx) {
// レベル0バーガーはパティ1枚
if (nn == 0) {
return (x <= 0 ? 0 : 1);
// xx層 が 1+レベ... | #include <bits/stdc++.h>
using namespace std;
long long n, x;
// レベルiバーガーの厚さ Ai
vector<long long> A;
// レベルiバーガーに含まれるパティの総数 Pi
vector<long long> P;
// レベルnnバーガーの下からxx層に含まれるパティの枚数 f(nn, xx)
long long f(long long nn, long long xx) {
// レベル0バーガーはパティ1枚
if (nn == 0) {
return (xx <= 0 ? 0 : 1);
// xx層 が 1+レ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,002,829 | 1,002,830 | u136869985 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
long long n, x;
// レベルiバーガーの厚さ Ai
vector<long long> A;
// レベルiバーガーに含まれるパティの総数 Pi
vector<long long> P;
// レベルnnバーガーの下からxx層に含まれるパティの枚数 f(nn, xx)
long long f(long long nn, long long xx) {
// レベル0バーガーはパティ1枚
if (nn == 0) {
return (x <= 0 ? 0 : 1);
// xx層 が 1+レベ... | #include <bits/stdc++.h>
using namespace std;
long long n, x;
// レベルiバーガーの厚さ Ai
vector<long long> A;
// レベルiバーガーに含まれるパティの総数 Pi
vector<long long> P;
// レベルnnバーガーの下からxx層に含まれるパティの枚数 f(nn, xx)
long long f(long long nn, long long xx) {
// レベル0バーガーはパティ1枚
if (nn == 0) {
return (xx <= 0 ? 0 : 1);
// xx層 が 1+レ... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 1,002,831 | 1,002,830 | u136869985 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
long long N;
long long X;
vector<long long> l, p;
long long func(long N, long long X) {
if (N == 0) {
if (X <= 0) {
return 0;
} else {
return 1;
}
} else if (X <= l.at(N - 1) + 1) {
return func(N - 1, X - 1);
} else {
return p.at(N - 1... | #include <bits/stdc++.h>
using namespace std;
long long N;
long long X;
vector<long long> l, p;
long long func(long N, long long X) {
if (N == 0) {
if (X <= 0) {
return 0;
} else {
return 1;
}
} else if (X <= l.at(N - 1) + 1) {
return func(N - 1, X - 1);
} else {
return p.at(N - 1... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,002,873 | 1,002,874 | u014655172 | cpp |
p03209 | #include <iostream>
using namespace std;
int main() {
long long N, X, ans = 0;
cin >> N >> X;
while (N > 0 && X > 0) {
long long half = ((long long)1 << N + 1) - 2;
if (X > half) {
ans += (half >> 1) + 1;
X -= half + 1;
} else {
X--;
}
N--;
}
cout << ans;
} |
#include <iostream>
using namespace std;
int main() {
long long N, X, ans = 0;
cin >> N >> X;
while (N >= 0 && X > 0) {
long long half = ((long long)1 << N + 1) - 2;
if (X > half) {
ans += (half >> 1) + 1;
X -= half + 1;
} else {
X--;
}
N--;
}
cout << ans;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,002,892 | 1,002,893 | u261132915 | cpp |
p03209 | #include <iostream>
using namespace std;
int main() {
long long N, X, ans = 0;
cin >> N >> X;
while (N > 0 && X > 0) {
long long half = ((long long)1 << N + 1) - 2;
if (X > half) {
ans += half >> 1 + 1;
X -= half + 1;
} else {
X--;
}
N--;
}
cout << ans;
} |
#include <iostream>
using namespace std;
int main() {
long long N, X, ans = 0;
cin >> N >> X;
while (N >= 0 && X > 0) {
long long half = ((long long)1 << N + 1) - 2;
if (X > half) {
ans += (half >> 1) + 1;
X -= half + 1;
} else {
X--;
}
N--;
}
cout << ans;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,002,894 | 1,002,893 | u261132915 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
#define inf 1000000000
#define INF 1000000000000000
#define ll long long
#define ull unsigned long long
#define M 1000000007
#define P pair<int, int>
#define PLL pair<ll, ll>
#define FOR(i, m, n) for (int i = (int)m; i < (int)n; i++)
#define RFOR(i, m, n) for (int i = (int)... | #include <bits/stdc++.h>
using namespace std;
#define inf 1000000000
#define INF 1000000000000000
#define ll long long
#define ull unsigned long long
#define M 1000000007
#define P pair<int, int>
#define PLL pair<ll, ll>
#define FOR(i, m, n) for (int i = (int)m; i < (int)n; i++)
#define RFOR(i, m, n) for (int i = (int)... | [
"control_flow.loop.condition.change"
] | 1,002,898 | 1,002,899 | u229842440 | cpp |
p03209 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
ll burgerDan[100];
ll burgerPatty[100];
ll yo(ll n, ll zan) {
ll i;
if (n == 0) {
//呼び出し時に末尾Bを取り外している
// PPP, P... | #include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
ll burgerDan[100];
ll burgerPatty[100];
ll yo(ll n, ll zan) {
if (n == 0) {
// BP PPBの先頭
// BP,P , "" のいずれかの状態
... | [
"variable_declaration.remove",
"identifier.replace.remove",
"literal.replace.add",
"function.return_value.change"
] | 1,002,941 | 1,002,942 | u485731913 | cpp |
p03209 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
ll burgerDan[100];
ll burgerPatty[100];
ll yo(ll n, ll zan) {
ll i;
if (n == 0) {
if (zan >= 2)
return 1;
... | #include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
ll burgerDan[100];
ll burgerPatty[100];
ll yo(ll n, ll zan) {
if (n == 0) {
// BP PPBの先頭
// BP,P , "" のいずれかの状態
... | [
"variable_declaration.remove",
"literal.number.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 1,002,943 | 1,002,942 | u485731913 | cpp |
p03209 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll num_layers(int n) {
if (n == 0) {
return 1;
} else {
return 2 * num_layers(n - 1) + 3;
}
}
ll num_patties(int n) {
if (n == 0) {
return 1;
} else {
return 2 * num_patties(n - 1) + 1;
}
}
ll solve(int n, int x) {
if (... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll num_layers(int n) {
if (n == 0) {
return 1;
} else {
return 2 * num_layers(n - 1) + 3;
}
}
ll num_patties(int n) {
if (n == 0) {
return 1;
} else {
return 2 * num_patties(n - 1) + 1;
}
}
ll solve(int n, ll x) {
if (n... | [] | 1,002,970 | 1,002,971 | u826487371 | cpp |
p03209 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n;
long long x, a = 1, b = 1, c = 0, d = 0;
cin >> n >> x;
rep(i, n) {
a = 2 * a + 3;
b = 2 * b + 1;
}
rep(i, n + 1) {
if (x == a) {
... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n;
long long x, a = 1, b = 1, c = 0, d = 0;
cin >> n >> x;
rep(i, n) {
a = 2 * a + 3;
b = 2 * b + 1;
}
rep(i, n + 2) {
if (x == a) {
... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,002,999 | 1,003,000 | u352228045 | cpp |
p03209 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <istream>
#include <random>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
typedef long long ll;
ll total = 1;
vector<ll> length;
vector<ll> P_length;
ll sum(ll N, ll X) {
if (N ==... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <istream>
#include <random>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
typedef long long ll;
ll total = 1;
vector<ll> length;
vector<ll> P_length;
ll sum(ll N, ll X) {
if (N ==... | [
"assignment.change"
] | 1,003,027 | 1,003,028 | u048791623 | cpp |
p03209 | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - 1 + 2 * p);
}
int main() {
cin >> n >> k;
cout << fun(... | #include <iostream>
#include <vector>
using namespace std;
using ll = long;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - 1 - 2 * p);
}
int main() {
cin >> n >> k;
cout << fun(n, k)... | [
"variable_declaration.type.narrow.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,003,041 | 1,003,042 | u394482932 | cpp |
p03209 | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - 1 + 2 * p);
}
int main() {
cin >> n >> k;
cout << fun(... | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - 1 - 2 * p);
}
int main() {
cin >> n >> k;
cout << fun(... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,003,041 | 1,003,043 | u394482932 | cpp |
p03209 | #include <iostream>
using namespace std;
using ll = long long;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - 1 + 2 * p);
}
int main() {
cin >> n >> k;
cout << fun(n, k) << endl;
} | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - 1 - 2 * p);
}
int main() {
cin >> n >> k;
cout << fun(... | [
"import.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,003,044 | 1,003,043 | u394482932 | cpp |
p03209 | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
vector<ll> lay;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - (1 + p));
}
int main() {
cin >> n >> k;
... | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
vector<ll> lay;
ll n, k;
ll fun(ll n, ll x) {
if (n == 0)
return (x <= 0 ? 0 : 1);
ll p = (1LL << n) - 1;
if (x <= 2 * p)
return fun(n - 1, x - 1);
return p + 1 + fun(n - 1, x - (1 + 2 * p));
}
int main() {
cin >> n >>... | [
"expression.operation.binary.add"
] | 1,003,045 | 1,003,046 | u394482932 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.