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 9
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(false);
_main();
}
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int A[5], K;
//---------------------------------------------------------------------------------------------------
void _main() {
rep(i, 0, 5) cin >> A[i];
cin >> K;
if (K < A[4] - A[0])
printf("Yay!\n");
else
printf(":(\n");
} | #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(false);
_main();
}
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int A[5], K;
//---------------------------------------------------------------------------------------------------
void _main() {
rep(i, 0, 5) cin >> A[i];
cin >> K;
if (K < A[4] - A[0])
printf(":(\n");
else
printf("Yay!\n");
} | [
"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, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
const int inf = 1e9 + 7;
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dx[] = {1, -1, 0, 0, -1, 1, 1, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int k;
cin >> k;
cout << (e - a > k ? ":)" : "Yay!") << endl;
}
| #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, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
const int inf = 1e9 + 7;
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dx[] = {1, -1, 0, 0, -1, 1, 1, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int k;
cin >> k;
cout << (e - a > k ? ":(" : "Yay!") << endl;
}
| [
"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
cout << ":(" << endl;
return 0;
} | #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
cout << ":(" << endl;
return 0;
} | [
"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 \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
// cin>>n;
fs(ar, 5);
cin >> n;
sort(ar + 1, ar + 6);
if (ar[5] - ar[1] > n)
cout << "Yay!";
else
cout << ":(";
} | #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 \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false)
#define fast2 \
freopen("myfile.in", "r", stdin); \
freopen("myfile.out", "w", stdout);
#define mod 1000000007
#define fs(x, y) \
for (int i = 1; i <= y; i++) \
cin >> x[i]
#define fo(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
ll n, m, ar[N], sum;
int main() {
fast;
// cin>>n;
fs(ar, 5);
cin >> n;
sort(ar + 1, ar + 6);
if (ar[5] - ar[1] <= n)
cout << "Yay!";
else
cout << ":(";
} | [
"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 0;
} | [
"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 1e7
typedef long long ll;
typedef long long int lli;
int main() {
string res = "Yay!";
int n = 5;
int k;
vector<int> nums;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
nums.push_back(num);
}
cin >> k;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j <= n; j++) {
if (nums[j] - nums[i - 1] > k) {
res = ":(";
break;
}
}
}
cout << res << endl;
return 0;
} | #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 1e7
typedef long long ll;
typedef long long int lli;
int main() {
string res = "Yay!";
int n = 5;
int k;
vector<int> nums;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
nums.push_back(num);
}
cin >> k;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j <= n; j++) {
if (nums[j] - nums[i] > k) {
res = ":(";
break;
}
}
}
cout << res << endl;
return 0;
} | [
"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(int a, int b) {
if (b == 0)
return a;
else
return (b, a % b);
}
/*ll isp[N]={1};
void sieve(int n)
{
isp[0]=isp[1]=0;
for(int i=2;i<=n;i++)
{
if(isp[i]==1)
{
for(int j=i*i;j<=n;j+=i)
{
isp[j]==0;
}
}
}
}*/
ll pow(int x, int y, int m) {
ll ans = 1;
while (y != 0) {
if (y % 2 == 1) {
ans = (ans * x) % m;
}
x = (x * x) % m;
y /= 2;
}
return ans;
}
template <class x> void swap(x &a, x &b) {
x tp;
tp = a;
a = b;
b = tp;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll ar[5], k;
for (ll i = 0; i < 5; ++i) {
cin >> ar[i];
}
sort(ar, ar + 5);
cin >> k;
if (ar[4] - ar[0] <= k) {
cout << ":)\n";
} else {
cout << ":(\n";
}
return 0;
}
| // 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(int a, int b) {
if (b == 0)
return a;
else
return (b, a % b);
}
/*ll isp[N]={1};
void sieve(int n)
{
isp[0]=isp[1]=0;
for(int i=2;i<=n;i++)
{
if(isp[i]==1)
{
for(int j=i*i;j<=n;j+=i)
{
isp[j]==0;
}
}
}
}*/
ll pow(int x, int y, int m) {
ll ans = 1;
while (y != 0) {
if (y % 2 == 1) {
ans = (ans * x) % m;
}
x = (x * x) % m;
y /= 2;
}
return ans;
}
template <class x> void swap(x &a, x &b) {
x tp;
tp = a;
a = b;
b = tp;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll ar[5], k;
for (ll i = 0; i < 5; ++i) {
cin >> ar[i];
}
sort(ar, ar + 5);
cin >> k;
if (ar[4] - ar[0] <= k) {
cout << "Yay!\n";
} else {
cout << ":(\n";
}
return 0;
}
| [
"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) for (int i = (a); i > (b); i--)
typedef unsigned long long ull;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false); // Fast I/O
cin.tie(0);
cout.tie(0);
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
int k, a[5];
FOR(i, 0, 5)
cin >> a[i];
cin >> k;
if (k - a[0] <= k)
cout << "Yay!\n";
else
cout << ":(\n";
return 0;
}
| #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) for (int i = (a); i > (b); i--)
typedef unsigned long long ull;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false); // Fast I/O
cin.tie(0);
cout.tie(0);
// freopen("input.in","r",stdin);
// freopen("output.out","w",stdout);
int k, a[5];
FOR(i, 0, 5)
cin >> a[i];
cin >> k;
if (a[4] - a[0] <= k)
cout << "Yay!\n";
else
cout << ":(\n";
return 0;
}
| [
"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 <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned int UI;
#define rSort(a) sort(a.rbegin(), a.rend())
#define Sort(a) sort(a.begin(), a.end())
#define Reverse(a) reverse(a.begin(), a.end())
#define Sum(a) accumulate(a.begin(), a.end(), 0)
#define REP(i, n) for (UI i = 0; i < n; i++)
#define REPR(i, n) for (UI i = n; i >= 0; i--)
#define FOR(i, m, n) for (UI i = m; i < n; i++)
#define pb(i) push_back(i)
#define MOD (LL)1e9 + 7;
#define INF (LL)1 << 62;
#define INF_I (int)100000009;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int dis[5], k;
bool ret = true;
for (int i = 0; i < 5; i++) {
cin >> dis[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = k + 1; j <= 5; j++) {
if (dis[j] - dis[i] > k) {
ret = false;
}
}
}
if (ret) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | // ----------------------------------------------------------
#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 <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned int UI;
#define rSort(a) sort(a.rbegin(), a.rend())
#define Sort(a) sort(a.begin(), a.end())
#define Reverse(a) reverse(a.begin(), a.end())
#define Sum(a) accumulate(a.begin(), a.end(), 0)
#define REP(i, n) for (UI i = 0; i < n; i++)
#define REPR(i, n) for (UI i = n; i >= 0; i--)
#define FOR(i, m, n) for (UI i = m; i < n; i++)
#define pb(i) push_back(i)
#define MOD (LL)1e9 + 7;
#define INF (LL)1 << 62;
#define INF_I (int)100000009;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int dis[5], k;
bool ret = true;
for (int i = 0; i < 5; i++) {
cin >> dis[i];
}
cin >> k;
for (int i = 0; i < 5 - 1; i++) {
for (int j = i + 1; j < 5; j++) {
if (dis[j] - dis[i] > k) {
ret = false;
}
}
}
if (ret) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"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 <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
long long int INF = 3e18;
double Pi = 3.1415926535897932384626;
vector<ll> G[500005];
vector<P> tree[500010];
priority_queue<ll> pql;
priority_queue<P> pqp;
// big priority queue
priority_queue<ll, vector<ll>, greater<ll>> pqls;
priority_queue<P, vector<P>, greater<P>> pqps;
// small priority queue
// top pop
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};
char dir[] = "DRUL";
// ll bit[500005];
//↓,→,↑,←
#define p(x) cout << x << endl;
#define el cout << endl;
#define pe(x) cout << (x) << " ";
#define ps(x) cout << fixed << setprecision(25) << x << endl;
#define pu(x) cout << (x);
#define pd(x) cerr << "//" << (x) << endl;
#define re(i, n) \
for (i = 0; i < n; i++) \
;
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define deba(x) cout << #x << " = " << x << endl
ll mod = 1000000007;
ll rui(ll number1, ll number2) {
if (number2 == 0) {
return 1;
} else {
ll number3 = rui(number1, number2 / 2);
number3 *= number3;
number3 %= mod;
if (number2 % 2 == 1) {
number3 *= number1;
number3 %= mod;
}
return number3;
}
}
ll gcd(ll number1, ll number2) {
if (number1 > number2) {
swap(number1, number2);
}
if (number1 == 0 || number1 == number2) {
return number2;
} else {
return gcd(number2 % number1, number1);
}
}
void YES(bool condition) {
if (condition) {
p("YES");
} else {
p("NO");
}
return;
}
void Yes(bool condition) {
if (condition) {
p("Yes");
} else {
p("No");
}
return;
}
ll n, m, num, sum, ans, a, b, c, d, e, g, h, w, i, j, k, l, q;
ll x[500005], y[500005], z[500005];
bool dp[205][205];
char s[500005];
bool flag, dame;
ll fact[400005];
ll rfact[400005];
void c3_init() {
fact[0] = rfact[0] = 1;
for (ll i = 1; i < 400000; i++) {
fact[i] = (fact[i - 1] * i) % mod;
rfact[i] = rui(fact[i], mod - 2);
}
}
ll ncr(ll n, ll r) {
return (((fact[n] * rfact[r]) % mod) * rfact[n - r]) % mod;
}
int main() {
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
p("Yay!");
} else {
p(":(");
}
return 0;
} | #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 <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
long long int INF = 3e18;
double Pi = 3.1415926535897932384626;
vector<ll> G[500005];
vector<P> tree[500010];
priority_queue<ll> pql;
priority_queue<P> pqp;
// big priority queue
priority_queue<ll, vector<ll>, greater<ll>> pqls;
priority_queue<P, vector<P>, greater<P>> pqps;
// small priority queue
// top pop
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};
char dir[] = "DRUL";
// ll bit[500005];
//↓,→,↑,←
#define p(x) cout << x << endl;
#define el cout << endl;
#define pe(x) cout << (x) << " ";
#define ps(x) cout << fixed << setprecision(25) << x << endl;
#define pu(x) cout << (x);
#define pd(x) cerr << "//" << (x) << endl;
#define re(i, n) \
for (i = 0; i < n; i++) \
;
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define deba(x) cout << #x << " = " << x << endl
ll mod = 1000000007;
ll rui(ll number1, ll number2) {
if (number2 == 0) {
return 1;
} else {
ll number3 = rui(number1, number2 / 2);
number3 *= number3;
number3 %= mod;
if (number2 % 2 == 1) {
number3 *= number1;
number3 %= mod;
}
return number3;
}
}
ll gcd(ll number1, ll number2) {
if (number1 > number2) {
swap(number1, number2);
}
if (number1 == 0 || number1 == number2) {
return number2;
} else {
return gcd(number2 % number1, number1);
}
}
void YES(bool condition) {
if (condition) {
p("YES");
} else {
p("NO");
}
return;
}
void Yes(bool condition) {
if (condition) {
p("Yes");
} else {
p("No");
}
return;
}
ll n, m, num, sum, ans, a, b, c, d, e, g, h, w, i, j, k, l, q;
ll x[500005], y[500005], z[500005];
bool dp[205][205];
char s[500005];
bool flag, dame;
ll fact[400005];
ll rfact[400005];
void c3_init() {
fact[0] = rfact[0] = 1;
for (ll i = 1; i < 400000; i++) {
fact[i] = (fact[i - 1] * i) % mod;
rfact[i] = rui(fact[i], mod - 2);
}
}
ll ncr(ll n, ll r) {
return (((fact[n] * rfact[r]) % mod) * rfact[n - r]) % mod;
}
int main() {
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
p(":(");
} else {
p("Yay!");
}
return 0;
} | [
"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;
}
}
}
if (num == 0) {
cout << "Yay!";
} else {
cout << ":(";
}
system("pause");
return 0;
} | #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;
}
}
}
if (num == 0) {
cout << "Yay!";
} else {
cout << ":(";
}
system("pause");
return 0;
} | [
"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;
}
}
}
if (num == 0) {
cout << "Yay!";
} else {
cout << ":(";
}
system("pause");
return 0;
} | #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;
}
}
}
if (num == 0) {
cout << "Yay!";
} else {
cout << ":(";
}
system("pause");
return 0;
} | [
"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) {
vector.erase(vector.begin() + index);
}
#define rep(i, n, m) for (int i = n; i <= m; i++)
#define Rep(i, n, m) for (int i = m; i >= 1; i--)
typedef long long ll;
int main() {
vector<int> an(5);
rep(i, 0, 4) cin >> an[i];
int k;
cin >> k;
rep(i, 0, 3) {
rep(j, i + 1, 4) {
if (k < an[j] - an[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yey!" << endl;
return 0;
} | #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) {
vector.erase(vector.begin() + index);
}
#define rep(i, n, m) for (int i = n; i <= m; i++)
#define Rep(i, n, m) for (int i = m; i >= 1; i--)
typedef long long ll;
int main() {
vector<int> an(5);
rep(i, 0, 4) cin >> an[i];
int k;
cin >> k;
rep(i, 0, 3) {
rep(j, i + 1, 4) {
if (k < an[j] - an[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
return 0;
} | [
"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) {
vector.erase(vector.begin() + index);
}
#define rep(i, n, m) for (int i = n; i <= m; i++)
#define Rep(i, n, m) for (int i = m; i >= 1; i--)
typedef long long ll;
int main() {
vector<int> an(5);
rep(i, 0, 4) cin >> an[i];
int k;
cin >> k;
rep(i, 0, 4) {
rep(j, i + 1, 4) {
if (k < an[j] - an[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yey!" << endl;
return 0;
} | #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) {
vector.erase(vector.begin() + index);
}
#define rep(i, n, m) for (int i = n; i <= m; i++)
#define Rep(i, n, m) for (int i = m; i >= 1; i--)
typedef long long ll;
int main() {
vector<int> an(5);
rep(i, 0, 4) cin >> an[i];
int k;
cin >> k;
rep(i, 0, 3) {
rep(j, i + 1, 4) {
if (k < an[j] - an[i]) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
return 0;
} | [
"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!" << endl;
return 0;
}
| #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!" << endl;
return 0;
}
| [
"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;
}
// `.`..`(WNNNNNNMNWWWH9rttwgHM8OtttwwVtttrrtrttrw0rtrtwrrrtrZUAOOrrrXWppHMHyZHpWHMHMkWWVHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.`..`(WMNMHfWH9ZtrtAdNM8ttttOwVtrrtrrtrrrrrdrrttrZkOrrrrrrXWyrtrrZWWWWMmwXWppWHHMmWHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .`.```_..(HMfWH9OtttwXWHBrttrOw0rttrOvrrrtrZrrRrtrrrtZHwrrrrrwwZHyrrrrZWWpWMmwWppkWHHMkHNkVWMNNNNN#NN#NN#NN#NN#NN#NN#NN#NN#NN#NNNN
// .``..
// ..HNfWW9wtrrOdWHM0trttOdSrtrtwwrtrtrw0twSrtOrrrrZHwtrrrrrXwdWwrrrrXHppWNkXWpkvWH@MkHMHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// -jMWWXXwtrttO0d@BrtrttwXVrtrrwVrrrtrtXrrd0rrXrrrrrZWyrrrrrrZXwWyZOrrvWWpWMkZHbkwrdHMMKMMNHkHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// v8Xdk9ttttrOwXM0tttrtwXwwrtrw0rrtrrtwKrrd0rrXrtrrrrZHkwrrrrrrXkVkrrrvrZHWpHHkWkwrwvVHHNWMMMMkWMNNNNNNN#NN#NN#NN#NN#NN#NN#NNNN
// ..
// JHZdbKOrrrtrtwWWOOttrOwSzVrOrw0rrttrrrdRrrdZrrdOrtrtrrZHkXwrrrrrZWXHwwrrrvWWWWNkWkvrrrwWM@RMMMNNmWMNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .
// .JGXHStttttrtwW9OrtrrrdSX0rtrdStrtrtrrwHVrrdkrrtSrrrrrrrdMyXrrrrrvXWXWmwvrrvdHWWNkWyvvvvvT@MNWM#N#MNWMMNNNNNNNNNNNNNNNNNNNNNNNNN
// (.zqHXZtrttrrOwU0trttrOdWX0OtOdRrrtrrrrrdNrrrdkrrrXOwrrrrrrdNySrrrrrwXXkUmvvwvrZHWfNkUkvwvvvdMMMRM#MMNNNkMMNNNNNN#NN#NN#NN#NN#NNNN
// (wdS0OttrtOOrwSrtttrrtwKukrrrwKrrrrrtrrwW@rrrXKrrrZkr0OrrrrrWNwkrvvrrvzXkXHwvvrvwWVVHkUyrvvvvZHMMNWMMNNNNNkWMNNNNNNNNNNNNNNNNNNNNN
// wWtrrttrrOwrwStrttrtrwWZXOrtwX0rrrttrrrXMSrrrXWrrrrXrwvrrrrvZHHXkrrrrvrzWkXNyvrvvvWWWHHWwvvvvvwHNMHRM#NNNNNMmWMMNNNNNNNNNNNNNNNNNN
// 8OtttrwZwwtwSrrttrrrwdyXwtrrdWrrtrrrrrdWH0rrrXWOrrrwRz0rrvrrrdMHWwvvrrvvXWkWHyrvvvrWWWHkHvvvvvvwWMMMNWMMNNNNNMHWMMNMNNNN#NN#NNNNNN
// wttrrdVrZrwWwtOrrrrwdWX0rrtdH0rrrtrrtwWHHrrrrXWRrrvrXXXrrvrrrvXHkSwvvrvrrXWkVHyvvvvwHVWHWRvvvvvvdHdMMMKMNNNNNNNMNkWMNNNNNNNNNNNNNM
// ttrrd0rwrOX0rrtrrtwXHXSrwrwHKrtrtrrtrdWH#rrrrdpkrrrrvHwkwvrrvrZWHXkzzvvvvwUWkpNwvrvvZHfVNHwvvvvvzXHWMNMNMNNNNNNNN#NkWMNNNNNNNNNM3>
// rrrdSrwwtXSrrtrrrwXWWKwrrrdHXrrrrrrrwWWH#vrrrvWpvrrvrdRXwvrvrvvXHWWwkvvrvvwWWKWHzwvvvXHVWWHvzzzzvzWRHMMMNHMNNNNNNNNMNkMMNNNNNN@<<>
// OOd9rw0rdKOtrtrrruXHW0rrrdH#rrrrrrrrdpWp#rrrrrXWkvrvvrWwkrvrrvwwWHpKdvvrrvvXHHfWmdwvzwWHVHWkzzzzzzwWXHMHHNWMNNNNNNNNNMNkMNNNN#z>>>
// OdSOwSwwW0rrrrtrwXNW8rrtrWWSrtrrrrrrXpHWHvrrrrXpHrrrvwZHdyvvvvvvXHpHwkvvvvvrXHHfNwXvzzwWWWKHzzzzzzzWSWHHHMMKMNNNNNNNNNNMNKMNN#>>;>
// wWwOXrwX8rtrrrrwWWpHrrrrdNNrrrrrrrrwppNWHrvrvrypWwvvrrvXKWvrvrvvZXHHkXzvvvvvwWWWWNdkvvzXHfHWkXzzzzzwWXHHHHNMHMNNNNNNNNNNNNNWMN+>>>
// R0rd0rdKrrtrtrrdWHWSrrrwWWDrrrrrrrrXpWHqWvrrrvdWbRvvrvvwWZkvvvrvvXHbHzRvvvvvvdHHpHkWwvzXWHWHHzuzzzzzXXWHHHMHMNHMNNNNNNNNNNNMNWh<>>
// wOwSrwXSrtrtrrwHWWMwrrrdNWSrrrrrrrvppWpHprrvrvddWHwvvrrvXHXwvvvrvzXWHkXzvvvvvzWWKWNdRvzzXWWHHXzzzzzzzudWHbH@HNNWMNNNNNNNNNNNNNkHe>
// rOXwwwKrrrrrrrXWHHDrrwrdHHXwrrrrrrwpWWbHWvvvrvwHHpHrvvvrXWHWwvvrwwXHkHdkvzvvvvZHHpHKWzzzwWHWHRzzzzuzzzzWHHkHHMMNWMNNNNNNNNNNNNNNKm
// rdX0OXSrrtrrrdHHWMXrrrwHWHrrrrrrrrXppqWHWkrrvvwWMHHXwwvvvZWKRvvvvrWHWHwWvzvzzzzXWKWNXRzzwXWWNHzzzzzzzzzXUHkHWMMHNWMNNNNNNNNNNNNNNN
// wSwww#rrrrrrwWWHM#vrrrd#WKvrrrrrvvXppmWMWkvvvvwXNNpNvSXzzvdHkkvvzvdWWWRXwzzzzzzdNNpMkHzzzWVHHpXzzzzzzzzdkHkHHHNMHNkMNNNNNNNNNNNNNN
// XwSwWwrrrrrrdHWWMKrvrvWHWSrvrvvvvwpppHW#HRwUUUWWMMMMMHHHHmmXHWwvvzwWHbNwRzzzzzzzWWWWHWkzzdXWWWRzzzzzzzuzWWbHHWMNMMNkMNNNNNNNNNNNNN
// 8drd#rrrrrrwWWkHMmXmywMfWXrvrrrvrwppWNWMNWvrvvwvW#MNHmdkrvvXHMMmmwzdWpM0WzzzzzzzdHHWNUHzzzWWmHHzzuzzuzuzWXbbNkHMqMHNkHNNNNNNNNNNNN
// dSwWSrrrrrrdHHHMHrrrwWMfWvvvrvrrrdppWNW#WWRvvrvvdM?WNHkXkzvvdWMHXHNmHHHkfwzzzzzzXHHpMWHkzuXWHNWXzzuzzuzzXXkkHbHMHMMMMkMNNNNNNNNNNN
// Xrd#wrrrrrrXpHWH#rrrvdMWWvrrvrvvrdppWHW#(NWwvvvvwMr~TNHmdkvzvXWMKzzzWMHKXXzzzzzzuWHbHkWKuzdWWHWkzzzuzzuuXXHkHkgHk@H@HHkMNNNNNNNNNN
// RvWDrrrrrrwHWkMW#rvvrMMfWwrvrrvvrdppWHW@~?HHuvvrvdb_~?NWkdkzzzUWMkzuuWWHWXuzwzzuzXHHHKWHuzzWW@WRuzuzzzzzduWbHHgMH@HHHMMHMNNNNNNNNN
// rdHwrrrrrrXHHWNW#vvvdMMHWkvrvrrvrdppWbWD~~?XKkrrrwMc~~~THHZHwzzWHNkvzwMRdHHzuzzzzXHHWHXNkuzdWHkWuzzuzuzzXzWkHHHMHHHkH@MMNWMNNNNNNN
// rdHvrrrrrrWkHHHW#rrrd#dNWKrvrvvrvwbpWWW$...vVkkOrtXb~~~~(WHkWkvwWWMkzzWRXkSWXzzzuwmNWHXHRuuwHMKWzzuzzzuzXzWHWHHMHHHkkMMMHHWNNNNNNN
// wW#rrvrrrwHWHMpWNrvrd@(NWWvrrrrrvvWpWXH$..._?dkkttOWl~~~~~?HHdHXXbWMkzUHXWkzzzzzzuHNk#XHHzzukHHXzuzzzuzuXuXqkMHMHMbbkHHH@HNWMNNNNN
// dH#rrrvrrdNWWNpHHwrrd@_WHWkrvvrrrrZpWXWr...__?WkWyOvN~~~~~__7HkWkbbkNkzXHZkzzzuzzzWHW#ugbXuzWWHXXuzzuzuuuzXkkHHH@MbkHMHMHMMNWMNNNN
// X@KrrvrvrXNHWHpHHHrrdb~(NWHrrrrrrrrXWXWr..`...-7HZkzvn~~~~~~~_TNyHHkHMyzXkXuzzzzuuWHW#uHkkzzWHHXuzzzzuzzuuXHkHHHMNbkHHHHHHMMNWMNNN
// WHKvvrvrvXHNMbpHmHkOwb..?HWRrwOrtrtrWKWr`.`.`..._?6dkJn~~~~~~-_~7NHMHbNkuUkzzuzzzuWHW#uHbRzuXHHXzzuuuuzuuzXHkHHMMbkkHkMkkkMMMNUMMN
// WHKrrvrrvXqHMpfHHHWkrb...vkHyOrtttttdNXr.`.J>~-((J+ggQkHXHHHmaJz7&JWHMMWkuHXzuuuzzWgHHwHkKuzXMKXuzuuzuzzuzdkHHHHHkHWMHHbkWHMMMNXM#
// Wg#rvrvrrXmHNpfHHHMMRd-.._4kfyttttllOHWr``
// <udT"""7"""""TMHHMNHHMNgv4HMRXHXHwuzzzuWHHKXHkHzzXMSWzuzzuzuuzudbkHHHHkkHqHuWkWHHMMMNWM
// WHNrvrvvvXHmNppgg@MMMHr..` UkWOlllllldW$..?! ` `
// ?@MMHHMM#NMMmMkXXWkHuzuzuWNHSXHHHuuXNSWuzuuzuzuzuWkHNgMkkkMHSuWkqmqHHMNNK
// WHMkvvrvrXHHMppHHHMNMTN_``` 4kWOz====vXP` ` `
// ``.HggmgM@MH###NKkkuXWHzzuXHHMzdMHHuzWNXKzuuzuzuzuuHkHHNMkkHHBuzWkHHHHuHMMM
// WHHNzvvrvwHMMppHMMMM>.#L`````?kyy====?0S`` ` `
// ``...dmqqqmmHHHMMM#WRSzuzWHuzXHq#uWHHHzuWHXKzuzzuzuzuXHkHWMNkWM#uzuWHHHHSuuWM#
// WM@MkwvvrzXMMHpgHMMM[.MN.`````(HXy1???zd.`` ` ` `
// dHkkqkkqkHHHHHHMMWWXzzuzwWwXHHKXMkHHuXMRXSuuuzuuzuzXHkHdHHWHHXuuwWHqHHuXzXWM
// XHHMNyrvvwdW@HpHWMHML MM[` ` `.4kGz<<>Or``` `
// `dWpbbbbbHMMbbbHHMXXuzzuzuzXWHHSXMkHHuXMSXuzzuzzuzuzWkkHWMHMSwuzzXHkHHXuzuWd#
// dHHH@NyzwwwWHMHHWMMMR dW]`` ` ```(HZx<<<4.```` `` ``
// OZppfppppWfpWpK9NKXuuzuuzuXWHHudMqNHXWNuHuzzuzuzuzuHkHXMMBuuuzuuWkHHUuuuXSMS
// wWHMMMMkwwvdNpHHHM#MH-jWP``` `` ```7kI<:<h.``````` ``
// ,2OWVVyVVyWWWWIdMKWzuuuzzuXHHSwHHHHKXHHXSuuzuuzuzuXHHHXMXuuuuuuXHHHuzuuXSX#X
// wdWHMMMMmwXwHbpMNHMM@b.hb```````````
// 7x1_(>_```````````(x7UUUV0XwvCI1dMWKXuzzuzuWHHudMkgkWbMSXuzzzuzzuzuWkHSW#zXwXuXXWHHuuXXuWXWSX
// vvXWHMMHWNkvWHbbMWMMMN_JF.```` ``
// `````?1_(_.`.`........(<777=<<<><<+dMXUuzuuuuWWMRwMHWMkWHHXSuuzuzuzzuXqHHXMHUXuXXHHHSuuwuXWud8uH
// mzzXWH#zHbHkXNbbWMMMMD~(_```````````````
// .~_`.``.`.`.....___(<~(<<(<<dHkkuuuuuXkHHuWMkHkkkHSXXzuuzuuuuzXHHSd#uuXXWHHXuuuZuXSuqHudS
// UHzzXWSXXWbbHHHbWHMH#<~...```` ``````````````.```.`
// -_____<~~_<_<~~(jMWSuzuzuXWHMHXMHHHkkH#XSuzzuzuzuzuKkHXMQkWHHWUXuXXUuXUuXHuXBu
// .(Smd8wSvXbbbbHHHWHW3___.``````` ``
// ``````.```.```.`...._.._~~..~_~~(#WuzuuzXXkHMqMMHMkkkMUXuXzuuwuuzuXkHSWMWUUuuuXXUUuXHXXWSuXHXu
// .. JKwSvwzWkkkkHHHH5~~..```````````````````.```.````````.`
// .........dWSuuzzzdkHMW@MHMkkkHHXXuzuuXSuzuuWWHd#uuuXXkWSuXXWUXXHUXWHuuu
// .`(HXSzzzzwWbkWHNHr_...``````````````````.```````.```````.`.`..`.-.(HKuzzuuwHHMNMHHMkkkHHuZuuzuuXuuuuXkHWMHHHUUuXXXWHXXHHUuXW8uuuu
// .-MXWwzzzuzXkHHMHHN-.``````````
// ````````````.`.````.``.```.`.`....-dXUXuzuXHWHMMHHBWHMMMSZuzuuzXXzuuXHHMHMHkHHHHHHHWHHSuXkHWSuuuuX
// (#XKzzzzzuzuWHHkWHHp
// ``.````````````````````````.````````.....-((-(NSXuzzXHW@D:~`(/1-
// .kXuzuuzXSuuzXXkHWMHHHHHHHHMWuuuQXUXWuuuXuXH
// MXWzuzzzzzuXHHbHNMMMt`.```````````````````````````.`.` ..-J7"!``
// XKuzzuXHHM9;/<-.J-u!JXXuuzuXWuuuuXHHH#WMNHmkkkuXXkWUXXWXXuuuXqHH
// XWzzzzuzzwXHHHH#"````<.````````````````````.``.`...-c"7``` ` `
// `(BzuuuXmHH8<!(- ?_!`jWUuzuuuWuuuzXWHNH> ..7WHHqHmQkWWXXuuuuuXWqHH
// SwuzzzXuwXHNHY`` `` <,`.`````````````` `` ..J7=``` ` ` ``
// ````.#zuzXXHHH$~`` ```(_(HSuuuzuXSuzuuXHHWCi(` ._ ?WggHHHHWkkkkWHHHHMH
// zzzuzuzwWHMY!` ` ` `(&.```````````` ..J7^ `` ` ` ` ` `. .HXuuXWHW#!` `
// ```` (WUuzzuXXSzuuudHHXY$. : (..``.THHkqkHHHgHHMHkkk zzzzzzXHWK`` ` `` ` ` `
// TJ.``````..J7=```` ` ` ` ` `` ` `.8zuXXHHW=` ``
// ..(XSuuuuuXWuuuuXHWH5~~` .`_?_,-``.TMMMMMMHkkqqHHH zzuuzdHHkN ` ` ` `` `
// ``(Wm,.(J7!``` ` ``` `` `` ` ` ``` .SzuXWHHY ``
// .._~<~~(dSuuuzzXHuuuuXHWHD::?C._.( -`(!_1 ,WHqHHHmqHHHHN zuzXXHHkHM;` ` ` `
// `` ` .;jY= ` .``_`` ` ` ` ` `` ` `.dXuXWm@^
// .._~_.~~~~~(d0uuzuuXHUuuuXHWH5:::::::_.<&._4r?_.;WMMM@MMY"<!` zzXHHHHMHMb``
// `` ` `` `` .J! ` ..`_~ ` ` ` `` ` ` ``.JXXXHY!
// .__.....~.~~~-d0wuzuXXHSuuuXWWH$::::;:::;:+- ~`(.i +HqHHkkHL..`. XWHHHMMHMHM;
// ` ` ` ` ._`` ...(:.=_` ` ` ` ` ````
// .-dVT7^``````......~~~~~_jWuuuuuXHSuzuXHHH3<;:::::;;j<+z ``` -dHNkkMqkkN..``
// HHHMMHHHHNMN.`` ` ` `!`z(. ~..~ ! . ` `` ` ` `
// ..gHr``````````........~~~~_jWuuuuuXkSuuuXHWHC:;::;;:::+v>:((J<!(WHHMkkHNqkM;`..
// HMMkkHHHHM9?b `` ` ` `` .``. ` ` ` ` ``` 4HkkkH,
// ``````.`......~~~~_+KuuuzuXHSuuuXHHK<(::::::<;<J+g9>::;< .4NkkqMHqH]..`
// MHkHHHMM$<<:?L` `` ` ` ` ``.` ` !`` ` ` ` ` `
// ?HbkkHx``````.`..`...~~~~_jKuuuuuXHSuuuqMHD<:<;:<++ddNMB3:;::;:<`
// `,HkkqH@HH].`` kkHHkHY``` (;?h`` ` ` `` ```` ` ` ` ` ` ` ` `
// ```.4XWbHx```..`......~~~~_gKuuuuXWH0uuuXHH3:;++1z<jgMB3<::::::::~`
// `jMkqkHMHHF.`. kHHHH=` . ` _<?L ` ` ` ` ` ` ` ` ` ` ` ` ` ` ?kwWHp
// .`.......~_~~(dKuuuuXWHUuuXWH9++z1<;+jWB3::::;;;::;:;_`` MNkqkqMNMF..` HHk@!.
// ` ` ` ~?L ` ` `` ` `` `` ` ` ` ` ` ` ` `
// -WuXHh..`.....~~~~(dWuuuXXkHUuuXHH9>:<:++YY<:;::::;:::::;:::+.``?HHkHHHM>`.`
| #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;
}
// `.`..`(WNNNNNNMNWWWH9rttwgHM8OtttwwVtttrrtrttrw0rtrtwrrrtrZUAOOrrrXWppHMHyZHpWHMHMkWWVHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.`..`(WMNMHfWH9ZtrtAdNM8ttttOwVtrrtrrtrrrrrdrrttrZkOrrrrrrXWyrtrrZWWWWMmwXWppWHHMmWHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .`.```_..(HMfWH9OtttwXWHBrttrOw0rttrOvrrrtrZrrRrtrrrtZHwrrrrrwwZHyrrrrZWWpWMmwWppkWHHMkHNkVWMNNNNN#NN#NN#NN#NN#NN#NN#NN#NN#NN#NNNN
// .``..
// ..HNfWW9wtrrOdWHM0trttOdSrtrtwwrtrtrw0twSrtOrrrrZHwtrrrrrXwdWwrrrrXHppWNkXWpkvWH@MkHMHkWMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// -jMWWXXwtrttO0d@BrtrttwXVrtrrwVrrrtrtXrrd0rrXrrrrrZWyrrrrrrZXwWyZOrrvWWpWMkZHbkwrdHMMKMMNHkHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// `.`.
// v8Xdk9ttttrOwXM0tttrtwXwwrtrw0rrtrrtwKrrd0rrXrtrrrrZHkwrrrrrrXkVkrrrvrZHWpHHkWkwrwvVHHNWMMMMkWMNNNNNNN#NN#NN#NN#NN#NN#NN#NNNN
// ..
// JHZdbKOrrrtrtwWWOOttrOwSzVrOrw0rrttrrrdRrrdZrrdOrtrtrrZHkXwrrrrrZWXHwwrrrvWWWWNkWkvrrrwWM@RMMMNNmWMNNNNNNNNNNNNNNNNNNNNNNNNNNNN
// .
// .JGXHStttttrtwW9OrtrrrdSX0rtrdStrtrtrrwHVrrdkrrtSrrrrrrrdMyXrrrrrvXWXWmwvrrvdHWWNkWyvvvvvT@MNWM#N#MNWMMNNNNNNNNNNNNNNNNNNNNNNNNN
// (.zqHXZtrttrrOwU0trttrOdWX0OtOdRrrtrrrrrdNrrrdkrrrXOwrrrrrrdNySrrrrrwXXkUmvvwvrZHWfNkUkvwvvvdMMMRM#MMNNNkMMNNNNNN#NN#NN#NN#NN#NNNN
// (wdS0OttrtOOrwSrtttrrtwKukrrrwKrrrrrtrrwW@rrrXKrrrZkr0OrrrrrWNwkrvvrrvzXkXHwvvrvwWVVHkUyrvvvvZHMMNWMMNNNNNkWMNNNNNNNNNNNNNNNNNNNNN
// wWtrrttrrOwrwStrttrtrwWZXOrtwX0rrrttrrrXMSrrrXWrrrrXrwvrrrrvZHHXkrrrrvrzWkXNyvrvvvWWWHHWwvvvvvwHNMHRM#NNNNNMmWMMNNNNNNNNNNNNNNNNNN
// 8OtttrwZwwtwSrrttrrrwdyXwtrrdWrrtrrrrrdWH0rrrXWOrrrwRz0rrvrrrdMHWwvvrrvvXWkWHyrvvvrWWWHkHvvvvvvwWMMMNWMMNNNNNMHWMMNMNNNN#NN#NNNNNN
// wttrrdVrZrwWwtOrrrrwdWX0rrtdH0rrrtrrtwWHHrrrrXWRrrvrXXXrrvrrrvXHkSwvvrvrrXWkVHyvvvvwHVWHWRvvvvvvdHdMMMKMNNNNNNNMNkWMNNNNNNNNNNNNNM
// ttrrd0rwrOX0rrtrrtwXHXSrwrwHKrtrtrrtrdWH#rrrrdpkrrrrvHwkwvrrvrZWHXkzzvvvvwUWkpNwvrvvZHfVNHwvvvvvzXHWMNMNMNNNNNNNN#NkWMNNNNNNNNNM3>
// rrrdSrwwtXSrrtrrrwXWWKwrrrdHXrrrrrrrwWWH#vrrrvWpvrrvrdRXwvrvrvvXHWWwkvvrvvwWWKWHzwvvvXHVWWHvzzzzvzWRHMMMNHMNNNNNNNNMNkMMNNNNNN@<<>
// OOd9rw0rdKOtrtrrruXHW0rrrdH#rrrrrrrrdpWp#rrrrrXWkvrvvrWwkrvrrvwwWHpKdvvrrvvXHHfWmdwvzwWHVHWkzzzzzzwWXHMHHNWMNNNNNNNNNMNkMNNNN#z>>>
// OdSOwSwwW0rrrrtrwXNW8rrtrWWSrtrrrrrrXpHWHvrrrrXpHrrrvwZHdyvvvvvvXHpHwkvvvvvrXHHfNwXvzzwWWWKHzzzzzzzWSWHHHMMKMNNNNNNNNNNMNKMNN#>>;>
// wWwOXrwX8rtrrrrwWWpHrrrrdNNrrrrrrrrwppNWHrvrvrypWwvvrrvXKWvrvrvvZXHHkXzvvvvvwWWWWNdkvvzXHfHWkXzzzzzwWXHHHHNMHMNNNNNNNNNNNNNWMN+>>>
// R0rd0rdKrrtrtrrdWHWSrrrwWWDrrrrrrrrXpWHqWvrrrvdWbRvvrvvwWZkvvvrvvXHbHzRvvvvvvdHHpHkWwvzXWHWHHzuzzzzzXXWHHHMHMNHMNNNNNNNNNNNMNWh<>>
// wOwSrwXSrtrtrrwHWWMwrrrdNWSrrrrrrrvppWpHprrvrvddWHwvvrrvXHXwvvvrvzXWHkXzvvvvvzWWKWNdRvzzXWWHHXzzzzzzzudWHbH@HNNWMNNNNNNNNNNNNNkHe>
// rOXwwwKrrrrrrrXWHHDrrwrdHHXwrrrrrrwpWWbHWvvvrvwHHpHrvvvrXWHWwvvrwwXHkHdkvzvvvvZHHpHKWzzzwWHWHRzzzzuzzzzWHHkHHMMNWMNNNNNNNNNNNNNNKm
// rdX0OXSrrtrrrdHHWMXrrrwHWHrrrrrrrrXppqWHWkrrvvwWMHHXwwvvvZWKRvvvvrWHWHwWvzvzzzzXWKWNXRzzwXWWNHzzzzzzzzzXUHkHWMMHNWMNNNNNNNNNNNNNNN
// wSwww#rrrrrrwWWHM#vrrrd#WKvrrrrrvvXppmWMWkvvvvwXNNpNvSXzzvdHkkvvzvdWWWRXwzzzzzzdNNpMkHzzzWVHHpXzzzzzzzzdkHkHHHNMHNkMNNNNNNNNNNNNNN
// XwSwWwrrrrrrdHWWMKrvrvWHWSrvrvvvvwpppHW#HRwUUUWWMMMMMHHHHmmXHWwvvzwWHbNwRzzzzzzzWWWWHWkzzdXWWWRzzzzzzzuzWWbHHWMNMMNkMNNNNNNNNNNNNN
// 8drd#rrrrrrwWWkHMmXmywMfWXrvrrrvrwppWNWMNWvrvvwvW#MNHmdkrvvXHMMmmwzdWpM0WzzzzzzzdHHWNUHzzzWWmHHzzuzzuzuzWXbbNkHMqMHNkHNNNNNNNNNNNN
// dSwWSrrrrrrdHHHMHrrrwWMfWvvvrvrrrdppWNW#WWRvvrvvdM?WNHkXkzvvdWMHXHNmHHHkfwzzzzzzXHHpMWHkzuXWHNWXzzuzzuzzXXkkHbHMHMMMMkMNNNNNNNNNNN
// Xrd#wrrrrrrXpHWH#rrrvdMWWvrrvrvvrdppWHW#(NWwvvvvwMr~TNHmdkvzvXWMKzzzWMHKXXzzzzzzuWHbHkWKuzdWWHWkzzzuzzuuXXHkHkgHk@H@HHkMNNNNNNNNNN
// RvWDrrrrrrwHWkMW#rvvrMMfWwrvrrvvrdppWHW@~?HHuvvrvdb_~?NWkdkzzzUWMkzuuWWHWXuzwzzuzXHHHKWHuzzWW@WRuzuzzzzzduWbHHgMH@HHHMMHMNNNNNNNNN
// rdHwrrrrrrXHHWNW#vvvdMMHWkvrvrrvrdppWbWD~~?XKkrrrwMc~~~THHZHwzzWHNkvzwMRdHHzuzzzzXHHWHXNkuzdWHkWuzzuzuzzXzWkHHHMHHHkH@MMNWMNNNNNNN
// rdHvrrrrrrWkHHHW#rrrd#dNWKrvrvvrvwbpWWW$...vVkkOrtXb~~~~(WHkWkvwWWMkzzWRXkSWXzzzuwmNWHXHRuuwHMKWzzuzzzuzXzWHWHHMHHHkkMMMHHWNNNNNNN
// wW#rrvrrrwHWHMpWNrvrd@(NWWvrrrrrvvWpWXH$..._?dkkttOWl~~~~~?HHdHXXbWMkzUHXWkzzzzzzuHNk#XHHzzukHHXzuzzzuzuXuXqkMHMHMbbkHHH@HNWMNNNNN
// dH#rrrvrrdNWWNpHHwrrd@_WHWkrvvrrrrZpWXWr...__?WkWyOvN~~~~~__7HkWkbbkNkzXHZkzzzuzzzWHW#ugbXuzWWHXXuzzuzuuuzXkkHHH@MbkHMHMHMMNWMNNNN
// X@KrrvrvrXNHWHpHHHrrdb~(NWHrrrrrrrrXWXWr..`...-7HZkzvn~~~~~~~_TNyHHkHMyzXkXuzzzzuuWHW#uHkkzzWHHXuzzzzuzzuuXHkHHHMNbkHHHHHHMMNWMNNN
// WHKvvrvrvXHNMbpHmHkOwb..?HWRrwOrtrtrWKWr`.`.`..._?6dkJn~~~~~~-_~7NHMHbNkuUkzzuzzzuWHW#uHbRzuXHHXzzuuuuzuuzXHkHHMMbkkHkMkkkMMMNUMMN
// WHKrrvrrvXqHMpfHHHWkrb...vkHyOrtttttdNXr.`.J>~-((J+ggQkHXHHHmaJz7&JWHMMWkuHXzuuuzzWgHHwHkKuzXMKXuzuuzuzzuzdkHHHHHkHWMHHbkWHMMMNXM#
// Wg#rvrvrrXmHNpfHHHMMRd-.._4kfyttttllOHWr``
// <udT"""7"""""TMHHMNHHMNgv4HMRXHXHwuzzzuWHHKXHkHzzXMSWzuzzuzuuzudbkHHHHkkHqHuWkWHHMMMNWM
// WHNrvrvvvXHmNppgg@MMMHr..` UkWOlllllldW$..?! ` `
// ?@MMHHMM#NMMmMkXXWkHuzuzuWNHSXHHHuuXNSWuzuuzuzuzuWkHNgMkkkMHSuWkqmqHHMNNK
// WHMkvvrvrXHHMppHHHMNMTN_``` 4kWOz====vXP` ` `
// ``.HggmgM@MH###NKkkuXWHzzuXHHMzdMHHuzWNXKzuuzuzuzuuHkHHNMkkHHBuzWkHHHHuHMMM
// WHHNzvvrvwHMMppHMMMM>.#L`````?kyy====?0S`` ` `
// ``...dmqqqmmHHHMMM#WRSzuzWHuzXHq#uWHHHzuWHXKzuzzuzuzuXHkHWMNkWM#uzuWHHHHSuuWM#
// WM@MkwvvrzXMMHpgHMMM[.MN.`````(HXy1???zd.`` ` ` `
// dHkkqkkqkHHHHHHMMWWXzzuzwWwXHHKXMkHHuXMRXSuuuzuuzuzXHkHdHHWHHXuuwWHqHHuXzXWM
// XHHMNyrvvwdW@HpHWMHML MM[` ` `.4kGz<<>Or``` `
// `dWpbbbbbHMMbbbHHMXXuzzuzuzXWHHSXMkHHuXMSXuzzuzzuzuzWkkHWMHMSwuzzXHkHHXuzuWd#
// dHHH@NyzwwwWHMHHWMMMR dW]`` ` ```(HZx<<<4.```` `` ``
// OZppfppppWfpWpK9NKXuuzuuzuXWHHudMqNHXWNuHuzzuzuzuzuHkHXMMBuuuzuuWkHHUuuuXSMS
// wWHMMMMkwwvdNpHHHM#MH-jWP``` `` ```7kI<:<h.``````` ``
// ,2OWVVyVVyWWWWIdMKWzuuuzzuXHHSwHHHHKXHHXSuuzuuzuzuXHHHXMXuuuuuuXHHHuzuuXSX#X
// wdWHMMMMmwXwHbpMNHMM@b.hb```````````
// 7x1_(>_```````````(x7UUUV0XwvCI1dMWKXuzzuzuWHHudMkgkWbMSXuzzzuzzuzuWkHSW#zXwXuXXWHHuuXXuWXWSX
// vvXWHMMHWNkvWHbbMWMMMN_JF.```` ``
// `````?1_(_.`.`........(<777=<<<><<+dMXUuzuuuuWWMRwMHWMkWHHXSuuzuzuzzuXqHHXMHUXuXXHHHSuuwuXWud8uH
// mzzXWH#zHbHkXNbbWMMMMD~(_```````````````
// .~_`.``.`.`.....___(<~(<<(<<dHkkuuuuuXkHHuWMkHkkkHSXXzuuzuuuuzXHHSd#uuXXWHHXuuuZuXSuqHudS
// UHzzXWSXXWbbHHHbWHMH#<~...```` ``````````````.```.`
// -_____<~~_<_<~~(jMWSuzuzuXWHMHXMHHHkkH#XSuzzuzuzuzuKkHXMQkWHHWUXuXXUuXUuXHuXBu
// .(Smd8wSvXbbbbHHHWHW3___.``````` ``
// ``````.```.```.`...._.._~~..~_~~(#WuzuuzXXkHMqMMHMkkkMUXuXzuuwuuzuXkHSWMWUUuuuXXUUuXHXXWSuXHXu
// .. JKwSvwzWkkkkHHHH5~~..```````````````````.```.````````.`
// .........dWSuuzzzdkHMW@MHMkkkHHXXuzuuXSuzuuWWHd#uuuXXkWSuXXWUXXHUXWHuuu
// .`(HXSzzzzwWbkWHNHr_...``````````````````.```````.```````.`.`..`.-.(HKuzzuuwHHMNMHHMkkkHHuZuuzuuXuuuuXkHWMHHHUUuXXXWHXXHHUuXW8uuuu
// .-MXWwzzzuzXkHHMHHN-.``````````
// ````````````.`.````.``.```.`.`....-dXUXuzuXHWHMMHHBWHMMMSZuzuuzXXzuuXHHMHMHkHHHHHHHWHHSuXkHWSuuuuX
// (#XKzzzzzuzuWHHkWHHp
// ``.````````````````````````.````````.....-((-(NSXuzzXHW@D:~`(/1-
// .kXuzuuzXSuuzXXkHWMHHHHHHHHMWuuuQXUXWuuuXuXH
// MXWzuzzzzzuXHHbHNMMMt`.```````````````````````````.`.` ..-J7"!``
// XKuzzuXHHM9;/<-.J-u!JXXuuzuXWuuuuXHHH#WMNHmkkkuXXkWUXXWXXuuuXqHH
// XWzzzzuzzwXHHHH#"````<.````````````````````.``.`...-c"7``` ` `
// `(BzuuuXmHH8<!(- ?_!`jWUuzuuuWuuuzXWHNH> ..7WHHqHmQkWWXXuuuuuXWqHH
// SwuzzzXuwXHNHY`` `` <,`.`````````````` `` ..J7=``` ` ` ``
// ````.#zuzXXHHH$~`` ```(_(HSuuuzuXSuzuuXHHWCi(` ._ ?WggHHHHWkkkkWHHHHMH
// zzzuzuzwWHMY!` ` ` `(&.```````````` ..J7^ `` ` ` ` ` `. .HXuuXWHW#!` `
// ```` (WUuzzuXXSzuuudHHXY$. : (..``.THHkqkHHHgHHMHkkk zzzzzzXHWK`` ` `` ` ` `
// TJ.``````..J7=```` ` ` ` ` `` ` `.8zuXXHHW=` ``
// ..(XSuuuuuXWuuuuXHWH5~~` .`_?_,-``.TMMMMMMHkkqqHHH zzuuzdHHkN ` ` ` `` `
// ``(Wm,.(J7!``` ` ``` `` `` ` ` ``` .SzuXWHHY ``
// .._~<~~(dSuuuzzXHuuuuXHWHD::?C._.( -`(!_1 ,WHqHHHmqHHHHN zuzXXHHkHM;` ` ` `
// `` ` .;jY= ` .``_`` ` ` ` ` `` ` `.dXuXWm@^
// .._~_.~~~~~(d0uuzuuXHUuuuXHWH5:::::::_.<&._4r?_.;WMMM@MMY"<!` zzXHHHHMHMb``
// `` ` `` `` .J! ` ..`_~ ` ` ` `` ` ` ``.JXXXHY!
// .__.....~.~~~-d0wuzuXXHSuuuXWWH$::::;:::;:+- ~`(.i +HqHHkkHL..`. XWHHHMMHMHM;
// ` ` ` ` ._`` ...(:.=_` ` ` ` ` ````
// .-dVT7^``````......~~~~~_jWuuuuuXHSuzuXHHH3<;:::::;;j<+z ``` -dHNkkMqkkN..``
// HHHMMHHHHNMN.`` ` ` `!`z(. ~..~ ! . ` `` ` ` `
// ..gHr``````````........~~~~_jWuuuuuXkSuuuXHWHC:;::;;:::+v>:((J<!(WHHMkkHNqkM;`..
// HMMkkHHHHM9?b `` ` ` `` .``. ` ` ` ` ``` 4HkkkH,
// ``````.`......~~~~_+KuuuzuXHSuuuXHHK<(::::::<;<J+g9>::;< .4NkkqMHqH]..`
// MHkHHHMM$<<:?L` `` ` ` ` ``.` ` !`` ` ` ` ` `
// ?HbkkHx``````.`..`...~~~~_jKuuuuuXHSuuuqMHD<:<;:<++ddNMB3:;::;:<`
// `,HkkqH@HH].`` kkHHkHY``` (;?h`` ` ` `` ```` ` ` ` ` ` ` ` `
// ```.4XWbHx```..`......~~~~_gKuuuuXWH0uuuXHH3:;++1z<jgMB3<::::::::~`
// `jMkqkHMHHF.`. kHHHH=` . ` _<?L ` ` ` ` ` ` ` ` ` ` ` ` ` ` ?kwWHp
// .`.......~_~~(dKuuuuXWHUuuXWH9++z1<;+jWB3::::;;;::;:;_`` MNkqkqMNMF..` HHk@!.
// ` ` ` ~?L ` ` `` ` `` `` ` ` ` ` ` ` ` `
// -WuXHh..`.....~~~~(dWuuuXXkHUuuXHH9>:<:++YY<:;::::;:::::;:::+.``?HHkHHHM>`.`
| [
"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 < 5; i++)
scanf("%d", &a[i]);
scanf("%d", &m);
flag = 1;
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 5; j++)
if (a[j] - a[i] >= m)
flag = 0;
}
if (flag)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | #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 < 5; i++)
scanf("%d", &a[i]);
scanf("%d", &m);
flag = 1;
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 5; j++)
if (a[j] - a[i] > m)
flag = 0;
}
if (flag)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | [
"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>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
typedef complex<ld> Point;
const ll mod = 1000000007;
const ll INF = mod * mod;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
void solve() {
int a[5];
rep(i, 5) cin >> a[i];
int k;
cin >> k;
if (k <= a[4] - a[0]) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
}
int main() {
solve();
// stop
return 0;
}
| #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>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
typedef complex<ld> Point;
const ll mod = 1000000007;
const ll INF = mod * mod;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
void solve() {
int a[5];
rep(i, 5) cin >> a[i];
int k;
cin >> k;
if (k >= a[4] - a[0]) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
}
int main() {
solve();
// stop
return 0;
}
| [
"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())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) unique(v.begin(), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int>>
#define all(v) (v).begin(), (v).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1ll << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a[5], k;
rep(i, 0, 5) cin >> a[i];
cin >> k;
sort(a, a + 5);
if (a[4] - a[0] < k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| #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())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) unique(v.begin(), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int>>
#define all(v) (v).begin(), (v).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1ll << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a[5], k;
rep(i, 0, 5) cin >> a[i];
cin >> k;
sort(a, a + 5);
if (a[4] - a[0] <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| [
"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 ll long long
#define MOD 1000000007
#define INF 2000000000
#define LINF 9000000000000000000
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define du(x) cout << #x << '=' << x << endl
#define du2(x, y) \
cout << #x << '=' << x << ' ' << #y << '=' << y << '\n' << endl
#define du3(x, y, z) \
cout << #x << '=' << x << ' ' << #y << '=' << y << ' ' << #z << '=' << z \
<< '\n' \
<< endl
#define darr(arr, n) \
rep(i, (n - arr)) { cout << *(arr + i) << ' '; } \
cout << endl
#define ddarr(arr, a, b) \
rep(i, a) { \
rep(j, b) { cout << *(arr + i * b + j) << ' '; } \
cout << endl; \
}
#define ddd \
ifstream in("Text.txt"); \
cin.rdbuf(in.rdbuf());
int a[10];
int main() {
rep(i, 6) cin >> a[i];
sort(a, a + 5);
if (abs(a[0] - a[4]) < a[5])
cout << "Yay!" << endl;
else
cout << ":(" << endl;
} | #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 ll long long
#define MOD 1000000007
#define INF 2000000000
#define LINF 9000000000000000000
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define du(x) cout << #x << '=' << x << endl
#define du2(x, y) \
cout << #x << '=' << x << ' ' << #y << '=' << y << '\n' << endl
#define du3(x, y, z) \
cout << #x << '=' << x << ' ' << #y << '=' << y << ' ' << #z << '=' << z \
<< '\n' \
<< endl
#define darr(arr, n) \
rep(i, (n - arr)) { cout << *(arr + i) << ' '; } \
cout << endl
#define ddarr(arr, a, b) \
rep(i, a) { \
rep(j, b) { cout << *(arr + i * b + j) << ' '; } \
cout << endl; \
}
#define ddd \
ifstream in("Text.txt"); \
cin.rdbuf(in.rdbuf());
int a[10];
int main() {
rep(i, 6) cin >> a[i];
sort(a, a + 5);
if (abs(a[0] - a[4]) <= a[5])
cout << "Yay!" << endl;
else
cout << ":(" << endl;
} | [
"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 int
// stod(s): string to double
// INT_MAX
// INT_MIN
// LLONG_MAX
// LLONG_MIN
// DBL_MIN
// DBL_MAX
// LDBL_MIN
// LDBL_MAX
// A-Z: 65~90
// a-z: 97~122
// |a-z| = 26
using namespace std;
using ll = long long;
int main(int argc, const char *argv[]) {
vector<int> v(5);
for (int i = 0; i < 5; i++) {
cin >> v[i];
}
int k;
cin >> k;
if (v[4] - v[0] < k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
}
| #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 int
// stod(s): string to double
// INT_MAX
// INT_MIN
// LLONG_MAX
// LLONG_MIN
// DBL_MIN
// DBL_MAX
// LDBL_MIN
// LDBL_MAX
// A-Z: 65~90
// a-z: 97~122
// |a-z| = 26
using namespace std;
using ll = long long;
int main(int argc, const char *argv[]) {
vector<int> v(5);
for (int i = 0; i < 5; i++) {
cin >> v[i];
}
int k;
cin >> k;
if (v[4] - v[0] <= k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
}
| [
"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 <typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
int main() {
vector<int> a;
REP(i, 5) cin >> a[i];
int k;
cin >> k;
REP(i, 5) FOR(j, i + 1, 5) {
if (a[j] - a[i] > k) {
cout << ":(" << endl;
return 0;
}
}
cout << "Yay!" << endl;
return 0;
}
| #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 <typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
int main() {
vector<int> a(5);
REP(i, 5) cin >> a[i];
int k;
cin >> k;
REP(i, 5) FOR(j, i + 1, 5) {
if (a[j] - a[i] > k) {
cout << ":(" << endl;
return 0;
}
}
cout << "Yay!" << endl;
return 0;
}
| [
"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;
#define all(v) v.begin(), v.end()
#define MP make_pair
#define pb push_back
using P = pair<int, int>;
signed main() {
int a[5], k;
rep(i, 5) cin >> a[i];
cin >> k;
rep(i, 5) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j]) >= k) {
put(":(");
return 0;
}
}
}
put("Yay!");
} | #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;
#define all(v) v.begin(), v.end()
#define MP make_pair
#define pb push_back
using P = pair<int, int>;
signed main() {
int a[5], k;
rep(i, 5) cin >> a[i];
cin >> k;
rep(i, 5) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j]) > k) {
put(":(");
return 0;
}
}
}
put("Yay!");
} | [
"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 {
ans = "Yay!";
}
cout << ans << endl;
return 0;
}
| #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 {
ans = "Yay!";
}
cout << ans << endl;
return 0;
}
| [
"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, l)); // lで初期化
#define vvll(vec, n, m, l) vector<vector<ll>> vec(n, vector<ll>(m, l));
#define vint vector<int>
#define pint pair<int, int>
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(x) (x).begin(), (x).end()
#define debug system("pause")
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int a[5], k;
bool b;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j]) > k)
b = true;
}
}
if (b) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | #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, l)); // lで初期化
#define vvll(vec, n, m, l) vector<vector<ll>> vec(n, vector<ll>(m, l));
#define vint vector<int>
#define pint pair<int, int>
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(x) (x).begin(), (x).end()
#define debug system("pause")
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int a[5], k;
bool b = false;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j]) > k)
b = true;
}
}
if (b) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | [
"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)
ju = 1;
}
}
if (ju == 0)
cout << "Yay!\n";
else
cout << ":(\n";
} | #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)
ju = 1;
}
}
if (ju == 0)
cout << "Yay!\n";
else
cout << ":(\n";
} | [
"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!" << std::endl;
return 0;
}
| #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!" << std::endl;
return 0;
}
| [
"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; ++i)
#define forn(i, n) for (int i = 0; i < n; ++i)
#define sz(x) int(x.size())
#define error(x) cout << #x << " " << x << endl
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
const int N = 100 * 1000;
const int mod = 1e9 + 7;
int min3(int a, int b, int c) { return min(a, min(b, c)); }
int max3(int a, int b, int c) { return max(a, max(b, c)); }
int min4(int a, int b, int c, int d) { return min(min(a, b), min(c, d)); }
int max4(int a, int b, int c, int d) { return max(max(a, b), max(c, d)); }
//#define int int64_t
int a[N + 2];
int32_t main() {
IOS;
for (int i = 1; i <= 5; ++i)
cin >> a[i];
int k;
cin >> k;
for (int i = 1; i <= 5; ++i) {
for (int j = i + 1; j <= 5; ++j) {
if (abs(a[i] - a[j]) <= k) {
cout << "Yay!\n";
return 0;
}
}
}
cout << ":(\n";
return 0;
}
| #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; ++i)
#define forn(i, n) for (int i = 0; i < n; ++i)
#define sz(x) int(x.size())
#define error(x) cout << #x << " " << x << endl
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
const int N = 100 * 1000;
const int mod = 1e9 + 7;
int min3(int a, int b, int c) { return min(a, min(b, c)); }
int max3(int a, int b, int c) { return max(a, max(b, c)); }
int min4(int a, int b, int c, int d) { return min(min(a, b), min(c, d)); }
int max4(int a, int b, int c, int d) { return max(max(a, b), max(c, d)); }
//#define int int64_t
int a[N + 2];
int32_t main() {
IOS;
for (int i = 1; i <= 5; ++i)
cin >> a[i];
int k;
cin >> k;
for (int i = 1; i <= 5; ++i) {
for (int j = i + 1; j <= 5; ++j) {
if (abs(a[i] - a[j]) > k) {
cout << ":(\n";
return 0;
}
}
}
cout << "Yay!\n";
return 0;
}
| [
"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;
}
}
}
cout << "Yay!";
return EXIT_SUCCESS;
} | #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;
}
}
}
cout << "Yay!";
return EXIT_SUCCESS;
} | [
"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];
int main() {
int k;
bool flag = true;
for (int i = 0; i < 5; i++) {
cin >> num[i];
}
cin >> k;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
if (num[j] - num[i] > k) {
flag = false;
}
}
}
if (flag) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | #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];
int main() {
int k;
bool flag = true;
for (int i = 0; i < 5; i++) {
cin >> num[i];
}
cin >> k;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (num[j] - num[i] > k) {
flag = false;
}
}
}
if (flag) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | [
"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]); }
fornum(i, 0, 4) {
if (a[i + 1] - a[i] > a[5]) {
printf(":(");
return 0;
}
}
printf("Yay!");
return 0;
} | #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]); }
fornum(i, 0, 4) {
if (a[i + 1] - a[0] > a[5]) {
printf(":(");
return 0;
}
}
printf("Yay!");
return 0;
} | [
"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;
return 0;
} | #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;
return 0;
}
| [
"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>::min() / 10;
static ll imax = std::numeric_limits<ll>::max() / 10;
#define rep(i, n) for (ll i = 0; (i) < (n); ++(i))
#define rep1(i, n) for (ll i = 1; (i) < (n); ++(i))
#define rev_rep(i, n) for (ll i = (n)-1; (i) >= 0; --(i))
#define range(a, i, b) for (ll i = (a); (i) < (b); ++(i))
#ifdef LOCAL
#define dump(x) cout << #x << ":" << (x) << "\n";
#endif
#ifndef LOCAL
#define dump(x)
#endif
#define all(v) v.begin(), v.end()
#define readl(N) \
ll N; \
cin >> N;
#define readlv(N, vec) \
vector<ll> vec(N); \
rep(i, N) { cin >> vec[i]; }
#define greater_than [](ll l, ll r) { return l > r; }
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::map<T1, T2> &mp);
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::pair<T1, T2> &pair);
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &vec);
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::pair<T1, T2> &pair) {
os << '(' << pair.first << ',' << pair.second << ')';
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &vec) {
std::size_t n = vec.size();
if (n == 0) {
return os;
}
os << " ";
for (ll i = 0; i < n - 1; ++i) {
os << vec[i] << " ";
}
os << vec[n - 1];
os << std::endl;
return os;
}
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::map<T1, T2> &mp) {
std::size_t n = mp.size();
if (n == 0) {
return os;
}
os << " ";
for (auto &&x : mp) {
os << x << " ";
}
os << std::endl;
return os;
}
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> &mp) {
std::size_t n = mp.size();
if (n == 0) {
return os;
}
os << " ";
for (auto &&x : mp) {
os << x << " ";
}
os << std::endl;
return os;
}
template <class T> inline bool chmin(T &a, T const b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T const b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(ll n) {
ll res = 1;
while (n > 0) {
res *= n;
n--;
}
return res;
}
ll pow(ll i, ll n) {
ll res = 1;
while (n >= 0) {
res *= i;
n--;
}
return res;
}
ll gcd(ll l, ll r) {
if (l < r) {
return gcd(r, l);
}
if (r == 0) {
return l;
}
return gcd(r, l % r);
}
template <class T> vector<T> accum_sum(vector<T> const &a) {
vector<T> b(a.size() + 1);
b[0] = 0;
rep(i, a.size()) { b[i + 1] = b[i] + a[i]; }
return b;
}
class modint {
public:
using ll = long long;
ll num;
static const ll MOD = 1e9 + 7;
static vector<modint> factorial;
modint() : num(0){};
modint(ll _n) : num((_n + MOD) % MOD) {}
modint(const modint &r) : num(r.num) {}
operator ll() const { return (num + MOD) % MOD; }
friend istream &operator>>(istream &is, modint &r) {
ll num_;
is >> num_;
r = num_;
return is;
}
modint operator+(const modint &r) const { return modint(num + r.num); }
modint operator-(const modint &r) const { return modint(num - r.num); }
modint operator*(const modint &r) const { return modint(num * r.num); }
template <typename T> modint operator^(const T &r) const {
if (r == 0)
return 1;
return (((*this) * (*this)) ^ (r / 2)) * modint(r & 1 ? num : 1);
}
modint operator/(const modint &r) const { return num * (r ^ (MOD - 2)); }
modint operator+=(const modint &r) { return *this = *this + r; }
modint operator-=(const modint &r) { return *this = *this - r; }
modint operator*=(const modint &r) { return *this = *this * r; }
modint operator/=(const modint &r) { return *this = *this / r; }
template <typename T> modint operator^=(const T &r) {
return *this = *this ^ r;
}
static modint fact(int n) {
if ((int)factorial.size() <= n)
factorial.resize(n + 1);
if (factorial[n])
return factorial[n];
if (n == 0)
return 1;
return factorial[n] = modint(n) * fact(n - 1);
}
static modint com(modint n, modint r) {
return n >= r ? fact(n) / (fact(n - r) * fact(r)) : modint(0);
}
};
vector<modint> modint::factorial;
constexpr ll mod = 1e9 + 7;
bool isprime(ll n) {
if (n < 2) {
return false;
}
range(2, i, sqrt(n) + 1) {
if (n == i) {
break;
}
if (n % i == 0) {
return false;
}
}
return true;
}
template <class ValueType> auto mkVec(ValueType init, size_t x) {
return vector<ValueType>(x, init);
}
template <class ValueType, class... Ns>
auto mkVec(ValueType init, size_t n, Ns... ns) {
return vector<decltype(mkVec(init, ns...))>(n, mkVec(init, ns...));
}
int main(int argc, char const *argv[]) {
vector<ll> v(6);
rep(i, 6) { cin >> v[i]; }
dump(v);
if (v[4] - v[0] < v[5]) {
cout << "Yay!" << endl;
dump(v[4] - v[0]);
} else {
cout << ":(" << endl;
}
return 0;
}
| #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>::min() / 10;
static ll imax = std::numeric_limits<ll>::max() / 10;
#define rep(i, n) for (ll i = 0; (i) < (n); ++(i))
#define rep1(i, n) for (ll i = 1; (i) < (n); ++(i))
#define rev_rep(i, n) for (ll i = (n)-1; (i) >= 0; --(i))
#define range(a, i, b) for (ll i = (a); (i) < (b); ++(i))
#ifdef LOCAL
#define dump(x) cout << #x << ":" << (x) << "\n";
#endif
#ifndef LOCAL
#define dump(x)
#endif
#define all(v) v.begin(), v.end()
#define readl(N) \
ll N; \
cin >> N;
#define readlv(N, vec) \
vector<ll> vec(N); \
rep(i, N) { cin >> vec[i]; }
#define greater_than [](ll l, ll r) { return l > r; }
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::map<T1, T2> &mp);
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::pair<T1, T2> &pair);
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &vec);
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::pair<T1, T2> &pair) {
os << '(' << pair.first << ',' << pair.second << ')';
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &vec) {
std::size_t n = vec.size();
if (n == 0) {
return os;
}
os << " ";
for (ll i = 0; i < n - 1; ++i) {
os << vec[i] << " ";
}
os << vec[n - 1];
os << std::endl;
return os;
}
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::map<T1, T2> &mp) {
std::size_t n = mp.size();
if (n == 0) {
return os;
}
os << " ";
for (auto &&x : mp) {
os << x << " ";
}
os << std::endl;
return os;
}
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> &mp) {
std::size_t n = mp.size();
if (n == 0) {
return os;
}
os << " ";
for (auto &&x : mp) {
os << x << " ";
}
os << std::endl;
return os;
}
template <class T> inline bool chmin(T &a, T const b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T const b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(ll n) {
ll res = 1;
while (n > 0) {
res *= n;
n--;
}
return res;
}
ll pow(ll i, ll n) {
ll res = 1;
while (n >= 0) {
res *= i;
n--;
}
return res;
}
ll gcd(ll l, ll r) {
if (l < r) {
return gcd(r, l);
}
if (r == 0) {
return l;
}
return gcd(r, l % r);
}
template <class T> vector<T> accum_sum(vector<T> const &a) {
vector<T> b(a.size() + 1);
b[0] = 0;
rep(i, a.size()) { b[i + 1] = b[i] + a[i]; }
return b;
}
class modint {
public:
using ll = long long;
ll num;
static const ll MOD = 1e9 + 7;
static vector<modint> factorial;
modint() : num(0){};
modint(ll _n) : num((_n + MOD) % MOD) {}
modint(const modint &r) : num(r.num) {}
operator ll() const { return (num + MOD) % MOD; }
friend istream &operator>>(istream &is, modint &r) {
ll num_;
is >> num_;
r = num_;
return is;
}
modint operator+(const modint &r) const { return modint(num + r.num); }
modint operator-(const modint &r) const { return modint(num - r.num); }
modint operator*(const modint &r) const { return modint(num * r.num); }
template <typename T> modint operator^(const T &r) const {
if (r == 0)
return 1;
return (((*this) * (*this)) ^ (r / 2)) * modint(r & 1 ? num : 1);
}
modint operator/(const modint &r) const { return num * (r ^ (MOD - 2)); }
modint operator+=(const modint &r) { return *this = *this + r; }
modint operator-=(const modint &r) { return *this = *this - r; }
modint operator*=(const modint &r) { return *this = *this * r; }
modint operator/=(const modint &r) { return *this = *this / r; }
template <typename T> modint operator^=(const T &r) {
return *this = *this ^ r;
}
static modint fact(int n) {
if ((int)factorial.size() <= n)
factorial.resize(n + 1);
if (factorial[n])
return factorial[n];
if (n == 0)
return 1;
return factorial[n] = modint(n) * fact(n - 1);
}
static modint com(modint n, modint r) {
return n >= r ? fact(n) / (fact(n - r) * fact(r)) : modint(0);
}
};
vector<modint> modint::factorial;
constexpr ll mod = 1e9 + 7;
bool isprime(ll n) {
if (n < 2) {
return false;
}
range(2, i, sqrt(n) + 1) {
if (n == i) {
break;
}
if (n % i == 0) {
return false;
}
}
return true;
}
template <class ValueType> auto mkVec(ValueType init, size_t x) {
return vector<ValueType>(x, init);
}
template <class ValueType, class... Ns>
auto mkVec(ValueType init, size_t n, Ns... ns) {
return vector<decltype(mkVec(init, ns...))>(n, mkVec(init, ns...));
}
int main(int argc, char const *argv[]) {
vector<ll> v(6);
rep(i, 6) { cin >> v[i]; }
dump(v);
if (v[4] - v[0] <= v[5]) {
cout << "Yay!" << endl;
dump(v[4] - v[0]);
} else {
cout << ":(" << endl;
}
return 0;
}
| [
"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;
if (d - a > k) {
cout << ":(" << endl;
return 0;
}
cout << "Yay!" << endl;
return 0;
} | #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;
if (e - a > k) {
cout << ":(" << endl;
return 0;
}
cout << "Yay!" << endl;
return 0;
} | [
"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 <typename T, typename U> inline void amax(T &x, U y) {
if (x < y)
x = y;
}
const ll inf = 1LL << 58;
const int iinf = 1 << 30;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a < k) {
cc("Yay!");
} else {
cc(":(");
}
} | #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 <typename T, typename U> inline void amax(T &x, U y) {
if (x < y)
x = y;
}
const ll inf = 1LL << 58;
const int iinf = 1 << 30;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= k) {
cc("Yay!");
} else {
cc(":(");
}
} | [
"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 >> d >> e >> k;
if (e - a < k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| #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 >> d >> e >> k;
if (e - a <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| [
"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"
#define MIN(con) (*min_element(ALL(con)))
#define MAX(con) (*max_element(ALL(con)))
#define NX(cont) next_permutation(ALL(cont))
#define PX(cont) prev_permutation(ALL(cont))
#define prec(n) cout << fixed << setprecision(n)
#define PI 3.14159265358979323846264338327951
#define all(c) c.begin(), c.end()
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define sp cout << " "
#define ifalse ios_base::sync_with_stdio(false), cin.tie(NULL)
#define debug(x) cout << #x << " = " << x << "\n";
using ll = long long;
using ld = long double;
template <typename T> T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T> T LCM(T a, T b) { return (a * b) / GCD(a, b); }
template <typename T> string toString(T a) { return to_string(a); }
template <typename T> void toInt(string s, T &x) {
stringstream str(s);
str >> x;
}
ll add(ll x, ll y, ll MOD) {
x += y;
if (x >= MOD)
x -= MOD;
return x;
}
ll sub(ll x, ll y, ll MOD) {
x -= y;
if (x < 0)
x += MOD;
return x;
}
ll mul(ll x, ll y, ll MOD) { return ((x % MOD) * (y % MOD)) % MOD; }
ll powr(ll a, ll b, ll MOD) {
ll x = 1LL;
while (b) {
if (b & 1)
x = mul(x, a, MOD);
a = mul(a, a, MOD);
b >>= 1;
}
return x;
}
ll inv(ll a, ll MOD) { return powr(a, MOD - 2, MOD); }
const ll INF = 1e18;
const int SINF = 1e9;
const ll MOD = 1e9 + 7;
bool check(ll n) {
if (n == 1)
return 0;
if (n == 2 or n == 3)
return 1;
if (n % 2 == 0 or n % 3 == 0)
return 0;
for (ll i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0)
return 0;
return 1;
}
/************************************START***************************************/
const int N = 100005;
int main() {
ifalse;
vector<int> v;
rep(i, 0, 5) {
int x;
cin >> x;
v.pb(x);
}
int k;
cin >> k;
bool flag = 0;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(v[i] - v[j]) < k) {
} else {
flag = 1;
}
}
}
if (!flag) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | /*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"
#define MIN(con) (*min_element(ALL(con)))
#define MAX(con) (*max_element(ALL(con)))
#define NX(cont) next_permutation(ALL(cont))
#define PX(cont) prev_permutation(ALL(cont))
#define prec(n) cout << fixed << setprecision(n)
#define PI 3.14159265358979323846264338327951
#define all(c) c.begin(), c.end()
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define sp cout << " "
#define ifalse ios_base::sync_with_stdio(false), cin.tie(NULL)
#define debug(x) cout << #x << " = " << x << "\n";
using ll = long long;
using ld = long double;
template <typename T> T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T> T LCM(T a, T b) { return (a * b) / GCD(a, b); }
template <typename T> string toString(T a) { return to_string(a); }
template <typename T> void toInt(string s, T &x) {
stringstream str(s);
str >> x;
}
ll add(ll x, ll y, ll MOD) {
x += y;
if (x >= MOD)
x -= MOD;
return x;
}
ll sub(ll x, ll y, ll MOD) {
x -= y;
if (x < 0)
x += MOD;
return x;
}
ll mul(ll x, ll y, ll MOD) { return ((x % MOD) * (y % MOD)) % MOD; }
ll powr(ll a, ll b, ll MOD) {
ll x = 1LL;
while (b) {
if (b & 1)
x = mul(x, a, MOD);
a = mul(a, a, MOD);
b >>= 1;
}
return x;
}
ll inv(ll a, ll MOD) { return powr(a, MOD - 2, MOD); }
const ll INF = 1e18;
const int SINF = 1e9;
const ll MOD = 1e9 + 7;
bool check(ll n) {
if (n == 1)
return 0;
if (n == 2 or n == 3)
return 1;
if (n % 2 == 0 or n % 3 == 0)
return 0;
for (ll i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0)
return 0;
return 1;
}
/************************************START***************************************/
const int N = 100005;
int main() {
ifalse;
vector<int> v;
rep(i, 0, 5) {
int x;
cin >> x;
v.pb(x);
}
int k;
cin >> k;
bool flag = 0;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (abs(v[i] - v[j]) <= k) {
} else {
flag = 1;
}
}
}
if (!flag) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | [
"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++) {
cin >> a[i];
}
int k;
cin >> k;
bool f = true;
if (a[4] - a[0] < k)
f = false;
if (!f)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
}
| #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++) {
cin >> a[i];
}
int k;
cin >> k;
bool f = true;
if (a[4] - a[0] <= k)
f = false;
if (!f)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
}
| [
"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) {
flg = false;
}
}
}
if (flg == true) {
cout << 'Yay!' << endl;
} else {
cout << ':(' << endl;
}
return 0;
} | #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) {
flg = false;
}
}
}
if (flg == true) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"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) {
flg = false;
}
}
}
if (flg == true) {
cout << 'Yay!' << endl;
} else {
cout << ':(' << endl;
}
return 0;
} | #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) {
flg = false;
}
}
}
if (flg == true) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"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;
return 0;
} | #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;
return 0;
} | [
"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 << ans << endl;
}
| #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 << ans << endl;
}
| [
"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;
int main() {
vector<int> a(5);
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int k;
cin >> k;
sort(ALL(a));
if (a[4] - a[0] <= k)
puts("Yey!");
else
puts(":(");
return 0;
}
| #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;
int main() {
vector<int> a(5);
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
int k;
cin >> k;
sort(ALL(a));
if (a[4] - a[0] <= k)
puts("Yay!");
else
puts(":(");
return 0;
}
| [
"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::cout << ":(" << std::endl;
}
}
| #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::cout << ":(" << std::endl;
}
} | [
"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::cout << ":(" << std::endl;
}
}
| #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::cout << ":(" << std::endl;
}
}
| [
"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 (num[tmp2] - num[tmp1] >= k) {
det = true;
}
}
}
if (det == false) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | #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[tmp2] - num[tmp1] > k) {
det = true;
}
}
}
if (det == false) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"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[tmp2] - num[tmp1] >= k) {
det = true;
}
}
}
if (det == false) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | #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[tmp2] - num[tmp1] > k) {
det = true;
}
}
}
if (det == false) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"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 \
cin.tie(0); \
ios::sync_with_stdio(false);
template <class T> using V = vector<T>;
template <class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll HIGHINF = (ll)1e18;
const ll LOWINF = (ll)1e15;
const long double PI = 3.1415926535897932384626433;
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const multiset<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
template <template <class tmp> class T, class U>
ostream &operator<<(ostream &o, const T<U> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max<T>(a, b); }
template <class T> void chmin(T &a, const T b) { a = min<T>(a, b); }
void YN(bool flg) { cout << ((flg) ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << ((flg) ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << ((flg) ? "yes" : "no") << endl; }
int main() {
V<int> a(5);
REP(i, 5) cin >> a[i];
int k;
cin >> k;
sort(ALL(a));
corner(k < a[5] - a[0], ":(");
cout << "Yay!" << endl;
return 0;
}
| #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 \
cin.tie(0); \
ios::sync_with_stdio(false);
template <class T> using V = vector<T>;
template <class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll MOD2 = 998244353;
const ll HIGHINF = (ll)1e18;
const ll LOWINF = (ll)1e15;
const long double PI = 3.1415926535897932384626433;
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const multiset<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
template <template <class tmp> class T, class U>
ostream &operator<<(ostream &o, const T<U> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max<T>(a, b); }
template <class T> void chmin(T &a, const T b) { a = min<T>(a, b); }
void YN(bool flg) { cout << ((flg) ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << ((flg) ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << ((flg) ? "yes" : "no") << endl; }
int main() {
V<int> a(5);
REP(i, 5) cin >> a[i];
int k;
cin >> k;
sort(ALL(a));
corner(k < a[4] - a[0], ":(");
cout << "Yay!" << endl;
return 0;
}
| [
"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 << " min" << min << endl;
ans = max - min;
if (ans < k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | #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" << min << endl;
ans = max - min;
// cout << "ans:" << ans << endl;
if (ans > k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | [
"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)
#define INF 100000000
#define debug(x) cout << #x << ": " << x << endl
#define all(x) x.begin(), x.end()
typedef pair<int, int> P;
typedef pair<int, P> PP;
int a[5];
int b;
int main() {
rep(i, 5) cin >> a[i];
cin >> b;
sort(a, a + 5);
if (a[4] - a[0] < b)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | #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)
#define INF 100000000
#define debug(x) cout << #x << ": " << x << endl
#define all(x) x.begin(), x.end()
typedef pair<int, int> P;
typedef pair<int, P> PP;
int a[5];
int b;
int main() {
rep(i, 5) cin >> a[i];
cin >> b;
sort(a, a + 5);
if (a[4] - a[0] <= b)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
return 0;
} | [
"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) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | #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) {
cout << "Yay!";
} else {
cout << ":(";
}
return 0;
} | [
"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; i--)
#define rreps(i, x) for (int i = ((int)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define INF 2e9
#define MOD 1000000007
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
typedef std::pair<ll, ll> P;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
using namespace std;
int main() {
int a[5];
int k;
rep(i, 5) cin >> a[i];
cin >> k;
int flag = 1;
rep(i, 4) {
for (int j = i + 1; j < 5; j++) {
if (a[j] - a[i] > 15)
flag *= 0;
}
}
if (flag == 0)
cout << ":(";
else if (flag == 1)
cout << "Yay!";
} | #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; i--)
#define rreps(i, x) for (int i = ((int)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define INF 2e9
#define MOD 1000000007
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
typedef std::pair<ll, ll> P;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
using namespace std;
int main() {
int a[5];
int k;
rep(i, 5) cin >> a[i];
cin >> k;
int flag = 1;
rep(i, 4) {
for (int j = i + 1; j < 5; j++) {
if (a[j] - a[i] > k)
flag *= 0;
}
}
if (flag == 0)
cout << ":(";
else if (flag == 1)
cout << "Yay!";
} | [
"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)
cout << "yay\n";
else
cout << ":(\n";
return 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) {
yay = 1;
break;
}
}
}
if (yay == 0)
cout << "Yay!\n";
else
cout << ":(\n";
return 0;
}
| [
"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 >= n)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
return 0;
}
| #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 > n)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
return 0;
}
| [
"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 ((max - min) > k)
cout << ":(" << endl;
if ((max - min) < k)
cout << "Yay!" << endl;
return 0;
} | #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 ((max - min) > k)
cout << ":(" << endl;
if ((max - min) <= k)
cout << "Yay!" << endl;
return 0;
} | [
"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 ((max - min) > k)
cout << ":(" << endl;
else if ((max - min) < k)
cout << "Yay!" << endl;
return 0;
} | #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 ((max - min) > k)
cout << ":(" << endl;
if ((max - min) <= k)
cout << "Yay!" << endl;
return 0;
} | [
"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 ((max - min) > k)
cout << ":(" << endl;
else if ((max - min) < k)
cout << "Yay!" << endl;
return 0;
} | #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 ((max - min) > k)
cout << ":(" << endl;
if ((max - min) <= k)
cout << "Yay!" << endl;
return 0;
} | [
"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 ((max - min) > k)
cout << ":(" << endl;
else if ((max - min) < k)
cout << "Yay!" << endl;
return 0;
} | #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 ((max - min) > k)
cout << ":(" << endl;
if ((max - min) <= k)
cout << "Yay!" << endl;
return 0;
} | [
"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;
break;
}
}
if (flag == 0)
break;
}
if (flag == 0)
cout << ":(\n";
else
cout << "Yay!\n";
}
| #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;
break;
}
}
if (flag == 0)
break;
}
if (flag == 0)
cout << ":(\n";
else
cout << "Yay!\n";
}
| [
"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;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end()
#define loop(i, times) for (llong i = 0; i < times; i++)
#define rloop(i, times) for (llong i = times - 1; 0 <= i; i--)
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
int main(void) {
// ABC123B abc123b;
llong k;
llong a[5];
loop(i, 5) cin >> a[i];
cin >> k;
rloop(i, 4) {
if (a[i] - a[0] > k) {
cout << ":(";
return 0;
}
}
cout << "Yay!";
return 0;
}
| #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;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end()
#define loop(i, times) for (llong i = 0; i < times; i++)
#define rloop(i, times) for (llong i = times - 1; 0 <= i; i--)
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
int main(void) {
// ABC123B abc123b;
// abc123b.Run();
llong k;
llong a[5];
loop(i, 5) cin >> a[i];
cin >> k;
rloop(i, 5) {
if (a[i] - a[0] > k) {
cout << ":(";
return 0;
}
}
cout << "Yay!";
return 0;
} | [
"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 <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
//------------------------------------------
// typedef
//------------------------------------------
typedef long long LL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef vector<VI> VVI;
typedef vector<VB> VVB;
typedef vector<VS> VVS;
typedef vector<VLL> VVLL;
typedef vector<VVI> VVVI;
typedef vector<VVLL> VVVLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<int, string> PIS;
typedef pair<string, int> PSI;
typedef pair<string, string> PSS;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<VPII> VVPII;
typedef vector<VPLL> VVPLL;
typedef vector<VS> VVS;
//------------------------------------------
// comparison
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a = min((a), (b))
#define CHMAX(a, b) a = max((a), (b))
#define C_ABS(a, b) ((a) < (b) ? (b) - (a) : (a) - (b))
//------------------------------------------
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define EACH(i, arr) \
for (typeof((arr).begin()) i = (arr).begin(); i != (arr).end(); ++i)
#define EXIST(str, e) ((str).find(e) != (str).end())
#define COUNT(arr, v) count((arr).begin(), (arr).end(), v)
#define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end())
#define B_SEARCH(arr, v) binary_search((arr).begin(), (arr).end(), v)
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define ROTATE_LEFT(arr, c) \
rotate((arr).begin(), (arr).begin() + (c), (arr).end())
#define ROTATE_RIGHT(arr, c) \
rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend())
#define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0)
#define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.)
#define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL)
#define SUMS(arr) accumulate((arr).begin(), (arr).end(), string())
#define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n)
#define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n)
#define OF_ALL(arr, func) all_of((arr).begin(), (arr).end(), (func))
#define OF_NONE(arr, func) none_of((arr).begin(), (arr).end(), (func))
#define OF_ANY(arr, func) any_of((arr).begin(), (arr).end(), (func))
#define PB push_back
#define MP make_pair
//------------------------------------------
// input output
//------------------------------------------
#define GL(s) getline(cin, (s))
#define INIT() \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define OUT(d) std::cout << (d)
#define OUT_L(d) std::cout << (d) << endl
#define FOUT(n, data) std::cout << std::fixed << std::setprecision(n) << (data)
#define FOUT_L(n, data) \
std::cout << std::fixed << std::setprecision(n) << (data) << "\n"
#define EL() printf("\n")
#define SHOW_VECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOW_MAP(v) \
{ \
std::cerr << #v << endl; \
for (const auto &xxx : v) { \
std::cerr << xxx.first << " " << xxx.second << "\n"; \
} \
}
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define YES() printf("YES\n")
#define NO() printf("NO\n")
//------------------------------------------
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FORLL(i, a, b) for (LL i = LL(a); i < LL(b); ++i)
#define RFORLL(i, a, b) for (LL i = LL(b) - 1; i >= LL(a); --i)
#define REPLL(i, n) for (LL i = 0; i < LL(n); ++i)
#define RREPLL(i, n) for (LL i = LL(n) - 1; i >= 0; --i)
#define FOREACH(x, arr) for (auto &(x) : (arr))
#define FORITER(x, arr) for (auto(x) = (arr).begin(); (x) != (arr).end(); ++(x))
//**************************************
//最大公約数
//**************************************
template <class T> inline T GCD(const T x, const T y) {
if (x < 0)
return GCD(-x, y);
if (y < 0)
return GCD(x, -y);
return (!y) ? x : GCD(y, x % y);
}
//**************************************
// nの約数
//**************************************
template <typename T> vector<T> DIVISOR(T n) {
vector<T> v;
for (LL i = 1; i * i <= n; ++i) {
if (n % i == 0) {
v.push_back(i);
if (i != n / i) {
v.push_back(n / i);
}
}
}
sort(v.begin(), v.end());
return v;
}
//------------------------------------------
// global
//------------------------------------------
// int A = 0;
LL A = 0;
// int B = 0;
LL B = 0;
LL C = 0;
LL D = 0;
LL E = 0;
LL N = 0;
LL M = 0;
LL K = 0;
LL H = 0;
LL W = 0;
LL Q = 0;
string S = "";
VPLL Pair;
LL i, j, k = 0;
LL ans, ans1, ans2 = 0;
VLL S_NUM;
VC t;
/*
std::string str[3];
int h[100] = {0};
int h_size = 0;
int MinCount = 0;
LL i,j,k = 0;
LL ans1,ans2 = 0;
VLL A;
LL K;
LL K_pow = 0;
LL K_num = 1;
LL tmp = 0;
*/
//------------------------------------------
// read
//------------------------------------------
void read(void) { cin >> A >> B >> C >> D >> E >> K; }
int main() {
LL sum = 0;
LL num = 0;
bool flag = false;
VLL tmp;
// 初期化
INIT();
// 読込み
read();
if ((E - A) >= K) {
printf(":(\n");
} else {
printf("Yay!\n");
}
return 0;
} | //------------------------------------------
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
//------------------------------------------
// typedef
//------------------------------------------
typedef long long LL;
typedef vector<int> VI;
typedef vector<bool> VB;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<LL> VLL;
typedef vector<VI> VVI;
typedef vector<VB> VVB;
typedef vector<VS> VVS;
typedef vector<VLL> VVLL;
typedef vector<VVI> VVVI;
typedef vector<VVLL> VVVLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<int, string> PIS;
typedef pair<string, int> PSI;
typedef pair<string, string> PSS;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<VPII> VVPII;
typedef vector<VPLL> VVPLL;
typedef vector<VS> VVS;
//------------------------------------------
// comparison
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a = min((a), (b))
#define CHMAX(a, b) a = max((a), (b))
#define C_ABS(a, b) ((a) < (b) ? (b) - (a) : (a) - (b))
//------------------------------------------
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define EACH(i, arr) \
for (typeof((arr).begin()) i = (arr).begin(); i != (arr).end(); ++i)
#define EXIST(str, e) ((str).find(e) != (str).end())
#define COUNT(arr, v) count((arr).begin(), (arr).end(), v)
#define SEARCH(v, w) search((v).begin(), (v).end(), (w).begin(), (w).end())
#define B_SEARCH(arr, v) binary_search((arr).begin(), (arr).end(), v)
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define ROTATE_LEFT(arr, c) \
rotate((arr).begin(), (arr).begin() + (c), (arr).end())
#define ROTATE_RIGHT(arr, c) \
rotate((arr).rbegin(), (arr).rbegin() + (c), (arr).rend())
#define SUMI(arr) accumulate((arr).begin(), (arr).end(), 0)
#define SUMD(arr) accumulate((arr).begin(), (arr).end(), 0.)
#define SUMLL(arr) accumulate((arr).begin(), (arr).end(), 0LL)
#define SUMS(arr) accumulate((arr).begin(), (arr).end(), string())
#define UB(arr, n) upper_bound((arr).begin(), (arr).end(), n)
#define LB(arr, n) lower_bound((arr).begin(), (arr).end(), n)
#define OF_ALL(arr, func) all_of((arr).begin(), (arr).end(), (func))
#define OF_NONE(arr, func) none_of((arr).begin(), (arr).end(), (func))
#define OF_ANY(arr, func) any_of((arr).begin(), (arr).end(), (func))
#define PB push_back
#define MP make_pair
//------------------------------------------
// input output
//------------------------------------------
#define GL(s) getline(cin, (s))
#define INIT() \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define OUT(d) std::cout << (d)
#define OUT_L(d) std::cout << (d) << endl
#define FOUT(n, data) std::cout << std::fixed << std::setprecision(n) << (data)
#define FOUT_L(n, data) \
std::cout << std::fixed << std::setprecision(n) << (data) << "\n"
#define EL() printf("\n")
#define SHOW_VECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOW_MAP(v) \
{ \
std::cerr << #v << endl; \
for (const auto &xxx : v) { \
std::cerr << xxx.first << " " << xxx.second << "\n"; \
} \
}
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define YES() printf("YES\n")
#define NO() printf("NO\n")
//------------------------------------------
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FORLL(i, a, b) for (LL i = LL(a); i < LL(b); ++i)
#define RFORLL(i, a, b) for (LL i = LL(b) - 1; i >= LL(a); --i)
#define REPLL(i, n) for (LL i = 0; i < LL(n); ++i)
#define RREPLL(i, n) for (LL i = LL(n) - 1; i >= 0; --i)
#define FOREACH(x, arr) for (auto &(x) : (arr))
#define FORITER(x, arr) for (auto(x) = (arr).begin(); (x) != (arr).end(); ++(x))
//**************************************
//最大公約数
//**************************************
template <class T> inline T GCD(const T x, const T y) {
if (x < 0)
return GCD(-x, y);
if (y < 0)
return GCD(x, -y);
return (!y) ? x : GCD(y, x % y);
}
//**************************************
// nの約数
//**************************************
template <typename T> vector<T> DIVISOR(T n) {
vector<T> v;
for (LL i = 1; i * i <= n; ++i) {
if (n % i == 0) {
v.push_back(i);
if (i != n / i) {
v.push_back(n / i);
}
}
}
sort(v.begin(), v.end());
return v;
}
//------------------------------------------
// global
//------------------------------------------
// int A = 0;
LL A = 0;
// int B = 0;
LL B = 0;
LL C = 0;
LL D = 0;
LL E = 0;
LL N = 0;
LL M = 0;
LL K = 0;
LL H = 0;
LL W = 0;
LL Q = 0;
string S = "";
VPLL Pair;
LL i, j, k = 0;
LL ans, ans1, ans2 = 0;
VLL S_NUM;
VC t;
/*
std::string str[3];
int h[100] = {0};
int h_size = 0;
int MinCount = 0;
LL i,j,k = 0;
LL ans1,ans2 = 0;
VLL A;
LL K;
LL K_pow = 0;
LL K_num = 1;
LL tmp = 0;
*/
//------------------------------------------
// read
//------------------------------------------
void read(void) { cin >> A >> B >> C >> D >> E >> K; }
int main() {
LL sum = 0;
LL num = 0;
bool flag = false;
VLL tmp;
// 初期化
INIT();
// 読込み
read();
if ((E - A) > K) {
printf(":(\n");
} else {
printf("Yay!\n");
}
return 0;
} | [
"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 << "Yey!" << endl;
}
return 0;
}
| #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 << "Yay!" << endl;
}
return 0;
}
| [
"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)
ans = false;
}
}
cout << (ans ? "Yey!" : ":(") << endl;
return 0;
}
| // 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)
ans = false;
}
}
cout << (ans ? "Yay!" : ":(") << endl;
return 0;
}
| [
"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 < min + k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
} | #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 <= min + k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
} | [
"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 << ":(" << endl;
return 0;
}
| #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 << ":(" << endl;
return 0;
}
| [
"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 << ":(" << endl;
return 0;
}
| #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 << ":(" << endl;
return 0;
}
| [
"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.