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 <algorithm>
#include <bits/stdc++.h>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using n... | #include <algorithm>
#include <bits/stdc++.h>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using n... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,001,042 | 1,001,043 | u767543103 | 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 ans = 10000000;
for (int i = 0; i < n - k; i++) {
if (ans > h[i + k - 1] - h[i])
ans... | #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 ans = 1000000003;
for (int i = 0; i <= n - k; i++) {
if (ans > h[i + k - 1] - h[i])
... | [
"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,001,046 | 1,001,045 | u803893892 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> heights(N);
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
sort(heights.begin(), heights.end());
int minDiff = 2000000000;
for (int i = 0; i < N ... | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> heights(N);
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
sort(heights.begin(), heights.end());
int minDiff = 2000000000;
for (int i = 0; i <= N... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,051 | 1,001,052 | u214685595 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> heights(N);
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
sort(heights.begin(), heights.end());
int minDiff = 2000000000;
for (int i = 0; i < K;... | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> heights(N);
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
sort(heights.begin(), heights.end());
int minDiff = 2000000000;
for (int i = 0; i <= N... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,053 | 1,001,052 | u214685595 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> heights(N);
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
sort(heights.begin(), heights.end());
int minDiff = 1000000000;
for (int i = 0; i < K;... | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> heights(N);
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
sort(heights.begin(), heights.end());
int minDiff = 2000000000;
for (int i = 0; i <= N... | [
"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,001,054 | 1,001,052 | u214685595 | cpp |
p03208 | //#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main() {
//入力
long a[100000], b[100000], x[100000];
long N, M = 1000000000, ans = 0, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
//処理
sort(a, a + N);
/... | //#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main() {
//入力
long a[100000], b[100000], x[100000];
long N, M = 1000000000, ans = 0, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
//処理
sort(a, a + N);
/... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,060 | 1,001,061 | u483697387 | cpp |
p03208 | //#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main() {
//入力
long a[100000], b[100000], x[100000];
long N, M = 1000000000, ans = 0, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
//処理
sort(a, a + N);
f... | //#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main() {
//入力
long a[100000], b[100000], x[100000];
long N, M = 1000000000, ans = 0, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
//処理
sort(a, a + N);
/... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,001,062 | 1,001,061 | u483697387 | 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 ans = 1e9;
for (int i = 0; i < n - k; i++) {
ans = min(ans, 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 ans = 1e9;
for (int i = 0; i < n - k + 1; i++) {
ans = min(ans, h[i + k - 1] - h[... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,071 | 1,001,072 | u195054737 | cpp |
p03208 | #include <bits/stdc++.h>
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());
vector<int> j(N - K + 1);
for (int i = 0; i < N - K + 1; i++) {
j[i] = j[i + K - 1] - j[i];
}
sort(j.begin(), j.end())... | #include <bits/stdc++.h>
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());
vector<int> j(N - K + 1);
for (int i = 0; i < N - K + 2; i++) {
j[i] = h[i + K - 1] - h[i];
}
sort(j.begin(), j.end())... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change"
] | 1,001,077 | 1,001,078 | u593555034 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, n, k, MIN = 1000000001;
cin >> n >> k;
int data[n];
for (int i = 0; i < n; i++) {
cin >> data[i];
}
sort(data, data + n, greater<int>());
for (int i = 0; i < n - k; i++) {
MIN = min(MIN, data[i] - data[k + i - 1]);
}
co... | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, n, k, MIN = 1000000001;
cin >> n >> k;
int data[n];
for (int i = 0; i < n; i++) {
cin >> data[i];
}
sort(data, data + n, greater<int>());
for (int i = 0; i <= n - k; i++) {
MIN = min(MIN, data[i] - data[k + i - 1]);
}
c... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,085 | 1,001,086 | u355424600 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
int main() {
int N, K;
cin >> N >> K;
vector<long long> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
long long ans = INF;
for (int i = 0; i <= N - K; i++) {
ans = min(ans, h[i - K + 1] - ... | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
int main() {
int N, K;
cin >> N >> K;
vector<long long> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
long long ans = INF;
for (int i = 0; i <= N - K; i++) {
ans = min(ans, h[i + K - 1] - ... | [
"expression.operation.binary.remove",
"assignment.change"
] | 1,001,089 | 1,001,090 | u508571192 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"call.remove",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,093 | 1,001,094 | u155416173 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,001,095 | 1,001,094 | u155416173 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
long long n, b, e = 1000000001;
cin >> n >> b;
long long a[123456];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int h = 0; h < n - 2; h++) {
e = min(a[h + 2] - a[h], ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
long long n, b, e = 1000000001;
cin >> n >> b;
long long a[123456];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int h = 0; h < n - b + 1; h++) {
e = min(a[h + b - 1] ... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"assignment.change"
] | 1,001,096 | 1,001,097 | u986568278 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define int64 long long
#define yokuwaruprime (10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7)
using namespace std... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define int64 long long
#define yokuwaruprime (10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7)
using namespace std... | [
"expression.operation.binary.add"
] | 1,001,110 | 1,001,111 | u170301438 | cpp |
p03208 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"identifier.change",
"io.output.change"
] | 1,001,112 | 1,001,113 | u332843157 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int INF = 1e9 + 7;
int main() {
int N, K, ans = INF;
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int INF = 1e9 + 7;
int main() {
int N, K, ans = INF;
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,129 | 1,001,130 | u230414490 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, m = 2000000000;
cin >> n >> k;
int h[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
for (i = 0; i < n - k; i++) {
m = min(m, h[i + k - 1] - h[i]);
}
cout << m;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, m = 2000000000;
cin >> n >> k;
int h[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
for (i = 0; i <= n - k; i++) {
m = min(m, h[i + k - 1] - h[i]);
}
cout << m;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,146 | 1,001,147 | u058348416 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, m = 2000000000;
cin >> n >> k;
int h[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
for (i = 0; i < n - k; i++) {
m = min(m, h[i + k] - h[i]);
}
cout << m;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, m = 2000000000;
cin >> n >> k;
int h[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
for (i = 0; i <= n - k; i++) {
m = min(m, h[i + k - 1] - h[i]);
}
cout << m;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.change"
] | 1,001,148 | 1,001,147 | u058348416 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using pi = pair<int32, int32>;
using pll = pair<int64, int64>;
using vi = vector<int32>;
using vvi = vector<vector<int32>>;
using vll = vector<int64>;
using l... | #include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using pi = pair<int32, int32>;
using pll = pair<int64, int64>;
using vi = vector<int32>;
using vvi = vector<vector<int32>>;
using vll = vector<int64>;
using l... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 1,001,165 | 1,001,166 | u572532976 | cpp |
p03208 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v),... | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v),... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,167 | 1,001,168 | u135572611 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <tuple>
#include <vector>
using namespace std;
void init();
#define REP(var, num) for (sll var = 0; var < num; var++)
typedef signed long long sll;
typedef unsigned long long ull;
/*
numeric_limits<sll>::max()
*/
int ma... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <tuple>
#include <vector>
using namespace std;
void init();
#define REP(var, num) for (sll var = 0; var < num; var++)
typedef signed long long sll;
typedef unsigned long long ull;
/*
numeric_limits<sll>::max()
*/
int ma... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,169 | 1,001,170 | u544156685 | cpp |
p03208 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1000000004;
int main() {
int N, K;
cin >> N >> K;
vector<int> hei(N);
for (int i = 0; i < N; i++) {
cin >> hei[i];
}
sort(hei.begin(), hei.end());
int ans = INF;
for (int i = 0; i < N - K; i++) {
int jun = hei[i + ... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1000000004;
int main() {
int N, K;
cin >> N >> K;
vector<int> hei(N);
for (int i = 0; i < N; i++) {
cin >> hei[i];
}
sort(hei.begin(), hei.end());
int ans = INF;
for (int i = 0; i < N - K + 1; i++) {
int jun = hei[... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,179 | 1,001,180 | u058186113 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
ll N, K, ans = 1000000000;
cin >> N >> K;
vector<ll> h(N, 0);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h.begin(), h.end());
for (int i... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string.h>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
ll N, K, ans = 1000000000;
cin >> N >> K;
vector<ll> h(N, 0);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h.begin(), h.end());
for (int i... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,181 | 1,001,182 | u831873811 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, k;
cin >> N >> k;
vector<long long int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
long long int min = vec[k - 1] - vec[0];
for (int i = 1; i < N - k; ... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, k;
cin >> N >> k;
vector<long long int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
long long int min = vec[k - 1] - vec[0];
for (int i = 1; i < N - k +... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,183 | 1,001,184 | u494928657 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
int mini = 1e9;
for (int i = 0; i <= n - k + 1; i++) {
mini = min(mi... | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
int mini = 1e9;
for (int i = 0; i <= n - k; i++) {
mini = min(mini, ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,001,189 | 1,001,190 | u136869985 | cpp |
p03208 | // encoding:utf-8
#include <algorithm> //sort とかにいる
#include <iostream> //c++
#include <math.h>
#include <queue> //キューに関して 最古のデータから捨てる
#include <stack> //スタックに関して 最新のデータから捨てる
#include <time.h> //時間にかんして
#include <vector>
#define ll long long
using namespace std;
int inf = INFINITY;
int main() {
int n, k;
cin >... | // encoding:utf-8
#include <algorithm> //sort とかにいる
#include <iostream> //c++
#include <math.h>
#include <queue> //キューに関して 最古のデータから捨てる
#include <stack> //スタックに関して 最新のデータから捨てる
#include <time.h> //時間にかんして
#include <vector>
#define ll long long
using namespace std;
int inf = INFINITY;
int main() {
int n, k;
cin >... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,197 | 1,001,198 | u059210959 | cpp |
p03208 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main() {
int n, k, m, s;
int h[100000];
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h, h + n);
m = (1 << 30);
for (int i = 0; i < n - k; i++) {
s = h[i + k - 1] -... | #include <algorithm>
#include <cstring>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main() {
int n, k, m, s;
int h[100000];
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
sort(h, h + n);
m = (1 << 30);
for (int i = 0; i < n - k + 1; i++) {
s = h[i + k - ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,207 | 1,001,208 | u192541825 | cpp |
p03208 | #include <algorithm>
#include <climits>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> inputs;
for (int i = 0; i < n; ++i) {
int input;
cin >> input;
inputs.push_back(input);
}
sort(inputs.begin(), inputs.end());
int min = INT_... | #include <algorithm>
#include <climits>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> inputs;
for (int i = 0; i < n; ++i) {
int input;
cin >> input;
inputs.push_back(input);
}
sort(inputs.begin(), inputs.end());
int min = INT_... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,211 | 1,001,212 | u829844117 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long int ll;
#define INF (1e9)
int N, K;
int main() {
cin >> N >> K;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end()... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long int ll;
#define INF (1e9)
int N, K;
int main() {
cin >> N >> K;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end()... | [
"variable_declaration.value.change"
] | 1,001,222 | 1,001,223 | u551373727 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#in... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#in... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change",
"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,001,226 | 1,001,227 | u134810655 | cpp |
p03208 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int compare_lld(const void *a, const void *b) {
long long int *A = (long long int *)a;
long long int *B = (long long int *)b;
if (*A > *B)
return 1;
if (*A < *B)
return -1;
return 0;
}
int main() {
long long int n, k, i;
scanf("%lld", &n... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int compare_lld(const void *a, const void *b) {
long long int *A = (long long int *)a;
long long int *B = (long long int *)b;
if (*A > *B)
return 1;
if (*A < *B)
return -1;
return 0;
}
int main() {
long long int n, k, i;
scanf("%lld", &n... | [
"control_flow.loop.for.condition.change"
] | 1,001,271 | 1,001,272 | u636273931 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> h(N), v(N - 1);... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<long long int> h(N), v(N - 1);... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,277 | 1,001,278 | u698142380 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> tree(N);
for (int i = 0; i < N; ++i)
cin >> tree.at(i);
sort(tree.begin(), tree.end());
int ans = 1000000;
for (int i = 0; i < N - K; ++i) {
int diff;
diff = tree.at(i + K - 1) - tree.at(i);
i... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> tree(N);
for (int i = 0; i < N; ++i)
cin >> tree.at(i);
sort(tree.begin(), tree.end());
int ans = 1000000000;
for (int i = 0; i < N - K + 1; ++i) {
int diff;
diff = tree.at(i + K - 1) - tree.at(i)... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,283 | 1,001,282 | u014655172 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(),... | #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(),... | [
"expression.operation.binary.add"
] | 1,001,288 | 1,001,289 | u518348232 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int n, k;
int h[100005];
vector<int> v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> h[i];
v.push_back(h[i]);
}
sort(v.begin(), v.end());
int answer = 100000000;
for (int i = 0; i < n - k; ++i) {
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int n, k;
int h[100005];
vector<int> v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> h[i];
v.push_back(h[i]);
}
sort(v.begin(), v.end());
int answer = 10000000000;
for (int i = 0; i < n - k + 1; ++... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,296 | 1,001,295 | u229235826 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k, i, ans;
cin >> n >> k;
vector<int> h(n);
for (i = 0; i < n; i++) {
cin >> h.at(i);
}
sort(h.begin(), h.end());
ans = 2000000000;
for (i = 0; i < n - k; i++) {
int h_min = h.a... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k, i, ans;
cin >> n >> k;
vector<int> h(n);
for (i = 0; i < n; i++) {
cin >> h.at(i);
}
sort(h.begin(), h.end());
ans = 2000000000;
for (i = 0; i < n - k + 1; i++) {
int h_min =... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,298 | 1,001,299 | u284092157 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k, i, ans;
cin >> n >> k;
vector<int> h(n);
for (i = 0; i < n; i++) {
cin >> h.at(i);
}
sort(h.begin(), h.end());
ans = 1000000000;
for (i = 0; i < n - k; i++) {
int h_min = h.a... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k, i, ans;
cin >> n >> k;
vector<int> h(n);
for (i = 0; i < n; i++) {
cin >> h.at(i);
}
sort(h.begin(), h.end());
ans = 2000000000;
for (i = 0; i < n - k + 1; i++) {
int h_min =... | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,300 | 1,001,299 | u284092157 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> v;
int tmp;
for (int i = 0; i < N; i++) {
cin >> tmp;
v.push_back(tmp);
}
sort(v.begin(), v.end());
int ans = pow(10, 9) - 1;
for (int i = K; i <=... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> v;
int tmp;
for (int i = 0; i < N; i++) {
cin >> tmp;
v.push_back(tmp);
}
sort(v.begin(), v.end());
int ans = pow(10, 9) - 1;
for (int i = K - 1; ... | [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,302 | 1,001,303 | u949406263 | cpp |
p03208 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define all(v) v.begin(... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define all(v) v.begin(... | [
"variable_declaration.value.change"
] | 1,001,308 | 1,001,309 | u675512317 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef unsigned long ul;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long> vl;
typedef vector<double> vd;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<... | #include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef unsigned long ul;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long> vl;
typedef vector<double> vd;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,314 | 1,001,315 | u741895052 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef unsigned long ul;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long> vl;
typedef vector<double> vd;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<... | #include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef unsigned long ul;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long> vl;
typedef vector<double> vd;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<... | [
"variable_declaration.type.change",
"variable_declaration.type.primitive.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,316 | 1,001,315 | u741895052 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
int main() {
int n, k;
vector<ll> vll;
cin >> n >> k;
rep(i, n) {
ll h;
cin >> h;
vll.push_back(h);
}
sort(vll.begin(), vl... | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
int main() {
int n, k;
vector<ll> vll;
cin >> n >> k;
rep(i, n) {
ll h;
cin >> h;
vll.push_back(h);
}
sort(vll.begin(), vl... | [
"assignment.change"
] | 1,001,323 | 1,001,324 | u934105772 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
cin >> n >> k;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
int diff = INT_MAX;
for (int i = 0; i < n; i++) {
diff = min(diff, v[i + k - 1] - v[i]);
}
cout << d... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
cin >> n >> k;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
int diff = INT_MAX;
for (int i = 0; i <= n - k; i++) {
diff = min(diff, v[i + k - 1] - v[i]);
}
cout... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,325 | 1,001,326 | u673058289 | cpp |
p03208 | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 5;
int arr[N], L[N], R[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
i... | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 5;
int arr[N], L[N], R[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,327 | 1,001,328 | u715191077 | cpp |
p03208 | #include <algorithm>
#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 mi = 1000000005;
for (int i = 1; i < n; i++) {
mi = min(mi, a[i] - a[i - 1]);
}
cout << mi;
return 0;
}
| #include <algorithm>
#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 mi = 1000000005;
for (int i = k - 1; i < n; i++) {
mi = min(mi, a[i] - a[i - k + 1]);
}
cout << mi;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"assignment.change"
] | 1,001,329 | 1,001,330 | u170464980 | cpp |
p03208 |
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define INF 2147483647
#define MODE 1
#if... |
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define INF 2147483647
#define MODE 1
#if... | [
"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,333 | 1,001,334 | u901561754 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long result = 0;
long N, K;
cin >> N >> K;
long h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
for (int i = 0; i < N - K; i++) {
if (i == 0 || h[K + i - 1] - h[i] < result) {
result = h[K + i - ... | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
long result = 0;
long N, K;
cin >> N >> K;
long h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
for (int i = 0; i < N - K + 1; i++) {
if (i == 0 || h[K + i - 1] - h[i] < result) {
result = h[K + ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,343 | 1,001,344 | u113589326 | cpp |
p03208 | #include <algorithm>
#include <assert.h>
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <iostream>
#include <map>
#include <math.h>
#include <memory.h>
#incl... | //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <iostream>
#include <map>
#include <math.h... | [
"assignment.change"
] | 1,001,353 | 1,001,354 | u957239743 | cpp |
p03208 | #include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
ll a[1005];
int Min = 0x3f3f3f3f;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (int i = ... | #include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
int a[100005];
int Min = 0x3f3f3f3f;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (int i... | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 1,001,362 | 1,001,363 | u566185387 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
#define OnlineJudge1
#define loop(a, n) for (int i = a; i < n; i++)
#define NumofDigits(n) ((int)log10(n) + 1)
#define CountofNumber(array, n, x) \
(upper_bound(array, array + n, x) - lower_bound(array, array + n, x))
#define ... | #include <bits/stdc++.h>
using namespace std;
#define OnlineJudge1
#define loop(a, n) for (int i = a; i < n; i++)
#define NumofDigits(n) ((int)log10(n) + 1)
#define CountofNumber(array, n, x) \
(upper_bound(array, array + n, x) - lower_bound(array, array + n, x))
#define ... | [
"control_flow.loop.for.condition.change"
] | 1,001,366 | 1,001,367 | u963606569 | cpp |
p03208 | /*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
... | /*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
... | [
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 1,001,372 | 1,001,373 | u010004797 | cpp |
p03208 | /*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
... | /*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
... | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 1,001,374 | 1,001,373 | u010004797 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int n, i, k, minn;
int a[100005];
int main() {
cin >> n >> k;
for (i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);
minn = a[k - 1] - a[0];
for (i = 0; i < n - k; ++i)
minn = min(minn, a[i + k - 1] - a[i]);
cout << minn << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, i, k, minn;
int a[100005];
int main() {
cin >> n >> k;
for (i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);
minn = a[k - 1] - a[0];
for (i = 0; i < n - k + 1; ++i)
minn = min(minn, a[i + k - 1] - a[i]);
cout << minn << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,389 | 1,001,390 | u018921758 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
vector<int> vec;
vector<int> sel;
int _min = INT_MAX;
int main() {
int n, k;
cin >> n >> k;
sel.resize(k);
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
for (int i = 0; i < n - k; i += k) {
_min = min(vec... | #include <bits/stdc++.h>
using namespace std;
vector<int> vec;
vector<int> sel;
int _min = INT_MAX;
int main() {
int n, k;
cin >> n >> k;
sel.resize(k);
vec.resize(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
for (int i = 0; i <= n - k; i++) {
_min = min(vec[i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,393 | 1,001,394 | u848676730 | cpp |
p03208 | #include <bits/stdc++.h>
void quick_sort(int a[], int left, int right) {
int pl, pr, pivot;
if (left >= right)
return;
pivot = a[(left + right) / 2];
pl = left;
pr = right;
while (pl <= pr) {
while (a[pl] < pivot)
pl++;
while (a[pr] > pivot)
pr--;
if (pl <= pr) {
int s = a... | #include <bits/stdc++.h>
void quick_sort(int a[], int left, int right) {
int pl, pr, pivot;
if (left >= right)
return;
pivot = a[(left + right) / 2];
pl = left;
pr = right;
while (pl <= pr) {
while (a[pl] < pivot)
pl++;
while (a[pr] > pivot)
pr--;
if (pl <= pr) {
int s = a... | [
"expression.operation.binary.add"
] | 1,001,395 | 1,001,396 | u792455295 | cpp |
p03208 | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for... | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for... | [
"preprocessor.define.value.change",
"literal.integer.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,405 | 1,001,406 | u504142483 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
#define ok1 printf... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
#define ok1 printf... | [
"expression.unary.arithmetic.add"
] | 1,001,410 | 1,001,411 | u373958718 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
#define ok1 printf... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
//#include<bits/stdc++.h>
using namespace std;
#define ok1 printf... | [
"expression.unary.arithmetic.add",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 1,001,412 | 1,001,411 | u373958718 | 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 Min = h[0];
for (int i = 0; i < N - K + 1; 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 Min = 1000000000;
for (int i = 0; i < N - K + 1; i++) {
// cout << h[i+K-1] << " " <... | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 1,001,415 | 1,001,416 | u201188078 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | [
"expression.operation.binary.add"
] | 1,001,419 | 1,001,420 | u271719815 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,421 | 1,001,422 | u271719815 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 1,001,423 | 1,001,422 | u271719815 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,424 | 1,001,422 | u271719815 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#inclu... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 1,001,425 | 1,001,422 | u271719815 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, K;
int trH[100001];
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> trH[i];
sort(trH, trH + N);
int min_d;
for (int f = 0; f < N - K + 1; ++f) {
int d = trH[f + K - 1] - trH[f];
if (d < min_d)
min_d = d;... | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, K;
int trH[100001];
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> trH[i];
sort(trH, trH + N);
int min_d = 1000000000;
for (int f = 0; f < N - K + 1; ++f) {
int d = trH[f + K - 1] - trH[f];
if (d < min_d)
... | [
"variable_declaration.value.change"
] | 1,001,435 | 1,001,436 | u521712919 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
int min = 1000000000;
for (int i = 0; i < n - k; i++) {
if (min > h[i + k - 1] - h[i])
min = h[i + k - 1] - h[i];
}
cout << min;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
int min = 1000000000;
for (int i = 0; i < n - k + 1; i++) {
if (min > h[i + k - 1] - h[i])
min = h[i + k - 1] - h[i];
}
cout << mi... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,447 | 1,001,448 | u717659249 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
int min = 1000000000;
for (int i = 0; i < n - k; i++) {
if (min > h[i + k] - h[i])
min = h[i + k] - h[i];
}
cout << min;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
int min = 1000000000;
for (int i = 0; i < n - k + 1; i++) {
if (min > h[i + k - 1] - h[i])
min = h[i + k - 1] - h[i];
}
cout << mi... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 1,001,449 | 1,001,448 | u717659249 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
typedef vector<ll> vi;
int main() {
ll N, K, tmp;
// ll max_v, min_v;
ll ans = 100000;
vi arr;
cin >> N >> K;
for (ll i = 0; i < N; i++) {
cin >> tmp;
arr.push_back(tmp);
}
sort(arr.begin(), a... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
typedef vector<ll> vi;
int main() {
ll N, K, tmp;
// ll max_v, min_v;
ll ans = 10000000000;
vi arr;
cin >> N >> K;
for (ll i = 0; i < N; i++) {
cin >> tmp;
arr.push_back(tmp);
}
sort(arr.begin... | [
"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,001,473 | 1,001,472 | u503052349 | cpp |
p03208 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define REP(i, N) for (int i = 0; i < N; i++)
using namespace std;
co... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define REP(i, N) for (int i = 0; i < N; i++)
using namespace std;
co... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,474 | 1,001,475 | u966854856 | cpp |
p03208 | #include <algorithm>
#include <iostream>
using namespace std;
const int INF = 1e9;
main() {
int N, K;
cin >> N >> K;
int h[N];
for (int ii = 0; ii < N; ii++) {
cin >> h[ii];
}
sort(h, h + N);
// reverse(h.begin(),h.end());
int ans = INF;
/* for(int ii=0;ii<N;ii++){
cout << h[ii] << endl;
... | #include <algorithm>
#include <iostream>
using namespace std;
const int INF = 1e9;
main() {
int N, K;
cin >> N >> K;
int h[N];
for (int ii = 0; ii < N; ii++) {
cin >> h[ii];
}
sort(h, h + N);
// reverse(h.begin(),h.end());
int ans = INF;
/* for(int ii=0;ii<N;ii++){
cout << h[ii] << endl;
... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,480 | 1,001,481 | u346834985 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K, Min = 1000000000;
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
for (int i = 0; i <= N - K; i++) {
Min = min(Min, h[i + 2] - h[i]);
}
cou... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K, Min = 1000000000;
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
sort(h.begin(), h.end());
for (int i = 0; i <= N - K; i++) {
Min = min(Min, h[i + K - 1] - h[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,001,482 | 1,001,483 | u863044225 | cpp |
p03208 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
long min = 10000000000000;
cin >> N;
cin >> K;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h.begin()... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
long min = 10000000000000;
cin >> N;
cin >> K;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h.begin()... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,001,512 | 1,001,513 | u632953276 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
int ans = 1000000001;
for (int i = 0; i < N - K; i++) {
ans = min(h[i + K - 1] - h[i], ans);
}
cout ... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
int ans = 1000000001;
for (int i = 0; i <= N - K; i++) {
ans = min(h[i + K - 1] - h[i], ans);
}
cout... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,516 | 1,001,517 | u994577348 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
#define MAX 10001
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int h[MAX];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
int ans = 1000000001;
for (int i = 0; i < N - K; i++) {
ans = min(h[i + K - 1] - h[i... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
int ans = 1000000001;
for (int i = 0; i <= N - K; i++) {
ans = min(h[i + K - 1] - h[i], ans);
}
cout... | [
"identifier.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,519 | 1,001,517 | u994577348 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#define MAX 10001
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int h[MAX];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
int ans = 1000000001;
for (int i = 0; i < N - K; i++) {
ans = min(h[i + K - 1] - h[i], ans);
}
cout... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
int ans = 1000000001;
for (int i = 0; i <= N - K; i++) {
ans = min(h[i + K - 1] - h[i], ans);
}
cout... | [
"identifier.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,520 | 1,001,517 | u994577348 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5;
int p[mxn + 11];
int main() {
// freopen("input.txt", "r", stdin);
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
}
sort(p, p + n);
int ans = INT_MAX;
for (int i = 0; i < n - k; i++) {
ans ... | #include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5;
int p[mxn + 11];
int main() {
// freopen("input.txt", "r", stdin);
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
}
sort(p, p + n);
int ans = INT_MAX;
for (int i = 0; i <= n - k; i++) {
ans... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,527 | 1,001,528 | u142832918 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
int minh = 1000000;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
sort(h.begin(), h.end());
for (int i = 0; i < n - k; ++i) {
minh = min(minh, ... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
int minh = 100000000000;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
sort(h.begin(), h.end());
for (int i = 0; i < n - k + 1; ++i) {
minh = m... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,537 | 1,001,536 | u999803454 | cpp |
p03208 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
vector<ll> a;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a.begin(), a.end());
ll mininum = a[n - 1] - a[0];
for (int i = 0; i ... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
vector<ll> a;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a.begin(), a.end());
ll mininum = a[n - 1] - a[0];
for (int i = 0; i ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,539 | 1,001,540 | u416434647 | cpp |
p03208 | /**
* File : c.cpp
* Author : recurze
* Date : 21:16 18.01.2019
* Last Modified Date: 21:18 18.01.2019
*/
#include <algorithm>
#include <limits.h>
#include <stdio.h>
void readInput();
void solve();
void printAns();
int main() {
int t = 1;
// scanf("%d", &t);
for (int t... | /**
* File : c.cpp
* Author : recurze
* Date : 21:16 18.01.2019
* Last Modified Date: 21:19 18.01.2019
*/
#include <algorithm>
#include <limits.h>
#include <stdio.h>
void readInput();
void solve();
void printAns();
int main() {
int t = 1;
// scanf("%d", &t);
for (int t... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,545 | 1,001,546 | u811925505 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
int ans = 0x7fffffff;
for (int i = 1; i <= n - k + 1; i++)
if ((a[n - k + 1] - a[i]) < ans)
ans = a[i + k - 1] - a[i];
cout <<... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
int ans = 0x7fffffff;
for (int i = 1; i <= n - k + 1; i++)
if ((a[i + k - 1] - a[i]) < ans)
ans = a[i + k - 1] - a[i];
cout <<... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,001,547 | 1,001,548 | u504403442 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
int ans = 0x7fffffff;
for (int i = 1; i <= n - k + 1; i++)
if ((a[i + k - 1] - a[i]) < ans)
ans = a[n - k + 1] - a[i];
cout <<... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
int ans = 0x7fffffff;
for (int i = 1; i <= n - k + 1; i++)
if ((a[i + k - 1] - a[i]) < ans)
ans = a[i + k - 1] - a[i];
cout <<... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"assignment.change"
] | 1,001,549 | 1,001,548 | u504403442 | cpp |
p03208 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#include <numeric>
#include <sstream>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
struct point {
int x;
int y;
};
int gcd(int m, int n) {
// 引数に０がある場合は０を返す
if ((0 == m) || (0 == n... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#include <numeric>
#include <sstream>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
struct point {
int x;
int y;
};
int gcd(int m, int n) {
// 引数に０がある場合は０を返す
if ((0 == m) || (0 == n... | [
"variable_declaration.type.primitive.change"
] | 1,001,565 | 1,001,566 | u334656323 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int h[100001];
int n, k;
int min_h = INT_MAX;
cin >> n >> k;
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(min_h, h[i + 2] - h[i]);
}
cout << min_h << '\n';
retu... | #include <bits/stdc++.h>
using namespace std;
int main() {
int h[100001];
int n, k;
int min_h = INT_MAX;
cin >> n >> k;
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(min_h, h[i + k - 1] - h[i]);
}
cout << min_h << '\n';
... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"assignment.c... | 1,001,572 | 1,001,573 | u517309493 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
scanf("%d%d", &N, &K);
int h[N];
for (int i = 0; i < N; i++) {
scanf("%d", &h[i]);
}
sort(h, h + N);
int dmin = INT_MAX;
for (int i = 0; i < N - K; i++) {
if (h[i + K - 1] - h[i] < dmin) {
dmin = h[i + K - 1] - h... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
scanf("%d%d", &N, &K);
int h[N];
for (int i = 0; i < N; i++) {
scanf("%d", &h[i]);
}
sort(h, h + N);
int dmin = INT_MAX;
for (int i = 0; i <= N - K; i++) {
if (h[i + K - 1] - h[i] < dmin) {
dmin = h[i + K - 1] - ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,588 | 1,001,589 | u519655118 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
int min = v[k - 1] - v[0];
for (int i = k; i < n; ++i) {
int tmp = v[i] - v[i - 2];
if ... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; ++i)
cin >> v[i];
sort(v.begin(), v.end());
int min = v[k - 1] - v[0];
for (int i = k; i < n; ++i) {
int tmp = v[i] - v[i - k + 1];
... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,001,592 | 1,001,593 | u964185015 | cpp |
p03208 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >> h.at(i);
}
sort(h.begin(), h.end());
int gap = 1000000000;
for (int i = K - 1; i < N - 1; i++) {
if (h.at(i) - h.at(i - K + 1) < gap)... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >> h.at(i);
}
sort(h.begin(), h.end());
int gap = 1000000000;
for (int i = K - 1; i < N; i++) {
if (h.at(i) - h.at(i - K + 1) < gap) {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,001,596 | 1,001,597 | u752170301 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, K;
vector<ll> tree;
cin >> N >> K;
tree.resize(N, 0);
for (ll i = 0; i < N; ++i)
cin >> tree[i];
sort(tree.begin(), tree.end());
ll min = 10000000000;
for (ll i = 0; i + K... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, K;
vector<ll> tree;
cin >> N >> K;
tree.resize(N, 0);
for (ll i = 0; i < N; ++i)
cin >> tree[i];
sort(tree.begin(), tree.end());
ll res = 10000000000;
for (ll i = 0; i + K... | [
"variable_declaration.name.change",
"identifier.change",
"assignment.variable.change",
"call.arguments.add",
"io.output.change"
] | 1,001,598 | 1,001,599 | u045291627 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i)... | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i)... | [
"expression.operation.binary.add"
] | 1,001,600 | 1,001,601 | u480831358 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i)... | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i)... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,602 | 1,001,601 | u480831358 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <limits>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
static int imin = std::numeric_limits<int>::min();
static int imax = std::numeric_limits<int>::max();
#define ll long long
#define rep(i, n) for (int i = 0... | #include <algorithm>
#include <iostream>
#include <limits>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
static int imin = std::numeric_limits<int>::min();
static int imax = std::numeric_limits<int>::max();
#define ll long long
#define rep(i, n) for (int i = 0... | [] | 1,001,618 | 1,001,619 | u068362919 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
long h[100000];
cin >> n >> k;
for (size_t i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
int min = 10000000000;
int sub;
for (size_t i = 0; i < n - k; i++) {
sub = h[i + k - 1] - h[i];
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
long h[100000];
cin >> n >> k;
for (size_t i = 0; i < n; i++) {
cin >> h[i];
}
sort(h, h + n);
int min = 10000000000;
int sub;
for (size_t i = 0; i < n - k + 1; i++) {
sub = h[i + k - 1] - h[... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,632 | 1,001,633 | u817999507 | cpp |
p03208 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int N, K;
int h[100000];
int ans = 1000000000;
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
for (int i = 0; i < N - K; i++) {
ans = min(ans, h[i + K - 1] - h[... | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
int N, K;
int h[100000];
int ans = 1000000000;
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
sort(h, h + N);
for (int i = 0; i <= N - K; i++) {
ans = min(ans, h[i + K - 1] - h... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,642 | 1,001,643 | u094718623 | cpp |
p03208 | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = n - 1; i >= m; i--)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1... | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = n - 1; i >= m; i--)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1... | [
"literal.number.change",
"assignment.variable.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,001,646 | 1,001,647 | u107995903 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans = 1123456789, ar[123456];
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> ar[i];
sort(ar, ar + n);
for (int i = 0; i < n - k; i++)
ans = min(ar[i + (k - 1)] - ar[i], ans);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans = 1123456789, ar[123456];
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> ar[i];
sort(ar, ar + n);
for (int i = 0; i <= n - k; i++)
ans = min(ar[i + (k - 1)] - ar[i], ans);
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,665 | 1,001,666 | u414768457 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,679 | 1,001,680 | u906208439 | cpp |
p03208 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define rer(i, a, b) for (int i = int(a) - 1; i >= int(b); i--)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, K;... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define rer(i, a, b) for (int i = int(a) - 1; i >= int(b); i--)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, K;... | [
"expression.operation.binary.add"
] | 1,001,683 | 1,001,684 | u235155157 | cpp |
p03208 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define mp make_pair
#define pb push_back
#define re return
#define... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define mp make_pair
#define pb push_back
#define re return
#define... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,001,687 | 1,001,688 | u247996218 | cpp |
p03208 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define all(a) (a).begin(), (a).end()
int main() {
int n, k;
cin >> n >> k;
vector<LL> h(n);
rep(i, n) cin >> h[i];
sort(all(h));
LL ans = 1010101... | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define all(a) (a).begin(), (a).end()
int main() {
int n, k;
cin >> n >> k;
vector<LL> h(n);
rep(i, n) cin >> h[i];
sort(all(h));
LL ans = 1010101... | [
"expression.operation.binary.remove",
"assignment.change"
] | 1,001,689 | 1,001,690 | u996252264 | cpp |
p03208 | #include <bits/stdc++.h>
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
ll ans = INF;
for (int... | #include <bits/stdc++.h>
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
ll ans = INF;
for (int... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,001,709 | 1,001,710 | u869282786 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.