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 <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int K;
int input;
vector<int> a;
for (int i = 0; i < 5; i++) {
cin >> input;
a.push_back(input);
}
cin >> K;
string ans = "Yay!";
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a.size();... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int K;
int input;
vector<int> a;
for (int i = 0; i < 5; i++) {
cin >> input;
a.push_back(input);
}
cin >> K;
string ans = "Yay!";
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a.size();... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,361 | 889,362 | u498436815 | cpp |
p03075 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
int main() {
int antena[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> antena[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
fo... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
int main() {
int antena[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> antena[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
fo... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,363 | 889,364 | u563518571 | cpp |
p03075 | #include <bits/stdc++.h>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (abs(a - e) < k) {
cout << "Yay!";
} else {
cout << ":(";
}
} | #include <bits/stdc++.h>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (abs(a - e) <= k) {
cout << "Yay!";
} else {
cout << ":(";
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,374 | 889,375 | u637568962 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e9;
bool graph[nmax][nmax];
vector<vector<ll>> di... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e9;
bool graph[nmax][nmax];
vector<vector<ll>> di... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 889,378 | 889,379 | u228295160 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define INF 10000000000000009
//#define INF 9223372036854775807
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define ORREP(i, n) for (int i = (n); i >= 1; --i)
#define ZREP(i, ... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define INF 10000000000000009
//#define INF 9223372036854775807
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define ORREP(i, n) for (int i = (n); i >= 1; --i)
#define ZREP(i, ... | [
"expression.operator.compare.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 889,384 | 889,385 | u554953477 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,392 | 889,393 | u484962958 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a[6];
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> a[5];
int flag = 1;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (abs(a[i] - a[j]) > a[5]) {
flag = 0;
break;
}
}
if (!flag)
bre... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int a[6];
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> a[5];
int flag = 1;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (abs(a[i] - a[j]) > a[5]) {
flag = 0;
break;
}
}
if (!flag)
bre... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,418 | 889,419 | u887066391 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
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 <bits/stdc++.h>
using namespace std;
int main(void) {
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,420 | 889,421 | u348723622 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
///////////////////////////////////////////
const long long int INF = 100000000000;
const long long int Mod = 1000000007;
using ll = long long int; // long long int は64bit
using vi = vector<int>;
using Vi = vector<long long int>;
#define pb(x) push_back(x)
#define mp(x, y) ... | #include <bits/stdc++.h>
using namespace std;
///////////////////////////////////////////
const long long int INF = 100000000000;
const long long int Mod = 1000000007;
using ll = long long int; // long long int は64bit
using vi = vector<int>;
using Vi = vector<long long int>;
#define pb(x) push_back(x)
#define mp(x, y) ... | [
"variable_declaration.add",
"expression.operation.binary.remove"
] | 889,428 | 889,429 | u896014917 | cpp |
p03075 | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int x, k;
int maxx = -1, minn = 10000;
for (int i = 1; i <= 5; i++) {
scanf("%d", &x);
maxx = max(maxx, x);
minn = min(minn, x);
}
scanf("%d", &k);
if (maxx - minn < k)
printf("Yay!\n");
else
printf(":(\n");
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int x, k;
int maxx = -1, minn = 10000;
for (int i = 1; i <= 5; i++) {
scanf("%d", &x);
maxx = max(maxx, x);
minn = min(minn, x);
}
scanf("%d", &k);
if (maxx - minn <= k)
printf("Yay!\n");
else
printf(":(\n");
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,434 | 889,435 | u276626173 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (k < a[j] - a[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yey!" << end... | #include <iostream>
using namespace std;
int main() {
int a[5];
int k;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (k < a[j] - a[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << end... | [
"literal.string.change",
"io.output.change"
] | 889,436 | 889,437 | u754489932 | 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;
int ab, ac, ad, ae;
int bc, bd, be;
int cd, ce;
int de;
ab = b - a;
ac = c - a;
ad = d - a;
ae = e - a;
bc = c - b;
bd = d - b;
be = e - b;
cd = d - c;
ce = e - c;
de = ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
int ab, ac, ad, ae;
int bc, bd, be;
int cd, ce;
int de;
ab = b - a;
ac = c - a;
ad = d - a;
ae = e - a;
bc = c - b;
bd = d - b;
be = e - b;
cd = d - c;
ce = e - c;
de = ... | [
"control_flow.branch.if.condition.change"
] | 889,438 | 889,439 | u698136564 | cpp |
p03075 |
#include <algorithm>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define LL long long
#define ALF "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define LLBIG 1999999999999999999
#define INTBIG 1111... |
#include <algorithm>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define LL long long
#define ALF "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define LLBIG 1999999999999999999
#define INTBIG 1111... | [
"literal.string.change",
"io.output.change"
] | 889,451 | 889,452 | u657512990 | cpp |
p03075 | #include <bits/stdc++.h>
#define ll long long
#define en "\n"
using namespace std;
const int M = 1e9 + 7;
int a[8];
int main() {
ios::sync_with_stdio(false);
int k;
for (int i = 1; i < 6; i++)
cin >> a[i];
cin >> k;
for (int i = 1; i < 6; i++) {
for (int j = i + 1; j < 6; j++)
if (abs(i - j) ... | #include <bits/stdc++.h>
#define ll long long
#define en "\n"
using namespace std;
const int M = 1e9 + 7;
int a[8];
int main() {
ios::sync_with_stdio(false);
int k;
for (int i = 1; i < 6; i++)
cin >> a[i];
cin >> k;
for (int i = 1; i < 6; i++) {
for (int j = i + 1; j < 6; j++)
if (abs(a[i] - ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 889,453 | 889,454 | u399616977 | cpp |
p03075 | #include <algorithm>
#include <complex>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <string.h>
#include <vector>
#define ll long long
using namespace std;
int main() {
int a[6], k, ans;
ans = 0;
for (int i = 0; i < 5; i++)
cin >> a[i];
cin >> k;
for (int i = 0; i < 5; i++)
for ... | #include <algorithm>
#include <complex>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <string.h>
#include <vector>
#define ll long long
using namespace std;
int main() {
int a[6], k, ans;
ans = 0;
for (int i = 0; i < 5; i++)
cin >> a[i];
cin >> k;
for (int i = 0; i < 5; i++)
for ... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,455 | 889,456 | u902428263 | cpp |
p03075 | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
using ll =... | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
using ll =... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"io.output.change"
] | 889,457 | 889,458 | u525672296 | cpp |
p03075 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define repd(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) repd(i, ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define repd(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) repd(i, ... | [
"expression.operator.compare.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 889,465 | 889,466 | u030992242 | cpp |
p03075 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int i, l, a[10], k;
for (i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
sort(a, a + 5);
scanf("%d", &k);
if (a[4] - a[0] < k) {
printf("Yay!");
} else
printf(":(");
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int i, l, a[10], k;
for (i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
sort(a, a + 5);
scanf("%d", &k);
if (a[4] - a[0] <= k) {
printf("Yay!");
} else
printf(":(");
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,467 | 889,468 | u007614284 | cpp |
p03075 | #include <iostream>
int main() {
int a[5];
int k;
for (auto i = 0; i < 5; i++) {
std::cin >> a[i];
}
std::cin >> k;
auto isOk = true;
for (auto i = 0; i < 5; i++) {
for (auto j = i + 1; j < 5; j++) {
if (abs(a[j] - a[i]) > k) {
isOk = false;
}
}
}
if (isOk) {
std... | #include <iostream>
int main() {
int a[5];
int k;
for (auto i = 0; i < 5; i++) {
std::cin >> a[i];
}
std::cin >> k;
auto isOk = true;
for (auto i = 0; i < 5; i++) {
for (auto j = i + 1; j < 5; j++) {
if (abs(a[j] - a[i]) > k) {
isOk = false;
}
}
}
if (isOk) {
std... | [
"literal.string.change",
"expression.operation.binary.change"
] | 889,472 | 889,473 | u664102385 | cpp |
p03075 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int p[5];
for (int i = 0; i < 5; i++) {
cin >> p[i];
}
int k;
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (abs(p[i] - p[j]) >= k) {
cout << ":(" << endl;
return 0;
}
... | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int p[5];
for (int i = 0; i < 5; i++) {
cin >> p[i];
}
int k;
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (abs(p[i] - p[j]) > k) {
cout << ":(" << endl;
return 0;
}
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,476 | 889,477 | u269476572 | cpp |
p03075 | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
int m[5];
// cin >> a >> b >> c >> d >> e >> k;
for (int i = 0; i < 5; i++) {
cin >> m[i];
}
cin >> k;
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1... | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
int m[5];
// cin >> a >> b >> c >> d >> e >> k;
for (int i = 0; i < 5; i++) {
cin >> m[i];
}
cin >> k;
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1... | [
"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,482 | 889,483 | u506431348 | cpp |
p03075 | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
int m[5];
// cin >> a >> b >> c >> d >> e >> k;
for (int i = 0; i < 5; i++) {
cin >> m[i];
}
cin >> k;
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1... | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
int m[5];
// cin >> a >> b >> c >> d >> e >> k;
for (int i = 0; i < 5; i++) {
cin >> m[i];
}
cin >> k;
int sum = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,484 | 889,483 | u506431348 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
int k;
int ans = 0;
#define INF 10e+11 + 7
void calc(int a, int b) {
if (abs(a - b) >= k) {
ans = 1;
}
}
int main() {
int a[5];
cin >> a[0] >> ... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
int k;
int ans = 0;
#define INF 10e+11 + 7
void calc(int a, int b) {
if (abs(a - b) > k) {
ans = 1;
}
}
int main() {
int a[5];
cin >> a[0] >> a... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,485 | 889,486 | u798944838 | cpp |
p03075 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
vector<int> list;
list.push_back(a);
list.push_back(b);
list.push_back(c);
list.push_back(d);
list.push_back(e);
bool flg = false;
for (int i = 0; i < 5; ++i) {
fo... | #include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
vector<int> list;
list.push_back(a);
list.push_back(b);
list.push_back(c);
list.push_back(d);
list.push_back(e);
bool flg = false;
for (int i = 0; i < 5; ++i) {
fo... | [] | 889,487 | 889,488 | u336096593 | cpp |
p03075 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
vector<int> list;
list.push_back(a);
list.push_back(b);
list.push_back(c);
list.push_back(d);
list.push_back(e);
bool flg = false;
for (int i = 0; i < 5; ++i) {
for... | #include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
vector<int> list;
list.push_back(a);
list.push_back(b);
list.push_back(c);
list.push_back(d);
list.push_back(e);
bool flg = false;
for (int i = 0; i < 5; ++i) {
fo... | [
"literal.string.change",
"io.output.change"
] | 889,489 | 889,488 | u336096593 | cpp |
p03075 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<int> a(5);
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int k;
cin >> k;
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 5; j++) {
... | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
vector<int> a(5);
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int k;
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 889,492 | 889,493 | u707072292 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// #include "prettyprint.hpp"
typedef long lo... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// #include "prettyprint.hpp"
typedef long lo... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,501 | 889,502 | u162172626 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <vector>
using namespace std;
template <typename T = int> T in() {
T temp;
cin >> temp;
return temp;
}
template <typename VType = int> list<VType> const LR(VType start, VType end) {
list<VType> ret;
for (VType i =... | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <vector>
using namespace std;
template <typename T = int> T in() {
T temp;
cin >> temp;
return temp;
}
template <typename VType = int> list<VType> const LR(VType start, VType end) {
list<VType> ret;
for (VType i =... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"io.output.change"
] | 889,509 | 889,510 | u074059110 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int a[5], q;
int main() {
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
q = max(q, abs(a[i] - a[j]));
}
}
int k;
cin >> k;
if (k > q) {
cout << "Yay!" << endl;
} else {
cout... | #include <bits/stdc++.h>
using namespace std;
int a[5], q = -1;
int main() {
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
q = max(q, abs(a[i] - a[j]));
}
}
int k;
cin >> k;
if (k >= q) {
cout << "Yay!" << endl;
} else {
... | [
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,513 | 889,514 | u207310767 | cpp |
p03075 | #include <stdio.h>
#define NUM 5
int main(void) {
int a[NUM];
int k;
for (int i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &k);
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (a[j] - a[i] > k) {
printf(":()\n");
return 0;
}
}
}
pri... | #include <stdio.h>
#define NUM 5
int main(void) {
int a[NUM];
int k;
for (int i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &k);
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (a[j] - a[i] > k) {
printf(":(\n");
return 0;
}
}
}
prin... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 889,517 | 889,518 | u101519275 | cpp |
p03075 | #include <iostream>
#include <string>
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 << ":(";
return 0;
} | #include <iostream>
#include <string>
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 << ":(";
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,519 | 889,520 | u772041670 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (b - a <= k && c - a <= k && d - a <= k && a - e <= 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() {
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.binary.remove",
"control_flow.branch.if.condition.change"
] | 889,521 | 889,522 | u958128735 | cpp |
p03075 | // SeeAlso: https://atcoder.jp/contests/abc123/tasks/abc123_a
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
using namespace std;
#define MAX 100
int main() {
int a, b, c, d, e, k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - ... | // SeeAlso: https://atcoder.jp/contests/abc123/tasks/abc123_a
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
using namespace std;
#define MAX 100
int main() {
int a, b, c, d, e, k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,525 | 889,526 | u185518252 | cpp |
p03075 | //#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define MAX_INT 2100000000
using namespace std;
typedef long long int ll;
//#include "Header.h"
int main() {
int a, b, c, d, e, k, i, j;
cin >> a >> b >> c >> d >> e >> k;
if (e - a < k... | //#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define MAX_INT 2100000000
using namespace std;
typedef long long int ll;
//#include "Header.h"
int main() {
int a, b, c, d, e, k, i, j;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,542 | 889,543 | u697367509 | cpp |
p03075 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
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 <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
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;
}
| [
"literal.string.change",
"io.output.change"
] | 889,544 | 889,545 | u317177661 | cpp |
p03075 | #include <stdio.h>
int main(void) {
int p[5];
int k;
for (int i = 0; i < 5; i++) {
scanf("%d", &p[i]);
}
scanf("%d", &k);
for (int j = 0; j < 4; j++) {
for (int i = j + 1; i < 5; i++) {
int x = p[j] - p[i];
if (x > k) {
printf(":(");
return 0;
}
}
}
print... | #include <stdio.h>
int main(void) {
int p[5];
int k;
for (int i = 0; i < 5; i++) {
scanf("%d", &p[i]);
}
scanf("%d", &k);
for (int j = 0; j < 4; j++) {
for (int i = j + 1; i < 5; i++) {
int x = p[i] - p[j];
if (x > k) {
printf(":(");
return 0;
}
}
}
print... | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 889,550 | 889,551 | u245335950 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int k;
vector<int> cor(5, 0);
for (int i = 0; i < 5; i++) {
cin >> cor[i];
}
cin >> k;
if (cor[4] - cor[0] > k)
cout << ":(";
cout << "Yay!";
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int k;
vector<int> cor(5, 0);
for (int i = 0; i < 5; i++) {
cin >> cor[i];
}
cin >> k;
if (cor[4] - cor[0] > k)
cout << ":(";
else
cout << "Yay!";
return 0;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 889,556 | 889,557 | u074014027 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int k;
vector<int> cor(5, 0);
for (int i = 0; i < 5; i++) {
cin >> cor[i];
}
if (cor[4] - cor[0] > k)
cout << ":(";
cout << "Yay!";
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int k;
vector<int> cor(5, 0);
for (int i = 0; i < 5; i++) {
cin >> cor[i];
}
cin >> k;
if (cor[4] - cor[0] > k)
cout << ":(";
else
cout << "Yay!";
return 0;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 889,558 | 889,557 | u074014027 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n = 5;
vector<int> annt;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
annt.push_back(x);
}
int k = 0;
cin >> k;
// int ret = 0;
// for (int i = 1; i < n; i++) {
// if (annt[i] - annt[i-1] > k) {
// ret++;
// ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n = 5;
vector<int> annt;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
annt.push_back(x);
}
int k = 0;
cin >> k;
// int ret = 0;
// for (int i = 1; i < n; i++) {
// if (annt[i] - annt[i-1] > k) {
// ret++;
// ... | [
"literal.string.change",
"io.output.change"
] | 889,559 | 889,560 | u611087334 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n = 5;
vector<int> annt;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
annt.push_back(x);
}
int k = 0;
cin >> k;
// int ret = 0;
// for (int i = 1; i < n; i++) {
// if (annt[i] - annt[i-1] > k) {
// ret++;
// ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n = 5;
vector<int> annt;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
annt.push_back(x);
}
int k = 0;
cin >> k;
// int ret = 0;
// for (int i = 1; i < n; i++) {
// if (annt[i] - annt[i-1] > k) {
// ret++;
// ... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 889,561 | 889,560 | u611087334 | cpp |
p03075 | #include <array>
#include <iostream>
using namespace std;
int main() {
array<int, 5> x;
int k;
for (int i = 0; i < 5; i++) {
cin >> x.at(i);
}
cin >> k;
bool ok = (x.at(4) - x.at(0)) < k;
if (!ok) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | #include <array>
#include <iostream>
using namespace std;
int main() {
array<int, 5> x;
int k;
for (int i = 0; i < 5; i++) {
cin >> x.at(i);
}
cin >> k;
bool ok = (x.at(4) - x.at(0)) <= k;
if (!ok) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | [
"expression.operator.compare.change",
"expression.operation.binary.change"
] | 889,564 | 889,565 | u123729319 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5];
int k;
bool check = true;
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 (a[j] - a[i] <= k) {
check = false;
}
}
}
if (check)... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5];
int k;
bool check = true;
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 (a[j] - a[i] > k) {
check = false;
}
}
}
if (check) ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,566 | 889,567 | u652790949 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k, ch;
cin >> a >> b >> c >> d >> e >> k;
ch = b - a + c - b + d - b + e - d;
if (ch > k)
cout << ":(" << endl;
else {
cout << "Yay!" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k, ch;
cin >> a >> b >> c >> d >> e >> k;
ch = b - a + c - b + d - c + e - d;
if (ch > k)
cout << ":(" << endl;
else {
cout << "Yay!" << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 889,569 | 889,570 | u817014213 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<int> v(6);
int k;
for (int i = 1; i < 6; i++)
cin >> v[i];
cin >> k;
sort(v.begin(), v.end());
int n;
n = v[1] - v[5];
// for(int i=1;i<6;i++)cout<<v[i]<<" ";
if (n > k)
cout << ":(" << endl;
else
cou... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<int> v(6);
int k;
for (int i = 1; i < 6; i++)
cin >> v[i];
cin >> k;
sort(v.begin(), v.end());
int n;
n = v[5] - v[1];
// for(int i=1;i<6;i++)cout<<v[i]<<" ";
// cout<<n<<endl;
if (n > k)
cout << ":(" << ... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 889,573 | 889,574 | u330689597 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<int> v(6);
int k;
for (int i = 0; i < 5; i++)
cin >> v[i];
cin >> k;
sort(v.begin(), v.end());
int n;
n = v[0] - v[4];
if (n > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<int> v(6);
int k;
for (int i = 1; i < 6; i++)
cin >> v[i];
cin >> k;
sort(v.begin(), v.end());
int n;
n = v[5] - v[1];
// for(int i=1;i<6;i++)cout<<v[i]<<" ";
// cout<<n<<endl;
if (n > k)
cout << ":(" << ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 889,575 | 889,574 | u330689597 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[6], k;
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 < 4 - i; j++) {
if (a[j] - a[i] > k) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Ya... | #include <iostream>
using namespace std;
int main() {
int a[6], k;
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 - i; j++) {
if (a[j] - a[i] > k) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Ya... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,593 | 889,594 | u111160776 | cpp |
p03075 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
int b = 1;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j] > k)) {
b = 0;
}
}
}
if (b =... | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int a[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
int b = 1;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j]) > k) {
b = 0;
}
}
}
if (b =... | [
"control_flow.branch.if.condition.change"
] | 889,599 | 889,600 | u850867546 | cpp |
p03075 | #include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> antennas(5);
for (int i = 0; i < 5; i++) {
cin >> antennas[i];
}
int k;
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 4; j > i; j++) {
if (antennas[j] - antennas[i] > k) {
cout << ":(";
... | #include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> antennas(5);
for (int i = 0; i < 5; i++) {
cin >> antennas[i];
}
int k;
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = 4; j > i; j--) {
if (antennas[j] - antennas[i] > k) {
cout << ":(";
... | [] | 889,610 | 889,611 | u117615163 | cpp |
p03075 | // C++ includes used for precompiling -*- C++ -*-
// Copyright (C) 2003-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free So... | // C++ includes used for precompiling -*- C++ -*-
// Copyright (C) 2003-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free So... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operation.binary.remove"
] | 889,624 | 889,625 | u139458416 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#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 {
... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#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 {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,626 | 889,627 | u566640130 | 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;
string ret = ":(";
if (e - a < k) {
ret = "Yay!";
}
cout << ret << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
string ret = ":(";
if (e - a <= k) {
ret = "Yay!";
}
cout << ret << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,632 | 889,633 | u966286365 | cpp |
p03075 | #include <algorithm>
#include <cstdint>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
//#include<boost/multiprecision/cpp_int.hpp>
#define rep(... | #include <algorithm>
#include <cstdint>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
//#include<boost/multiprecision/cpp_int.hpp>
#define rep(... | [
"literal.number.change",
"call.arguments.change"
] | 889,634 | 889,635 | u775013393 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <string>
#include <utility>
#include <vector>
#define rep(p, q) for (int i = p; i < q; i++)
using namespace std;
const int cons = 1e9 + 7;
int main(void) {
string ans = "Yay!";
int a, b, c, d, e, k;
int n[5];
... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <string>
#include <utility>
#include <vector>
#define rep(p, q) for (int i = p; i < q; i++)
using namespace std;
const int cons = 1e9 + 7;
/*
//B
int main(void) {
int a, b, c, d, e;
cin >> a >> b >> c... | [] | 889,636 | 889,637 | u693569496 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int d[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> d[i];
}
cin >> k;
if (d[4] - d[0] >= k)
cout << ":(\n";
else
cout << "Yay!\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int d[5];
int k;
for (int i = 0; i < 5; i++) {
cin >> d[i];
}
cin >> k;
if (d[4] - d[0] > k)
cout << ":(\n";
else
cout << "Yay!\n";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,647 | 889,648 | u069389947 | cpp |
p03075 | #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i ... | #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i ... | [
"literal.string.change",
"io.output.change"
] | 889,649 | 889,650 | u292813062 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, min, max) for (int i = min; i < max; i++)
#define rrep(i, min, max) for (int i = max; i >= min; i--)
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> ... | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, min, max) for (int i = min; i < max; i++)
#define rrep(i, min, max) for (int i = max; i >= min; i--)
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 889,651 | 889,652 | u780709476 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <string>
#include <vector>
using namespace std;
int main() {
int k;
vector<int> an;
int tmp;
for (int i = 0; i < 5; i++) {
scanf("%d\n", &tmp);
an.push_back(tmp);
}
scanf("%d\n", &k);
if ((*max_element(an.begin(), an.end()) -
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <string>
#include <vector>
using namespace std;
int main() {
int k;
vector<int> an;
int tmp;
for (int i = 0; i < 5; i++) {
scanf("%d\n", &tmp);
an.push_back(tmp);
}
scanf("%d\n", &k);
if ((*max_element(an.begin(), an.end()) -
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,656 | 889,657 | u784332273 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5];
int k, sum = 0;
int count = 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 (a[i] - a[j] > 15)
count++;
}
}
if (count > 0) {
c... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], b = 1;
int k, sum = 0;
int count = 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 (a[i] - a[j] > k)
count++;
}
}
if (count > 0) {... | [
"variable_declaration.add",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 889,658 | 889,659 | u167755809 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a[5];
int k, i;
for (i = 0; i < 5; i++)
cin >> a[i];
cin >> k;
if (a[4] - a[0] < k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a[5];
int k, i;
for (i = 0; i < 5; i++)
cin >> a[i];
cin >> k;
if (a[4] - a[0] <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,664 | 889,665 | u638264018 | cpp |
p03075 | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int a[5], k, i, s;
for (i = 0; i < 5; i++)
scanf("%d", &a[i]);
scanf("%d", &k);
sort(a, a + 5);
s = a[4] - a[0];
if (s < k)
printf("Yay!\n");
else
printf(":(\n");
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int a[5], k, i, s;
for (i = 0; i < 5; i++)
scanf("%d", &a[i]);
scanf("%d", &k);
sort(a, a + 5);
s = a[4] - a[0];
if (s <= k)
printf("Yay!\n");
else
printf(":(\n");
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,673 | 889,674 | u680968127 | cpp |
p03075 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef l... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef l... | [
"literal.string.change",
"io.output.change"
] | 889,675 | 889,676 | u924153316 | cpp |
p03075 | #define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int main(int argc, char *argv[]) {
int d[... | #define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int main(int argc, char *argv[]) {
int d[... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,679 | 889,680 | u992287017 | cpp |
p03075 | #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (abs(e - a) < k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
} | #include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (abs(e - a) <= k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 889,681 | 889,682 | u767430468 | cpp |
p03075 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long int ll;
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, a) repi(i, 0... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long int ll;
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, a) repi(i, 0... | [
"literal.string.change",
"io.output.change"
] | 889,691 | 889,692 | u640303028 | cpp |
p03075 | #include <bits/stdc++.h>
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
int min = 124, max = -1;
int antenna;
int k = 0;
for (int i = 0; i < 5; ++i) {
std::cin >> antenna;
min = std::min(min, antenna);
max = std::max(max, antenna);
}
std::cin >> k;
std::cout << (m... | #include <bits/stdc++.h>
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
int min = 124, max = -1;
int antenna;
int k = 0;
for (int i = 0; i < 5; ++i) {
std::cin >> antenna;
min = std::min(min, antenna);
max = std::max(max, antenna);
}
std::cin >> k;
std::cout << (m... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 889,703 | 889,704 | u264304509 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int>> vec(5);
int i;
for (i = 0; i < 5; i++) {
int a;
cin >> a;
vec.at(i) = make_pair(a % 10, a);
if (vec.at(i).first == 0) {
vec.at(i).first = 10;
}
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec... | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int>> vec(5);
int i;
for (i = 0; i < 5; i++) {
int a;
cin >> a;
vec.at(i) = make_pair(a % 10, a);
if (vec.at(i).first == 0) {
vec.at(i).first = 10;
}
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 889,723 | 889,724 | u130651752 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> menu(5);
int mini = 9;
for (int i = 0; i < 5; i++) {
cin >> menu[i];
if (menu[i] % 10 != 0) {
mini = min(mini, menu[i] % 10);
}
}
int sum = 0;
for (int i = 0; i < 5; i++) {
if (menu[i] % 10 == 0) {
sum += m... | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> menu(5);
int mini = 9;
for (int i = 0; i < 5; i++) {
cin >> menu[i];
if (menu[i] % 10 != 0) {
mini = min(mini, menu[i] % 10);
}
}
int sum = 0;
for (int i = 0; i < 5; i++) {
if (menu[i] % 10 == 0) {
sum += m... | [
"expression.operation.binary.remove"
] | 889,763 | 889,764 | u176218583 | cpp |
p03076 | #include <algorithm>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
#define rep(i, a, n) fo... | #include <algorithm>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
#define rep(i, a, n) fo... | [
"variable_declaration.name.change",
"identifier.change",
"control_flow.loop.for.initializer.change",
"assignment.variable.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 889,769 | 889,770 | u407213771 | cpp |
p03076 | #include "bits/stdc++.h"
using namespace std;
int main() {
int A, B, C, D, E;
cin >> A >> B >> C >> D >> E;
int ans = (A + 9) / 10 * 10 + (B + 9) / 10 * 10 + (C + 9) / 10 * 10 +
(D + 9) / 10 * 10 + (E + 9) / 10 * 10;
ans +=
max({(A + 9) / 10 * 10 - A, (B + 9) / 10 * 10 - B, (C + 9) / 10 * 10 ... | #include "bits/stdc++.h"
using namespace std;
int main() {
int A, B, C, D, E;
cin >> A >> B >> C >> D >> E;
int ans = (A + 9) / 10 * 10 + (B + 9) / 10 * 10 + (C + 9) / 10 * 10 +
(D + 9) / 10 * 10 + (E + 9) / 10 * 10;
ans -=
max({(A + 9) / 10 * 10 - A, (B + 9) / 10 * 10 - B, (C + 9) / 10 * 10 ... | [
"expression.operator.change"
] | 889,777 | 889,778 | u906839513 | cpp |
p03076 | #include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
int main() {
int a[5];
int ans = 0;
int a_max = 0;
REP(... | #include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
int main() {
int a[5];
int ans = 0;
int a_max = 0;
REP(... | [
"assignment.change"
] | 889,779 | 889,780 | u281876921 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define memi cout << endl
#define kono(n) cout << fixed << setprecision(n)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define hina... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define memi cout << endl
#define kono(n) cout << fixed << setprecision(n)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define hina... | [
"call.arguments.change"
] | 889,788 | 889,789 | u917049698 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
vector<int> A(5);
for (int i = 0; i < 5; i++)
cin >> A[i];
int matsu = 9;
int jun = 0;
for (int i = 0; i < 5; i++) {
if (A[i] >= 100 && A[i] % 100 != 0) {
matsu = min(matsu, A[i] % 100);
if (matsu == A[i] % 100)
jun = i... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
vector<int> A(5);
for (int i = 0; i < 5; i++)
cin >> A[i];
int matsu = 9;
int jun = 0;
for (int i = 0; i < 5; i++) {
if (A[i] >= 100 && A[i] % 10 != 0) {
matsu = min(matsu, A[i] % 10);
if (matsu == A[i] % 10)
jun = i;
... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 889,812 | 889,813 | u406634703 | cpp |
p03076 | #include <iostream>
using namespace std;
int main() {
int c, mx;
mx = 0;
int ans = 0;
for (int i = 0; i < 5; i++) {
cin >> c;
ans += (c + 9) / 10;
if (mx < 10 - c % 10 && c % 10 != 0)
mx = 10 - c % 10;
}
cout << ans - mx << endl;
} | #include <iostream>
using namespace std;
int main() {
int c, mx;
mx = 0;
int ans = 0;
for (int i = 0; i < 5; i++) {
cin >> c;
ans += (c + 9) / 10;
if (mx < 10 - c % 10 && c % 10 != 0)
mx = 10 - c % 10;
}
cout << ans * 10 - mx << endl;
} | [
"expression.operation.binary.add"
] | 889,820 | 889,821 | u993074316 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, a, b, c, d, e;
cin >> A >> B >> C >> D >> E;
a = (A + 9) / 10;
b = (B + 9) / 10;
c = (C + 9) / 10;
d = (D + 9) / 10;
e = (E + 9) / 10;
a *= 10;
b *= 10;
c *= 10;
d *= 10;
e *= 10;
cout << a + b + c + d + e - min({a -... | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, a, b, c, d, e;
cin >> A >> B >> C >> D >> E;
a = (A + 9) / 10;
b = (B + 9) / 10;
c = (C + 9) / 10;
d = (D + 9) / 10;
e = (E + 9) / 10;
a *= 10;
b *= 10;
c *= 10;
d *= 10;
e *= 10;
cout << a + b + c + d + e - max({a -... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 889,824 | 889,825 | u820224016 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], sum = 0, min = 10;
for (int i = 0; i < 5; i++) {
cin >> a[i];
if (a[i] % 10 == 0) {
sum += a[i];
continue;
} else if (a[i] % 10 < min) {
min = a[i] % 10;
}
sum += a[i] + 10 - (a[i] % 10);
}
cout << sum - m... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], sum = 0, min = 10;
for (int i = 0; i < 5; i++) {
cin >> a[i];
if (a[i] % 10 == 0) {
sum += a[i];
continue;
} else if (a[i] % 10 < min) {
min = a[i] % 10;
}
sum += a[i] + 10 - (a[i] % 10);
}
cout << sum - 1... | [
"expression.operation.binary.add"
] | 889,828 | 889,829 | u950901760 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], sum = 0, min = 10;
for (int i = 0; i < 5; i++) {
cin >> a[i];
if (a[i] % 10 == 0) {
sum += a[i];
continue;
} else if (a[i] % 10 < min) {
min = a[i] % 10;
}
sum += a[i] + 10 - a[i] % 10;
}
cout << sum - min... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], sum = 0, min = 10;
for (int i = 0; i < 5; i++) {
cin >> a[i];
if (a[i] % 10 == 0) {
sum += a[i];
continue;
} else if (a[i] % 10 < min) {
min = a[i] % 10;
}
sum += a[i] + 10 - (a[i] % 10);
}
cout << sum - 1... | [
"expression.operation.binary.add"
] | 889,830 | 889,829 | u950901760 | cpp |
p03076 | #include <algorithm> //next_permutation
#include <cmath> //min,max
#include <complex>
#include <iomanip>
#include <iostream> //swap(#inc<utility>より)
#include <locale>
#include <map> //map
#include <math.h> //要ります？
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <std... | #include <algorithm> //next_permutation
#include <cmath> //min,max
#include <complex>
#include <iomanip>
#include <iostream> //swap(#inc<utility>より)
#include <locale>
#include <map> //map
#include <math.h> //要ります？
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <std... | [
"literal.number.change",
"call.arguments.change"
] | 889,874 | 889,875 | u742306624 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> T(5);
int Min = 9, last, Last, sum = 0;
for (int i = 0; i < 5; i++) {
cin >> T[i];
if (T[i] % 10 < Min && T[i] != 0) {
last = i;
Min = T[i] % 10;
}
}
Last = T[last];
T[last] = 0;
for (int i = 0; i < 5; i++) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> T(5);
int Min = 9, last, Last, sum = 0;
for (int i = 0; i < 5; i++) {
cin >> T[i];
if (T[i] % 10 < Min && T[i] % 10 != 0) {
last = i;
Min = T[i] % 10;
}
}
Last = T[last];
T[last] = 0;
for (int i = 0; i < 5; i+... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 889,897 | 889,898 | u410888565 | cpp |
p03076 | #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#define MIN 100000
using namespace std;
int main() {
int a[6];
int flag = 0, ans;
for (int i = 1; i < 6; i++) {
cin >> a[i];
if (i > 1)
if (a[i] != a[i - 1])
flag = 1;
}
if (!flag) {
if (a[1] % 10 == 0) {
cout << a[... | #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#define MIN 100000
using namespace std;
int main() {
int a[6];
int flag = 0, ans;
for (int i = 1; i < 6; i++) {
cin >> a[i];
if (i > 1)
if (a[i] != a[i - 1])
flag = 1;
}
if (!flag) {
if (a[1] % 10 == 0) {
cout << a[... | [
"assignment.add"
] | 889,899 | 889,900 | u615884372 | cpp |
p03076 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
int main() {
std::vector<int> D(5);
int min = 10;
int I;
for (int i = 0; i < 5; ++i) {
std::cin >> D[i];
if (D[i] % 10 < min && D[i] % 10 != 0) {
min = D[i] % 10;
I = i;
}... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
int main() {
std::vector<int> D(5);
int min = 10;
int I;
for (int i = 0; i < 5; ++i) {
std::cin >> D[i];
if (D[i] % 10 < min && D[i] % 10 != 0) {
min = D[i] % 10;
I = i;
}... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 889,940 | 889,941 | u917678406 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
int t[5];
for (int i = 0; i < 5; i++)
cin >> t[i];
vector<vector<int>> perm(0, vector<int>(5));
for (int a = 0; a < 5; a++) {
for (int b = 0; b < 5; b++) {
if (b != a) {
for (int c = 0; c < 5; c++) {
if (c != a && c != ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int t[5];
for (int i = 0; i < 5; i++)
cin >> t[i];
vector<vector<int>> perm(0, vector<int>(5));
for (int a = 0; a < 5; a++) {
for (int b = 0; b < 5; b++) {
if (b != a) {
for (int c = 0; c < 5; c++) {
if (c != a && c != ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 889,942 | 889,943 | u528258842 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a... | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 889,966 | 889,967 | u946082956 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
vector<int> time = {a, b, c, d, e};
int n = 0;
vector<int> nexttime(n);
for (int i = 0; i < n; i++) {
if (time.at(i) % 10 == 0) {
nexttime.at(i) = time.at(i);
} else {
nexttime.at(... | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
vector<int> time = {a, b, c, d, e};
int n = 5;
vector<int> nexttime(n);
for (int i = 0; i < n; i++) {
if (time.at(i) % 10 == 0) {
nexttime.at(i) = time.at(i);
} else {
nexttime.at(... | [
"literal.number.change",
"variable_declaration.value.change"
] | 889,968 | 889,969 | u856957535 | cpp |
p03076 | #include <iostream>
using namespace std;
int main() {
int a[6] = {}, f = -1, g = 0, h = 0, j = 0;
for (int i = 0; i < 5; i++) {
cin >> a[i];
if (10 - a[i] % 10 > f && 10 - a[i] % 10 != 10) {
f = 10 - a[i] % 10;
j = a[i];
}
}
for (int i = 0; i < 5; i++) {
if (a[i] == j) {
a[i] ... | #include <iostream>
using namespace std;
int main() {
int a[6] = {}, f = -1, g = 0, h = 0, j = 0;
for (int i = 0; i < 5; i++) {
cin >> a[i];
if (10 - a[i] % 10 > f && 10 - a[i] % 10 != 10) {
f = 10 - a[i] % 10;
j = a[i];
}
}
for (int i = 0; i < 5; i++) {
if (a[i] == j) {
a[i] ... | [
"control_flow.break.add"
] | 889,972 | 889,973 | u834488582 | cpp |
p03076 | #include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
int a, b, c, d, e, x;
int f, h;
x = 0;
char c1;
string s;
// cin>> a;
// cin>> s;
// cin >> b;
// c1 = s[b-1];
// for (int i = 0; i< s.length(); i++){
// if(s[i] ==c1 ){
// cout << ... | #include <iostream>
using namespace std;
int main(int argc, const char *argv[]) {
int a, b, c, d, e, x;
int f, h;
x = 0;
char c1;
string s;
// cin>> a;
// cin>> s;
// cin >> b;
// c1 = s[b-1];
// for (int i = 0; i< s.length(); i++){
// if(s[i] ==c1 ){
// cout << ... | [
"literal.number.change",
"control_flow.loop.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 889,974 | 889,975 | u834488582 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int a1, b1, c1, d1, e1;
int a2, b2, c2, d2, e2;
a1 = a % 10;
a2 = a / 10;
if (a1 != 0)
a2++;
b1 = b % 10;
b2 = b / 10;
if (b1 != 0)
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int a1, b1, c1, d1, e1;
int a2, b2, c2, d2, e2;
a1 = a % 10;
a2 = a / 10;
if (a1 != 0)
a2++;
b1 = b % 10;
b2 = b / 10;
if (b1 != 0)
... | [
"assignment.variable.change",
"identifier.change"
] | 890,012 | 890,013 | u406647332 | cpp |
p03076 | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, g = 0;
cin >> a >> b >> c >> d >> e;
int f = 10;
if (a % 10 == 0)
g += a;
else {
g += a / 10 * 10 + 10;
f = min(f, a % 10);
}
if (b % 10 == 0)
... | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, g = 0;
cin >> a >> b >> c >> d >> e;
int f = 10;
if (a % 10 == 0)
g += a;
else {
g += a / 10 * 10 + 10;
f = min(f, a % 10);
}
if (b % 10 == 0)
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 890,014 | 890,015 | u683078179 | cpp |
p03076 | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, f = 10, g = 0;
cin >> a >> b >> c >> d >> e;
if (a % 10 != 0) {
f = min(f, a % 10);
g += (a / 10 + 1) * 10;
} else
g += a;
if (b % 10 != 0) {
f =... | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, f = 10, g = 0;
cin >> a >> b >> c >> d >> e;
if (a % 10 != 0) {
f = min(f, a % 10);
g += (a / 10 + 1) * 10;
} else
g += a;
if (b % 10 != 0) {
f =... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 890,016 | 890,017 | u683078179 | cpp |
p03076 | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, f = 10, g = 0;
cin >> a >> b >> c >> d >> e;
if (a % 10 != 0) {
f = min(f, a % 10);
g += (a / 10 + 1) * 10;
} else
g += a;
if (b % 10 != 0) {
f =... | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, f = 10, g = 0;
cin >> a >> b >> c >> d >> e;
if (a % 10 != 0) {
f = min(f, a % 10);
g += (a / 10 + 1) * 10;
} else
g += a;
if (b % 10 != 0) {
f =... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 890,019 | 890,017 | u683078179 | cpp |
p03076 | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, f = 10, g = 0;
cin >> a >> b >> c >> d >> e;
if (a % 10 != 0) {
f = min(f, a % 10);
g += (a / 10 + 1) * 10;
} else
g += a;
if (b % 10 != 0) {
f =... | #include <bits/stdc++.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int a, b, c, d, e, f = 10, g = 0;
cin >> a >> b >> c >> d >> e;
if (a % 10 != 0) {
f = min(f, a % 10);
g += (a / 10 + 1) * 10;
} else
g += a;
if (b % 10 != 0) {
f =... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 890,020 | 890,017 | u683078179 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
const int inf = 1012345678;
int main() {
vector<int> A(5);
cin >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
vector<int> P = {0, 1, 2, 3, 4};
int ans = inf;
do {
int tmp = 0;
for (int i = 0; i < 5; i++) {
while (ans % 10 != 0)
ans++; // 料理が注文可能に... | #include <bits/stdc++.h>
using namespace std;
const int inf = 1012345678;
int main() {
vector<int> A(5);
cin >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
vector<int> P = {0, 1, 2, 3, 4};
int ans = inf;
do {
int tmp = 0;
for (int i = 0; i < 5; i++) {
while (tmp % 10 != 0)
tmp++; // 料理が注文可能に... | [
"identifier.change",
"control_flow.loop.condition.change"
] | 890,039 | 890,040 | u336145516 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
const int inf = 1012345678;
int main() {
vector<int> A(5);
cin >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
vector<int> P = {0, 1, 2, 3, 4};
int ans = inf;
do {
int tmp = 0;
for (int i = 0; i < 5; i++) {
while (ans % 10 != 0)
ans++; // 料理が注文可能に... | #include <bits/stdc++.h>
using namespace std;
const int inf = 1012345678;
int main() {
vector<int> A(5);
cin >> A[0] >> A[1] >> A[2] >> A[3] >> A[4];
vector<int> P = {0, 1, 2, 3, 4};
int ans = inf;
do {
int tmp = 0;
for (int i = 0; i < 5; i++) {
while (tmp % 10 != 0)
tmp++; // 料理が注文可能に... | [
"identifier.change",
"control_flow.loop.condition.change",
"assignment.variable.change"
] | 890,041 | 890,040 | u336145516 | cpp |
p03076 | bool DBG = false;
// #pragma GCC optimize("Ofast")
// #pragma GCC
// target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_dec_float.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace s... | bool DBG = false;
// #pragma GCC optimize("Ofast")
// #pragma GCC
// target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_dec_float.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace s... | [
"call.remove"
] | 890,042 | 890,043 | u952090000 | cpp |
p03076 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef... | [
"control_flow.break.remove",
"control_flow.continue.add"
] | 890,081 | 890,082 | u950174376 | cpp |
p03076 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> Time(5);
for (int i = 0; i < 5; i++)
cin >> Time.at(i);
vector<int> Mod(5);
for (int i = 0; i < 5; i++)
Mod.at(i) = Time.at(i) % 10;
for (int i = 0; i < 5; i++) {
if (Mod.at(i) != 0)
Mod.at(i) = 10 - Mod.at(i);
}
int... | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> Time(5);
for (int i = 0; i < 5; i++)
cin >> Time.at(i);
vector<int> Mod(5);
for (int i = 0; i < 5; i++)
Mod.at(i) = Time.at(i) % 10;
for (int i = 0; i < 5; i++) {
if (Mod.at(i) != 0)
Mod.at(i) = 10 - Mod.at(i);
}
int... | [
"assignment.value.change",
"call.arguments.change",
"call.add"
] | 890,085 | 890,086 | u075250977 | cpp |
p03076 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int N = 5;
vector<int> time = {a, ... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int N = 5;
vector<int> time = {a, ... | [
"control_flow.branch.if.condition.change"
] | 890,096 | 890,097 | u224794697 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#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("ok1\n");
#define ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#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("ok1\n");
#define ... | [
"expression.operation.binary.remove",
"literal.string.change",
"io.output.change"
] | 890,102 | 890,103 | u373958718 | cpp |
p03075 | #include <algorithm>
#include <cmath>
#include <cstdio>
#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("ok1\n");
#define ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#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("ok1\n");
#define ... | [
"literal.string.change",
"io.output.change"
] | 890,104 | 890,103 | u373958718 | cpp |
p03075 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - a) < k)
cout << "Yay!";
else {
cout << ":(";
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a;
cin >> b;
cin >> c;
cin >> d;
cin >> e;
cin >> k;
if ((e - a) <= k)
cout << "Yay!";
else {
cout << ":(";
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 890,108 | 890,109 | u771072294 | 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;
int ab, ac, ad, ae;
ab = b - a;
ac = c - a;
ad = d - a;
ae = e - a;
if (ab < k && ac < k && ad < k && ae < 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;
int ab, ac, ad, ae;
ab = b - a;
ac = c - a;
ad = d - a;
ae = e - a;
if (ab <= k && ac <= k && ad <= k && ae <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 890,110 | 890,111 | u626360077 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.