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 |
|---|---|---|---|---|---|---|---|
p03129 | #include <iostream>
// #include<vector>
// #include<algorithm>
// #include<math.h>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
bool result = true;
int count = 1;
for (int i = 1; i <= N; i += 2) {
count++;
}
if (count < K) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} // g++ -std=c++11 test.cpp -o test && ./test | #include <iostream>
// #include<vector>
// #include<algorithm>
// #include<math.h>
using namespace std;
int main() {
int K, N;
cin >> N >> K;
bool result = true;
int count = 1;
for (int i = 1; i + 2 <= N; i += 2) {
count++;
}
if (count < K) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} // g++ -std=c++11 test.cpp -o test && ./test | [
"control_flow.loop.for.condition.change"
] | 931,532 | 931,533 | u822172788 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n - k >= k - 1) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n - k >= k - 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,535 | 931,537 | u280512618 | cpp |
p03129 | #pragma comment(linker, "/STACK:102400000,102400000")
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define vi vector<int>
#define pii pair<int, int>
#define x first
#define y second
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define SZ(x) (int)x.size()
#define rep(i, a, b) for (int i = a; i < b; i++)
#define per(i, a, b) for (int i = b - 1; i >= a; i--)
#define pi acos(-1)
#define mod 1000000007
#define inf 1000000007
#define ll long long
#define ull unsigned long long
#define DBG(x) cerr << (#x) << "=" << x << "\n";
#define N 100010
#define _DEBUG
template <class U, class T> void Max(U &x, T y) {
if (x < y)
x = y;
}
template <class U, class T> void Min(U &x, T y) {
if (x > y)
x = y;
}
template <class T> void add(int &a, T b) { a = (a + b) % mod; }
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
inline ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1)
ans = 1LL * ans * a % mod;
a = 1LL * a * a % mod;
b >>= 1;
}
return ans;
}
int pow(int a, int b, int c) {
int ans = 1;
while (b) {
if (b & 1)
ans = 1LL * ans * a % c;
a = 1LL * a * a % c;
b >>= 1;
}
return ans;
}
int main() {
// srand(time(NULL)+clock());
int T, ca = 0, k, i, j, m = 0, K, n;
// double start=clock();
scanf("%d%d", &n, &K);
if (K >= (n + 1) / 2)
puts("YES");
else
puts("NO");
// cerr<<(1.*clock()-start)/CLOCKS_PER_SEC<<"\n";
}
| #pragma comment(linker, "/STACK:102400000,102400000")
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define vi vector<int>
#define pii pair<int, int>
#define x first
#define y second
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define SZ(x) (int)x.size()
#define rep(i, a, b) for (int i = a; i < b; i++)
#define per(i, a, b) for (int i = b - 1; i >= a; i--)
#define pi acos(-1)
#define mod 1000000007
#define inf 1000000007
#define ll long long
#define ull unsigned long long
#define DBG(x) cerr << (#x) << "=" << x << "\n";
#define N 100010
#define _DEBUG
template <class U, class T> void Max(U &x, T y) {
if (x < y)
x = y;
}
template <class U, class T> void Min(U &x, T y) {
if (x > y)
x = y;
}
template <class T> void add(int &a, T b) { a = (a + b) % mod; }
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
inline ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1)
ans = 1LL * ans * a % mod;
a = 1LL * a * a % mod;
b >>= 1;
}
return ans;
}
int pow(int a, int b, int c) {
int ans = 1;
while (b) {
if (b & 1)
ans = 1LL * ans * a % c;
a = 1LL * a * a % c;
b >>= 1;
}
return ans;
}
int main() {
// srand(time(NULL)+clock());
int T, ca = 0, k, i, j, m = 0, K, n;
// double start=clock();
scanf("%d%d", &n, &K);
if (K <= (n + 1) / 2)
puts("YES");
else
puts("NO");
// cerr<<(1.*clock()-start)/CLOCKS_PER_SEC<<"\n";
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,541 | 931,543 | u298360432 | cpp |
p03129 | #include <iostream>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
if (N % 2 == 0) {
if (K <= N / 2 + 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
if (K <= (N + 1) / 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
if (N % 2 == 0) {
if (K <= N / 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
if (K <= (N + 1) / 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
} | [
"expression.operation.binary.remove"
] | 931,544 | 931,546 | u813840685 | cpp |
p03129 | #include <iostream>
int main(void) {
int N, K;
std::cin >> N >> K;
std::cout << (K <= (N + 1) ? "YES" : "NO") << std::endl;
return 0;
} | #include <iostream>
int main(void) {
int N, K;
std::cin >> N >> K;
std::cout << (K <= (N + 1) / 2 ? "YES" : "NO") << std::endl;
return 0;
} | [
"expression.operation.binary.add"
] | 931,554 | 931,556 | u040550169 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k <= n * 2 + 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k <= (n + 1) / 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 931,557 | 931,559 | u565219356 | cpp |
p03129 | #include <stdio.h>
int main() {
int N, K;
scanf("%d %d", &N, &K);
int count = 0;
for (int val = 1; val <= N; val += 2) {
count++;
}
if (count <= K) {
printf("NO\n");
} else {
printf("YES\n");
}
} | #include <stdio.h>
int main() {
int N, K;
scanf("%d %d", &N, &K);
int count = 0;
for (int val = 1; val <= N; val += 2) {
count++;
}
if (count < K) {
printf("NO\n");
} else {
printf("YES\n");
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,561 | 931,564 | u657217497 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if ((n - 1) >= k * 2 - 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if ((n - 1) / 2 >= k - 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 931,566 | 931,568 | u717021668 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int ans = (N + 1) / 2;
if (ans >= K) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int ans = (N + 1) / 2;
if (ans >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,570 | 931,572 | u947883560 | cpp |
p03129 | #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<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n, k;
cin >> n >> k;
if (n / 2 * 2 + n % 2 >= k)
puts("YES");
else
puts("NO");
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<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n, k;
cin >> n >> k;
if (n / 2 + n % 2 >= k)
puts("YES");
else
puts("NO");
return 0;
}
| [
"expression.operation.binary.remove"
] | 931,586 | 931,587 | u640323045 | cpp |
p03129 | #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<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n, k;
cin >> n >> k;
if (n / 2 * 2 >= k)
puts("YES");
else
puts("NO");
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<int, int> P;
const LL mod = 1000000007;
const LL LINF = 1LL << 62;
const LL INF = 1 << 17;
int main() {
int n, k;
cin >> n >> k;
if (n / 2 + n % 2 >= k)
puts("YES");
else
puts("NO");
return 0;
}
| [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 931,589 | 931,587 | u640323045 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main() {
int n, k;
cin >> n >> k;
cout << (k <= n / 2 + n % 2) ? "YES" : "NO";
cout << endl;
exit(0);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main() {
int n, k;
cin >> n >> k;
cout << ((k <= n / 2 + n % 2) ? "YES" : "NO");
cout << endl;
exit(0);
}
| [] | 931,591 | 931,593 | u012143329 | cpp |
p03129 | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp> // Including
//tree_order_statistics_node_update
using namespace std;
// using namespace __gnu_pbds;
// typedef tree<
// pair<int, int>, // change type
// null_type,
// less<pair<int, int> >, // change type
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
typedef long long ll;
#define rep(i, start, end) for (int i = start; i < end; ++i)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("facebook.txt", "w", stdout);
#endif
int n, k;
cin >> n >> k;
if (k <= n / 2)
cout << "YES";
else
cout << "NO";
return 0;
} | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp> // Including
//tree_order_statistics_node_update
using namespace std;
// using namespace __gnu_pbds;
// typedef tree<
// pair<int, int>, // change type
// null_type,
// less<pair<int, int> >, // change type
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
typedef long long ll;
#define rep(i, start, end) for (int i = start; i < end; ++i)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("facebook.txt", "w", stdout);
#endif
int n, k;
cin >> n >> k;
if (k <= (n + 1) / 2)
cout << "YES";
else
cout << "NO";
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 931,599 | 931,602 | u611826259 | cpp |
p03129 | #include <bits/stdc++.h>
#define ll long long
#define pll pair<long long, long long>
#define pii pair<int, int>
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define Forn(i, n) for (int i = 1; i <= int(n); i++)
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int maxi = (n + 1) / 2;
cout << (k <= maxi ? "Yes" : "No") << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define pll pair<long long, long long>
#define pii pair<int, int>
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define Forn(i, n) for (int i = 1; i <= int(n); i++)
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int maxi = (n + 1) / 2;
cout << (k <= maxi ? "YES" : "NO") << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,603 | 931,605 | u647463444 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
int n = read(), k = read();
(n + 1) / 2 >= k ? printf("Yes\n") : printf("No\n");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
int n = read(), k = read();
(n + 1) / 2 >= k ? printf("YES\n") : printf("NO\n");
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 931,619 | 931,621 | u860104539 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
void doc() {}
void solve() {
int n, k;
cin >> n >> k;
cout << (k >= (n + 1) / 2 ? "YES" : "NO");
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
doc();
solve();
}
| #include <bits/stdc++.h>
using namespace std;
void doc() {}
void solve() {
int n, k;
cin >> n >> k;
cout << (k <= (n + 1) / 2 ? "YES" : "NO");
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
doc();
solve();
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 931,623 | 931,624 | u521455622 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
cout << (k > (n % 2 == 1 ? n / 2 + 1 : n / 2) + 1 ? "NO" : "YES") << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
cout << (k > (n % 2 == 1 ? n / 2 + 1 : n / 2) ? "NO" : "YES") << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 931,631 | 931,632 | u382073340 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
// string F(int n,int k);
bool F(int n, int k) {
if (2 * (k)-n >= 1) {
return true;
}
return false;
}
int main() {
int n, k;
cin >> n >> k;
bool s = F(n, k);
if (s == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// string F(int n,int k);
bool F(int n, int k) {
if (2 * (k)-1 <= n) {
return true;
}
return false;
}
int main() {
int n, k;
cin >> n >> k;
bool s = F(n, k);
if (s == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 931,635 | 931,636 | u809458301 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
puts(n + 1 >= 2 * k ? "Yes" : "No");
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
puts(n + 1 >= 2 * k ? "YES" : "NO");
}
| [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 931,637 | 931,638 | u434765267 | cpp |
p03129 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define DEBUG
#ifdef DEBUG
#define debug printf
#else
#define debug(...)
#endif
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
if (n >= k * 2 - 1) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define DEBUG
#ifdef DEBUG
#define debug printf
#else
#define debug(...)
#endif
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
if (n >= k * 2 - 1) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 931,641 | 931,642 | u320267258 | cpp |
p03129 | // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#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;
typedef map<int, int> MII;
typedef map<LL, LL> MLL;
typedef map<string, int> MSI;
typedef map<int, string> MIS;
//数値・文字列
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline LL toLongLong(string s) {
LL v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline VC toVC(string s) {
VC data(s.begin(), s.end());
return data;
}
template <typename List>
void SPRIT(const std::string &s, const std::string &delim, List &result) {
result.clear();
string::size_type pos = 0;
while (pos != string::npos) {
string::size_type p = s.find(delim, pos);
if (p == string::npos) {
result.push_back(s.substr(pos));
break;
} else {
result.push_back(s.substr(pos, p - pos));
}
pos = p + delim.size();
}
}
vector<string> SPRIT(const std::string &s, const std::string &delim) {
vector<string> result;
string::size_type pos = 0;
while (pos != string::npos) {
string::size_type p = s.find(delim, pos);
if (p == string::npos) {
result.push_back(s.substr(pos));
break;
} else {
result.push_back(s.substr(pos, p - pos));
}
pos = p + delim.size();
}
return result;
}
string TRIM(const string &str, const char *trimCharacterList = " \t\v\r\n") {
string result;
string::size_type left = str.find_first_not_of(trimCharacterList);
if (left != string::npos) {
string::size_type right = str.find_last_not_of(trimCharacterList);
result = str.substr(left, right - left + 1);
}
return result;
}
string REPLACE_STRING(const string source, const string find,
const string alt) {
string result = source;
string::size_type pos = 0;
while (pos = result.find(find, pos), pos != string::npos) {
result.replace(pos, find.length(), alt);
pos += alt.length();
}
return result;
}
template <typename T> bool VECTOR_EXISTS(vector<T> vec, T data) {
auto itr = std::find(vec.begin(), vec.end(), data);
size_t index = distance(vec.begin(), itr);
if (index != vec.size())
return true;
else
return false;
}
template <typename T> vector<T> VECTOR_UNIQUE_ERASE(vector<T> vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
template <typename T> void VECTOR_REMOVE_VALUE_ALL(vector<T> &vec, T data) {
vec.erase(remove(vec.begin(), vec.end(), data), vec.end());
}
template <typename T>
vector<T> VECTOR_REMOVE_VALUE_ALL_FAST(vector<T> vec, T data) {
vector<T> vec2;
for (auto &x : vec)
if (x != data)
vec2.push_back(x);
return vec2;
}
bool REG_MATCH(string const &text, regex const &re) {
bool result = regex_match(text, re);
return result;
}
bool REG_MATCH(string const &text, smatch &match, regex const &re) {
bool result = regex_match(text, match, re);
return result;
}
smatch REG_SEARCH(string const &text, regex const &re) {
smatch m;
regex_search(text, m, re);
return m;
}
vector<smatch> REG_ALL_SEARCH(string const &text, regex const &re) {
vector<smatch> matchs;
sregex_iterator iter(text.cbegin(), text.cend(), re);
sregex_iterator end;
for (; iter != end; iter++)
matchs.push_back(*iter);
return matchs;
}
string REG_REPLACE(string const &text, regex const &re, string const &replace) {
string result =
regex_replace(text, re, replace, regex_constants::format_first_only);
return result;
}
string REG_ALL_REPLACE(string const &text, regex const &re,
string const &replace) {
string result = regex_replace(text, re, replace);
return result;
}
template <typename T, typename U, typename V, typename W>
auto operator+(const std::pair<T, U> &l, const std::pair<V, W> &r)
-> std::pair<decltype(l.first + r.first), decltype(l.second + r.second)> {
return {l.first + r.first, l.second + r.second};
}
template <typename T, typename U, typename V, typename W>
auto operator-(const std::pair<T, U> &l, const std::pair<V, W> &r)
-> std::pair<decltype(l.first - r.first), decltype(l.second - r.second)> {
return {l.first - r.first, l.second - r.second};
}
#define UPPER(s) transform((s).begin(), (s).end(), (s).begin(), ::toupper)
#define LOWER(s) transform((s).begin(), (s).end(), (s).begin(), ::tolower)
//四捨五入 nLen=小数点第n位にする
//------------------------------------------
//切り上げ
double ceil_n(double dIn, int nLen) {
double dOut;
dOut = dIn * pow(10.0, nLen);
dOut = (double)(long long)(dOut + 0.9);
return dOut * pow(10.0, -nLen);
}
//切り捨て
double floor_n(double dIn, int nLen) {
double dOut;
dOut = dIn * pow(10.0, nLen);
dOut = (double)(long long)(dOut);
return dOut * pow(10.0, -nLen);
}
//四捨五入
double round_n(double dIn, int nLen) {
double dOut;
dOut = dIn * pow(10.0, nLen);
dOut = (double)(long long)(dOut + 0.5);
return dOut * pow(10.0, -nLen);
}
// n桁目の数の取得
int take_a_n(LL num, int n) {
string str = toString(num);
return str[str.length() - n] - '0';
}
//整数を2進数表記したときの1の個数を返す
LL bitcount64(LL bits) {
bits = (bits & 0x5555555555555555) + (bits >> 1 & 0x5555555555555555);
bits = (bits & 0x3333333333333333) + (bits >> 2 & 0x3333333333333333);
bits = (bits & 0x0f0f0f0f0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f0f0f0f0f);
bits = (bits & 0x00ff00ff00ff00ff) + (bits >> 8 & 0x00ff00ff00ff00ff);
bits = (bits & 0x0000ffff0000ffff) + (bits >> 16 & 0x0000ffff0000ffff);
return (bits & 0x00000000ffffffff) + (bits >> 32 & 0x00000000ffffffff);
}
// comparison
//------------------------------------------
#define C_MAX(a, b) ((a) > (b) ? (a) : (b))
#define C_MIN(a, b) ((a) < (b) ? (a) : (b))
#define C_ABS(a, b) ((a) < (b) ? (b) - (a) : (a) - (b))
template <typename T1, typename T2> inline void S_MAX(T1 &a, T2 b) {
a = C_MAX(a, b);
};
template <typename T1, typename T2> inline void S_MIN(T1 &a, T2 b) {
a = C_MIN(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
#define ft first
#define sd second
// 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")
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T> istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v)
in >> x;
return in;
}
// 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))
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
// math
//--------------------------------------------
// min <= aim <= max
template <typename T>
inline bool BETWEEN(const T aim, const T min, const T max) {
if (min <= aim && aim <= max) {
return true;
} else {
return false;
}
}
template <typename T1, typename T2>
inline bool IS_OUT(const T1 toY, const T1 toX, const T2 H, const T2 W) {
return (toY < 0 || toY >= H || toX < 0 || toX >= W);
}
template <class T> inline T SQR(const T x) { return x * x; }
template <class T1, class T2> inline T1 POW(const T1 x, const T2 y) {
if (!y)
return 1;
else if ((y & 1) == 0) {
return SQR(POW(x, y >> 1));
} else
return POW(x, y ^ 1) * x;
}
template <typename T> constexpr T ABS(T x) { return x < 0 ? -x : x; }
// partial_permutation nPr 順列
// first・・最初の数
// middle・・r(取り出す数)
// last・・n(全体数)
template <class Iter>
bool next_partial_permutation(Iter first, Iter middle, Iter last) {
reverse(middle, last);
return next_permutation(first, last);
}
// combination nCr 組み合わせ
// first1・・最初の数
// last1==first2・・r(取り出す数)
// last2・・n(全体数)
template <class Iter>
bool next_combination(Iter first1, Iter last1, Iter first2, Iter last2) {
if ((first1 == last1) || (first2 == last2)) {
return false;
}
Iter m1 = last1;
Iter m2 = last2;
--m2;
while (--m1 != first1 && !(*m1 < *m2)) {
}
bool result = (m1 == first1) && !(*first1 < *m2);
if (!result) {
while (first2 != m2 && !(*m1 < *first2)) {
++first2;
}
first1 = m1;
std::iter_swap(first1, first2);
++first1;
++first2;
}
if ((first1 != last1) && (first2 != last2)) {
m1 = last1;
m2 = first2;
while ((m1 != first1) && (m2 != last2)) {
std::iter_swap(--m1, m2);
++m2;
}
std::reverse(first1, m1);
std::reverse(first1, last1);
std::reverse(m2, last2);
std::reverse(first2, last2);
}
return !result;
}
// numeric_law
//--------------------------------------------
template <typename T> constexpr bool ODD(T x) { return x % 2 != 0; }
template <typename T> constexpr bool EVEN(T x) { return x % 2 == 0; }
//最大公約数
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);
}
//最小公倍数
template <class T> inline T LCM(const T x, const T y) {
if (x < 0)
return LCM(-x, y);
if (y < 0)
return LCM(x, -y);
return x * (y / GCD(x, y));
}
// ax + by = 1
// x,yが変数に格納される
template <class T> inline T EXTGCD(const T a, const T b, T &x, T &y) {
if (a < 0) {
T d = EXTGCD(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EXTGCD(a, -b, x, y);
y = -y;
return d;
}
if (!b) {
x = 1;
y = 0;
return a;
} else {
T d = EXTGCD(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
//素数
template <class T> inline bool ISPRIME(const T x) {
if (x <= 1)
return false;
for (T i = 2; i * i <= x; i++)
if (x % i == 0)
return false;
return true;
}
//素数をtrueとして返す
template <class T> VB ERATOSTHENES(const T n) {
VB arr(n + 1, true);
arr[0] = arr[1] = false;
for (LL i = 2; i * i <= n; i++) {
if (arr[i]) {
for (LL j = i * 2LL; j <= n; j += i) {
arr[j] = false;
}
}
}
return arr;
}
// a <= x < b の素数を返す
template <typename T> VB ERATOSTHENES(const T a, const T b) {
VB small = ERATOSTHENES(b);
VB prime(b - a, true);
for (LL i = 2; i * i <= b; i++) {
if (small[i]) {
for (LL j = max(2LL, (a + i - 1) / i) * i; j < b; j += i) {
prime[j - a] = false;
}
}
}
return prime;
}
// 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;
}
// nまでのすべての約数
template <typename T> vector<vector<T>> DIVISOR_ALL(T n) {
vector<vector<T>> res(n + 1);
for (LL i = 1; i <= n; i++) {
for (LL j = i; j <= n; j += i) {
res[j].push_back(i);
}
}
return res;
}
//素因数分解
template <typename T> vector<pair<T, LL>> FACTORIZATION(T x) {
vector<pair<T, LL>> ans;
for (T i = 2; i * i <= x; i++) {
if (x % i == 0) {
LL count = 0;
while (x % i == 0) {
count++;
x /= i;
}
ans.push_back(MP(i, count));
}
}
if (x != 1)
ans.push_back(MP(x, 1));
return ans;
}
// N^P (mod M)
LL POW_MOD(LL N, LL P, LL M) {
if (P == 0)
return 1LL;
if (P % 2 == 0) {
LL ret = POW_MOD(N, P / 2, M);
return ret * ret % M;
}
return N * POW_MOD(N, P - 1, M) % M;
}
//組み合わせ個数
template <typename T> inline T NCR(T n, T r) {
if (r > n - r)
r = n - r;
T ans = 1;
REPLL(i, r) { ans = ans * (n - i) / (i + 1); }
return ans;
}
//組み合わせ個数 (mod M)
LL NCR_MOD(LL n, LL r, LL M) {
if (r > n - r)
return NCR_MOD(n, n - r, M);
LL numerator = 1LL; //分子
LL denominator = 1LL; //分母
for (LL i = 0; i < r; i++) {
numerator *= (n - i);
numerator %= M;
denominator *= (i + 1);
denominator %= M;
}
return numerator * POW_MOD(denominator, M - 2, M) % M;
}
// confirmation
//--------------------------------------------
// clear memory
#define CLR(arr, d) memset((arr), (d), sizeof(arr))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << endl;
/*
*
*
* ~~~~Below My Answer~~~~
*
*
*/
int main() {
int N, K;
cin >> N >> K;
int cnt = 1;
for (int i = 1; i <= N; i += 2)
cnt++;
if (cnt >= K)
YES();
else
NO();
return 0;
}
| // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#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;
typedef map<int, int> MII;
typedef map<LL, LL> MLL;
typedef map<string, int> MSI;
typedef map<int, string> MIS;
//数値・文字列
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline LL toLongLong(string s) {
LL v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline VC toVC(string s) {
VC data(s.begin(), s.end());
return data;
}
template <typename List>
void SPRIT(const std::string &s, const std::string &delim, List &result) {
result.clear();
string::size_type pos = 0;
while (pos != string::npos) {
string::size_type p = s.find(delim, pos);
if (p == string::npos) {
result.push_back(s.substr(pos));
break;
} else {
result.push_back(s.substr(pos, p - pos));
}
pos = p + delim.size();
}
}
vector<string> SPRIT(const std::string &s, const std::string &delim) {
vector<string> result;
string::size_type pos = 0;
while (pos != string::npos) {
string::size_type p = s.find(delim, pos);
if (p == string::npos) {
result.push_back(s.substr(pos));
break;
} else {
result.push_back(s.substr(pos, p - pos));
}
pos = p + delim.size();
}
return result;
}
string TRIM(const string &str, const char *trimCharacterList = " \t\v\r\n") {
string result;
string::size_type left = str.find_first_not_of(trimCharacterList);
if (left != string::npos) {
string::size_type right = str.find_last_not_of(trimCharacterList);
result = str.substr(left, right - left + 1);
}
return result;
}
string REPLACE_STRING(const string source, const string find,
const string alt) {
string result = source;
string::size_type pos = 0;
while (pos = result.find(find, pos), pos != string::npos) {
result.replace(pos, find.length(), alt);
pos += alt.length();
}
return result;
}
template <typename T> bool VECTOR_EXISTS(vector<T> vec, T data) {
auto itr = std::find(vec.begin(), vec.end(), data);
size_t index = distance(vec.begin(), itr);
if (index != vec.size())
return true;
else
return false;
}
template <typename T> vector<T> VECTOR_UNIQUE_ERASE(vector<T> vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec;
}
template <typename T> void VECTOR_REMOVE_VALUE_ALL(vector<T> &vec, T data) {
vec.erase(remove(vec.begin(), vec.end(), data), vec.end());
}
template <typename T>
vector<T> VECTOR_REMOVE_VALUE_ALL_FAST(vector<T> vec, T data) {
vector<T> vec2;
for (auto &x : vec)
if (x != data)
vec2.push_back(x);
return vec2;
}
bool REG_MATCH(string const &text, regex const &re) {
bool result = regex_match(text, re);
return result;
}
bool REG_MATCH(string const &text, smatch &match, regex const &re) {
bool result = regex_match(text, match, re);
return result;
}
smatch REG_SEARCH(string const &text, regex const &re) {
smatch m;
regex_search(text, m, re);
return m;
}
vector<smatch> REG_ALL_SEARCH(string const &text, regex const &re) {
vector<smatch> matchs;
sregex_iterator iter(text.cbegin(), text.cend(), re);
sregex_iterator end;
for (; iter != end; iter++)
matchs.push_back(*iter);
return matchs;
}
string REG_REPLACE(string const &text, regex const &re, string const &replace) {
string result =
regex_replace(text, re, replace, regex_constants::format_first_only);
return result;
}
string REG_ALL_REPLACE(string const &text, regex const &re,
string const &replace) {
string result = regex_replace(text, re, replace);
return result;
}
template <typename T, typename U, typename V, typename W>
auto operator+(const std::pair<T, U> &l, const std::pair<V, W> &r)
-> std::pair<decltype(l.first + r.first), decltype(l.second + r.second)> {
return {l.first + r.first, l.second + r.second};
}
template <typename T, typename U, typename V, typename W>
auto operator-(const std::pair<T, U> &l, const std::pair<V, W> &r)
-> std::pair<decltype(l.first - r.first), decltype(l.second - r.second)> {
return {l.first - r.first, l.second - r.second};
}
#define UPPER(s) transform((s).begin(), (s).end(), (s).begin(), ::toupper)
#define LOWER(s) transform((s).begin(), (s).end(), (s).begin(), ::tolower)
//四捨五入 nLen=小数点第n位にする
//------------------------------------------
//切り上げ
double ceil_n(double dIn, int nLen) {
double dOut;
dOut = dIn * pow(10.0, nLen);
dOut = (double)(long long)(dOut + 0.9);
return dOut * pow(10.0, -nLen);
}
//切り捨て
double floor_n(double dIn, int nLen) {
double dOut;
dOut = dIn * pow(10.0, nLen);
dOut = (double)(long long)(dOut);
return dOut * pow(10.0, -nLen);
}
//四捨五入
double round_n(double dIn, int nLen) {
double dOut;
dOut = dIn * pow(10.0, nLen);
dOut = (double)(long long)(dOut + 0.5);
return dOut * pow(10.0, -nLen);
}
// n桁目の数の取得
int take_a_n(LL num, int n) {
string str = toString(num);
return str[str.length() - n] - '0';
}
//整数を2進数表記したときの1の個数を返す
LL bitcount64(LL bits) {
bits = (bits & 0x5555555555555555) + (bits >> 1 & 0x5555555555555555);
bits = (bits & 0x3333333333333333) + (bits >> 2 & 0x3333333333333333);
bits = (bits & 0x0f0f0f0f0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f0f0f0f0f);
bits = (bits & 0x00ff00ff00ff00ff) + (bits >> 8 & 0x00ff00ff00ff00ff);
bits = (bits & 0x0000ffff0000ffff) + (bits >> 16 & 0x0000ffff0000ffff);
return (bits & 0x00000000ffffffff) + (bits >> 32 & 0x00000000ffffffff);
}
// comparison
//------------------------------------------
#define C_MAX(a, b) ((a) > (b) ? (a) : (b))
#define C_MIN(a, b) ((a) < (b) ? (a) : (b))
#define C_ABS(a, b) ((a) < (b) ? (b) - (a) : (a) - (b))
template <typename T1, typename T2> inline void S_MAX(T1 &a, T2 b) {
a = C_MAX(a, b);
};
template <typename T1, typename T2> inline void S_MIN(T1 &a, T2 b) {
a = C_MIN(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
#define ft first
#define sd second
// 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")
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T> istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v)
in >> x;
return in;
}
// 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))
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
// math
//--------------------------------------------
// min <= aim <= max
template <typename T>
inline bool BETWEEN(const T aim, const T min, const T max) {
if (min <= aim && aim <= max) {
return true;
} else {
return false;
}
}
template <typename T1, typename T2>
inline bool IS_OUT(const T1 toY, const T1 toX, const T2 H, const T2 W) {
return (toY < 0 || toY >= H || toX < 0 || toX >= W);
}
template <class T> inline T SQR(const T x) { return x * x; }
template <class T1, class T2> inline T1 POW(const T1 x, const T2 y) {
if (!y)
return 1;
else if ((y & 1) == 0) {
return SQR(POW(x, y >> 1));
} else
return POW(x, y ^ 1) * x;
}
template <typename T> constexpr T ABS(T x) { return x < 0 ? -x : x; }
// partial_permutation nPr 順列
// first・・最初の数
// middle・・r(取り出す数)
// last・・n(全体数)
template <class Iter>
bool next_partial_permutation(Iter first, Iter middle, Iter last) {
reverse(middle, last);
return next_permutation(first, last);
}
// combination nCr 組み合わせ
// first1・・最初の数
// last1==first2・・r(取り出す数)
// last2・・n(全体数)
template <class Iter>
bool next_combination(Iter first1, Iter last1, Iter first2, Iter last2) {
if ((first1 == last1) || (first2 == last2)) {
return false;
}
Iter m1 = last1;
Iter m2 = last2;
--m2;
while (--m1 != first1 && !(*m1 < *m2)) {
}
bool result = (m1 == first1) && !(*first1 < *m2);
if (!result) {
while (first2 != m2 && !(*m1 < *first2)) {
++first2;
}
first1 = m1;
std::iter_swap(first1, first2);
++first1;
++first2;
}
if ((first1 != last1) && (first2 != last2)) {
m1 = last1;
m2 = first2;
while ((m1 != first1) && (m2 != last2)) {
std::iter_swap(--m1, m2);
++m2;
}
std::reverse(first1, m1);
std::reverse(first1, last1);
std::reverse(m2, last2);
std::reverse(first2, last2);
}
return !result;
}
// numeric_law
//--------------------------------------------
template <typename T> constexpr bool ODD(T x) { return x % 2 != 0; }
template <typename T> constexpr bool EVEN(T x) { return x % 2 == 0; }
//最大公約数
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);
}
//最小公倍数
template <class T> inline T LCM(const T x, const T y) {
if (x < 0)
return LCM(-x, y);
if (y < 0)
return LCM(x, -y);
return x * (y / GCD(x, y));
}
// ax + by = 1
// x,yが変数に格納される
template <class T> inline T EXTGCD(const T a, const T b, T &x, T &y) {
if (a < 0) {
T d = EXTGCD(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EXTGCD(a, -b, x, y);
y = -y;
return d;
}
if (!b) {
x = 1;
y = 0;
return a;
} else {
T d = EXTGCD(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
//素数
template <class T> inline bool ISPRIME(const T x) {
if (x <= 1)
return false;
for (T i = 2; i * i <= x; i++)
if (x % i == 0)
return false;
return true;
}
//素数をtrueとして返す
template <class T> VB ERATOSTHENES(const T n) {
VB arr(n + 1, true);
arr[0] = arr[1] = false;
for (LL i = 2; i * i <= n; i++) {
if (arr[i]) {
for (LL j = i * 2LL; j <= n; j += i) {
arr[j] = false;
}
}
}
return arr;
}
// a <= x < b の素数を返す
template <typename T> VB ERATOSTHENES(const T a, const T b) {
VB small = ERATOSTHENES(b);
VB prime(b - a, true);
for (LL i = 2; i * i <= b; i++) {
if (small[i]) {
for (LL j = max(2LL, (a + i - 1) / i) * i; j < b; j += i) {
prime[j - a] = false;
}
}
}
return prime;
}
// 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;
}
// nまでのすべての約数
template <typename T> vector<vector<T>> DIVISOR_ALL(T n) {
vector<vector<T>> res(n + 1);
for (LL i = 1; i <= n; i++) {
for (LL j = i; j <= n; j += i) {
res[j].push_back(i);
}
}
return res;
}
//素因数分解
template <typename T> vector<pair<T, LL>> FACTORIZATION(T x) {
vector<pair<T, LL>> ans;
for (T i = 2; i * i <= x; i++) {
if (x % i == 0) {
LL count = 0;
while (x % i == 0) {
count++;
x /= i;
}
ans.push_back(MP(i, count));
}
}
if (x != 1)
ans.push_back(MP(x, 1));
return ans;
}
// N^P (mod M)
LL POW_MOD(LL N, LL P, LL M) {
if (P == 0)
return 1LL;
if (P % 2 == 0) {
LL ret = POW_MOD(N, P / 2, M);
return ret * ret % M;
}
return N * POW_MOD(N, P - 1, M) % M;
}
//組み合わせ個数
template <typename T> inline T NCR(T n, T r) {
if (r > n - r)
r = n - r;
T ans = 1;
REPLL(i, r) { ans = ans * (n - i) / (i + 1); }
return ans;
}
//組み合わせ個数 (mod M)
LL NCR_MOD(LL n, LL r, LL M) {
if (r > n - r)
return NCR_MOD(n, n - r, M);
LL numerator = 1LL; //分子
LL denominator = 1LL; //分母
for (LL i = 0; i < r; i++) {
numerator *= (n - i);
numerator %= M;
denominator *= (i + 1);
denominator %= M;
}
return numerator * POW_MOD(denominator, M - 2, M) % M;
}
// confirmation
//--------------------------------------------
// clear memory
#define CLR(arr, d) memset((arr), (d), sizeof(arr))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << endl;
/*
*
*
* ~~~~Below My Answer~~~~
*
*
*/
int main() {
int N, K;
cin >> N >> K;
int cnt = 0;
for (int i = 1; i <= N; i += 2)
cnt++;
if (cnt >= K)
YES();
else
NO();
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 931,643 | 931,644 | u259053514 | cpp |
p03129 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rep2(i, a, b) for (int i = a; i >= b; i--)
#define mod 1000000007
#define INF 1e9 + 5
#define fr first
#define se second
#define int long long
#define ll long long
#define PI 3.1415926535
#define pll pair<ll, ll>
#define vl vector<ll>
#define mll map<ll, ll>
#define mci map<char, int>
#define msi map<string, int>
#define vb vector<bool>
#define pb push_back
#define mpr make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Senky_Bansal ios_base::sync_with_stdio(false);
#define IIIT_ALLAHABAD \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
const int N = 100005;
int height[N];
bool vis[N];
vl adj[N];
ll r = 100, c = 100;
ll r1, c1;
ll M[100][100];
ll level[N];
bool visited[100][100];
void dfs(ll M[][100], ll R, ll C, bool visited[][100]) {
visited[R][C] = true;
ll row[] = {-1, -1, -1, 0, 0, 1, 1, 1};
ll col[] = {-1, 0, 1, -1, 1, -1, 0, 1};
for (int k = 0; k < 8; k++) {
if (R + row[k] >= 0 && R + row[k] <= r1 && C + col[k] >= 0 &&
C + col[k] <= c1 && M[R + row[k]][C + col[k]] &&
visited[R + row[k]][C + col[k]] == 0)
dfs(M, R + row[k], C + col[k], visited);
}
}
void bfs(ll s) {
queue<ll> q;
q.push(s);
vis[s] = true;
level[s] = 0;
while (!q.empty()) {
ll p = q.front();
q.pop();
for (int i = 0; i < adj[p].size(); i++) {
if (vis[adj[p][i]] == false) {
level[adj[p][i]] = level[p] + 1;
vis[adj[p][i]] = true;
q.push(adj[p][i]);
}
}
}
}
ll power(ll a, ll b, ll c) {
ll result = 1;
while (b) {
if (b & 1)
result = (result * b) % c;
a = (a * a) % c;
b = b / 2;
}
return result % c;
}
signed main() {
Senky_Bansal IIIT_ALLAHABAD
ll a,
b;
cin >> a >> b;
if (a >= 2 * b - 1)
cout << "Yes" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rep2(i, a, b) for (int i = a; i >= b; i--)
#define mod 1000000007
#define INF 1e9 + 5
#define fr first
#define se second
#define int long long
#define ll long long
#define PI 3.1415926535
#define pll pair<ll, ll>
#define vl vector<ll>
#define mll map<ll, ll>
#define mci map<char, int>
#define msi map<string, int>
#define vb vector<bool>
#define pb push_back
#define mpr make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Senky_Bansal ios_base::sync_with_stdio(false);
#define IIIT_ALLAHABAD \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
const int N = 100005;
int height[N];
bool vis[N];
vl adj[N];
ll r = 100, c = 100;
ll r1, c1;
ll M[100][100];
ll level[N];
bool visited[100][100];
void dfs(ll M[][100], ll R, ll C, bool visited[][100]) {
visited[R][C] = true;
ll row[] = {-1, -1, -1, 0, 0, 1, 1, 1};
ll col[] = {-1, 0, 1, -1, 1, -1, 0, 1};
for (int k = 0; k < 8; k++) {
if (R + row[k] >= 0 && R + row[k] <= r1 && C + col[k] >= 0 &&
C + col[k] <= c1 && M[R + row[k]][C + col[k]] &&
visited[R + row[k]][C + col[k]] == 0)
dfs(M, R + row[k], C + col[k], visited);
}
}
void bfs(ll s) {
queue<ll> q;
q.push(s);
vis[s] = true;
level[s] = 0;
while (!q.empty()) {
ll p = q.front();
q.pop();
for (int i = 0; i < adj[p].size(); i++) {
if (vis[adj[p][i]] == false) {
level[adj[p][i]] = level[p] + 1;
vis[adj[p][i]] = true;
q.push(adj[p][i]);
}
}
}
}
ll power(ll a, ll b, ll c) {
ll result = 1;
while (b) {
if (b & 1)
result = (result * b) % c;
a = (a * a) % c;
b = b / 2;
}
return result % c;
}
signed main() {
Senky_Bansal IIIT_ALLAHABAD
ll a,
b;
cin >> a >> b;
if (a >= 2 * b - 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,656 | 931,657 | u942813425 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
if (n * 2 + 1 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
if (k * 2 - 1 <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 931,662 | 931,663 | u656572785 | cpp |
p03129 | #include <stdio.h>
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
if (n % 2 == 1) {
n--;
}
if (k <= n / 2) {
printf("Yes\n");
} else {
printf("NO\n");
}
return 0;
} | #include <stdio.h>
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
if (n % 2 == 1) {
n++;
}
if (k <= n / 2) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 931,667 | 931,668 | u217596176 | cpp |
p03129 | #include <stdio.h>
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
if (n % 2 == 1) {
n++;
}
if (k <= n / 2) {
printf("Yes\n");
} else {
printf("NO\n");
}
return 0;
} | #include <stdio.h>
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
if (n % 2 == 1) {
n++;
}
if (k <= n / 2) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 931,669 | 931,668 | u217596176 | cpp |
p03129 | #include <iostream>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
int judge = 2 * K - 1;
if (N >= judge) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
| #include <iostream>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
int judge = 2 * K - 1;
if (N >= judge) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,679 | 931,680 | u190018920 | cpp |
p03129 | #include <iostream>
int main(void) {
using namespace std;
int N, K;
cin >> N >> K;
if (N % 2 == 1) {
K += 1;
}
if (N / 2 >= K) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
| #include <iostream>
int main(void) {
using namespace std;
int N, K;
cin >> N >> K;
if (N % 2 == 1) {
N += 1;
}
if (N / 2 >= K) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change"
] | 931,689 | 931,690 | u653206280 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll k, m, n;
ll t[1 << 17], d[1 << 17];
vector<ll> u, v;
int main() {
cin >> n >> k;
for (int i = 1; i < n; i += 2) {
m++;
}
if (m >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll k, m = 0, n;
ll t[1 << 17], d[1 << 17];
vector<ll> u, v;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i += 2) {
m++;
}
if (m >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 931,693 | 931,694 | u394482932 | cpp |
p03129 | #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long LL;
const LL INF = 1 << 31;
int main() {
int n, k;
cin >> n >> k;
if (n + 1 / 2 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long LL;
const LL INF = 1 << 31;
int main() {
int n, k;
cin >> n >> k;
if ((n + 1) / 2 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"control_flow.branch.if.condition.change"
] | 931,699 | 931,700 | u999803454 | cpp |
p03129 | #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long LL;
const LL INF = 1 << 31;
int main() {
int n, k;
cin >> n >> k;
if (n + 1 / 2 > k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long LL;
const LL INF = 1 << 31;
int main() {
int n, k;
cin >> n >> k;
if ((n + 1) / 2 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 931,701 | 931,700 | u999803454 | cpp |
p03129 | #include <cstdio>
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
printf("%s\n", (n / 2 + 1 >= k) ? "YES" : "NO");
return (0);
} | #include <cstdio>
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
printf("%s\n", (n / 2 + n % 2 >= k) ? "YES" : "NO");
return (0);
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 931,702 | 931,703 | u530396049 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int b = 0;
if (N % 2 == 0) {
for (int i = 0; i < N / 2; i++) {
b = b + 1;
}
} else {
for (int j = 0; j < +1; j = j + 2) {
b = b++;
}
}
if (b >= M) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int b = 0;
if (N % 2 == 0) {
for (int i = 0; i < N / 2; i++) {
b = b + 1;
}
} else {
for (int j = 0; j < N + 1; j = j + 2) {
b++;
}
}
if (b >= M) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 931,709 | 931,710 | u343355096 | cpp |
p03129 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (n - 2 > k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| #include <cmath>
#include <iostream>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (n - (n / 2) >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 931,714 | 931,715 | u406145181 | cpp |
p03129 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
typedef unsigned long long ll;
int main() {
ll N, K;
std::cin >> N >> K;
if (2 * K - 1 <= N) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
typedef unsigned long long ll;
int main() {
ll N, K;
std::cin >> N >> K;
if (2 * K - 1 <= N) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 931,718 | 931,719 | u176331779 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, maxv;
cin >> n >> k;
maxv = max((n + 1) / 2, n / 2);
if (maxv <= k)
cout << "YES";
else
cout << "NO";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, maxv;
cin >> n >> k;
maxv = max((n + 1) / 2, n / 2);
if (maxv >= k)
cout << "YES";
else
cout << "NO";
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,720 | 931,721 | u543034659 | cpp |
p03129 |
#include <bits/stdc++.h>
#define null ""
#define endl '\n'
#define all(dat) dat.begin(), dat.end()
#define loop(i, to) for (int i = 0; i < to; ++i)
#define cont(i, to) for (int i = 1; i <= to; ++i)
#define circ(i, fr, to) for (int i = fr; i <= to; ++i)
#define foreach(i, dat) \
for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
typedef long long num;
using namespace std;
int n, k;
int main() {
cin >> n >> k;
if (k >= (n + 1) / 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
#define null ""
#define endl '\n'
#define all(dat) dat.begin(), dat.end()
#define loop(i, to) for (int i = 0; i < to; ++i)
#define cont(i, to) for (int i = 1; i <= to; ++i)
#define circ(i, fr, to) for (int i = fr; i <= to; ++i)
#define foreach(i, dat) \
for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
typedef long long num;
using namespace std;
int n, k;
int main() {
cin >> n >> k;
if (k <= (n + 1) / 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,722 | 931,723 | u263369790 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
/* int i, sum=1;
for(i=0; i<N-2; i++){
sum *= i;
}
if(sum < K) cout << "NO" << endl;
else cout << "YES" << endl;
*/
int sum = N / 2;
if (sum < K)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
/* int i, sum=1;
for(i=0; i<N-2; i++){
sum *= i;
}
if(sum < K) cout << "NO" << endl;
else cout << "YES" << endl;
*/
int sum = (N + 1) / 2;
// cout << sum << endl;
if (sum < K)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| [] | 931,724 | 931,725 | u067481442 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (N % 2 == 0) {
N = N / 2;
} else {
N = N / 2 + 1;
}
if (N >= K)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (N % 2 == 0) {
N = N / 2;
} else {
N = N / 2 + 1;
}
if (N >= K)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,726 | 931,727 | u915714716 | cpp |
p03129 | #include <iostream>
using namespace std;
int main(void) {
int n, k, max;
cin >> n >> k;
if (n % 2 == 0) {
max = n - 2;
} else {
max = n - 1;
}
if (max >= k) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int n, k, max;
cin >> n >> k;
if (n % 2 == 0) {
max = n / 2;
} else {
max = (n + 1) / 2;
}
if (max >= k) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"misc.opposites",
"assignment.change"
] | 931,728 | 931,729 | u158734041 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
bool ans = false;
cin >> n >> k;
if (n % 2 == 0) {
if (n / 2 > k) {
ans = true;
}
} else if (n % 2 != 0) {
if ((n + 1) / 2 > k) {
ans = true;
}
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
bool ans = false;
cin >> n >> k;
if (n % 2 == 0) {
if (n / 2 >= k) {
ans = true;
}
} else if (n % 2 != 0) {
if ((n + 1) / 2 >= k) {
ans = true;
}
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,734 | 931,735 | u250906113 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int n, k, c;
cin >> n >> k;
string s = "No";
c = (n + 1) / 2;
if (k <= c) {
s = "Yes";
}
cout << s << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, k, c;
cin >> n >> k;
string s = "NO";
c = (n + 1) / 2;
if (k <= c) {
s = "YES";
}
cout << s << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 931,738 | 931,739 | u740385803 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Graph = vector<vector<int>>;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
#define rep(i, N) for (int i = 0; i < N; i++)
#define rep2(i, l, r) for (ll i = (ll)l; i < (ll)(r); i++)
#define INF 1000000000000000000
#define MAX 200001
const ll MOD = 1000000007;
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
};
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD>;
int main() {
vector<int> cnt(4, 0);
rep(i, 3) {
int a, b;
cin >> a >> b;
a--;
b--;
cnt[a]++;
cnt[b]++;
}
int flag = 1;
rep(i, 4) {
if (cnt[i] == 2)
continue;
flag = 0;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Graph = vector<vector<int>>;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
#define rep(i, N) for (int i = 0; i < N; i++)
#define rep2(i, l, r) for (ll i = (ll)l; i < (ll)(r); i++)
#define INF 1000000000000000000
#define MAX 200001
const ll MOD = 1000000007;
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
};
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD>;
int main() {
vector<int> cnt(4, 0);
rep(i, 3) {
int a, b;
cin >> a >> b;
a--;
b--;
cnt[a]++;
cnt[b]++;
}
int flag = 1;
rep(i, 4) {
if (cnt[i] <= 2)
continue;
flag = 0;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,751 | 931,752 | u266874640 | cpp |
p03130 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
vector<int> a(8);
rep(i, 6) { cin >> a[i]; }
vector<int> b(4);
rep(i, 6) {
rep(j, 6) {
if (a[i] == a[j]) {
b[a[i]]++;
break;
}
}
if (b[a[i]] >= 3) {
cout << "No" << endl;
// cout << a[i] << " " << b[a[i]] << endl;
break;
}
if (i + 1 == 6) {
cout << "Yes" << endl;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
vector<int> a(8);
rep(i, 6) { cin >> a[i]; }
vector<int> b(4);
rep(i, 6) {
rep(j, 6) {
if (a[i] == a[j]) {
b[a[i]]++;
break;
}
}
if (b[a[i]] >= 3) {
cout << "NO" << endl;
// cout << a[i] << " " << b[a[i]] << endl;
break;
}
if (i + 1 == 6) {
cout << "YES" << endl;
break;
}
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,758 | 931,759 | u451171595 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(6);
vector<int> cnt(4, 0);
for (int i = 0; i < 6; i++) {
cin >> a[i];
cnt[a[i] - 1]++;
}
sort(cnt.begin(), cnt.end());
bool flg = true;
for (int i = 0; i < 4; i++) {
// printf("%d\n",cnt[i]);
if (i < 2 && cnt[i] != 1) {
flg = false;
} else if (i >= 2 && cnt[i] != 2) {
flg = false;
}
}
cout << (flg ? "Yes" : "No") << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(6);
vector<int> cnt(4, 0);
for (int i = 0; i < 6; i++) {
cin >> a[i];
cnt[a[i] - 1]++;
}
sort(cnt.begin(), cnt.end());
bool flg = true;
for (int i = 0; i < 4; i++) {
// printf("%d\n",cnt[i]);
if (i < 2 && cnt[i] != 1) {
flg = false;
} else if (i >= 2 && cnt[i] != 2) {
flg = false;
}
}
cout << (flg ? "YES" : "NO") << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,760 | 931,761 | u180133008 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(), x.end()
#define rep(i, j, n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//(a+b-1)/b
// priority_queue<ll, vector<ll>, greater<ll>> q;
using pl = pair<ll, ll>;
signed main() {
map<ll, ll> mp;
rep(i, 0, 6) {
ll a;
cin >> a;
mp[a]++;
}
bool ok = true;
rep(i, 1, 4) {
if (mp[i] >= 3)
ok = 0;
}
cout << (ok ? "YES" : "NO") << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(), x.end()
#define rep(i, j, n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//(a+b-1)/b
// priority_queue<ll, vector<ll>, greater<ll>> q;
using pl = pair<ll, ll>;
signed main() {
map<ll, ll> mp;
rep(i, 0, 6) {
ll a;
cin >> a;
mp[a]++;
}
bool ok = true;
rep(i, 1, 5) {
if (mp[i] >= 3)
ok = 0;
}
cout << (ok ? "YES" : "NO") << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 931,762 | 931,763 | u164181205 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> vec(4, 0);
for (int i = 0; i < 6; i++) {
int K;
cin >> K;
vec[K - 1]++;
}
for (int i = 0; i < 4; i++) {
if (vec[i] != 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> vec(4, 0);
for (int i = 0; i < 6; i++) {
int K;
cin >> K;
vec[K - 1]++;
}
for (int i = 0; i < 4; i++) {
if (vec[i] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| [
"control_flow.loop.for.condition.change"
] | 931,764 | 931,765 | u187772564 | cpp |
p03130 | #pragma region header
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for (int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
constexpr ll mod = 1e9 + 7;
constexpr int inf = INT32_MAX / 2;
constexpr ll INF = LLONG_MAX / 2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------テンプレート------------------ */
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;
}
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0)
return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a * b / gcd(a, b);
}
int keta(ll n) { //桁数を求める
if (n == 0)
return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
#pragma endregion
bool isprime(int n) {
if (n == 1)
return false;
if (n == 2)
return true;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return true;
}
int ans[4];
signed main() {
rep(i, 6) {
int a;
cin >> a;
a--;
ans[a]++;
}
int count = 0;
rep(i, 6) {
if (ans[i] % 2 == 1)
count++;
}
if (count == 0 || count == 2)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #pragma region header
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for (int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
constexpr ll mod = 1e9 + 7;
constexpr int inf = INT32_MAX / 2;
constexpr ll INF = LLONG_MAX / 2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------テンプレート------------------ */
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;
}
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0)
return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a * b / gcd(a, b);
}
int keta(ll n) { //桁数を求める
if (n == 0)
return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
#pragma endregion
bool isprime(int n) {
if (n == 1)
return false;
if (n == 2)
return true;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return true;
}
int ans[4];
signed main() {
rep(i, 6) {
int a;
cin >> a;
a--;
ans[a]++;
}
int count = 0;
rep(i, 6) {
if (ans[i] % 2 == 1)
count++;
}
if (count == 0 || count == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,766 | 931,767 | u608773191 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#include <iomanip>
#include <math.h>
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1001001001;
vector<pair<int64_t, int64_t>> prime_factorize(int64_t x) {
vector<pair<int64_t, int64_t>> p;
for (int64_t i = 2; i * i <= x; i++) {
int cnt = 0;
if (x % i == 0) {
while (x % i == 0) {
cnt++;
x /= i;
}
p.push_back(make_pair(i, cnt));
}
}
if (x != 1) {
p.push_back(make_pair(x, 1));
}
return p;
}
int main() {
vector<int> a(3), b(3);
vector<int> g[4];
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
for (int i = 0; i < 4; i++) {
if (g[i].size() == 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <iomanip>
#include <math.h>
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1001001001;
vector<pair<int64_t, int64_t>> prime_factorize(int64_t x) {
vector<pair<int64_t, int64_t>> p;
for (int64_t i = 2; i * i <= x; i++) {
int cnt = 0;
if (x % i == 0) {
while (x % i == 0) {
cnt++;
x /= i;
}
p.push_back(make_pair(i, cnt));
}
}
if (x != 1) {
p.push_back(make_pair(x, 1));
}
return p;
}
int main() {
vector<int> a(3), b(3);
vector<int> g[4];
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
for (int i = 0; i < 4; i++) {
if (g[i].size() == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,772 | 931,773 | u209457657 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int a[6], ap[4];
int main() {
for (int i = 0; i < 6; i++) {
cin >> a[i];
ap[a[i] - 1]++;
}
for (int i = 0; i < 4; i++)
if (ap[i] == 4) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int a[6], ap[4];
int main() {
for (int i = 0; i < 6; i++) {
cin >> a[i];
ap[a[i] - 1]++;
}
for (int i = 0; i < 4; i++)
if (ap[i] == 3) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 931,774 | 931,775 | u450832845 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
#define rep(i, m, n) for (int(i) = (m); (i) < (n); ++(i))
#define rREP(i, m, n) for (int(i) = (n)-1; (i) >= (m); --(i))
#define all(x) (x).begin(), (x).end()
#define out(y, x, h, w) (y) < 0 || (x) < 0 || (y) >= (h) || (x) >= (w)
constexpr int INF = 1000000001;
constexpr ll mod = 1000000007;
constexpr double PI = 3.1415926535897932;
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;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
int main() {
init();
Graph G(4);
rep(i, 0, 3) {
int a, b;
cin >> a >> b;
--a;
--b;
G[a].push_back(b);
G[b].push_back(a);
}
bool ok = true;
rep(i, 1, 3) {
if (G[i].size() == 3)
ok = false;
}
cout << (ok ? "YES" : "NO") << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
#define rep(i, m, n) for (int(i) = (m); (i) < (n); ++(i))
#define rREP(i, m, n) for (int(i) = (n)-1; (i) >= (m); --(i))
#define all(x) (x).begin(), (x).end()
#define out(y, x, h, w) (y) < 0 || (x) < 0 || (y) >= (h) || (x) >= (w)
constexpr int INF = 1000000001;
constexpr ll mod = 1000000007;
constexpr double PI = 3.1415926535897932;
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;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
int main() {
init();
Graph G(4);
rep(i, 0, 3) {
int a, b;
cin >> a >> b;
--a;
--b;
G[a].push_back(b);
G[b].push_back(a);
}
bool ok = true;
rep(i, 0, 4) {
if (G[i].size() == 3)
ok = false;
}
cout << (ok ? "YES" : "NO") << "\n";
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 931,784 | 931,785 | u813559924 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) {
if (y == 0)
return 0;
return gcd(y, x % y);
}
int dis2(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
double cut(int r, int n, int i) {
double res =
r * r - (r - r * (double)i / (double)n) * (r - r * (double)i / (double)n);
return pow(res, 0.5) * 2;
}
int main() {
int a, b;
vector<int> c(4, 0);
for (int i = 0; i < 3; i++) {
cin >> a >> b;
a--;
b--;
c[a]++;
c[b]++;
}
for (int i = 0; i < 4; i++) {
if (c[i] != 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) {
if (y == 0)
return 0;
return gcd(y, x % y);
}
int dis2(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
double cut(int r, int n, int i) {
double res =
r * r - (r - r * (double)i / (double)n) * (r - r * (double)i / (double)n);
return pow(res, 0.5) * 2;
}
int main() {
int a, b;
vector<int> c(4, 0);
for (int i = 0; i < 3; i++) {
cin >> a >> b;
a--;
b--;
c[a]++;
c[b]++;
}
for (int i = 0; i < 4; i++) {
if (c[i] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 931,789 | 931,790 | u765815947 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
int main() {
vector<int> cnt(4);
int tmp;
rep(i, 3) {
cin >> tmp;
tmp--;
cnt[tmp]++;
}
rep(i, 4) {
if (cnt[i] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
int main() {
vector<int> cnt(4);
int tmp;
rep(i, 6) {
cin >> tmp;
tmp--;
cnt[tmp]++;
}
rep(i, 4) {
if (cnt[i] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 931,794 | 931,795 | u552357043 | cpp |
p03130 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef long double ld;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define F first
#define S second
const int mx = 1000010;
const ll mod = 1e9 + 7;
int main() {
map<int, int> mp;
rep(i, 6) {
int a;
cin >> a;
mp[a]++;
if (mp[a] == 3) {
cout << "No" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef long double ld;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define F first
#define S second
const int mx = 1000010;
const ll mod = 1e9 + 7;
int main() {
map<int, int> mp;
rep(i, 6) {
int a;
cin >> a;
mp[a]++;
if (mp[a] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,798 | 931,799 | u980909653 | cpp |
p03130 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip>
#include <iostream>
#include <map> // map
#include <numeric>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <stdio.h>
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
ll Max(ll(a), ll(b), ll(c)) { return max(max(a, b), c); }
ll Min(ll(a), ll(b), ll(c)) { return min(min(a, b), c); }
ll gcd(ll(a), ll(b)) {
ll c = a;
while (a % b != 0) {
c = a % b;
a = b;
b = c;
}
return b;
}
int main() {
int A, B, C, D, E, F;
string an = "No";
cin >> A >> B >> C >> D >> E >> F;
vector<int> n(4);
n.at(A - 1)++;
n.at(B - 1)++;
n.at(C - 1)++;
n.at(D - 1)++;
n.at(E - 1)++;
n.at(F - 1)++;
if (Max(max(n.at(0), n.at(1)), n.at(2), n.at(3)) < 3) {
an = "Yes";
}
cout << an << endl;
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip>
#include <iostream>
#include <map> // map
#include <numeric>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <stdio.h>
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
ll Max(ll(a), ll(b), ll(c)) { return max(max(a, b), c); }
ll Min(ll(a), ll(b), ll(c)) { return min(min(a, b), c); }
ll gcd(ll(a), ll(b)) {
ll c = a;
while (a % b != 0) {
c = a % b;
a = b;
b = c;
}
return b;
}
int main() {
int A, B, C, D, E, F;
string an = "NO";
cin >> A >> B >> C >> D >> E >> F;
vector<int> n(4);
n.at(A - 1)++;
n.at(B - 1)++;
n.at(C - 1)++;
n.at(D - 1)++;
n.at(E - 1)++;
n.at(F - 1)++;
if (Max(max(n.at(0), n.at(1)), n.at(2), n.at(3)) < 3) {
an = "YES";
}
cout << an << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 931,802 | 931,803 | u927801748 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int c[5] = {0};
for (int i = 0; i < 6; i++) {
int ab;
cin >> ab;
c[ab]++;
}
int i;
for (i = 1; i <= 4; i++) {
if (c[i] > 3)
break;
}
if (i == 5)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int c[5] = {0};
for (int i = 0; i < 6; i++) {
int ab;
cin >> ab;
c[ab]++;
}
int i;
for (i = 1; i <= 4; i++) {
if (c[i] >= 3)
break;
}
if (i == 5)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 931,804 | 931,805 | u494609869 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int c[5] = {0};
for (int i = 0; i < 6; i++) {
int ab;
cin >> ab;
c[ab]++;
}
int i;
for (i = 1; i <= 4; i++) {
if (c[i] > 3)
break;
}
if (i == 5)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int c[5] = {0};
for (int i = 0; i < 6; i++) {
int ab;
cin >> ab;
c[ab]++;
}
int i;
for (i = 1; i <= 4; i++) {
if (c[i] >= 3)
break;
}
if (i == 5)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,806 | 931,805 | u494609869 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define DIVCEIL(a, b) ((a + b - 1) / b)
// int CHMAX
int intpow(int a, int n) {
// a^nのint ver
rep(i, n - 1) a *= a;
return a;
}
int MODPOW(int a, int n, int mod) {
// a^n mod
int ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int MODFACT(int a, int mod) {
if (a == 0)
return 1;
else
return (a * FACT(a - 1)) % mod;
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
int MODnPr(int n, int r, int mod) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++) {
sum *= i;
sum = sum % MOD;
}
return sum;
}
// int nCr(int n, int r)
int nCr2(int n, int r) { return FACT(n) / (FACT(r) * FACT(n - r)); }
int GCD(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int NUMOFDIV(int n) {
//約数の数（だっけ？）
int ans = 0;
REP(i, n) {
if (n % i == 0)
ans++;
}
return ans;
}
int CEIL1(int n) {
// 1桁目切り上げ
return (n + 9) / 10 * 10;
}
int GetDigit(int n) { return log10(n) + 1; }
int DIGIT(int n, int k) {
// nのk桁目
rep(i, k - 1) n /= 10;
return n % 10;
}
int DIGITSUM(int n) {
int sum = 0, dig;
while (n) {
dig = n % 10;
sum += dig;
n /= 10;
}
return sum;
}
int DIVTIME(int n, int k) {
// nをkで何回割れるか的な
int div = 0;
while (n % k == 0) {
div++;
n /= k;
}
return div;
}
int binary(int n) {
// 10進数→2進数
int ans = 0;
for (int i = 0; n > 0; i++) {
ans += n % 2 * intpow(10, i);
n /= 2;
}
return ans;
}
int intabs(int n) {
if (n < 0)
return -1 * n;
else
return n;
}
double LOG(int a, int b) { return log(b) / log(a); }
double DISTANCE(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool between(int x, int min, int max) {
if (min < x && x < max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
bool SQRTOR(int n) {
if (sqrt(n) == (int)sqrt(n))
return true;
else
return false;
}
// 順位付け
using namespace std;
#pragma endregion
signed main() {
vector<int> a(6);
int x;
rep(i, 6) {
cin >> x;
a[x]++;
}
string ans = "YES";
REP(i, 3) {
if (a[i] == 3)
ans = "NO";
}
cout << ans;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define DIVCEIL(a, b) ((a + b - 1) / b)
// int CHMAX
int intpow(int a, int n) {
// a^nのint ver
rep(i, n - 1) a *= a;
return a;
}
int MODPOW(int a, int n, int mod) {
// a^n mod
int ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int MODFACT(int a, int mod) {
if (a == 0)
return 1;
else
return (a * FACT(a - 1)) % mod;
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
int MODnPr(int n, int r, int mod) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++) {
sum *= i;
sum = sum % MOD;
}
return sum;
}
// int nCr(int n, int r)
int nCr2(int n, int r) { return FACT(n) / (FACT(r) * FACT(n - r)); }
int GCD(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int NUMOFDIV(int n) {
//約数の数（だっけ？）
int ans = 0;
REP(i, n) {
if (n % i == 0)
ans++;
}
return ans;
}
int CEIL1(int n) {
// 1桁目切り上げ
return (n + 9) / 10 * 10;
}
int GetDigit(int n) { return log10(n) + 1; }
int DIGIT(int n, int k) {
// nのk桁目
rep(i, k - 1) n /= 10;
return n % 10;
}
int DIGITSUM(int n) {
int sum = 0, dig;
while (n) {
dig = n % 10;
sum += dig;
n /= 10;
}
return sum;
}
int DIVTIME(int n, int k) {
// nをkで何回割れるか的な
int div = 0;
while (n % k == 0) {
div++;
n /= k;
}
return div;
}
int binary(int n) {
// 10進数→2進数
int ans = 0;
for (int i = 0; n > 0; i++) {
ans += n % 2 * intpow(10, i);
n /= 2;
}
return ans;
}
int intabs(int n) {
if (n < 0)
return -1 * n;
else
return n;
}
double LOG(int a, int b) { return log(b) / log(a); }
double DISTANCE(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool between(int x, int min, int max) {
if (min < x && x < max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
bool SQRTOR(int n) {
if (sqrt(n) == (int)sqrt(n))
return true;
else
return false;
}
// 順位付け
using namespace std;
#pragma endregion
signed main() {
vector<int> a(6);
int x;
rep(i, 6) {
cin >> x;
a[x]++;
}
string ans = "YES";
REP(i, 4) {
if (a[i] == 3)
ans = "NO";
}
cout << ans;
} | [
"literal.number.change",
"call.arguments.change"
] | 931,818 | 931,819 | u545364250 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define DIVCEIL(a, b) ((a + b - 1) / b)
// int CHMAX
int intpow(int a, int n) {
// a^nのint ver
rep(i, n - 1) a *= a;
return a;
}
int MODPOW(int a, int n, int mod) {
// a^n mod
int ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int MODFACT(int a, int mod) {
if (a == 0)
return 1;
else
return (a * FACT(a - 1)) % mod;
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
int MODnPr(int n, int r, int mod) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++) {
sum *= i;
sum = sum % MOD;
}
return sum;
}
// int nCr(int n, int r)
int nCr2(int n, int r) { return FACT(n) / (FACT(r) * FACT(n - r)); }
int GCD(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int NUMOFDIV(int n) {
//約数の数（だっけ？）
int ans = 0;
REP(i, n) {
if (n % i == 0)
ans++;
}
return ans;
}
int CEIL1(int n) {
// 1桁目切り上げ
return (n + 9) / 10 * 10;
}
int GetDigit(int n) { return log10(n) + 1; }
int DIGIT(int n, int k) {
// nのk桁目
rep(i, k - 1) n /= 10;
return n % 10;
}
int DIGITSUM(int n) {
int sum = 0, dig;
while (n) {
dig = n % 10;
sum += dig;
n /= 10;
}
return sum;
}
int DIVTIME(int n, int k) {
// nをkで何回割れるか的な
int div = 0;
while (n % k == 0) {
div++;
n /= k;
}
return div;
}
int binary(int n) {
// 10進数→2進数
int ans = 0;
for (int i = 0; n > 0; i++) {
ans += n % 2 * intpow(10, i);
n /= 2;
}
return ans;
}
int intabs(int n) {
if (n < 0)
return -1 * n;
else
return n;
}
double LOG(int a, int b) { return log(b) / log(a); }
double DISTANCE(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool between(int x, int min, int max) {
if (min < x && x < max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
bool SQRTOR(int n) {
if (sqrt(n) == (int)sqrt(n))
return true;
else
return false;
}
// 順位付け
using namespace std;
#pragma endregion
signed main() {
vector<int> a(5);
int x;
rep(i, 6) {
cin >> x;
a[x + 1]++;
}
string ans = "YES";
REP(i, 3) {
if (a[i] == 3)
ans = "NO";
}
cout << ans;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define DIVCEIL(a, b) ((a + b - 1) / b)
// int CHMAX
int intpow(int a, int n) {
// a^nのint ver
rep(i, n - 1) a *= a;
return a;
}
int MODPOW(int a, int n, int mod) {
// a^n mod
int ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int MODFACT(int a, int mod) {
if (a == 0)
return 1;
else
return (a * FACT(a - 1)) % mod;
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
int MODnPr(int n, int r, int mod) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++) {
sum *= i;
sum = sum % MOD;
}
return sum;
}
// int nCr(int n, int r)
int nCr2(int n, int r) { return FACT(n) / (FACT(r) * FACT(n - r)); }
int GCD(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int NUMOFDIV(int n) {
//約数の数（だっけ？）
int ans = 0;
REP(i, n) {
if (n % i == 0)
ans++;
}
return ans;
}
int CEIL1(int n) {
// 1桁目切り上げ
return (n + 9) / 10 * 10;
}
int GetDigit(int n) { return log10(n) + 1; }
int DIGIT(int n, int k) {
// nのk桁目
rep(i, k - 1) n /= 10;
return n % 10;
}
int DIGITSUM(int n) {
int sum = 0, dig;
while (n) {
dig = n % 10;
sum += dig;
n /= 10;
}
return sum;
}
int DIVTIME(int n, int k) {
// nをkで何回割れるか的な
int div = 0;
while (n % k == 0) {
div++;
n /= k;
}
return div;
}
int binary(int n) {
// 10進数→2進数
int ans = 0;
for (int i = 0; n > 0; i++) {
ans += n % 2 * intpow(10, i);
n /= 2;
}
return ans;
}
int intabs(int n) {
if (n < 0)
return -1 * n;
else
return n;
}
double LOG(int a, int b) { return log(b) / log(a); }
double DISTANCE(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool between(int x, int min, int max) {
if (min < x && x < max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
bool SQRTOR(int n) {
if (sqrt(n) == (int)sqrt(n))
return true;
else
return false;
}
// 順位付け
using namespace std;
#pragma endregion
signed main() {
vector<int> a(6);
int x;
rep(i, 6) {
cin >> x;
a[x]++;
}
string ans = "YES";
REP(i, 4) {
if (a[i] == 3)
ans = "NO";
}
cout << ans;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.remove"
] | 931,820 | 931,819 | u545364250 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define DIVCEIL(a, b) ((a + b - 1) / b)
// int CHMAX
int intpow(int a, int n) {
// a^nのint ver
rep(i, n - 1) a *= a;
return a;
}
int MODPOW(int a, int n, int mod) {
// a^n mod
int ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int MODFACT(int a, int mod) {
if (a == 0)
return 1;
else
return (a * FACT(a - 1)) % mod;
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
int MODnPr(int n, int r, int mod) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++) {
sum *= i;
sum = sum % MOD;
}
return sum;
}
// int nCr(int n, int r)
int nCr2(int n, int r) { return FACT(n) / (FACT(r) * FACT(n - r)); }
int GCD(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int NUMOFDIV(int n) {
//約数の数（だっけ？）
int ans = 0;
REP(i, n) {
if (n % i == 0)
ans++;
}
return ans;
}
int CEIL1(int n) {
// 1桁目切り上げ
return (n + 9) / 10 * 10;
}
int GetDigit(int n) { return log10(n) + 1; }
int DIGIT(int n, int k) {
// nのk桁目
rep(i, k - 1) n /= 10;
return n % 10;
}
int DIGITSUM(int n) {
int sum = 0, dig;
while (n) {
dig = n % 10;
sum += dig;
n /= 10;
}
return sum;
}
int DIVTIME(int n, int k) {
// nをkで何回割れるか的な
int div = 0;
while (n % k == 0) {
div++;
n /= k;
}
return div;
}
int binary(int n) {
// 10進数→2進数
int ans = 0;
for (int i = 0; n > 0; i++) {
ans += n % 2 * intpow(10, i);
n /= 2;
}
return ans;
}
int intabs(int n) {
if (n < 0)
return -1 * n;
else
return n;
}
double LOG(int a, int b) { return log(b) / log(a); }
double DISTANCE(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool between(int x, int min, int max) {
if (min < x && x < max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
bool SQRTOR(int n) {
if (sqrt(n) == (int)sqrt(n))
return true;
else
return false;
}
// 順位付け
using namespace std;
#pragma endregion
signed main() {
vector<int> a(4);
int x;
rep(i, 6) {
cin >> x;
a[x + 1]++;
}
string ans = "YES";
REP(i, 3) {
if (a[i] == 3)
ans = "NO";
}
cout << ans;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define LAST(x) x[x.size() - 1]
#define ALL(x) (x).begin(), (x).end()
#define swap(a, b) (a += b, b = a - b, a -= b)
#define DIVCEIL(a, b) ((a + b - 1) / b)
// int CHMAX
int intpow(int a, int n) {
// a^nのint ver
rep(i, n - 1) a *= a;
return a;
}
int MODPOW(int a, int n, int mod) {
// a^n mod
int ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int MODFACT(int a, int mod) {
if (a == 0)
return 1;
else
return (a * FACT(a - 1)) % mod;
}
int nPr(int n, int r) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++)
sum *= i;
return sum;
}
int MODnPr(int n, int r, int mod) {
int s = n - r + 1;
int sum = 1;
for (int i = s; i <= n; i++) {
sum *= i;
sum = sum % MOD;
}
return sum;
}
// int nCr(int n, int r)
int nCr2(int n, int r) { return FACT(n) / (FACT(r) * FACT(n - r)); }
int GCD(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int NUMOFDIV(int n) {
//約数の数（だっけ？）
int ans = 0;
REP(i, n) {
if (n % i == 0)
ans++;
}
return ans;
}
int CEIL1(int n) {
// 1桁目切り上げ
return (n + 9) / 10 * 10;
}
int GetDigit(int n) { return log10(n) + 1; }
int DIGIT(int n, int k) {
// nのk桁目
rep(i, k - 1) n /= 10;
return n % 10;
}
int DIGITSUM(int n) {
int sum = 0, dig;
while (n) {
dig = n % 10;
sum += dig;
n /= 10;
}
return sum;
}
int DIVTIME(int n, int k) {
// nをkで何回割れるか的な
int div = 0;
while (n % k == 0) {
div++;
n /= k;
}
return div;
}
int binary(int n) {
// 10進数→2進数
int ans = 0;
for (int i = 0; n > 0; i++) {
ans += n % 2 * intpow(10, i);
n /= 2;
}
return ans;
}
int intabs(int n) {
if (n < 0)
return -1 * n;
else
return n;
}
double LOG(int a, int b) { return log(b) / log(a); }
double DISTANCE(int x1, int y1, int x2, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
inline bool between(int x, int min, int max) {
if (min < x && x < max)
return true;
else
return false;
}
inline bool PRIMEOR(int x) {
if (x == 1)
return false;
if (x == 2)
return true;
if (x % 2 == 0)
return false;
double sqrtx = sqrt(x);
for (int i = 3; i <= sqrtx; i += 2) {
if (x % i == 0)
return false;
}
return true;
}
bool SQRTOR(int n) {
if (sqrt(n) == (int)sqrt(n))
return true;
else
return false;
}
// 順位付け
using namespace std;
#pragma endregion
signed main() {
vector<int> a(6);
int x;
rep(i, 6) {
cin >> x;
a[x]++;
}
string ans = "YES";
REP(i, 4) {
if (a[i] == 3)
ans = "NO";
}
cout << ans;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.remove"
] | 931,821 | 931,819 | u545364250 | cpp |
p03130 | #include <algorithm> //辞書順=next_permutation
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <locale>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string> //char 小文字のほうが32大きい
#include <time.h>
#include <utility> //swap=数値交換
#include <vector> //s1.erase(n)=文字列s1の、n文字目以降削除
#define rt "\n"
#define rep(i, n) for (int i = 0; i < n; i++)
#define rop(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define drop(i, n) for (int i = n; 0 < i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << rt; \
else \
cout << "no" << rt;
#define Yes(ans) \
if (ans) \
cout << "Yes" << rt; \
else \
cout << "No" << rt;
#define YES(ans) \
if (ans) \
cout << "YES" << rt; \
else \
cout << "NO" << rt;
#define sec(a, b, ans) \
if (ans) \
cout << a << rt; \
else \
cout << b << rt;
#define vcin(s, n) rep(i, n) cin >> s[i]; // vcin(配列名),(繰り返し回数)
#define sort(s) sort(s.begin(), s.end()) //標準=昇順
#define reve(s) reverse(s.begin(), s.end())
#define asas int ans = 0
#define llcncn llint cnt = 0
#define llasas llint ans = 0
#define str string
#define please return
#define AC 0
#define ic_a \
int a; \
cin >> a;
#define ic_b \
int b; \
cin >> b;
#define ic_s \
string s; \
cin >> s;
#define Rapid_pleaseAC_fast \
cin.tie(0); \
ios::sync_with_stdio(false)
#define Pi 3.1415926535897932384626
#define nine 1000000000
using namespace std;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
typedef vector<double> vdou;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<char>> vvchar;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<string>> vvstr;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
typedef long double ld;
const ld eps = 1.0e-10; // 許容される誤差
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
unsigned GetDigit(unsigned num) { return std::to_string(num).length(); }
int tow(int n) { // 2のn乗
if (n == 0)
return 1;
int x = tow(n / 2);
x *= x;
if (n % 2 == 1)
x *= 2;
return x; //@domino
}
int keta(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum; // Nanashi,tRue,wai
}
/*
(char)toupper(a[n])=文字列のn文字目を大文字で出力
pow(a,b)=aのb乗
*/
ld mysqrtl(ld x) {
ld a = sqrtl((double)x); // 近似値
do {
a = (a + x / a) / 2.0L;
} while (fabsl(x - a * a) > eps);
return a;
}
//平方根を求める。sqrtより精度が高い。
// epsを変えて誤差を調整する。
int main(void) {
Rapid_pleaseAC_fast;
llint ans = 0, n = 0, m = 1, count = 0, sum = 0, ch = 0;
llint a, aa, aaa, rr = 0, gg = 0, bb = 0, b = 0;
llint bbb = 0, bbbb = 0;
bool check = false;
string s, out;
vector<llint> r, g;
char c;
rep(i, 6) {
cin >> a;
if (a == 1)
b++;
if (a == 2)
bb++;
if (a == 3)
bbb++;
else
bbbb++;
}
if (b <= 2 && bb <= 2 && bbb <= 2 && bbbb <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
please AC;
}
| #include <algorithm> //辞書順=next_permutation
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <locale>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string> //char 小文字のほうが32大きい
#include <time.h>
#include <utility> //swap=数値交換
#include <vector> //s1.erase(n)=文字列s1の、n文字目以降削除
#define rt "\n"
#define rep(i, n) for (int i = 0; i < n; i++)
#define rop(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define drop(i, n) for (int i = n; 0 < i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << rt; \
else \
cout << "no" << rt;
#define Yes(ans) \
if (ans) \
cout << "Yes" << rt; \
else \
cout << "No" << rt;
#define YES(ans) \
if (ans) \
cout << "YES" << rt; \
else \
cout << "NO" << rt;
#define sec(a, b, ans) \
if (ans) \
cout << a << rt; \
else \
cout << b << rt;
#define vcin(s, n) rep(i, n) cin >> s[i]; // vcin(配列名),(繰り返し回数)
#define sort(s) sort(s.begin(), s.end()) //標準=昇順
#define reve(s) reverse(s.begin(), s.end())
#define asas int ans = 0
#define llcncn llint cnt = 0
#define llasas llint ans = 0
#define str string
#define please return
#define AC 0
#define ic_a \
int a; \
cin >> a;
#define ic_b \
int b; \
cin >> b;
#define ic_s \
string s; \
cin >> s;
#define Rapid_pleaseAC_fast \
cin.tie(0); \
ios::sync_with_stdio(false)
#define Pi 3.1415926535897932384626
#define nine 1000000000
using namespace std;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vchar;
typedef vector<double> vdou;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<char>> vvchar;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<string>> vvstr;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
typedef long double ld;
const ld eps = 1.0e-10; // 許容される誤差
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
unsigned GetDigit(unsigned num) { return std::to_string(num).length(); }
int tow(int n) { // 2のn乗
if (n == 0)
return 1;
int x = tow(n / 2);
x *= x;
if (n % 2 == 1)
x *= 2;
return x; //@domino
}
int keta(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum; // Nanashi,tRue,wai
}
/*
(char)toupper(a[n])=文字列のn文字目を大文字で出力
pow(a,b)=aのb乗
*/
ld mysqrtl(ld x) {
ld a = sqrtl((double)x); // 近似値
do {
a = (a + x / a) / 2.0L;
} while (fabsl(x - a * a) > eps);
return a;
}
//平方根を求める。sqrtより精度が高い。
// epsを変えて誤差を調整する。
int main(void) {
Rapid_pleaseAC_fast;
llint ans = 0, n = 0, m = 1, count = 0, sum = 0, ch = 0;
llint a, aa, aaa, rr = 0, gg = 0, bb = 0, b = 0;
llint bbb = 0, bbbb = 0;
bool check = false;
string s, out;
vector<llint> r, g;
char c;
rep(i, 6) {
cin >> a;
if (a == 1)
b++;
else if (a == 2)
bb++;
else if (a == 3)
bbb++;
else
bbbb++;
}
if (b <= 2 && bb <= 2 && bbb <= 2 && bbbb <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
please AC;
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 931,824 | 931,825 | u830366840 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
int i;
vector<int> v(5);
rep(i, 6) {
cin >> i;
v.at(i)++;
}
if (v.at(1) <= 2 && v.at(2) <= 2 && v.at(3) <= 2 && v.at(4) <= 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
int i;
vector<int> v(5);
rep(j, 6) {
cin >> i;
v.at(i)++;
}
if (v.at(1) <= 2 && v.at(2) <= 2 && v.at(3) <= 2 && v.at(4) <= 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"identifier.change",
"call.arguments.change"
] | 931,830 | 931,831 | u089241640 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
int i;
vector<int> v(10);
rep(i, 6) {
cin >> i;
v.at(i)++;
}
if (v.at(1) <= 2 && v.at(2) <= 2 && v.at(3) <= 2 && v.at(4) <= 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
int i;
vector<int> v(5);
rep(j, 6) {
cin >> i;
v.at(i)++;
}
if (v.at(1) <= 2 && v.at(2) <= 2 && v.at(3) <= 2 && v.at(4) <= 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"literal.number.change",
"call.arguments.change",
"identifier.change"
] | 931,832 | 931,831 | u089241640 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
void solve() {
vector<int> g(4, 0);
REP(i, 6) {
int a;
cin >> a;
a--;
g[a]++;
}
REP(i, 4) {
if (g[i] == 0 || g[i] == 3) {
cout << "No" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
void solve() {
vector<int> g(4, 0);
REP(i, 6) {
int a;
cin >> a;
a--;
g[a]++;
}
REP(i, 4) {
if (g[i] == 0 || g[i] == 3) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,840 | 931,841 | u973991908 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int s[5];
for (int i = 0; i < 5; i++)
s[i] = 0;
for (int i = 0; i < 6; i++) {
int a;
cin >> a;
s[a]++;
}
if (s[1] <= 2 && s[2] <= 2 && s[3] <= 2 && s[4] <= 2)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int s[5];
for (int i = 0; i < 5; i++)
s[i] = 0;
for (int i = 0; i < 6; i++) {
int a;
cin >> a;
s[a]++;
}
if (s[1] <= 2 && s[2] <= 2 && s[3] <= 2 && s[4] <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,842 | 931,843 | u955282280 | cpp |
p03130 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int s[4];
rep(i, 3) {
int a, b;
cin >> a >> b;
s[a - 1]++;
s[b - 1]++;
}
sort(s, s + 4);
if (s[0] == 1 && s[1] == 1 && s[2] == 2 && s[3] == 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int s[4] = {};
rep(i, 3) {
int a, b;
cin >> a >> b;
s[a - 1]++;
s[b - 1]++;
}
sort(s, s + 4);
if (s[0] == 1 && s[1] == 1 && s[2] == 2 && s[3] == 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"variable_declaration.value.change"
] | 931,844 | 931,845 | u561143568 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> data(4);
int a;
for (int i = 0; i < 6; i++) {
cin >> a;
data.at(a - 1)++;
}
int one = 0, two = 0;
for (int i = 0; i < 4; i++) {
if (data.at(i) == 2)
two++;
if (data.at(i) == 1)
one++;
}
int flag = 0;
if (one == 2 && two == 2)
flag = 1;
cout << (flag ? "YES" : "No") << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> data(4);
int a;
for (int i = 0; i < 6; i++) {
cin >> a;
data.at(a - 1)++;
}
int one = 0, two = 0;
for (int i = 0; i < 4; i++) {
if (data.at(i) == 2)
two++;
if (data.at(i) == 1)
one++;
}
int flag = 0;
if (one == 2 && two == 2)
flag = 1;
cout << (flag ? "YES" : "NO") << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,846 | 931,847 | u239087789 | cpp |
p03130 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<int> enum_div(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
map<int, int> m;
REP(i, 3) {
int a, b;
cin >> a >> b;
m[a]++;
m[b]++;
}
bool yes = true;
FOR(i, 1, 4) {
if (m[i] == 3)
yes = false;
}
YESNO(yes, "YES", "NO");
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<int> enum_div(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
map<int, int> m;
REP(i, 3) {
int a, b;
cin >> a >> b;
m[a]++;
m[b]++;
}
bool yes = true;
FOR(i, 1, 5) {
if (m[i] == 3)
yes = false;
}
YESNO(yes, "YES", "NO");
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 931,851 | 931,852 | u303039933 | cpp |
p03130 | #include <bits/stdc++.h>
#define BIT(n) (1LL << (n))
#define BITF(n, i) (((n) >> i) & 1)
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPI(i, x) for (int i = 1; i <= x; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define REPZ(i, x) for (int i = 0; i <= x; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORA(i, n) for (auto &&i : n)
#define FORI(i, m, n) for (int i = m; i <= n; i++)
using namespace std;
#define DUMPOUT cerr
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
REP(i, (int)vec.size())
os << vec[i] << (i + 1 == (int)vec.size() ? "" : ", ");
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
FORA(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
FORA(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0)
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define DUMP(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#define PRINTARR(x, y) \
cerr << #x << "=\n"; \
for (auto itr = x; itr != y; itr++) \
cerr << *itr << " "; \
cerr << endl;
#define PRINTARR2(x, i0, i1) \
cerr << #x << "=\n"; \
for (int ii0 = 0; ii0 < i0; ii0++) { \
for (int ii1 = 0; ii1 < i1; ii1++) \
cerr << x[ii0][ii1] << " "; \
cerr << endl; \
}
#else
#define DEB if (false)
#define DUMP(...)
#define PRINTARR(x, y)
#define PRINTARR2(x, i0, i1)
#endif
#define ALL(v) v.begin(), v.end()
#define fst first
#define snd second
#define mp make_pair
#define pb push_back
#define epb emplace_back
#define int long long
#define pint pair<int, int>
#define ld long double
using namespace std;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using vec = std::vector<T>;
template <class T> void print(const T &x) { cout << x << "\n"; }
const int MOD = 1000000007, INF0 = 1061109567, INF = INF0 * INF0;
const double EPS = 1e-10, PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
/*
下のスラッシュを2つ追加しただけ.上のスラッシュを2つにすれば外れる.
//*/
#define MAXN 200200
int cnt[3];
signed main() {
cin.tie(0), ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
REP(i, 6) {
int p;
cin >> p;
cnt[p - 1]++;
}
if (*max_element(cnt, cnt + 3) == 3) {
print("NO");
} else {
print("YES");
}
} | #include <bits/stdc++.h>
#define BIT(n) (1LL << (n))
#define BITF(n, i) (((n) >> i) & 1)
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPI(i, x) for (int i = 1; i <= x; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define REPZ(i, x) for (int i = 0; i <= x; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORA(i, n) for (auto &&i : n)
#define FORI(i, m, n) for (int i = m; i <= n; i++)
using namespace std;
#define DUMPOUT cerr
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
REP(i, (int)vec.size())
os << vec[i] << (i + 1 == (int)vec.size() ? "" : ", ");
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
FORA(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
FORA(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0)
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define DUMP(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#define PRINTARR(x, y) \
cerr << #x << "=\n"; \
for (auto itr = x; itr != y; itr++) \
cerr << *itr << " "; \
cerr << endl;
#define PRINTARR2(x, i0, i1) \
cerr << #x << "=\n"; \
for (int ii0 = 0; ii0 < i0; ii0++) { \
for (int ii1 = 0; ii1 < i1; ii1++) \
cerr << x[ii0][ii1] << " "; \
cerr << endl; \
}
#else
#define DEB if (false)
#define DUMP(...)
#define PRINTARR(x, y)
#define PRINTARR2(x, i0, i1)
#endif
#define ALL(v) v.begin(), v.end()
#define fst first
#define snd second
#define mp make_pair
#define pb push_back
#define epb emplace_back
#define int long long
#define pint pair<int, int>
#define ld long double
using namespace std;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using vec = std::vector<T>;
template <class T> void print(const T &x) { cout << x << "\n"; }
const int MOD = 1000000007, INF0 = 1061109567, INF = INF0 * INF0;
const double EPS = 1e-10, PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
/*
下のスラッシュを2つ追加しただけ.上のスラッシュを2つにすれば外れる.
//*/
#define MAXN 200200
int cnt[4];
signed main() {
cin.tie(0), ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
REP(i, 6) {
int p;
cin >> p;
cnt[p - 1]++;
}
if (*max_element(cnt, cnt + 4) == 3) {
print("NO");
} else {
print("YES");
}
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.branch.if.condition.change"
] | 931,859 | 931,860 | u468262978 | cpp |
p03130 | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
vector<int> a(6);
rep(i, 6) cin >> a[i];
vector<int> ans(4);
rep(i, 6) ans[i - 1]++;
bool b = true;
rep(i, 4) {
if (ans[i] = 3)
b = false;
}
if (b)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
vector<int> a(6);
rep(i, 6) cin >> a[i];
vector<int> ans(4);
rep(i, 6) ans[a[i] - 1]++;
bool b = true;
rep(i, 4) {
if (ans[i] == 3)
b = false;
}
if (b)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 931,861 | 931,862 | u648009244 | cpp |
p03130 | //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
//定数
#define MOD 1000000007
//マクロ
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define reprev(i, n) for (int(i) = (n - 1); (i) >= 0; (i)--)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define vsort(v) sort((v).begin(), (v).end());
typedef unsigned long long int ull;
typedef long long lint;
using namespace std;
int main() {
int a[4], b[4];
vector<int> num(5, 0);
//入力
rep(i, 3) {
int a, b;
cin >> a >> b;
num[a]++;
num[b]++;
}
rep(i, 4) if (num[1 + 1] >= 3) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
// cout << endl;
// rep(i,4) cout << num[i+1] << endl;
return 0;
} | //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
//定数
#define MOD 1000000007
//マクロ
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define reprev(i, n) for (int(i) = (n - 1); (i) >= 0; (i)--)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define vsort(v) sort((v).begin(), (v).end());
typedef unsigned long long int ull;
typedef long long lint;
using namespace std;
int main() {
int a[4], b[4];
vector<int> num(5, 0);
//入力
rep(i, 3) {
int a, b;
cin >> a >> b;
num[a]++;
num[b]++;
}
rep(i, 4) if (num[i + 1] >= 3) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
// cout << endl;
// rep(i,4) cout << num[i+1] << endl;
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 931,863 | 931,864 | u212083331 | cpp |
p03130 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = acos(-1);
// const double EPS = 1e-15;
// long long INF=(long long)1E17;
#define i_7 (long long)(1e9 + 7)
//#define i_7 998'244'353
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
using namespace std;
bool prime_(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd_(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long lcm_(long long x, long long y) { return (x / gcd_(x, y)) * y; }
int main() {
vector<int> G[3];
int a, b;
REP(i, 3) {
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
bool flag = true;
REP(i, 4) {
int d = G[i].size();
if (d == 3) {
flag = false;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = acos(-1);
// const double EPS = 1e-15;
// long long INF=(long long)1E17;
#define i_7 (long long)(1e9 + 7)
//#define i_7 998'244'353
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
using namespace std;
bool prime_(int n) {
if (n == 1) {
return false;
} else if (n == 2) {
return true;
} else {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
long long gcd_(long long a, long long b) {
if (a < b) {
swap(a, b);
}
if (a % b == 0) {
return b;
} else {
return gcd_(b, a % b);
}
}
long long lcm_(long long x, long long y) { return (x / gcd_(x, y)) * y; }
int main() {
vector<int> G[4];
int a, b;
REP(i, 3) {
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
bool flag = true;
REP(i, 4) {
int d = G[i].size();
if (d == 3) {
flag = false;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 931,865 | 931,866 | u222293734 | cpp |
p03130 | #include "bits/stdc++.h"
using namespace std;
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(x) (x).begin(), (x).end() //昇順
#define RALL(x) (x).rbegin(), (x).rend() // 降順
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
const long long mod = 1e9 + 7;
typedef priority_queue<int> PQ;
typedef vector<long long> VL;
typedef vector<bool> VB;
typedef vector<int> VI; // VI a(n);
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<char> VC;
typedef vector<VS> VSS;
typedef vector<VC> VCC;
typedef vector<VI> VII; // VII a(n,vector<int>(m)) n * m
typedef vector<VL> VLL;
typedef pair<int, int> PII;
typedef map<int, int> MP; // MP a;
typedef vector<pair<int, int>> PS;
typedef long long ll; // ll とdoubleは違う
template <class T, class U> // chmax(max, a);
bool chmax(T &a, U b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U> // chmin(min,a)
bool chmin(T &a, U b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> // operator << (cout,a);
ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
rep(i, (int)v.size()) { os << v[i] << (i < v.size() - 1 ? ", " : ""); }
os << "}";
return os;
}
// g++ -std=c++11 prac.cpp
int main() {
int d, n, x, y = 0, z, m, k, w, sum = 0, ans = 0, Max = -1e9, Min = 1e9 + 1;
string s, t;
bool count = false, ok = false;
VI a(4);
rep(i, 6) {
cin >> x;
a[x - 1]++;
}
if (a[0] <= 2 && a[1] <= 2 && a[2] <= 2 && a[3] <= 2)
cout << "YES" << endl;
else
cout << "YES" << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(x) (x).begin(), (x).end() //昇順
#define RALL(x) (x).rbegin(), (x).rend() // 降順
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
const long long mod = 1e9 + 7;
typedef priority_queue<int> PQ;
typedef vector<long long> VL;
typedef vector<bool> VB;
typedef vector<int> VI; // VI a(n);
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<char> VC;
typedef vector<VS> VSS;
typedef vector<VC> VCC;
typedef vector<VI> VII; // VII a(n,vector<int>(m)) n * m
typedef vector<VL> VLL;
typedef pair<int, int> PII;
typedef map<int, int> MP; // MP a;
typedef vector<pair<int, int>> PS;
typedef long long ll; // ll とdoubleは違う
template <class T, class U> // chmax(max, a);
bool chmax(T &a, U b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U> // chmin(min,a)
bool chmin(T &a, U b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> // operator << (cout,a);
ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
rep(i, (int)v.size()) { os << v[i] << (i < v.size() - 1 ? ", " : ""); }
os << "}";
return os;
}
// g++ -std=c++11 prac.cpp
int main() {
int d, n, x, y = 0, z, m, k, w, sum = 0, ans = 0, Max = -1e9, Min = 1e9 + 1;
string s, t;
bool count = false, ok = false;
VI a(4);
rep(i, 6) {
cin >> x;
a[x - 1]++;
}
if (a[0] <= 2 && a[1] <= 2 && a[2] <= 2 && a[3] <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 931,867 | 931,868 | u718774863 | cpp |
p03130 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
int main() {
vector<int> a(3);
vector<int> b(3);
for (int i = 0; i < 3; i++)
cin >> a[i];
for (int i = 0; i < 3; i++)
cin >> b[i];
vector<int> cnt(3);
for (int i = 0; i < 3; i++) {
cnt[a[i] - 1]++;
cnt[b[i] - 1]++;
}
sort(all(cnt));
if (cnt[2] > 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
int main() {
vector<int> a(3);
vector<int> b(3);
for (int i = 0; i < 3; i++)
cin >> a[i];
for (int i = 0; i < 3; i++)
cin >> b[i];
vector<int> cnt(4);
for (int i = 0; i < 3; i++) {
cnt[a[i] - 1]++;
cnt[b[i] - 1]++;
}
sort(all(cnt));
if (cnt[3] > 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} | [
"literal.number.change",
"call.arguments.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 931,875 | 931,876 | u412550879 | cpp |
p03130 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
int main() {
vector<int> a(3);
vector<int> b(3);
for (int i = 0; i < 3; i++)
cin >> a[i];
for (int i = 0; i < 3; i++)
cin >> b[i];
vector<int> cnt(3);
for (int i = 0; i < 3; i++) {
cnt[a[i]]++;
cnt[b[i]]++;
}
sort(all(cnt));
if (cnt[2] > 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
int main() {
vector<int> a(3);
vector<int> b(3);
for (int i = 0; i < 3; i++)
cin >> a[i];
for (int i = 0; i < 3; i++)
cin >> b[i];
vector<int> cnt(4);
for (int i = 0; i < 3; i++) {
cnt[a[i] - 1]++;
cnt[b[i] - 1]++;
}
sort(all(cnt));
if (cnt[3] > 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} | [
"literal.number.change",
"call.arguments.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 931,877 | 931,876 | u412550879 | cpp |
p03130 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
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;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
int used[4][4];
int main() {
vector<vector<int>> edge(4);
REP(i, 3) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
REP(i, 4) {
if (edge[i].size() == 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
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;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
int used[4][4];
int main() {
vector<vector<int>> edge(4);
REP(i, 3) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
REP(i, 4) {
if (edge[i].size() == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,878 | 931,879 | u824337972 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define all_map(itr, mp) for (auto itr = mp.begin(); itr != mp.end(); itr++)
#define ALL(a) (a).begin(), (a).end()
int main() {
int cnt[4];
rep(i, 3) {
int a, b;
cin >> a >> b;
cnt[a - 1]++, cnt[b - 1]++;
}
rep(i, 4) if (cnt[i] >= 3) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define all_map(itr, mp) for (auto itr = mp.begin(); itr != mp.end(); itr++)
#define ALL(a) (a).begin(), (a).end()
int main() {
int cnt[4] = {};
rep(i, 3) {
int a, b;
cin >> a >> b;
cnt[a - 1]++, cnt[b - 1]++;
}
rep(i, 4) if (cnt[i] >= 3) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
} | [
"variable_declaration.value.change"
] | 931,882 | 931,883 | u969116807 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; --(i)) // Reversi rep
#define nfor(i, a, b) for (int(i) = (a); (i) < (b); ++(i)) // Natural for
#define rfor(i, a, b) for (int(i) = (b)-1; (i) >= (a); --(i)) // Reversi for
#define ll long long
#define mod (1000000007)
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define yes cout << "yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
#define no cout << "no" << endl;
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int desc(const void *a, const void *b) { return *(int *)b - *(int *)a; }
int main() {
int x;
vector<int> a(4, 0);
rep(i, 6) {
cin >> x;
++a[x];
}
if (a[0] <= 2 && a[1] <= 2 && a[2] <= 2 && a[3] <= 2) {
YES;
} else {
NO;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define rrep(i, n) for (int(i) = (n)-1; (i) >= 0; --(i)) // Reversi rep
#define nfor(i, a, b) for (int(i) = (a); (i) < (b); ++(i)) // Natural for
#define rfor(i, a, b) for (int(i) = (b)-1; (i) >= (a); --(i)) // Reversi for
#define ll long long
#define mod (1000000007)
#define YES cout << "YES" << endl;
#define Yes cout << "Yes" << endl;
#define yes cout << "yes" << endl;
#define NO cout << "NO" << endl;
#define No cout << "No" << endl;
#define no cout << "no" << endl;
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int desc(const void *a, const void *b) { return *(int *)b - *(int *)a; }
int main() {
int x;
vector<int> a(4, 0);
rep(i, 6) {
cin >> x;
++a[x - 1];
}
if (a[0] <= 2 && a[1] <= 2 && a[2] <= 2 && a[3] <= 2) {
YES;
} else {
NO;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 931,884 | 931,885 | u801513186 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int city[4] = {};
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
city[a - 1]++;
city[b - 1]++;
}
for (int i = 0; i < 3; i++) {
if (city[i] == 0 || city[i] >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int city[4] = {};
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
city[a - 1]++;
city[b - 1]++;
}
for (int i = 0; i < 4; i++) {
if (city[i] == 0 || city[i] >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 931,886 | 931,887 | u522200796 | cpp |
p03130 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath> // abs() for float, and fabs()
#include <cstdlib> // abs() for integer 絶対値求めやつ
#include <iomanip> //浮動小数点数を出力する制度の指定
#include <string>
#include <vector>
//使い方 数値をnumとして cout<<setprecision(n)<<num ;nは桁数
#define rep(i, n) for (int i = 0; i < (n); i++)
#define SORT(a) sort((a).begin(), (a).end())
#define REV(a) reverse((a).begin(), (a).end())
using namespace std;
using ll = long long;
#define INF 2000000000
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;
}
#define che(a, string) cout << "//" << string << "==" << (a) << "//" << endl;
bool IsInt(double a) {
int b = a / 1;
if (a == b) {
return true;
} else {
return false;
}
}
/*覚えてないことメaモ
数値型から文字列に変換 to_string(number);これは簡単
文字列から数値型に変換 stoi(number)
文字列からllに変換 stoll(number)*/
//ここから書き始める
int main() {
vector<int> a(4, 0);
rep(i, 6) {
int s;
cin >> s;
s--;
a[s]++;
}
SORT(a);
// for(auto x:a){
// cout<<x<<" " ;
// }
if (a[3] >= 3)
cout << "N0" << endl;
else
cout << "YES" << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath> // abs() for float, and fabs()
#include <cstdlib> // abs() for integer 絶対値求めやつ
#include <iomanip> //浮動小数点数を出力する制度の指定
#include <string>
#include <vector>
//使い方 数値をnumとして cout<<setprecision(n)<<num ;nは桁数
#define rep(i, n) for (int i = 0; i < (n); i++)
#define SORT(a) sort((a).begin(), (a).end())
#define REV(a) reverse((a).begin(), (a).end())
using namespace std;
using ll = long long;
#define INF 2000000000
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;
}
#define che(a, string) cout << "//" << string << "==" << (a) << "//" << endl;
bool IsInt(double a) {
int b = a / 1;
if (a == b) {
return true;
} else {
return false;
}
}
/*覚えてないことメaモ
数値型から文字列に変換 to_string(number);これは簡単
文字列から数値型に変換 stoi(number)
文字列からllに変換 stoll(number)*/
//ここから書き始める
int main() {
vector<int> a(4, 0);
rep(i, 6) {
int s;
cin >> s;
s--;
a[s]++;
}
SORT(a);
// for(auto x:a){
// cout<<x<<" " ;
// }
if (a[3] >= 3)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| [
"literal.string.change",
"io.output.change"
] | 931,890 | 931,891 | u298620933 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, d = 0;
int c[100] = {};
for (int i = 0; i < 3; i++) {
cin >> a >> b;
c[a]++;
c[b]++;
}
for (int i = 0; i < 5; i++) {
if (c[i] >= 3)
d = 1;
}
if (d)
cout << "YES";
else
cout << "NO";
cout << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, d = 0;
int c[100] = {};
for (int i = 0; i < 3; i++) {
cin >> a >> b;
c[a]++;
c[b]++;
}
for (int i = 0; i < 5; i++) {
if (c[i] >= 3)
d = 1;
}
if (d == 0)
cout << "YES";
else
cout << "NO";
cout << "\n";
} | [
"control_flow.branch.if.condition.change"
] | 931,894 | 931,895 | u831161882 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
vector<int> P(4);
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a;
P[a]++;
cin >> b;
P[b]++;
}
sort(P.begin(), P.end(), greater<int>());
if (P[0] > 2 || P[3] == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
vector<int> P(4);
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a;
P[--a]++;
cin >> b;
P[--b]++;
}
sort(P.begin(), P.end(), greater<int>());
// for(int i = 0; i < 4; i++) cout << P[i] << endl;
if (P[0] > 2 || P[3] == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
} | [] | 931,898 | 931,899 | u964726243 | cpp |
p03130 | #include <algorithm>
#include <cassert>
#include <cfenv>
#include <cmath>
#include <functional>
#include <iostream>
#include <vector>
using ll = unsigned long long;
using namespace std;
int main() {
vector<int> vec(4);
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
vec[a]++;
vec[b]++;
}
int c = 0;
for (int i = 0; i < 4; i++) {
if (vec[i] % 2 == 1) {
c++;
}
if (c >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "Yes" << endl;
} | #include <algorithm>
#include <cassert>
#include <cfenv>
#include <cmath>
#include <functional>
#include <iostream>
#include <vector>
using ll = unsigned long long;
using namespace std;
int main() {
vector<int> vec(4);
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
vec[a]++;
vec[b]++;
}
int c = 0;
for (int i = 0; i < 4; i++) {
if (vec[i] % 2 == 1) {
c++;
}
if (c >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,902 | 931,903 | u759162415 | cpp |
p03130 | #include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n - 1); i >= 0; i--)
#define pb push_back
#define f first
#define s second
const ll INFL = 1LL << 60; // 10^18 = 2^60
const int INF = 1 << 30; // 10^9
ll MOD = 1000000007;
// ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll max(ll a, ll b) { return (a > b) ? a : b; }
ll min(ll a, ll b) { return (a < b) ? a : b; }
ll pow_long(ll x, ll k) {
ll res = 1;
while (k > 0) {
if (k % 2)
res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k) {
x %= MOD;
x += MOD;
x %= MOD;
ll res = 1;
while (k > 0) {
if (k % 2) {
res *= x;
res %= MOD;
}
x *= x;
x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x) { return pow_mod(x, MOD - 2); };
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; };
ll kai_mod(ll x) {
if (x == 0)
return 1;
return x * kai_mod(x - 1) % MOD;
}
/*
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAXcomb; i++){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll comb(int n, int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n-k] % MOD;
}
*/
int main() {
vector<ll> cnt(4, 0);
rep(i, 6) {
int a;
cin >> a;
cnt[a--]++;
}
rep(i, 4) {
if (cnt[i] >= 3) {
cout << "NO" << endl;
return 0;
}
}
rep(i, 4) {
if (cnt[i] == 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| #include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n - 1); i >= 0; i--)
#define pb push_back
#define f first
#define s second
const ll INFL = 1LL << 60; // 10^18 = 2^60
const int INF = 1 << 30; // 10^9
ll MOD = 1000000007;
// ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll max(ll a, ll b) { return (a > b) ? a : b; }
ll min(ll a, ll b) { return (a < b) ? a : b; }
ll pow_long(ll x, ll k) {
ll res = 1;
while (k > 0) {
if (k % 2)
res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k) {
x %= MOD;
x += MOD;
x %= MOD;
ll res = 1;
while (k > 0) {
if (k % 2) {
res *= x;
res %= MOD;
}
x *= x;
x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x) { return pow_mod(x, MOD - 2); };
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; };
ll kai_mod(ll x) {
if (x == 0)
return 1;
return x * kai_mod(x - 1) % MOD;
}
/*
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAXcomb; i++){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll comb(int n, int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n-k] % MOD;
}
*/
int main() {
vector<ll> cnt(4, 0);
rep(i, 6) {
int a;
cin >> a;
cnt[--a]++;
}
rep(i, 4) {
if (cnt[i] >= 3) {
cout << "NO" << endl;
return 0;
}
}
rep(i, 4) {
if (cnt[i] == 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| [] | 931,908 | 931,909 | u633284019 | cpp |
p03130 | #include <stdio.h>
int main() {
int i, a, b, c[10];
for (i = 0; i < 10; i++)
c[i] = 0;
for (i = 0; i < 3; i++) {
printf("%d%d", &a, &b);
c[a]++;
c[b]++;
}
for (i = 1; i <= 4; i++) {
if (c[i] == 0 || c[i] == 3) {
printf("NO\0");
return 0;
}
}
printf("YES\n");
return 0;
} | #include <stdio.h>
int main() {
int i, a, b, c[10];
for (i = 0; i < 10; i++)
c[i] = 0;
for (i = 0; i < 3; i++) {
scanf("%d%d", &a, &b);
c[a]++;
c[b]++;
}
for (i = 1; i <= 4; i++) {
if (c[i] == 0 || c[i] == 3) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| [
"identifier.change",
"call.function.change",
"io.output.change",
"literal.string.change",
"call.arguments.change",
"io.output.newline.add"
] | 931,910 | 931,911 | u933068010 | cpp |
p03130 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
typedef long long int ll;
int main() {
int cnt[4];
for (int i = 0; i < 6; i++) {
int t;
cin >> t;
cnt[t - 1]++;
}
if (cnt[0] * cnt[1] * cnt[2] * cnt[3] > 0 && cnt[0] < 3 && cnt[1] < 3 &&
cnt[2] < 3 && cnt[3] < 3) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
typedef long long int ll;
int main() {
int cnt[4] = {};
for (int i = 0; i < 6; i++) {
int t;
cin >> t;
cnt[t - 1]++;
}
if (cnt[0] * cnt[1] * cnt[2] * cnt[3] > 0 && cnt[0] < 3 && cnt[1] < 3 &&
cnt[2] < 3 && cnt[3] < 3) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"variable_declaration.value.change"
] | 931,914 | 931,915 | u928536113 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define each(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define all(v) v.begin(), v.end()
#define mset(a, n) memset(a, n, sizeof(a))
typedef long long ll;
const int INF = 1000000000;
const int MOD = 1000000007;
int main(int argc, char *argv[]) {
// cin.tie(0);
// ios::sync_with_stdio(false);
vector<int> town(4, 0);
rep(i, 3) {
int a, b;
cin >> a >> b;
town[a]++, town[b]++;
}
bool flg = true;
rep(i, 4) if (town[i] > 2) flg = false;
cout << (flg ? "YES" : "NO") << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define each(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define all(v) v.begin(), v.end()
#define mset(a, n) memset(a, n, sizeof(a))
typedef long long ll;
const int INF = 1000000000;
const int MOD = 1000000007;
int main(int argc, char *argv[]) {
// cin.tie(0);
// ios::sync_with_stdio(false);
vector<int> town(4, 0);
rep(i, 3) {
int a, b;
cin >> a >> b;
town[--a]++, town[--b]++;
}
bool flg = true;
rep(i, 4) if (town[i] > 2) flg = false;
cout << (flg ? "YES" : "NO") << endl;
return 0;
} | [] | 931,916 | 931,917 | u569778242 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define INF 1e9
#define ALL(v) v.begin(), v.end()
#define max(v) *max_element(v.begin(), v.end())
#define min(v) *min_element(v.begin(), v.end())
using namespace std;
int main(void) {
vector<int> a, b;
int s, t;
for (int i = 0; i < 3; i++) {
cin >> s >> t;
a.push_back(s);
b.push_back(t);
}
vector<int> cnt(4);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
if (a[i] == j)
cnt[j] += 1;
if (b[i] == j)
cnt[j] += 1;
}
}
int key = 0;
for (int i = 0; i < 4; i++) {
if (cnt[i] >= 3)
key = 1;
}
if (key == 1)
cout << "NO";
else
cout << "YES";
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define INF 1e9
#define ALL(v) v.begin(), v.end()
#define max(v) *max_element(v.begin(), v.end())
#define min(v) *min_element(v.begin(), v.end())
using namespace std;
int main(void) {
vector<int> a, b;
int s, t;
for (int i = 0; i < 3; i++) {
cin >> s >> t;
a.push_back(s);
b.push_back(t);
}
vector<int> cnt(5);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
if (a[i] == j)
cnt[j] += 1;
if (b[i] == j)
cnt[j] += 1;
}
}
int key = 0;
for (int i = 0; i < 5; i++) {
if (cnt[i] >= 3)
key = 1;
}
if (key == 1)
cout << "NO";
else
cout << "YES";
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 931,931 | 931,932 | u054559808 | cpp |
p03130 | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int now, n, k;
int main() {
int ans = 0;
vector<int> ain(6);
vector<int> a(4);
REP(i, 6) {
cin >> n;
a[n] += 1;
}
n = 0;
REP(i, 4) {
if (a[i] >= 3) {
n = 1;
}
if (a[i] == 0) {
n = 1;
}
}
if (n == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int now, n, k;
int main() {
int ans = 0;
vector<int> ain(6);
vector<int> a(4);
REP(i, 6) {
cin >> n;
a[n - 1] += 1;
}
n = 0;
REP(i, 4) {
if (a[i] >= 3) {
n = 1;
}
if (a[i] == 0) {
n = 1;
}
}
if (n == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"assignment.change"
] | 931,933 | 931,934 | u837951457 | cpp |
p03130 | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int now, n, k;
int main() {
int ans = 0;
vector<int> ain(6);
vector<int> a(4);
REP(i, 6) {
cin >> n;
a[n] += 1;
}
n = 0;
REP(i, 4) {
if (a[i] >= 3)
n = 1;
if (a[i] == 0)
n = 1;
}
if (n == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int now, n, k;
int main() {
int ans = 0;
vector<int> ain(6);
vector<int> a(4);
REP(i, 6) {
cin >> n;
a[n - 1] += 1;
}
n = 0;
REP(i, 4) {
if (a[i] >= 3) {
n = 1;
}
if (a[i] == 0) {
n = 1;
}
}
if (n == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"assignment.change"
] | 931,935 | 931,934 | u837951457 | cpp |
p03130 |
#include "math.h"
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int a[4] = {};
int x[6];
for (int i = 0; i < 6; i++) {
cin >> x[i];
}
for (int i = 0; i < 6; i++) {
a[x[i] - 1]++;
if (a[x[i] - 1] == 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} |
#include "math.h"
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int a[4] = {};
int x[6];
for (int i = 0; i < 6; i++) {
cin >> x[i];
}
for (int i = 0; i < 6; i++) {
a[x[i] - 1]++;
if (a[x[i] - 1] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 931,936 | 931,937 | u959822889 | cpp |
p03130 |
/*vvv>
zzzzzI
.---. zzuzuI .vgggg&,.
+++++= dunkoI .WbbWo JMM9^```?TMB` ..&gNNg,. gggggggJ, qgggggggg]
(&&&&&&&&[ c+OA&J, (&&&&&&+J, .cJeAA&-. (&&&&&&&&x .&AA&=-.
+++++= dunkoI Xpbpbp JM#` (M#^ ?MMp MM| +TMN. JMF '
|yk ` dVY 7Vk, Vy XV cVf ?Y! JM V$ `
+++++= OunkoI Xppppp dMN .MM+ .MM MM| MM] JMMMMMM+
|@tqkoh) ,y0 (V$ yyyyyyyV7 VV JMWyZWr TWVVVVW&,
++++++ dZZZZ0 Xppppp ^HMN, _.db WMm, .MMF MM| ..MM` JMF .
|yk .WV&. .XW' yy 4yn. jyn +. JM #S
`++++` ?ZZZX= ?WWWW= -THMMMMH9^ (TMMMMM9! MMMMMMM"" JMMMMMMMME
|UU. ?TUUUUY= UU. (UU- ^7TUUUV7! JUUUUUUUU 7TUNKO*/
// Ricty Diminished
#include "bits/stdc++.h"
using namespace std;
typedef long long lint;
typedef vector<lint> liv;
//#define rep(i,n) for(int i=0;i<n;++i)
#define all(v) v.begin(), v.end()
#define linf 1152921504606846976
#define MAXN 100100
#define md 1000000007 // 998244353
#define pb push_back
#define _vcppunko4(tuple) _getname4 tuple
#define _getname4(_1, _2, _3, _4, name, ...) name
#define _getname3(_1, _2, _3, name, ...) name
#define _trep2(tuple) _rep2 tuple
#define _trep3(tuple) _rep3 tuple
#define _trep4(tuple) _rep4 tuple
#define _rep1(n) for (lint i = 0; i < n; ++i)
#define _rep2(i, n) for (lint i = 0; i < n; ++i)
#define _rep3(i, a, b) for (lint i = a; i < b; ++i)
#define _rep4(i, a, b, c) for (lint i = a; i < b; i += c)
#define _trrep2(tuple) _rrep2 tuple
#define _trrep3(tuple) _rrep3 tuple
#define _trrep4(tuple) _rrep4 tuple
#define _rrep1(n) for (lint i = n - 1; i >= 0; --i)
#define _rrep2(i, n) for (lint i = n - 1; i >= 0; --i)
#define _rrep3(i, a, b) for (lint i = b - 1; i >= a; --i)
#define _rrep4(i, a, b, c) \
for (lint i = a + (b - a - 1) / c * c; i >= a; i -= c)
template <class T> istream &operator>>(istream &is, vector<T> &vec);
template <class T, size_t size>
istream &operator>>(istream &is, array<T, size> &vec);
template <class T, class L> istream &operator>>(istream &is, pair<T, L> &p);
template <class T> ostream &operator<<(ostream &os, vector<T> &vec);
template <class T, class L> ostream &operator<<(ostream &os, pair<T, L> &p);
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <class T, class L> istream &operator>>(istream &is, pair<T, L> &p) {
is >> p.first;
is >> p.second;
return is;
}
// template<class T>
// ostream& operator<<(ostream& os,vector<T>& vec){
// os<<vec[0];rep(i,1,vec.size())os<<' '<<vec[i];return os; } template<class T>
// ostream& operator<<(ostream& os,deque<T>& deq){
// os<<deq[0];rep(i,1,deq.size())os<<' '<<deq[i];return os; }
template <class T, class L> ostream &operator<<(ostream &os, pair<T, L> &p) {
os << p.first << " " << p.second;
return os;
}
inline void in() {}
template <class Head, class... Tail>
inline void in(Head &&head, Tail &&...tail) {
cin >> head;
in(move(tail)...);
}
template <class T> inline bool out(T t) {
cout << t << '\n';
return 0;
}
inline bool out() {
cout << '\n';
return 0;
}
template <class Head, class... Tail> inline bool out(Head head, Tail... tail) {
cout << head << ' ';
out(move(tail)...);
return 0;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
} // http://beet-aizu.hatenablog.com/entry/2018/04/08/145516
#define rep(...) \
_vcppunko4((__VA_ARGS__, _trep4, _trep3, _trep2, _rep1))((__VA_ARGS__))
#define rrep(...) \
_vcppunko4((__VA_ARGS__, _trrep4, _trrep3, _trrep2, _rrep1))((__VA_ARGS__))
#define each(v) for (auto &i : v)
#define lin(...) \
lint __VA_ARGS__; \
in(__VA_ARGS__)
#define stin(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define vin(type, name, size) \
vector<type> name(size); \
in(name)
#define fi i.first
#define se i.second
#define YES(c) cout << ((c) ? "YES\n" : "NO\n"), 0
#define Yes(c) cout << ((c) ? "Yes\n" : "No\n"), 0
#define dd(n) cout << fixed << setprecision(n)
#define inf linf
int main() {
lint b[4];
vin(lint, a, 6);
rep(6)++ b[--a[i]];
sort(b, b + 4);
YES(b[0] == 1 && b[1] == 1 && b[2] == 2);
} |
/*vvv>
zzzzzI
.---. zzuzuI .vgggg&,.
+++++= dunkoI .WbbWo JMM9^```?TMB` ..&gNNg,. gggggggJ, qgggggggg]
(&&&&&&&&[ c+OA&J, (&&&&&&+J, .cJeAA&-. (&&&&&&&&x .&AA&=-.
+++++= dunkoI Xpbpbp JM#` (M#^ ?MMp MM| +TMN. JMF '
|yk ` dVY 7Vk, Vy XV cVf ?Y! JM V$ `
+++++= OunkoI Xppppp dMN .MM+ .MM MM| MM] JMMMMMM+
|@tqkoh) ,y0 (V$ yyyyyyyV7 VV JMWyZWr TWVVVVW&,
++++++ dZZZZ0 Xppppp ^HMN, _.db WMm, .MMF MM| ..MM` JMF .
|yk .WV&. .XW' yy 4yn. jyn +. JM #S
`++++` ?ZZZX= ?WWWW= -THMMMMH9^ (TMMMMM9! MMMMMMM"" JMMMMMMMME
|UU. ?TUUUUY= UU. (UU- ^7TUUUV7! JUUUUUUUU 7TUNKO*/
// Ricty Diminished
#include "bits/stdc++.h"
using namespace std;
typedef long long lint;
typedef vector<lint> liv;
//#define rep(i,n) for(int i=0;i<n;++i)
#define all(v) v.begin(), v.end()
#define linf 1152921504606846976
#define MAXN 100100
#define md 1000000007 // 998244353
#define pb push_back
#define _vcppunko4(tuple) _getname4 tuple
#define _getname4(_1, _2, _3, _4, name, ...) name
#define _getname3(_1, _2, _3, name, ...) name
#define _trep2(tuple) _rep2 tuple
#define _trep3(tuple) _rep3 tuple
#define _trep4(tuple) _rep4 tuple
#define _rep1(n) for (lint i = 0; i < n; ++i)
#define _rep2(i, n) for (lint i = 0; i < n; ++i)
#define _rep3(i, a, b) for (lint i = a; i < b; ++i)
#define _rep4(i, a, b, c) for (lint i = a; i < b; i += c)
#define _trrep2(tuple) _rrep2 tuple
#define _trrep3(tuple) _rrep3 tuple
#define _trrep4(tuple) _rrep4 tuple
#define _rrep1(n) for (lint i = n - 1; i >= 0; --i)
#define _rrep2(i, n) for (lint i = n - 1; i >= 0; --i)
#define _rrep3(i, a, b) for (lint i = b - 1; i >= a; --i)
#define _rrep4(i, a, b, c) \
for (lint i = a + (b - a - 1) / c * c; i >= a; i -= c)
template <class T> istream &operator>>(istream &is, vector<T> &vec);
template <class T, size_t size>
istream &operator>>(istream &is, array<T, size> &vec);
template <class T, class L> istream &operator>>(istream &is, pair<T, L> &p);
template <class T> ostream &operator<<(ostream &os, vector<T> &vec);
template <class T, class L> ostream &operator<<(ostream &os, pair<T, L> &p);
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <class T, class L> istream &operator>>(istream &is, pair<T, L> &p) {
is >> p.first;
is >> p.second;
return is;
}
// template<class T>
// ostream& operator<<(ostream& os,vector<T>& vec){
// os<<vec[0];rep(i,1,vec.size())os<<' '<<vec[i];return os; } template<class T>
// ostream& operator<<(ostream& os,deque<T>& deq){
// os<<deq[0];rep(i,1,deq.size())os<<' '<<deq[i];return os; }
template <class T, class L> ostream &operator<<(ostream &os, pair<T, L> &p) {
os << p.first << " " << p.second;
return os;
}
inline void in() {}
template <class Head, class... Tail>
inline void in(Head &&head, Tail &&...tail) {
cin >> head;
in(move(tail)...);
}
template <class T> inline bool out(T t) {
cout << t << '\n';
return 0;
}
inline bool out() {
cout << '\n';
return 0;
}
template <class Head, class... Tail> inline bool out(Head head, Tail... tail) {
cout << head << ' ';
out(move(tail)...);
return 0;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
} // http://beet-aizu.hatenablog.com/entry/2018/04/08/145516
#define rep(...) \
_vcppunko4((__VA_ARGS__, _trep4, _trep3, _trep2, _rep1))((__VA_ARGS__))
#define rrep(...) \
_vcppunko4((__VA_ARGS__, _trrep4, _trrep3, _trrep2, _rrep1))((__VA_ARGS__))
#define each(v) for (auto &i : v)
#define lin(...) \
lint __VA_ARGS__; \
in(__VA_ARGS__)
#define stin(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define vin(type, name, size) \
vector<type> name(size); \
in(name)
#define fi i.first
#define se i.second
#define YES(c) cout << ((c) ? "YES\n" : "NO\n"), 0
#define Yes(c) cout << ((c) ? "Yes\n" : "No\n"), 0
#define dd(n) cout << fixed << setprecision(n)
#define inf linf
int main() {
lint b[4] = {};
vin(lint, a, 6);
rep(6)++ b[--a[i]];
sort(b, b + 4);
YES(b[0] == 1 && b[1] == 1 && b[2] == 2);
} | [
"variable_declaration.value.change"
] | 931,938 | 931,939 | u555405510 | cpp |
p03130 | #include "bits/stdc++.h"
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> count(4, 0);
for (int i = 0; i < 6; i++) {
int a;
cin >> a;
count[a]++;
}
int num = 0;
for (int i = 0; i < 4; i++) {
if (count[i] == 1) {
num++;
}
}
string result = "NO";
if (num == 2)
result = "YES";
cout << result << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> count(4, 0);
for (int i = 0; i < 6; i++) {
int a;
cin >> a;
a--;
count[a]++;
}
int num = 0;
for (int i = 0; i < 4; i++) {
if (count[i] == 1) {
num++;
}
}
string result = "NO";
if (num == 2)
result = "YES";
cout << result << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 931,949 | 931,950 | u487641373 | cpp |
p03130 | #include "bits/stdc++.h"
using namespace std;
int main() {
vector<int> AB(6);
vector<int> cnt(4);
for (int i = 0; i < 6; i++) {
cin >> AB[i];
cnt[AB[i] - 1]++;
}
int res1, res2;
for (int i = 0; i < 4; i++) {
if (cnt[i] == 1)
res1++;
else if (cnt[i] == 2)
res2++;
}
if (res1 == 2 && res2 == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
vector<int> AB(6);
vector<int> cnt(4);
for (int i = 0; i < 6; i++) {
cin >> AB[i];
cnt[AB[i] - 1]++;
}
int res1 = 0, res2 = 0;
for (int i = 0; i < 4; i++) {
if (cnt[i] == 1)
res1++;
else if (cnt[i] == 2)
res2++;
}
if (res1 == 2 && res2 == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"variable_declaration.value.change"
] | 931,951 | 931,952 | u365956698 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
#define N 4
#define M 3
int main(void) {
int i, L[N];
pair<int, int> path;
string ans = "YES";
for (i = 0; i < N; i++)
L[i] = 0;
for (i = 0; i < M; i++) {
cin >> path.first >> path.second;
L[path.first - 1]++;
L[path.second - 1]++;
}
for (i = 0; i < N; i++) {
if (L[i] > 2)
ans = "No";
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define N 4
#define M 3
int main(void) {
int i, L[N];
pair<int, int> path;
string ans = "YES";
for (i = 0; i < N; i++)
L[i] = 0;
for (i = 0; i < M; i++) {
cin >> path.first >> path.second;
L[path.first - 1]++;
L[path.second - 1]++;
}
for (i = 0; i < N; i++) {
if (L[i] > 2)
ans = "NO";
}
cout << ans << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"assignment.value.change"
] | 931,957 | 931,958 | u069450081 | cpp |
p03130 | #include <iostream>
using namespace std;
int main() {
int a[3], b[3];
int ans[5] = {0};
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < 3; i++) {
ans[a[i]]++;
ans[b[i]]++;
}
for (int i = 1; i < 5; i++) {
if (ans[i] >= 3) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a[3], b[3];
int ans[5] = {0};
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < 3; i++) {
ans[a[i]]++;
ans[b[i]]++;
}
for (int i = 1; i < 5; i++) {
if (ans[i] >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 931,969 | 931,970 | u273110458 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int in[5], i, j, k, x, y;
for (i = 0; i < 3; i++) {
cin >> x >> y;
++in[x];
++in[y];
}
if (in[1] == 0 || in[2] == 0 || in[3] == 0 || in[4] == 0 || in[1] == 3 ||
in[2] == 3 || in[3] == 3 || in[4] == 3)
cout << "NO";
else
cout << "YES";
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int in[5] = {0}, i, j, k, x, y;
for (i = 0; i < 3; i++) {
cin >> x >> y;
++in[x];
++in[y];
}
if (in[1] == 0 || in[2] == 0 || in[3] == 0 || in[4] == 0 || in[1] == 3 ||
in[2] == 3 || in[3] == 3 || in[4] == 3)
cout << "NO";
else
cout << "YES";
}
| [
"variable_declaration.value.change"
] | 931,975 | 931,976 | u711948228 | cpp |
p03130 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int cnt[4] = {0};
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
cnt[a]++;
cnt[b]++;
}
for (int i = 0; i < 4; i++) {
if (cnt[i] > 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int cnt[4] = {0};
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
cnt[--a]++;
cnt[--b]++;
}
for (int i = 0; i < 4; i++) {
if (cnt[i] > 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| [] | 931,981 | 931,982 | u105959367 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5] = {0, 0, 0, 0, 0};
int p[6];
bool l = 1;
for (int i = 0; i < 6; i++) {
cin >> p[i];
a[p[i]]++;
}
for (int k = 0; k < 5; k++) {
if (a[k] > 2) {
l = 0;
break;
}
}
if (l = 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5] = {0, 0, 0, 0, 0};
int p[6];
bool l = 1;
for (int i = 0; i < 6; i++) {
cin >> p[i];
a[p[i]]++;
}
for (int k = 0; k < 5; k++) {
if (a[k] > 2) {
l = 0;
break;
}
}
if (l == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 931,994 | 931,995 | u833295869 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int num[4] = {0, 0, 0, 0};
for (int i = 0; i < 6; i++) {
int k;
cin >> k;
num[k - 1] += 1;
}
int one, two;
for (int i = 0; i < 4; i++) {
if (num[i] == 1)
one++;
else if (num[i] == 2)
two++;
}
if (one == 2 && two == 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int num[4] = {0, 0, 0, 0};
for (int i = 0; i < 6; i++) {
int k;
cin >> k;
num[k - 1] += 1;
}
int one = 0, two = 0;
for (int i = 0; i < 4; i++) {
if (num[i] == 1)
one++;
else if (num[i] == 2)
two++;
}
if (one == 2 && two == 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| [
"variable_declaration.value.change"
] | 932,008 | 932,009 | u297590902 | cpp |
p03130 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, k) for (int i = n; i < k; i++)
#define P(p) cout << (p) << endl;
#define sP(p) cout << setprecision(15) << fixed << p << endl;
#define vi vector<int>
#define printv(v) \
for (int i = 0; i < v.size(); i++) \
P(v[i]);
#define printt(a, b) cout << a << " " << b << endl;
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int MOD = 1e9 + 7;
void solve() {
int count[4] = {0, 0, 0, 0};
rep(i, 3) {
int a, b;
cin >> a >> b;
count[a - 1]++;
count[b - 1]++;
}
bool f = true;
rep(i, 3) {
if (count[i] > 2 || count[i] == 0) {
f = false;
}
}
if (f) {
P("YES");
} else {
P("NO");
}
}
int main() {
solve();
return 0;
}
| #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, k) for (int i = n; i < k; i++)
#define P(p) cout << (p) << endl;
#define sP(p) cout << setprecision(15) << fixed << p << endl;
#define vi vector<int>
#define printv(v) \
for (int i = 0; i < v.size(); i++) \
P(v[i]);
#define printt(a, b) cout << a << " " << b << endl;
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int MOD = 1e9 + 7;
void solve() {
int count[4] = {0, 0, 0, 0};
rep(i, 3) {
int a, b;
cin >> a >> b;
count[a - 1]++;
count[b - 1]++;
}
bool f = true;
rep(i, 4) {
if (count[i] > 2 || count[i] == 0) {
f = false;
}
}
if (f) {
P("YES");
} else {
P("NO");
}
}
int main() {
solve();
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 932,010 | 932,011 | u687470137 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.