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 |
|---|---|---|---|---|---|---|---|
p03075 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
//#pragma GCC optimize ("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(fals... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
//#pragma GCC optimize ("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(fals... | [
"call.remove",
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"call.add"
] | 888,729 | 888,730 | u141378465 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, ... | [
"literal.string.change",
"io.output.change"
] | 888,733 | 888,734 | u277556971 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int A[5];
int K;
REP(i, 5) cin >> A[i];
puts(A[4] - A[0] <= K ? "Yay!" : ":(");
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int A[5];
int K;
REP(i, 5) cin >> A[i];
cin >> K;
puts(A[4] - A[0] <= K ? "Yay!" : ":(");
}
| [] | 888,755 | 888,756 | u006493569 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], k, c = 0;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (abs(a[i] - a[j]) > k)
c++;
}
}
if (c == 0)
cout << "Yey!" << endl;
else... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], k, c = 0;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (abs(a[i] - a[j]) > k)
c++;
}
}
if (c == 0)
cout << "Yay!" << endl;
else... | [
"literal.string.change",
"io.output.change"
] | 888,757 | 888,758 | u565219356 | cpp |
p03075 | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast ... | #include <bits/stdc++.h>
#define N 1000005
#define ll long long int
#define MP make_pair
#define pb push_back
#define ppb pop_back
#define sp " "
#define endl "\n"
#define fi first
#define se second
#define ii pair<int, int>
#define lli pair<ll, ll>
#define fast ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,772 | 888,773 | u533101919 | cpp |
p03075 | #include <iostream>
#include <string>
using namespace std;
int main(void) {
// Your code here!
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
if (k <= e - a) {
ans = "Yay!";
} else {
ans = ":(";
}
//出力
cout << ans << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main(void) {
// Your code here!
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
if (k >= e - a) {
ans = "Yay!";
} else {
ans = ":(";
}
//出力
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,774 | 888,775 | u782295629 | cpp |
p03075 | #include <iostream>
#include <string>
using namespace std;
int main(void) {
// Your code here!
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
if (k < e - a) {
ans = "Yay!";
} else {
ans = ":(";
}
//出力
cout << ans << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main(void) {
// Your code here!
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
if (k >= e - a) {
ans = "Yay!";
} else {
ans = ":(";
}
//出力
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,777 | 888,775 | u782295629 | cpp |
p03075 | #include <iostream>
#include <string>
using namespace std;
int main(void) {
// Your code here!
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
if (k > e - a) {
ans = "Yay!";
} else {
ans = ":(";
}
//出力
cout << ans << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main(void) {
// Your code here!
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
if (k >= e - a) {
ans = "Yay!";
} else {
ans = ":(";
}
//出力
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,778 | 888,775 | u782295629 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
cout << (e - a < k ? "Yay!" : ":(") << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
cout << (e - a <= k ? "Yay!" : ":(") << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"io.output.change"
] | 888,783 | 888,784 | u701743518 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int a[5];
int k;
int main() {
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
if (a[4] - a[0] > k)
cout << ":(" << endl;
cout << "Yay!" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int a[5];
int k;
int main() {
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
if (a[4] - a[0] > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 888,787 | 888,788 | u693953100 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int x[5], k;
bool ok = 0;
cin >> x[0] >> x[1] >> x[2] >> x[3] >> x[4] >> k;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
if (abs(x[i] - x[j]) >= k)
ok = 1;
if (ok)
cout << ":(";
else
cout << "Yay!";
return 0;... | #include <bits/stdc++.h>
using namespace std;
int main() {
int x[5], k;
bool ok = 0;
cin >> x[0] >> x[1] >> x[2] >> x[3] >> x[4] >> k;
for (int i = 0; i < 5; ++i)
for (int j = i + 1; j < 5; ++j)
if (abs(x[i] - x[j]) > k)
ok = 1;
if (ok)
cout << ":(";
else
cout << "Yay!";
return... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,806 | 888,807 | u992218377 | cpp |
p03075 | #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define N_MAX (100000)
#define LL_MAX_NUM (1LL << 60)
#define INF... | #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define N_MAX (100000)
#define LL_MAX_NUM (1LL << 60)
#define INF... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 888,820 | 888,821 | u221174888 | cpp |
p03075 | #include <iostream>
int main(void) {
int a[6] = {0};
for (int i = 0; i < 6; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < 5; ++i) {
for (int j = i + 1; j < 5; ++i) {
if (abs(a[i] - a[j]) > a[5]) {
printf(":(");
return 0;
}
}
}
printf("Yay!");
return 0;
}
| #include <iostream>
int main(void) {
int a[6] = {0};
for (int i = 0; i < 6; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < 5; ++i) {
for (int j = i + 1; j < 5; ++j) {
if (abs(a[j] - a[i]) > a[5]) {
printf(":(");
return 0;
}
}
}
printf("Yay!");
return 0;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 888,830 | 888,831 | u757851362 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, k;
int main() {
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << ":(";
else
cout << "yay";
} | #include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, k;
int main() {
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << ":(";
else
cout << "Yay!";
} | [
"literal.string.change",
"io.output.change"
] | 888,850 | 888,851 | u068958382 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
int sum = 0;
sum = e - a;
if (sum < k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
int sum = 0;
sum = e - a;
if (sum <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,860 | 888,861 | u580418790 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
int sum = 0;
sum = e - a;
if (sum > k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
int sum = 0;
sum = e - a;
if (sum <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,862 | 888,861 | u580418790 | cpp |
p03075 | // Author: Rahul Purohit
#include <bits/stdc++.h>
#define vi vector<int>
#define rep(i, a, b) for (ll i = a; i < b; ++i)
#define ll long long int
#define pi pair<ll, ll>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
int gcd(i... | // Author: Rahul Purohit
#include <bits/stdc++.h>
#define vi vector<int>
#define rep(i, a, b) for (ll i = a; i < b; ++i)
#define ll long long int
#define pi pair<ll, ll>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
int gcd(i... | [
"literal.string.change",
"io.output.change"
] | 888,891 | 888,892 | u707655771 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define sz size
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define FORN(i, a, b) for (int i = a; i <= b; i++)
#define FORRN(i, a, b) for (int i = (a); i >= (b); i--)
#define FORR(i, a, b) fo... | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define sz size
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define FORN(i, a, b) for (int i = a; i <= b; i++)
#define FORRN(i, a, b) for (int i = (a); i >= (b); i--)
#define FORR(i, a, b) fo... | [
"control_flow.branch.if.condition.change"
] | 888,899 | 888,900 | u921592714 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= k)
cout << ":(" << endl;
else {
cout << "Yay!" << endl;
}
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << ":(" << endl;
else {
cout << "Yay!" << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,917 | 888,918 | u207521866 | cpp |
p03075 | #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
int a, e, k;
scanf("%d%d%d%d%d%d", &a, &e, &e, &e, &e, &k);
if (e - a <= k)
puts("Yey!");
else
puts(":(");
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main() {
int a, e, k;
scanf("%d%d%d%d%d%d", &a, &e, &e, &e, &e, &k);
if (e - a <= k)
puts("Yay!");
else
puts(":(");
return 0;
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 888,921 | 888,922 | u858766837 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
int diff;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
diff = a[4] - a[0];
if (diff < k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
int diff;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
diff = a[4] - a[0];
if (diff <= k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,927 | 888,928 | u768301880 | cpp |
p03075 | // ----------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <que... | // ----------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <que... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"expression.off_by_one"
] | 888,939 | 888,940 | u335104842 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a, b, k;
cin >> a >> b >> b >> b >> b >> k;
if (b - a > k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a, b, k;
cin >> a >> b >> b >> b >> b >> k;
if (b - a > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
return 0;
} | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 888,941 | 888,942 | u787420015 | cpp |
p03075 | #include <stdio.h>
int main(void) {
int a, b, c, d, e, k, x = 0;
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &k);
if (k > e - a) {
x = 1;
}
if (x == 0) {
printf("Yay!");
} else {
printf(":(");
}
return 0;
} | #include <stdio.h>
int main(void) {
int a, b, c, d, e, k, x = 0;
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &k);
if (k < e - a) {
x = 1;
}
if (x == 0) {
printf("Yay!");
} else {
printf(":(");
}
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,943 | 888,944 | u316046218 | cpp |
p03075 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <time.h>
#include <tup... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <time.h>
#include <tup... | [
"literal.string.change",
"call.arguments.change"
] | 888,954 | 888,955 | u399527088 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
// 今回はa<b<c<・・・<e
// 最大値であるaとeの距離がk以下ならok
if (a[0] - a[4] < k and a[0] - a[4] > -k) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
// 今回はa<b<c<・・・<e
// 最大値であるaとeの距離がk以下ならok
if (a[0] - a[4] <= k and a[0] - a[4] >= -k) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,976 | 888,977 | u934246119 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a, tmp, e, k;
cin >> a >> tmp >> tmp >> tmp >> e >> k;
if ((e - a) >= k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
}
| #include <iostream>
using namespace std;
int main() {
int a, tmp, e, k;
cin >> a >> tmp >> tmp >> tmp >> e >> k;
if ((e - a) > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 888,990 | 888,991 | u393637574 | cpp |
p03075 | #include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> ant;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
ant.push_back(x);
}
int num = 0;
for (int j = 0; j < 4; j++) {
for (int k = j + 1; k < 4; k++) {
if (ant[k] - ant[j] > ant[5]) {
num = num + 1;
... | #include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> ant;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
ant.push_back(x);
}
int num = 0;
for (int j = 0; j < 4; j++) {
for (int k = j + 1; k < 5; k++) {
if (ant[k] - ant[j] > ant[5]) {
num = num + 1;
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 888,992 | 888,993 | u196746947 | cpp |
p03075 | #include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> ant;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
ant.push_back(x);
}
int num = 0;
for (int j = 0; j < 4; j++) {
for (int k = j; k < 4; k++) {
if (ant[k] - ant[j] > ant[5]) {
num = num + 1;
... | #include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> ant;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
ant.push_back(x);
}
int num = 0;
for (int j = 0; j < 4; j++) {
for (int k = j + 1; k < 5; k++) {
if (ant[k] - ant[j] > ant[5]) {
num = num + 1;
... | [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 888,994 | 888,993 | u196746947 | cpp |
p03075 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
ve... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
ve... | [
"literal.string.change",
"io.output.change"
] | 889,001 | 889,002 | u577189232 | cpp |
p03075 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
ve... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
ve... | [
"literal.number.change",
"call.arguments.change",
"literal.string.change",
"io.output.change"
] | 889,003 | 889,002 | u577189232 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (d - a > k)
cout << ":(\n";
else
cout << "Yay!\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << ":(\n";
else
cout << "Yay!\n";
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 889,009 | 889,010 | u608850287 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) REP(i, 0, n)
#define REP(i, a, n) for (int i = (a); i < (n); i++)
int main() {
int a, e, k;
cin >> a;
rep(i, 4) cin >> e;
cout << (e - a > k ? ":(" : "Yay!") << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) REP(i, 0, n)
#define REP(i, a, n) for (int i = (a); i < (n); i++)
int main() {
int a, e, k;
cin >> a;
rep(i, 4) cin >> e;
cin >> k;
cout << (e - a > k ? ":(" : "Yay!") << endl;
} | [] | 889,015 | 889,016 | u227951688 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int A[6], k;
int main(void) {
for (int i = 0; i < 5; i++)
cin >> A[i];
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(A[j] - A[i]) > k) {
cout << ":(" << endl;
exit(0);
}
}
}
cout << "Yah!"... | #include <bits/stdc++.h>
using namespace std;
int A[6], k;
int main(void) {
for (int i = 0; i < 5; i++)
cin >> A[i];
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(A[j] - A[i]) > k) {
cout << ":(" << endl;
exit(0);
}
}
}
cout << "Yay!"... | [
"literal.string.change",
"io.output.change"
] | 889,022 | 889,023 | u902337825 | cpp |
p03075 | #include "bits/stdc++.h"
using namespace std;
#define int long long
#define endl '\n'
int mod = 1e9 + 7;
int mod2 = 998244353;
const int INF = 1e9;
signed main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
int x = e - a;
if (x > k)
cout << ":(" << endl;
cout << "Yay!" << endl;
}
// `.`..`... | #include "bits/stdc++.h"
using namespace std;
#define int long long
#define endl '\n'
int mod = 1e9 + 7;
int mod2 = 998244353;
const int INF = 1e9;
signed main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
int x = e - a;
if (x > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
}
... | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 889,036 | 889,037 | u890465662 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if ((e - a) < k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if ((e - a) <= k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,039 | 889,040 | u416758623 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
using namespace std;
typedef long long ll;
const int maxx = 1e6 + 5;
int main() {
int n, m, i, j, flag;
int a[6];
for (i = 0; i < ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
using namespace std;
typedef long long ll;
const int maxx = 1e6 + 5;
int main() {
int n, m, i, j, flag;
int a[6];
for (i = 0; i < ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,047 | 889,048 | u560140313 | cpp |
p03075 | #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 <utility>
#in... | #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 <utility>
#in... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,049 | 889,050 | u294531924 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// d... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// d... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,053 | 889,054 | u355254193 | cpp |
p03075 | #include <stdio.h>
int main() {
int a[5] = {}, M = 0, S = 0, k, ans;
for (int i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &k);
ans = a[4] - a[0];
if (ans < k)
printf("Yay!\n");
else
printf(":(\n");
} | #include <stdio.h>
int main() {
int a[5] = {}, M = 0, S = 0, k, ans;
for (int i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &k);
ans = a[4] - a[0];
if (ans <= k)
printf("Yay!\n");
else
printf(":(\n");
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,062 | 889,063 | u189961895 | cpp |
p03075 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,076 | 889,077 | u281384315 | cpp |
p03075 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define X first
#define Y second
#define vsort(v) sort(v.begin(), v.end())
#define vrev(v) reverse(v.begin(), v.end())
#define P pair
// stoi(s): string to i... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define X first
#define Y second
#define vsort(v) sort(v.begin(), v.end())
#define vrev(v) reverse(v.begin(), v.end())
#define P pair
// stoi(s): string to i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,086 | 889,087 | u493080913 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,090 | 889,091 | u571305142 | cpp |
p03075 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;
template <typename T> vector<T> make_v(size_t a, T b) {
return vector<T>(a, b);
}
template <typenam... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;
template <typename T> vector<T> make_v(size_t a, T b) {
return vector<T>(a, b);
}
template <typenam... | [
"call.arguments.add"
] | 889,092 | 889,093 | u772304668 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1e9;
const int MOD = INF + 7;
#define rep(i, N) for (int(i) = 0; (i) < (N); ++(i))
#define rrep(i, N) for (int(i) = (N - 1); (i) > 0; --i)
#define FOR(i, j, N) for (int(i) = (j); (i) < (N); ++(i))
#define put(n) cout << (n) << endl;
#de... | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1e9;
const int MOD = INF + 7;
#define rep(i, N) for (int(i) = 0; (i) < (N); ++(i))
#define rrep(i, N) for (int(i) = (N - 1); (i) > 0; --i)
#define FOR(i, j, N) for (int(i) = (j); (i) < (N); ++(i))
#define put(n) cout << (n) << endl;
#de... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,094 | 889,095 | u031178961 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const ll mo = 1000000007;
string ans;
ll dp[0][0];
int main() {
ll a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a >= k) {
ans = ":(";
} else {
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const ll mo = 1000000007;
string ans;
ll dp[0][0];
int main() {
ll a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
ans = ":(";
} else {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,100 | 889,101 | u419307948 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) \
vector<vector<int>> vec(n, vector<int>(m... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) \
vector<vector<int>> vec(n, vector<int>(m... | [
"variable_declaration.value.change"
] | 889,110 | 889,111 | u776194115 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a >= k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,112 | 889,113 | u338520482 | cpp |
p03075 | #include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int ante[5];
for (int i = 0; i < 5; i++) {
cin >> ante[i];
}
int k;
cin >> k;
int ju = 0;
for (int i = 0; i < 5; i++) {
for (int j = i; j < 5; j++) {
if (ante[j] - ante[i] >= k)
... | #include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int ante[5];
for (int i = 0; i < 5; i++) {
cin >> ante[i];
}
int k;
cin >> k;
int ju = 0;
for (int i = 0; i < 5; i++) {
for (int j = i; j < 5; j++) {
if (ante[j] - ante[i] > k)
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,114 | 889,115 | u942868002 | cpp |
p03075 | #include <iostream>
int main() {
int a[5];
for (int i = 0; i < 5; ++i)
std::cin >> a[i];
int k;
std::cin >> k;
for (int i = 0; i < 3; ++i) {
for (int j = i + 1; j < 4; ++j) {
if (a[j] - a[i] > k) {
std::cout << ":(" << std::endl;
return 0;
}
}
}
std::cout << "Yay... | #include <iostream>
int main() {
int a[5];
for (int i = 0; i < 5; ++i)
std::cin >> a[i];
int k;
std::cin >> k;
for (int i = 0; i < 4; ++i) {
for (int j = i + 1; j < 5; ++j) {
if (a[j] - a[i] > k) {
std::cout << ":(" << std::endl;
return 0;
}
}
}
std::cout << "Yay... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,120 | 889,121 | u047150897 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define all(x) x.begin(), x.end()
#define pb push_back
#define ff first
#define ss second
#define pii pair<int, int>
#define vi vector<int>
#define vc vector<char>
#define vii vector<pii>
#define vvi vector<vi>
#define fori(i, n) for (int i = 1; i <= n; +... | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define all(x) x.begin(), x.end()
#define pb push_back
#define ff first
#define ss second
#define pii pair<int, int>
#define vi vector<int>
#define vc vector<char>
#define vii vector<pii>
#define vvi vector<vi>
#define fori(i, n) for (int i = 1; i <= n; +... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 889,126 | 889,127 | u964299793 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int lst[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> lst[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; i < 5; j++) {
if (lst[j] - lst[i] > k) {
cout << ":(";
return EXIT_SUCCESS;
}
}
}
c... | #include <iostream>
using namespace std;
int main() {
int lst[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> lst[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (lst[j] - lst[i] > k) {
cout << ":(";
return EXIT_SUCCESS;
}
}
}
c... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 889,128 | 889,129 | u917557045 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
int main() {
int a, b, c, d, e, k;
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &k);
if (e - a < k) {
printf("Yay!");
} else {
printf(":(");
}
} | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
int main() {
int a, b, c, d, e, k;
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &k);
if (e - a <= k) {
printf("Yay!");
} else {
printf(":(");
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,132 | 889,133 | u457644358 | cpp |
p03075 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int num[5... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int num[5... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,134 | 889,135 | u814440174 | cpp |
p03075 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll a[6], f;
ll i, j;
int main() {
fornum(i, 0, 6) { scanf("%lld", &a[i]);... | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
ll a[6], f;
ll i, j;
int main() {
fornum(i, 0, 6) { scanf("%lld", &a[i]);... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 889,136 | 889,137 | u259396003 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5], k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
if (a[4] - a[0] > k) {
cout << ":(" << endl;
} else {
cout << "Yay" << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
if (a[4] - a[0] > k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | [
"literal.string.change",
"io.output.change"
] | 889,140 | 889,141 | u693133807 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5], k;
for (int i = 0; i < 5; ++i)
cin >> a[i];
cin >> k;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5 - i; ++i) {
if (a[i + j] - a[i] > k) {
cout << ":(" << endl;
return 0;
}
}
cout << "Yay!" << endl;
... | #include <iostream>
using namespace std;
int main() {
int a[5], k;
for (int i = 0; i < 5; ++i)
cin >> a[i];
cin >> k;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5 - i; ++j) {
if (a[i + j] - a[i] > k) {
cout << ":(" << endl;
return 0;
}
}
cout << "Yay!" << endl;
... | [
"identifier.change"
] | 889,143 | 889,144 | u698883164 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<ll, ll>;
static ll imin = std::numeric_limits<ll>::... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using ll = long long;
using namespace std;
using P = pair<ll, ll>;
static ll imin = std::numeric_limits<ll>::... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,145 | 889,146 | u068362919 | cpp |
p03075 | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
const int INF = 100000001;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
... | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
const int INF = 100000001;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 889,147 | 889,148 | u244834838 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define cc(x) cout << (x) << endl
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
typedef long long ll;
template <typename T, typename U> inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typen... | #include <bits/stdc++.h>
using namespace std;
#define cc(x) cout << (x) << endl
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
typedef long long ll;
template <typename T, typename U> inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typen... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,149 | 889,150 | u654470292 | cpp |
p03075 | #include <algorithm>
#include <cassert>
#include <climits>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define all(x) begin(x), end(x)
using namespace std;
using ll = long long;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >>... | #include <algorithm>
#include <cassert>
#include <climits>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define all(x) begin(x), end(x)
using namespace std;
using ll = long long;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >>... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,155 | 889,156 | u393187783 | cpp |
p03075 | /*input
*/
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define pb push_back
#define pp pop_back
#define nl cout << "\n"
... | /*input
*/
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define pb push_back
#define pp pop_back
#define nl cout << "\n"
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,157 | 889,158 | u464574147 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int main() {
int a[5];
for (int i = 0; i < 5; i++) {
... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int main() {
int a[5];
for (int i = 0; i < 5; i++) {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,166 | 889,167 | u024764559 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
cout << "Yay!";
} else {
cout << ":(";
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
cout << ":(";
} else {
cout << "Yay!";
}
} | [
"literal.string.change",
"io.output.change"
] | 889,182 | 889,183 | u325573017 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
cout << (k <= (e - a) ? ":(" : "Yay!");
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
cout << (k < (e - a) ? ":(" : "Yay!");
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"io.output.change"
] | 889,184 | 889,185 | u210718367 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
cout << (k > (e - a) ? ":(" : "Yay!");
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
cout << (k < (e - a) ? ":(" : "Yay!");
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 889,186 | 889,185 | u210718367 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
int distance;
bool flg = true;
int i, j;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
distance = a[i] - a[j];
if (distance > k) {
... | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
int distance;
bool flg = true;
int i, j;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
distance = a[j] - a[i];
if (distance > k) {
... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"literal.string.change",
"io.output.change"
] | 889,196 | 889,197 | u828664775 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
int distance;
bool flg = true;
int i, j;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
distance = a[j] - a[i];
if (distance > k) {
... | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
int distance;
bool flg = true;
int i, j;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
distance = a[j] - a[i];
if (distance > k) {
... | [
"literal.string.change",
"io.output.change"
] | 889,198 | 889,197 | u828664775 | cpp |
p03075 | #include <iostream>
using namespace std;
int main(void) {
int a[5], k;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
for (int i = 0; i < 4; i++) {
for (int j = i; j < 5; j++) {
if (k < a[j] - a[i]) {
cout << ":)" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
ret... | #include <iostream>
using namespace std;
int main(void) {
int a[5], k;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
for (int i = 0; i < 4; i++) {
for (int j = i; j < 5; j++) {
if (k < a[j] - a[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
ret... | [
"literal.string.change",
"io.output.change"
] | 889,204 | 889,205 | u940000534 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
string ans;
if ((e - a) < k)
ans = "Yay!";
else
ans = ":(";
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
string ans;
if ((e - a) <= k)
ans = "Yay!";
else
ans = ":(";
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,206 | 889,207 | u351482714 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
//入力
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
int L = e - a;
if (L > k)
ans = "Yay!";
else
ans = ":(";
//出力
cout << ... | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
//入力
int a, b, c, d, e;
int k;
cin >> a >> b >> c >> d >> e;
cin >> k;
//処理
string ans;
int L = e - a;
if (L <= k)
ans = "Yay!";
else
ans = ":(";
//出力
cout <<... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,208 | 889,209 | u987412812 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<char, LL> P;
const LL mod = 1e9 + 7;
const LL LINF = 1LL << 62;
in... | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<char, LL> P;
const LL mod = 1e9 + 7;
const LL LINF = 1LL << 62;
in... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 889,221 | 889,222 | u640323045 | cpp |
p03075 | #define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <iostream>
int main() {
int locate[5];
for (int i = 0; i < 5; i++) {
int N = 0;
scanf("%d", &N);
locate[i] = N;
}
int K = 0;
scanf("%d", &K);
if (locate[4] - locate[0] < K) {
std::cout << "Yay!" << std::endl;
} else {
std::cou... | #define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <iostream>
int main() {
int locate[5];
for (int i = 0; i < 5; i++) {
int N = 0;
scanf("%d", &N);
locate[i] = N;
}
int K = 0;
scanf("%d", &K);
if (locate[4] - locate[0] <= K) {
std::cout << "Yay!" << std::endl;
} else {
std::co... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,233 | 889,234 | u689560153 | cpp |
p03075 | #define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <iostream>
int main() {
int locate[5];
for (int i = 0; i < 5; i++) {
int N = 0;
scanf("%d", &N);
locate[i] = N;
}
int K = 0;
scanf("%d", &K);
if (locate[4] - locate[0] < K) {
std::cout << "Yay!" << std::endl;
} else {
std::cou... | #define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <iostream>
int main() {
int locate[5];
for (int i = 0; i < 5; i++) {
int N = 0;
scanf("%d", &N);
locate[i] = N;
}
int K = 0;
scanf("%d", &K);
if (locate[4] - locate[0] <= K) {
std::cout << "Yay!" << std::endl;
} else {
std::co... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,233 | 889,235 | u689560153 | cpp |
p03075 | #include <cmath>
#include <iostream>
#include <vector>
#define vi vector<int>
using namespace std;
int main(void) {
vi num(5);
int k;
bool det = false;
cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4] >> k;
for (int tmp1 = 0; tmp1 <= 4; tmp1++) {
for (int tmp2 = 0; tmp2 <= 4; tmp2++) {
if (nu... | #include <cmath>
#include <iostream>
#include <vector>
#define vi vector<int>
using namespace std;
int main(void) {
vi num(5);
int k;
bool det = false;
cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4] >> k;
for (int tmp1 = 0; tmp1 <= 4; tmp1++) {
for (int tmp2 = 0; tmp2 <= 4; tmp2++) {
if (nu... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,236 | 889,237 | u178099056 | cpp |
p03075 | #include <cmath>
#include <iostream>
#include <vector>
#define vi vector<int>
using namespace std;
int main(void) {
vi num(5);
int k;
bool det = false;
cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4] >> k;
for (int tmp1 = 0; tmp1 < 4; tmp1++) {
for (int tmp2 = 0; tmp2 < 4; tmp2++) {
if (num[... | #include <cmath>
#include <iostream>
#include <vector>
#define vi vector<int>
using namespace std;
int main(void) {
vi num(5);
int k;
bool det = false;
cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4] >> k;
for (int tmp1 = 0; tmp1 <= 4; tmp1++) {
for (int tmp2 = 0; tmp2 <= 4; tmp2++) {
if (nu... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 889,238 | 889,237 | u178099056 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, m, n) for (long long i = (m); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SPEED ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, m, n) for (long long i = (m); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SPEED ... | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 889,242 | 889,243 | u898651494 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int p[5];
int k, ans;
int max = 0;
int min = 0;
for (int i = 0; i < sizeof(p); i++) {
cin >> p[i];
if (max < p[i]) {
max = p[i];
}
if (min > p[i] || i == 0) {
min = p[i];
}
}
cin >> k;
// cout << "max:" << max << " m... | #include <iostream>
using namespace std;
int main() {
int p[5];
int k, ans;
int max = 0;
int min = 0;
for (int i = 0; i < 5; i++) {
cin >> p[i];
if (max < p[i]) {
max = p[i];
}
if (min > p[i] || i == 0) {
min = p[i];
}
}
cin >> k;
// cout << "max:" << max << " min" << m... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,252 | 889,253 | u172258329 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
cout << ":(" << endl;
} else {
cout << "Yay" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | [
"literal.string.change",
"io.output.change"
] | 889,269 | 889,270 | u288905450 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep2(x, from, to) for (int x = (from); (x) < (to); (x)++)
#define rep(x, to) rep2(x, 0, to)
#d... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep2(x, from, to) for (int x = (from); (x) < (to); (x)++)
#define rep(x, to) rep2(x, 0, to)
#d... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,271 | 889,272 | u798441421 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <math.h>
#include <stack>
#include <string>
#include <vector>
//#include<stdlib.h>
using namespace std;
int main() {
short i[5];
int l;
for (int k = 0; k < 5; k++) {
cin >> i[k];
}
cin >> l;
if (i[4] - i[0] < l) {
... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <math.h>
#include <stack>
#include <string>
#include <vector>
//#include<stdlib.h>
using namespace std;
int main() {
short i[5];
int l;
for (int k = 0; k < 5; k++) {
cin >> i[k];
}
cin >> l;
if (i[4] - i[0] <= l) {... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,280 | 889,281 | u468506413 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, x) for (int i = 0; i < (int)(x); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0... | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, x) for (int i = 0; i < (int)(x); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 889,282 | 889,283 | u150255544 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int k;
int a[5];
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
bool yay = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[j] - a[i]) > k) {
yay = 1;
break;
}
}
}
if (yay == 0)
... | #include <bits/stdc++.h>
using namespace std;
int main() {
// ios::sync_with_stdio(false);
// cin.tie(0);
int k;
int a[5];
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
bool yay = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[j] - a[i]) > k) {
ya... | [
"literal.string.change",
"io.output.change"
] | 889,290 | 889,291 | u053680645 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, K;
cin >> A >> B >> C >> D >> E >> K;
if (E - A <= K)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, K;
cin >> A >> B >> C >> D >> E >> K;
if (E - A <= K)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
} | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 889,292 | 889,293 | u922917362 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, K;
cin >> A >> B >> C >> D >> E >> K;
if (E - A >= K)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, K;
cin >> A >> B >> C >> D >> E >> K;
if (E - A <= K)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 889,294 | 889,293 | u922917362 | cpp |
p03075 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, a[300000] = {0}, i, j, max = -1, c = 0;
for (i = 0; i < 5; i++)
cin >> a[i];
cin >> n;
for (i = 0; i < 5; i++)
for (j = i + 1; j < 5; j++) {
c = a[j] - a[i];
if (c > max)
max = c;
}
if (max >... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n, a[300000] = {0}, i, j, max = -1, c = 0;
for (i = 0; i < 5; i++)
cin >> a[i];
cin >> n;
for (i = 0; i < 5; i++)
for (j = i + 1; j < 5; j++) {
c = a[j] - a[i];
if (c > max)
max = c;
}
if (max >... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,308 | 889,309 | u749530685 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 123;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n >= max)
max = n;
if (n <= min)
min = n;
}
cin >> k;
if ... | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 123;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n >= max)
max = n;
if (n <= min)
min = n;
}
cin >> k;
if ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,314 | 889,315 | u734455596 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 124;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n > max)
max = n;
if (n < min)
min = n;
}
cin >> k;
if ((... | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 123;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n >= max)
max = n;
if (n <= min)
min = n;
}
cin >> k;
if ... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.if.replace.add",
"control_flow.branch.else_if.replace.remove"
] | 889,316 | 889,315 | u734455596 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 0;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n > max)
max = n;
if (n < min)
min = n;
}
cin >> k;
if ((ma... | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 123;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n >= max)
max = n;
if (n <= min)
min = n;
}
cin >> k;
if ... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.if.replace.add",
"control_flow.branch.else_if.replace.remove"
] | 889,317 | 889,315 | u734455596 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 123;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n > max)
max = n;
if (n < min)
min = n;
}
cin >> k;
if ((... | #include <bits/stdc++.h>
using namespace std;
bool isValid(int min, int max, int k) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n = 0, k = 0, max = 0, min = 123;
for (int i = 0; i < 5; i++) {
cin >> n;
if (n >= max)
max = n;
if (n <= min)
min = n;
}
cin >> k;
if ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.if.replace.add",
"control_flow.branch.else_if.replace.remove"
] | 889,318 | 889,315 | u734455596 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int flag = 1;
int arr[10];
int k;
for (int i = 0; i < 5; i++)
cin >> arr[i];
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 4; j++) {
if (abs(arr[i] - arr[j]) <= k) {
flag = 1;
} else {
flag = 0;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int flag = 1;
int arr[10];
int k;
for (int i = 0; i < 5; i++)
cin >> arr[i];
cin >> k;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(arr[i] - arr[j]) <= k) {
flag = 1;
} else {
flag = 0;
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,325 | 889,326 | u047442155 | cpp |
p03075 | #include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using llong = long long;
using ullong = unsigned long long;
#i... | #include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using llong = long long;
using ullong = unsigned long long;
#i... | [
"literal.number.change",
"call.arguments.change"
] | 889,331 | 889,332 | u153390822 | cpp |
p03075 | //------------------------------------------
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <... | //------------------------------------------
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,333 | 889,334 | u226861390 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a;
int b;
int c;
int d;
int e;
int k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - a) > k) {
cout << ":(";
} else {
cout << "Yey!";
}
} | #include <iostream>
using namespace std;
int main() {
int a;
int b;
int c;
int d;
int e;
int k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - a) > k) {
cout << ":(";
} else {
cout << "Yay!";
}
} | [
"literal.string.change",
"io.output.change"
] | 889,337 | 889,338 | u616719627 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a;
int b;
int c;
int d;
int e;
int k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - a) > k) {
cout << ":(";
} else {
cout << "yey!";
}
} | #include <iostream>
using namespace std;
int main() {
int a;
int b;
int c;
int d;
int e;
int k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - a) > k) {
cout << ":(";
} else {
cout << "Yay!";
}
} | [
"literal.string.change",
"io.output.change"
] | 889,339 | 889,338 | u616719627 | cpp |
p03075 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<int> A(5);
int k;
for (int i = 0; i < 5; i++) {
cin >> A[i];
}
cin >> k;
if (A[4] - A[0] > k) {
cout << ":(" << endl;
} else {
cout << "Y... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<int> A(5);
int k;
for (int i = 0; i < 5; i++) {
cin >> A[i];
}
cin >> k;
if (A[4] - A[0] > k) {
cout << ":(" << endl;
} else {
cout << "Y... | [
"literal.string.change",
"io.output.change"
] | 889,340 | 889,341 | u684056175 | cpp |
p03075 | // c++14
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int x[5];
for (int i = 0; i < 5; i++) {
cin >> x[i];
}
int k;
cin >> k;
bool ans = true;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (x[i] - x[j] > k)
... | // c++14
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int x[5];
for (int i = 0; i < 5; i++) {
cin >> x[i];
}
int k;
cin >> k;
bool ans = true;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (x[i] - x[j] > k)
... | [
"literal.string.change",
"io.output.change"
] | 889,342 | 889,343 | u397718143 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int i;
int antenna[5];
for (i = 0; i < 5; i++) {
cin >> antenna[i];
}
int k;
cin >> k;
int max;
max = *max_element(antenna, antenna + 5);
int min;
min = *min_element(antenna, antenna + 5);
if (max < ... | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int i;
int antenna[5];
for (i = 0; i < 5; i++) {
cin >> antenna[i];
}
int k;
cin >> k;
int max;
max = *max_element(antenna, antenna + 5);
int min;
min = *min_element(antenna, antenna + 5);
if (max <=... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,344 | 889,345 | u397070717 | cpp |
p03075 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (b - a <= k && c - a <= k && d - a <= k && e - a <= -k && c - b <= k &&
d - b <= k && e - b <= k && d - c <= k && e - c <= k && e - d <= k)
cout << "Yay!" << endl;
else
cout << ":(... | #include <iostream>
using namespace std;
int main(void) {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (b - a <= k && c - a <= k && d - a <= k && e - a <= k && c - b <= k &&
d - b <= k && e - b <= k && d - c <= k && e - c <= k && e - d <= k)
cout << "Yay!" << endl;
else
cout << ":("... | [
"expression.operation.unary.arithmetic.remove",
"control_flow.branch.if.condition.change"
] | 889,358 | 889,359 | u528256243 | cpp |
p03075 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (b - a <= k && c - a <= k && d - a <= k && e - a < -k && c - b <= k &&
d - b <= k && e - b <= k && d - c <= k && e - c <= k && e - d <= k)
cout << "Yay!" << endl;
else
cout << ":("... | #include <iostream>
using namespace std;
int main(void) {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (b - a <= k && c - a <= k && d - a <= k && e - a <= k && c - b <= k &&
d - b <= k && e - b <= k && d - c <= k && e - c <= k && e - d <= k)
cout << "Yay!" << endl;
else
cout << ":("... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.unary.arithmetic.remove"
] | 889,360 | 889,359 | u528256243 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.