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 |
|---|---|---|---|---|---|---|---|
p03024 | #include <bits/stdc++.h>
#define fi first
#define se second
#define bug cout << "--------------" << endl
using namespace std;
typedef long long ll;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 1e9;
const ll llf = 1e18;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 10;
char s[55];
int k;
int main() {
// ios::sync_with_stdio(false);
// freopen("in","r",stdin);
cin >> s + 1;
k = strlen(s + 1);
int ans = 0;
for (int i = 1; i <= k; i++) {
if (s[i] == 'o')
ans++;
}
if (ans >= 8)
puts("YES");
else
puts("NO");
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define bug cout << "--------------" << endl
using namespace std;
typedef long long ll;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 1e9;
const ll llf = 1e18;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 10;
char s[55];
int k;
int main() {
// ios::sync_with_stdio(false);
// freopen("in","r",stdin);
cin >> s + 1;
k = strlen(s + 1);
int ans = 0;
for (int i = 1; i <= k; i++) {
if (s[i] == 'o')
ans++;
}
if (ans + 15 - k >= 8)
puts("YES");
else
puts("NO");
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 836,136 | 836,137 | u384161413 | cpp |
p03024 | #include <bits/stdc++.h>
#include <iomanip>
using namespace std;
int main() {
string S;
int s = S.size(), ans = 0;
for (int i = 0; i < s; i++) {
if (S[i] == 'x')
ans++;
}
if (ans < 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
#include <iomanip>
using namespace std;
int main() {
string S;
cin >> S;
int s = S.size(), ans = 0;
for (int i = 0; i < s; i++) {
if (S[i] == 'x')
ans++;
}
if (ans < 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [] | 836,140 | 836,141 | u732571394 | cpp |
p03024 | #include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
#define REP(i, m, n) for (int i = m; i < n; i++)
#define rep(i, n) REP(i, 0, n)
template <class T> void chmax(T &a, T b) {
if (a < b) {
a = b;
}
}
template <class T> void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
using namespace std;
int main(void) {
string S;
cin >> S;
int lose_count = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'x') {
lose_count++;
}
}
if (7 >= lose_count) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
#define REP(i, m, n) for (int i = m; i < n; i++)
#define rep(i, n) REP(i, 0, n)
template <class T> void chmax(T &a, T b) {
if (a < b) {
a = b;
}
}
template <class T> void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
using namespace std;
int main(void) {
string S;
cin >> S;
int lose_count = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'x') {
lose_count++;
}
}
if (7 >= lose_count) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,144 | 836,145 | u139235669 | cpp |
p03024 | #include "bits/stdc++.h"
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0;
int tmp = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'x') {
cnt++;
} else {
tmp++;
}
}
if (cnt >= 7 && tmp <= 7) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0;
int tmp = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'x') {
cnt++;
} else {
tmp++;
}
}
if (cnt >= 8) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 836,148 | 836,149 | u692207013 | cpp |
p03024 | #include <iostream>
#include <vector>
using namespace std;
int main() {
string S;
cin >> S;
int win{0}, lose{0};
for (int i = 0; i < S.size(); ++i) {
if (S[i] == 'o')
++win;
else
++lose;
}
if (15 - S.size() + win >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
string S;
cin >> S;
int win{0}, lose{0};
for (int i = 0; i < S.size(); ++i) {
if (S[i] == 'o')
++win;
else
++lose;
}
if (15 - S.size() + win >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,159 | 836,160 | u894555185 | cpp |
p03024 | #include <iostream>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0, win = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o')
win++;
cnt++;
}
int pw = S.size() - cnt;
if (pw + win >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0, win = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o')
win++;
cnt++;
}
int pw = 15 - S.size();
if (pw + win >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 836,167 | 836,168 | u067128860 | cpp |
p03024 | #include <iostream>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0, win = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o')
win++;
cnt++;
}
int pw = S.size();
if (pw + win >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0, win = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o')
win++;
cnt++;
}
int pw = 15 - S.size();
if (pw + win >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"assignment.change"
] | 836,169 | 836,168 | u067128860 | cpp |
p03024 | /*------------------------Original Copyright belongs
to-------------------------/ !
! ! ## ## ## ##
! ! # #
# # !
! ### #### ### ### ## # ! !
# # # # # # # # # ## !
! # # # ### ### #### # ! !
# # # # # # # # # # !
! ### #### ### # # # # ### ###
! ! !
/------------------------------------------------------------------------------*/
#include <bits/stdc++.h>
using namespace std;
//------------Template begins--------------------//
#define ss string
#define last(s) s.length() - 1
#define lli long long int
#define v(type) vector<type>
#define pr(type1, type2) pair<type1, type2>
#define ma(type1, type2) map<type1, type2>
#define f first
#define s second
#define all(v) v.begin(), v.end()
#define pb push_back
#define pf push_front
#define mp make_pair
#define L(i, start, end) for (lli i = start; i <= end; i++)
#define R(i, start, end) for (lli i = start; i >= end; i--)
#define inp(var, start, end, array) \
for (var = start; var <= end; var++) \
cin >> array[var];
#define whatIs(x) cout << #x << " is " << x << endl
#define dbg1D(i, start, end, arr) \
for (lli i = start; i <= end; i++) \
cout << i << "th : " << arr[i] << endl;
#define dbg2D(i, j, s1, e1, s2, e2, arr) \
for (lli i = s1; i <= e1; i++) { \
cout << i << "th :"; \
for (lli j = s2; j <= e2; j++) \
cout << arr[i][j] << " "; \
cout << endl; \
}
lli dx[4] = {-1, 0, 0, +1};
lli dy[4] = {0, -1, +1, 0};
const lli LINF = 1e18;
const lli INF = 1e9;
const lli mod = 1e9 + 7;
lli power(lli a, lli b, lli m) {
if (b == 0)
return 1;
if (b == 1)
return a % m;
lli t = power(a, b / 2, m);
t = (t * t) % m;
if (b & 1)
t = (t * a) % m;
return t;
}
lli modInverse(lli a, lli m) { return power(a, m - 2, m); }
//---------------Template ends------------------//
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
// freopen("ip.txt","r",stdin);
// freopen("op.txt","w",stdout);
#endif
//#################### CATCH HERE ##########################
/* Uncomment if t test cases
lli t;
cin>>t;
while(t--)
{
lli n,ans,i,j;
cout<<ans<<endl;
}
*/
lli n, i, x;
ss s;
cin >> s;
L(i, 0, s.length() - 1) {
if (s.at(i == 'x'))
x++;
}
if (x <= 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
// cout<<ans<<endl;
//##########################################################
return 0;
} | /*------------------------Original Copyright belongs
to-------------------------/ !
! ! ## ## ## ##
! ! # #
# # !
! ### #### ### ### ## # ! !
# # # # # # # # # ## !
! # # # ### ### #### # ! !
# # # # # # # # # # !
! ### #### ### # # # # ### ###
! ! !
/------------------------------------------------------------------------------*/
#include <bits/stdc++.h>
using namespace std;
//------------Template begins--------------------//
#define ss string
#define last(s) s.length() - 1
#define lli long long int
#define v(type) vector<type>
#define pr(type1, type2) pair<type1, type2>
#define ma(type1, type2) map<type1, type2>
#define f first
#define s second
#define all(v) v.begin(), v.end()
#define pb push_back
#define pf push_front
#define mp make_pair
#define L(i, start, end) for (lli i = start; i <= end; i++)
#define R(i, start, end) for (lli i = start; i >= end; i--)
#define inp(var, start, end, array) \
for (var = start; var <= end; var++) \
cin >> array[var];
#define whatIs(x) cout << #x << " is " << x << endl
#define dbg1D(i, start, end, arr) \
for (lli i = start; i <= end; i++) \
cout << i << "th : " << arr[i] << endl;
#define dbg2D(i, j, s1, e1, s2, e2, arr) \
for (lli i = s1; i <= e1; i++) { \
cout << i << "th :"; \
for (lli j = s2; j <= e2; j++) \
cout << arr[i][j] << " "; \
cout << endl; \
}
lli dx[4] = {-1, 0, 0, +1};
lli dy[4] = {0, -1, +1, 0};
const lli LINF = 1e18;
const lli INF = 1e9;
const lli mod = 1e9 + 7;
lli power(lli a, lli b, lli m) {
if (b == 0)
return 1;
if (b == 1)
return a % m;
lli t = power(a, b / 2, m);
t = (t * t) % m;
if (b & 1)
t = (t * a) % m;
return t;
}
lli modInverse(lli a, lli m) { return power(a, m - 2, m); }
//---------------Template ends------------------//
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
// freopen("ip.txt","r",stdin);
// freopen("op.txt","w",stdout);
#endif
//#################### CATCH HERE ##########################
/* Uncomment if t test cases
lli t;
cin>>t;
while(t--)
{
lli n,ans,i,j;
cout<<ans<<endl;
}
*/
lli n, i, x = 0;
ss s;
cin >> s;
L(i, 0, s.length() - 1) {
if (s.at(i) == 'x')
x++;
}
if (x <= 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
// cout<<ans<<endl;
//##########################################################
return 0;
} | [
"variable_declaration.value.change",
"control_flow.branch.if.condition.change"
] | 836,174 | 836,175 | u344266329 | cpp |
p03024 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int win = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o') {
win++;
}
}
if ((15 - s.size() + win) >= 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int win = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o') {
win++;
}
}
if ((15 - s.size() + win) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,176 | 836,177 | u120564432 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int win = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'o')
win++;
}
if (win + (15 - s.length()) >= 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int win = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'o')
win++;
}
if (win + (15 - s.length()) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,180 | 836,181 | u355424600 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int win = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'o')
win++;
}
if (win + s.length() >= 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int win = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'o')
win++;
}
if (win + (15 - s.length()) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,182 | 836,181 | u355424600 | cpp |
p03024 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o')
c++;
}
cout << (c >= 8 ? "YES" : "NO") << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x') {
c++;
}
}
cout << (15 - c >= 8 ? "YES" : "NO") << endl;
}
| [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 836,187 | 836,188 | u959815036 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
string S;
cin >> S;
int k = 0;
for (int i = 0; i < S.size(); ++i) {
if (S[i] = 'o')
++k;
}
if (k + 15 - S.size() >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
string S;
cin >> S;
int k = 0;
for (int i = 0; i < S.size(); ++i) {
if (S[i] == 'o')
++k;
}
if (k + 15 - S.size() >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 836,189 | 836,190 | u600896094 | cpp |
p03024 | #include <iostream>
#include <string.h>
using namespace std;
int main() {
string S;
int res = 0;
cin >> S;
for (int i = 0; i < S.length(); i++) {
if (S[i] == 'o')
res++;
}
res += 15 - S.length();
if (res >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| #include <iostream>
#include <string.h>
using namespace std;
int main() {
string S;
int res = 0;
cin >> S;
for (int i = 0; i < S.length(); i++) {
if (S[i] == 'o')
res++;
}
res += 15 - S.length();
if (res >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,198 | 836,199 | u291552830 | cpp |
p03024 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string S;
cin >> S;
int win_cnt = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o') {
win_cnt++;
}
}
int remain = 15 - S.size();
if (win_cnt + remain >= 8) {
cout << "Yes\n";
} else {
cout << "No\n";
}
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string S;
cin >> S;
int win_cnt = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'o') {
win_cnt++;
}
}
int remain = 15 - S.size();
if (win_cnt + remain >= 8) {
cout << "YES\n";
} else {
cout << "NO\n";
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,200 | 836,201 | u190018920 | cpp |
p03024 | #include <algorithm>
#include <cstdbool>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
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 long long INF = 1000000000000000;
const ll inf = -1e18;
typedef pair<int, int> P;
ll ma = 1000000000 + 7;
ll h, w, n, k, m, d, x;
string s, t;
char maze[60][60];
int dis[101][101];
int graph[52][52];
bool vis[52];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
ll gcd(ll x, ll y) {
if (x % y == 0)
return y;
return gcd(y, x % y);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
int main() {
cin >> s;
int cnt1 = 0;
int cnt = 0;
rep(i, s.size()) {
if (s[0] == 'o')
cnt1++;
else
cnt++;
}
int kk = 15 - s.size();
if (cnt1 + kk >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <algorithm>
#include <cstdbool>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
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 long long INF = 1000000000000000;
const ll inf = -1e18;
typedef pair<int, int> P;
ll ma = 1000000000 + 7;
ll h, w, n, k, m, d, x;
string s, t;
char maze[60][60];
int dis[101][101];
int graph[52][52];
bool vis[52];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
ll gcd(ll x, ll y) {
if (x % y == 0)
return y;
return gcd(y, x % y);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
int main() {
cin >> s;
int cnt1 = 0;
int cnt = 0;
rep(i, s.size()) {
if (s[i] == 'o')
cnt1++;
else
cnt++;
}
int kk = 15 - s.size();
if (cnt1 + kk >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 836,202 | 836,203 | u240031669 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define start_routine() int begtime = clock();
#define end_routine() \
int endtime = clock(); \
cerr << "\n\n" \
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC \
<< " ms\n\n"; \
return 0
#define ll long long int
#define ull unsigned long long int
#define db long double
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define pdd pair<db, db>
#define pll pair<ll, ll>
#define vpl vector<pll>
#define vll vector<ll>
#define mod 1000000007
#define mod1 998244353
#define inf 1000000000000000007
#define eps 0.000001
#define stp fixed << setprecision(20)
#define endl '\n'
int main() {
fastio;
#ifdef APNA_IO
start_routine();
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
string s;
cin >> s;
ll f = 0, n = s.size();
for (ll i = 0; i < s.size(); i++)
if (s[i] == 'o')
f++;
if (f + (15 - n) >= 8)
cout << "Yes";
else
cout << "No";
#ifdef APNA_IO
end_routine();
#endif
} | #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define start_routine() int begtime = clock();
#define end_routine() \
int endtime = clock(); \
cerr << "\n\n" \
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC \
<< " ms\n\n"; \
return 0
#define ll long long int
#define ull unsigned long long int
#define db long double
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define pii pair<int, int>
#define pdd pair<db, db>
#define pll pair<ll, ll>
#define vpl vector<pll>
#define vll vector<ll>
#define mod 1000000007
#define mod1 998244353
#define inf 1000000000000000007
#define eps 0.000001
#define stp fixed << setprecision(20)
#define endl '\n'
int main() {
fastio;
#ifdef APNA_IO
start_routine();
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
string s;
cin >> s;
ll f = 0, n = s.size();
for (ll i = 0; i < s.size(); i++)
if (s[i] == 'o')
f++;
if ((f + (15 - n)) >= 8)
cout << "YES";
else
cout << "NO";
#ifdef APNA_IO
end_routine();
#endif
} | [
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,204 | 836,205 | u266509174 | cpp |
p03024 | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
int cnt = 0;
cin >> s;
for (char c : s) {
if (c == 'o')
cnt++;
}
cout << (cnt + (15 - s.length()) >= 8 ? "Yes" : "No");
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
int cnt = 0;
cin >> s;
for (char c : s) {
if (c == 'o')
cnt++;
}
cout << (cnt + (15 - s.length()) >= 8 ? "YES" : "NO");
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,206 | 836,207 | u809153881 | cpp |
p03024 | #include <algorithm>
#include <bits/stdc++.h>
#include <stdint.h>
#include <vector>
using namespace std;
int main() {
string s;
int size = 0;
cin >> s;
size = s.size();
int def = 0;
for (int i = 0; i < size; i++) {
if (s.at(i) == 'x')
def++;
}
if (15 - def > 7) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <stdint.h>
#include <vector>
using namespace std;
int main() {
string s;
int size = 0;
cin >> s;
size = s.size();
int def = 0;
for (int i = 0; i < size; i++) {
if (s.at(i) == 'x')
def++;
}
if (15 - def > 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 836,208 | 836,209 | u641922479 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int compare_char(char *a, char *b) { return strcmp(a, b); }
int intsort(const void *a, const void *b) {
return *(int *)b - *(int *)a;
/*qsort(a,aの配列数,sizeof(int),intsort);*/
}
int longsort(const void *a, const void *b) {
long *A = (long *)a;
long *B = (long *)b;
if (*A > *B)
return -1;
if (*A < *B)
return 1;
return 0;
}
int main() {
int i, N, K, a[200000], cnt = 0;
char ss[10000];
scanf("%s", ss);
N = strlen(ss);
for (i = 0; i < N; i++) {
if (ss[i] == 'o')
cnt++;
}
if (cnt + 15 - N > 7) {
printf("Yes");
} else {
printf("No");
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int compare_char(char *a, char *b) { return strcmp(a, b); }
int intsort(const void *a, const void *b) {
return *(int *)b - *(int *)a;
/*qsort(a,aの配列数,sizeof(int),intsort);*/
}
int longsort(const void *a, const void *b) {
long *A = (long *)a;
long *B = (long *)b;
if (*A > *B)
return -1;
if (*A < *B)
return 1;
return 0;
}
int main() {
int i, N, K, a[200000], cnt = 0;
char ss[10000];
scanf("%s", ss);
N = strlen(ss);
for (i = 0; i < N; i++) {
if (ss[i] == 'o')
cnt++;
}
if (cnt + 15 - N > 7) {
printf("YES");
} else {
printf("NO");
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 836,212 | 836,213 | u251847465 | cpp |
p03024 | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// const long long int MOD = 1000000007;
const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
// long long int N, M, K, H, W, L, R;
int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
N = s.size();
for (auto i : s) {
if (i == 'o')
M++;
}
M += 15 - N;
if (M >= 8)
cout << "Yes\n";
else
cout << "No\n";
} | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// const long long int MOD = 1000000007;
const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
// long long int N, M, K, H, W, L, R;
int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
N = s.size();
for (auto i : s) {
if (i == 'o')
M++;
}
M += 15 - N;
if (M >= 8)
cout << "YES\n";
else
cout << "NO\n";
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,214 | 836,215 | u468700753 | cpp |
p03025 | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <utility>
#include <vector>
#define _USE_MATH_DEFINES
#include <iostream>
#include <math.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, double> pld;
typedef pair<double, double> pdd;
typedef pair<double, ll> pdl;
typedef pair<int, char> pic;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef priority_queue<ll, vector<ll>, greater<ll>> llgreaterq;
typedef priority_queue<pll, vector<pll>, greater<pll>> pllgreaterq;
typedef priority_queue<pair<ll, pll>, vector<pair<ll, pll>>,
greater<pair<ll, pll>>>
plpllgreaterq;
typedef priority_queue<vi, vector<vi>, greater<vi>> vigreaterq;
typedef priority_queue<vl, vector<vl>, greater<vl>> vlgreaterq;
template <class o, class p, class q>
using tuple3q = priority_queue<tuple<o, p, q>, vector<tuple<o, p, q>>,
greater<tuple<o, p, q>>>;
template <class o, class p, class q, class r>
using tuple4q = priority_queue<tuple<o, p, q, r>, vector<tuple<o, p, q, r>>,
greater<tuple<o, p, q, r>>>;
template <class o, class p, class q, class r, class s>
using tuple5q =
priority_queue<tuple<o, p, q, r, s>, vector<tuple<o, p, q, r, s>>,
greater<tuple<o, p, q, r, s>>>;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
#define bit(x, v) ((ll)x << v)
#define rep(x, n) for (ll x = 0; x < n; x++)
#define rep2(x, f, v) for (ll x = f; x < v; x++)
#define repe(v, x) for (auto v : x)
// 許容する誤差ε
#define EPS (1e-10)
// 2つのスカラーが等しいかどうか
#define EQ(a, b) (std::abs(a - b) < EPS)
// 2つのベクトルが等しいかどうか
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define all(a) a.begin(), a.end()
#define all0(a) memset(a, 0, sizeof(a))
#define allm1(a) memset(a, -1, sizeof(a))
#define put_float(v) \
cout << fixed << setprecision(10); \
cout << v << endl
#define put(v) cout << v << endl
#define vinsert(v, p, x) v.insert(v.begin() + p, x)
#define vsort(v) sort(all(v));
#define dup(v) v.erase(unique(all(v)), v.end())
#define ion(i, j) ((i & (1LL << j)) > 0)
#define next(i) \
i++; \
i %= 2
#define Len size()
#define ull unsignd long long
#define psp(a, b) push_back(make_pair(a, b))
#define psp2(a, b) push(make_pair(a, b))
#define cini(a) \
a; \
cin >> a
#define infa(a, b) (a + b) % INF
#define infm(a, b) (a * b) % INF
#define infd(a, b) (a * modinv(b)) % INF
#define infs(a, b) (a + INF - b) % INF
#define inf(a) (a) %= INF
#define inff(a) ((a) % INF)
#define No cout << "No" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define YES cout << "YES" << endl
#define smal -INF *INF
#define big INF *INF
const ll INF = 1000000007;
const int MAX = 2000010;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; 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;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll getpow(ll b, ll x, ll md) {
ll t = b;
ll res = 1;
while (x > 0) {
if (x & 1) {
res *= t;
res %= md;
}
x >>= 1;
t *= t;
t %= md;
}
return res;
}
ll getpow(ll b, ll x) { return getpow(b, x, INF); }
ll modinv(ll x) { return getpow(x, INF - 2); }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
class mint {
int md = 1000000007;
public:
long long x;
mint(ll x, ll md) {
this->md = md;
this->x = (x % md + md) % md;
}
mint(long long x = 0) : x((x % md + md) % md) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint &a) {
if ((x += a.x) >= md)
x -= md;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += md - a.x) >= md)
x -= md;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= md;
return *this;
}
mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(md - 2); }
mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
int pr[100010];
int lank[100010];
void uini(int n) {
for (size_t i = 0; i <= n; i++) {
pr[i] = i;
lank[i] = 1;
}
}
int parent(int x) {
if (x == pr[x])
return x;
return pr[x] = parent(pr[x]);
}
int same(int x, int y) { return parent(x) == parent(y); }
bool unit(int x, int y) {
int px = parent(x);
int py = parent(y);
if (px == py)
return false;
if (lank[py] < lank[px]) {
pr[py] = px;
lank[px] += lank[py];
} else {
pr[px] = py;
lank[py] += lank[px];
}
return true;
}
ll n;
int ci = 0;
struct Node {
int key;
int priority;
Node *parent, *left, *right;
Node(int key, int priority);
Node() {}
};
Node NIL;
Node::Node(int key, int priority) : key(key), priority(priority) {
left = &NIL;
right = &NIL;
}
Node *root = new Node();
void cenrec(Node *k) {
if (k->key == NIL.key)
return;
cenrec(k->left);
cout << " " << k->key;
cenrec(k->right);
}
void fastrec(Node *k) {
if (k->key == NIL.key)
return;
cout << " " << k->key;
fastrec(k->left);
fastrec(k->right);
}
void insert(Node *v) {
Node *y = &NIL;
Node *x = root;
while (x->key != NIL.key) {
y = x;
if (v->key < x->key) {
x = x->left;
} else {
x = x->right;
}
}
v->parent = y;
if (y->key == NIL.key) {
root = v;
} else if (v->key < y->key) {
y->left = v;
} else {
y->right = v;
}
}
Node *find(Node *k, ll v) {
if (k->key == NIL.key)
return &NIL;
if (k->key == v)
return k;
if (v < k->key)
return find(k->left, v);
return find(k->right, v);
}
void delp12(Node *x) {
if (x->key == NIL.key)
return;
Node *l = x->left;
Node *r = x->right;
Node *pr = x->parent;
if (l->key == NIL.key && r->key == NIL.key) {
if (pr->left == x) {
pr->left = &NIL;
} else
pr->right = &NIL;
} else if (l->key != NIL.key) {
if (pr->left == x) {
pr->left = l;
} else
pr->right = l;
l->parent = pr;
} else if (r->key != NIL.key) {
if (pr->left == x) {
pr->left = r;
} else
pr->right = r;
r->parent = pr;
}
}
Node *get_next(Node *k) {
if (k->key == NIL.key)
return &NIL;
Node *res = get_next(k->left);
if (res->key != NIL.key)
return res;
return k;
}
void del(Node *x) {
if (x->key == NIL.key)
return;
Node *l = x->left;
Node *r = x->right;
Node *pr = x->parent;
if (l->key != NIL.key && r->key != NIL.key) {
Node *nex = get_next(r);
x->key = nex->key;
delp12(nex);
} else {
delp12(x);
}
}
Node *rightRotate(Node *t) {
Node *s = t->left;
t->left = s->right;
s->right = t;
return s;
}
Node *leftRotate(Node *t) {
Node *s = t->right;
t->right = s->left;
s->left = t;
return s;
}
Node *_insert(Node *t, int key, int priority) {
if (t->key == NIL.key) {
return new Node(key, priority);
}
if (key == t->key) {
return t;
}
if (key < t->key) {
t->left = _insert(t->left, key, priority);
if (t->priority < t->left->priority) {
t = rightRotate(t);
}
} else {
t->right = _insert(t->right, key, priority);
if (t->priority < t->right->priority) {
t = leftRotate(t);
}
}
return t;
}
Node *delete1(Node *t, int key);
Node *_delete(Node *t, int key) {
if (t->left->key == NIL.key && t->right->key == NIL.key) {
return &NIL;
} else if (t->left->key == NIL.key) {
t = leftRotate(t);
} else if (t->right->key == NIL.key) {
t = rightRotate(t);
} else {
if (t->left->priority > t->right->priority) {
t = rightRotate(t);
} else
t = leftRotate(t);
}
return delete1(t, key);
}
Node *delete1(Node *t, int key) {
if (t->key == NIL.key) {
return &NIL;
}
if (key < t->key) {
t->left = delete1(t->left, key);
} else if (key > t->key) {
t->right = delete1(t->right, key);
} else
return _delete(t, key);
return t;
}
int H;
int left(int i) { return i * 2 + 1; }
int right(int i) { return i * 2 + 2; }
class edge {
public:
int from, to, i;
ll val;
edge() {}
edge(ll to) : to(to) {}
edge(ll to, ll i) : to(to), i(i) {}
edge(ll from, ll to, ll val) : from(from), to(to), val(val) {}
};
class LCA {
private:
vector<vector<edge>> v;
vector<vector<int>> parent;
vector<int> depth;
void dfs(int n, int m, int d) {
parent[0][n] = m;
depth[n] = d;
for (auto x : v[n]) {
if (x.to != m)
dfs(x.to, n, d + 1);
}
}
public:
LCA(ll N, ll root, vector<vector<edge>> &tree) {
v = tree;
parent = vector<vector<int>>(21, vector<int>(N + 1, 0));
depth = vector<int>(N + 1, 0);
dfs(root, -1, 0);
for (int j = 0; j + 1 < 20; j++) {
for (int i = 1; i <= N; i++) {
if (parent[j][i] < 0)
parent[j + 1][i] = -1;
else
parent[j + 1][i] = parent[j][parent[j][i]];
}
}
}
int lca(int n, int m) {
if (depth[n] > depth[m])
swap(n, m);
for (int j = 0; j < 20; j++) {
if ((depth[m] - depth[n]) >> j & 1)
m = parent[j][m];
}
if (n == m)
return n;
for (int j = 19; j >= 0; j--) {
if (parent[j][n] != parent[j][m]) {
n = parent[j][n];
m = parent[j][m];
}
}
return parent[0][n];
}
int dep(int n) { return depth[n]; }
};
ll k;
int _rank[1010];
int temp[1010];
bool compare_sa(int i, int j) {
if (_rank[i] != _rank[j])
return _rank[i] < _rank[j];
else {
int ri = i + k <= n ? _rank[i + k] : -1;
int rj = j + k <= n ? _rank[j + k] : -1;
return ri < rj;
}
}
void construct_sa(string S, int *sa) {
n = S.length();
for (size_t i = 0; i <= n; i++) {
sa[i] = i;
_rank[i] = i < n ? S[i] : -1;
}
for (k = 1; k <= n; k *= 2) {
sort(sa, sa + n + 1, compare_sa);
// saはソート後の接尾辞の並びになっている、rankは元の位置のindexを保持したまま、更新されている。
// ピンとこなかった部分
temp[sa[0]] = 0;
for (size_t i = 1; i <= n; i++) {
temp[sa[i]] = temp[sa[i - 1]] + (compare_sa(sa[i - 1], sa[i]) ? 1 : 0);
}
for (size_t i = 0; i <= n; i++) {
_rank[i] = temp[i];
}
}
}
bool contain(string S, int *sa, string T) {
int a = 0, b = S.length();
// sa は 接尾辞が辞書順に並んでいる、入っているのはその位置のインデックス
while (b - a > 1) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.length(), T) < 0)
a = c;
else
b = c;
}
return S.compare(sa[b], T.length(), T) == 0;
}
#define bit(x, v) ((ll)x << v)
class BIT {
static const int MAX_N = 500010;
public:
BIT() { memset(bit, 0, sizeof(bit)); }
ll bit[MAX_N + 1], n;
ll sum(int i) {
ll s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
};
struct UnionFind {
vector<int> A;
UnionFind(int n) : A(n, -1) {}
int find(int x) {
if (A[x] < 0)
return x;
return A[x] = find(A[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (A[x] > A[y])
swap(x, y);
A[x] += A[y];
A[y] = x;
}
int ngroups() {
int ans = 0;
for (auto a : A)
if (a < 0)
ans++;
return ans;
}
};
vector<ll> getp(ll n) {
vector<ll> res;
ll a = 2;
if (n % 2 == 0) {
res.push_back(2);
while (n % 2 == 0)
n /= 2;
}
for (ll i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
res.push_back(i);
while (n % i == 0)
n /= i;
}
}
if (n != 1)
res.push_back(n);
return res;
}
vector<ll> getp2(ll n) {
vector<ll> res;
ll a = 2;
if (n % 2 == 0) {
while (n % 2 == 0) {
n /= 2;
res.push_back(2);
}
}
for (ll i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
res.push_back(i);
}
}
}
if (n != 1)
res.push_back(n);
return res;
}
vector<pll> getp3(ll n) {
vector<pll> res;
ll a = 2;
int si = 0;
if (n % 2 == 0) {
res.push_back(make_pair(2, 0));
while (n % 2 == 0) {
n /= 2;
res[si].second++;
}
si++;
}
for (ll i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
res.push_back(make_pair(i, 0));
while (n % i == 0) {
n /= i;
res[si].second++;
}
si++;
}
}
if (n != 1) {
res.push_back(make_pair(n, 1));
}
return res;
}
vector<ll> getDivisors(ll n) {
vector<ll> res;
ll a = 2;
res.push_back(1);
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (n / i != i)
res.push_back(n / i);
}
}
return res;
}
struct ve {
public:
vector<ve> child;
int _t = INF;
ve(int t) : _t(t) {}
ve(ve _left, ve _right) {
_t = _left._t + _right._t;
child.push_back(_left);
child.push_back(_right);
}
bool operator<(const ve &t) const { return _t > t._t; }
};
vector<bool> elas(ll n) {
vector<bool> r(n);
fill(r.begin(), r.end(), 1);
r[0] = 0;
r[1] = 0;
for (ll i = 2; i * i < n; i++) {
if (!r[i])
continue;
ll ti = i * 2;
while (ti < n) {
r[ti] = false;
ti += i;
}
}
return r;
}
bool isPrime(ll v) {
for (ll i = 2; i * i <= v; i++) {
if (v % i == 0)
return false;
}
return true;
}
class SegTree {
public:
const static int MAX_N = 100010;
const static int DAT_SIZE = (1 << 18) - 1;
int N, Q;
int A[MAX_N];
ll data[DAT_SIZE], datb[DAT_SIZE];
void init(int _n) {
N = 1;
while (N < _n)
N <<= 1;
memset(data, 0, sizeof(data));
memset(datb, 0, sizeof(datb));
}
void init(int _n, ll iv) {
N = 1;
while (N < _n)
N <<= 1;
rep(i, DAT_SIZE) {
data[i] = iv;
datb[i] = iv;
}
}
void add(int a, int b, int x) { add(a, b + 1, x, 0, 0, N); }
void add(int a, int b, int x, int k, int l, int r) {
if (a <= l && r <= b) {
data[k] += x;
} else if (l < b && a < r) {
datb[k] += (min(b, r) - max(a, l)) * x;
add(a, b, x, k * 2 + 1, l, (l + r) / 2);
add(a, b, x, k * 2 + 2, (l + r) / 2, r);
}
}
void change(int a, int b, int x) { change(a, b + 1, x, 0, 0, N); }
void change(int a, int b, int x, int k, int l, int r) {
if (a <= l && r <= b) {
data[k] = x;
} else if (l < b && a < r) {
datb[k] = x;
change(a, b, x, k * 2 + 1, l, (l + r) / 2);
change(a, b, x, k * 2 + 2, (l + r) / 2, r);
}
}
ll sum(int a, int b) { return sum(a, b + 1, 0, 0, N); }
ll sum(int a, int b, int k, int l, int r) {
if (b <= l || r <= a) {
return 0;
}
if (a <= l && r <= b) {
return data[k] * (r - l) + datb[k];
}
ll res = (min(b, r) - max(a, l)) * data[k];
res += sum(a, b, k * 2 + 1, l, (l + r) / 2);
res += sum(a, b, k * 2 + 2, (l + r) / 2, r);
return res;
}
};
class Segment;
class Circle;
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
double abs() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
static double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
static double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
static bool isOrthogonal(Point a, Point b) { return EQ(dot(a, b), 0.0); }
static bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
return isOrthogonal(a1 - a2, b1 - b2);
}
static bool isOrthogonal(Segment s1, Segment s2);
static bool isPalallel(Point a, Point b) { return EQ(cross(a, b), 0.0); }
static bool isPalallel(Point a1, Point a2, Point b1, Point b2) {
return isPalallel(a1 - a2, b1 - b2);
}
static bool isPalallel(Segment s1, Segment s2);
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
static int ccw(Point p0, Point p1, Point p2) {
// 線分はp0とp1でp2がどこにあるかを探る
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (a.norm() < b.norm())
return ONLINE_FRONT;
return ON_SEGMENT;
}
static bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
static bool intersect(Segment s1, Segment s2);
static Point project(Segment s, Point p);
static Point reflect(Segment s, Point p);
static Point getDistance(Point a, Point b) { return (a - b).abs(); }
static double getDistanceLP(Segment s, Point p);
static double getDistanceSP(Segment s, Point p);
static double getDistance(Segment s1, Segment s2);
static Point getIntersection(Segment s1, Segment s2);
static pair<Point, Point> crossPoints(Circle c, Segment s);
static int contains(vector<Point> g, Point p) {
int n = g.size();
bool x = false;
rep(i, n) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
// 線の上に載っているか
if (std::abs(cross(a, b)) < EPS && dot(a, b) < EPS)
return 1;
// pを基準として上下にあるか
// または外積が正か?(→にあるか)
if (a.y > b.y)
swap(a, b);
if (a.y < EPS && EPS < b.y && cross(a, b) > EPS)
x = !x;
}
return x ? 2 : 0;
}
static vector<Point> andrewScan(vector<Point> s) {
vector<Point> u, l;
if (s.size() < 3)
return s;
sort(all(s));
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size() - 1]);
l.push_back(s[s.size() - 2]);
for (int i = 2; i < s.size(); i++) {
for (int _n = u.size();
_n >= 2 && ccw(u[_n - 2], u[_n - 1], s[i]) > CLOCKWISE; _n--) {
u.pop_back();
}
u.push_back(s[i]);
}
for (int i = s.size() - 3; i >= 0; i--) {
for (int _n = l.size();
_n >= 2 && ccw(l[_n - 2], l[_n - 1], s[i]) > CLOCKWISE; _n--) {
l.pop_back();
}
l.push_back(s[i]);
}
reverse(all(l));
for (int i = u.size() - 2; i >= 1; i--) {
l.push_back(u[i]);
}
return l;
}
void get_cin() { cin >> x >> y; }
};
class Segment {
public:
Point p1, p2;
Segment() {}
Segment(Point p1, Point p2) : p1(p1), p2(p2) {}
void get_cin() { cin >> p1.x >> p1.y >> p2.x >> p2.y; }
Point p1tp2() { return p2 - p1; }
Point p2tp1() { return p1 - p2; }
double abs() { return std::abs(norm()); }
double norm() { return (p2 - p1).norm(); }
};
bool Point::isOrthogonal(Segment s1, Segment s2) {
return EQ(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool Point::isPalallel(Segment s1, Segment s2) {
return EQ(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool Point::intersect(Segment s1, Segment s2) {
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
Point Point::project(Segment s, Point p) {
Point base = s.p2 - s.p1;
double r = Point::dot(p - s.p1, base) / base.norm();
return s.p1 + base * r;
}
Point Point::reflect(Segment s, Point p) { return (project(s, p) * 2) - p; }
double Point::getDistanceLP(Segment s, Point p) {
return std::abs(cross(s.p2 - s.p1, p - s.p1) / (s.p2 - s.p1).abs());
}
double Point::getDistanceSP(Segment s, Point p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
return (p - s.p1).abs();
if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
return (p - s.p2).abs();
return getDistanceLP(s, p);
}
double Point::getDistance(Segment s1, Segment s2) {
if (intersect(s1, s2))
return 0.0;
return min({getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2),
getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)});
}
Point Point::getIntersection(Segment s1, Segment s2) {
// (s1.p1 - s2.p1).norm()
auto bs = s1.p2 - s1.p1;
auto n1 = s2.p1 - s1.p1;
auto n2 = s2.p2 - s1.p1;
auto c1 = std::abs(cross(n1, bs)) / bs.norm();
auto c2 = std::abs(cross(n2, bs)) / bs.norm();
return s2.p1 + (s2.p2 - s2.p1) * (c1 / (c1 + c2));
// c1:c2=t:1-t
// c2t=(1-t)c1
// t/(1-t)=c1/(c1+c2)
//
}
double arg(Point p) { return atan2(p.y, p.x); }
Point polar(double a, double r) { return Point(cos(r) * a, sin(r) * a); }
class Circle {
public:
Point c;
double r;
Circle(Point c = Point(), double r = 0.0) : c(c), r(r) {}
void get_cin() { cin >> c.x >> c.y >> r; }
static pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
double d = (c1.c - c2.c).abs(); // 中心点どうしの距離
double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
double t = arg(c2.c - c1.c);
return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
};
pair<Point, Point> Point::crossPoints(Circle c, Segment s) {
auto pp = project(s, c.c);
auto f = (pp - c.c).norm();
auto mu = sqrt(c.r * c.r - f);
auto e = s.p1tp2() / s.p1tp2().abs();
return make_pair(pp + e * mu, pp - e * mu);
}
ll divRm(string s, ll x) {
ll r = 0;
for (ll i = 0; i < s.size(); i++) {
r *= 10;
r += s[i] - '0';
r %= x;
}
return r;
}
ll cmbi(ll x, ll b) {
ll res = 1;
for (size_t i = 0; i < b; i++) {
res *= x - i;
res %= INF;
res *= inv[b - i];
res %= INF;
}
return res;
}
double digsum(ll x) {
ll res = 0;
while (x > 0) {
res += x % 10;
x /= 10;
}
return res;
}
bool check_parindrome(string s) {
int n = s.size();
rep(i, n / 2) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
// ここまでライブラリ
// ここからコード
void solv() {
ll a, b, c;
cin >> n >> a >> b >> c;
ll res = 0;
ll at = inff(a * inv[a + b]);
ll bt = inff(b * inv[a + b]);
rep2(i, n, 2 * n) {
ll v = inff(getpow(at, n) * getpow(bt, i - n));
inf(v += inff(getpow(at, i - n) * getpow(bt, n)));
inf(v *= COM(i - 1, n - 1));
inf(v *= i);
inf(res += v);
}
inf(res *= 100 * inv[100 - c]);
cout << res << endl;
}
int main() {
COMinit();
solv();
return 0;
}
| #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <utility>
#include <vector>
#define _USE_MATH_DEFINES
#include <iostream>
#include <math.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, double> pld;
typedef pair<double, double> pdd;
typedef pair<double, ll> pdl;
typedef pair<int, char> pic;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef priority_queue<ll, vector<ll>, greater<ll>> llgreaterq;
typedef priority_queue<pll, vector<pll>, greater<pll>> pllgreaterq;
typedef priority_queue<pair<ll, pll>, vector<pair<ll, pll>>,
greater<pair<ll, pll>>>
plpllgreaterq;
typedef priority_queue<vi, vector<vi>, greater<vi>> vigreaterq;
typedef priority_queue<vl, vector<vl>, greater<vl>> vlgreaterq;
template <class o, class p, class q>
using tuple3q = priority_queue<tuple<o, p, q>, vector<tuple<o, p, q>>,
greater<tuple<o, p, q>>>;
template <class o, class p, class q, class r>
using tuple4q = priority_queue<tuple<o, p, q, r>, vector<tuple<o, p, q, r>>,
greater<tuple<o, p, q, r>>>;
template <class o, class p, class q, class r, class s>
using tuple5q =
priority_queue<tuple<o, p, q, r, s>, vector<tuple<o, p, q, r, s>>,
greater<tuple<o, p, q, r, s>>>;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
#define bit(x, v) ((ll)x << v)
#define rep(x, n) for (ll x = 0; x < n; x++)
#define rep2(x, f, v) for (ll x = f; x < v; x++)
#define repe(v, x) for (auto v : x)
// 許容する誤差ε
#define EPS (1e-10)
// 2つのスカラーが等しいかどうか
#define EQ(a, b) (std::abs(a - b) < EPS)
// 2つのベクトルが等しいかどうか
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define all(a) a.begin(), a.end()
#define all0(a) memset(a, 0, sizeof(a))
#define allm1(a) memset(a, -1, sizeof(a))
#define put_float(v) \
cout << fixed << setprecision(10); \
cout << v << endl
#define put(v) cout << v << endl
#define vinsert(v, p, x) v.insert(v.begin() + p, x)
#define vsort(v) sort(all(v));
#define dup(v) v.erase(unique(all(v)), v.end())
#define ion(i, j) ((i & (1LL << j)) > 0)
#define next(i) \
i++; \
i %= 2
#define Len size()
#define ull unsignd long long
#define psp(a, b) push_back(make_pair(a, b))
#define psp2(a, b) push(make_pair(a, b))
#define cini(a) \
a; \
cin >> a
#define infa(a, b) (a + b) % INF
#define infm(a, b) (a * b) % INF
#define infd(a, b) (a * modinv(b)) % INF
#define infs(a, b) (a + INF - b) % INF
#define inf(a) (a) %= INF
#define inff(a) ((a) % INF)
#define No cout << "No" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define YES cout << "YES" << endl
#define smal -INF *INF
#define big INF *INF
const ll INF = 1000000007;
const int MAX = 2000010;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; 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;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll getpow(ll b, ll x, ll md) {
ll t = b;
ll res = 1;
while (x > 0) {
if (x & 1) {
res *= t;
res %= md;
}
x >>= 1;
t *= t;
t %= md;
}
return res;
}
ll getpow(ll b, ll x) { return getpow(b, x, INF); }
ll modinv(ll x) { return getpow(x, INF - 2); }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
class mint {
int md = 1000000007;
public:
long long x;
mint(ll x, ll md) {
this->md = md;
this->x = (x % md + md) % md;
}
mint(long long x = 0) : x((x % md + md) % md) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint &a) {
if ((x += a.x) >= md)
x -= md;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += md - a.x) >= md)
x -= md;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= md;
return *this;
}
mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(md - 2); }
mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
int pr[100010];
int lank[100010];
void uini(int n) {
for (size_t i = 0; i <= n; i++) {
pr[i] = i;
lank[i] = 1;
}
}
int parent(int x) {
if (x == pr[x])
return x;
return pr[x] = parent(pr[x]);
}
int same(int x, int y) { return parent(x) == parent(y); }
bool unit(int x, int y) {
int px = parent(x);
int py = parent(y);
if (px == py)
return false;
if (lank[py] < lank[px]) {
pr[py] = px;
lank[px] += lank[py];
} else {
pr[px] = py;
lank[py] += lank[px];
}
return true;
}
ll n;
int ci = 0;
struct Node {
int key;
int priority;
Node *parent, *left, *right;
Node(int key, int priority);
Node() {}
};
Node NIL;
Node::Node(int key, int priority) : key(key), priority(priority) {
left = &NIL;
right = &NIL;
}
Node *root = new Node();
void cenrec(Node *k) {
if (k->key == NIL.key)
return;
cenrec(k->left);
cout << " " << k->key;
cenrec(k->right);
}
void fastrec(Node *k) {
if (k->key == NIL.key)
return;
cout << " " << k->key;
fastrec(k->left);
fastrec(k->right);
}
void insert(Node *v) {
Node *y = &NIL;
Node *x = root;
while (x->key != NIL.key) {
y = x;
if (v->key < x->key) {
x = x->left;
} else {
x = x->right;
}
}
v->parent = y;
if (y->key == NIL.key) {
root = v;
} else if (v->key < y->key) {
y->left = v;
} else {
y->right = v;
}
}
Node *find(Node *k, ll v) {
if (k->key == NIL.key)
return &NIL;
if (k->key == v)
return k;
if (v < k->key)
return find(k->left, v);
return find(k->right, v);
}
void delp12(Node *x) {
if (x->key == NIL.key)
return;
Node *l = x->left;
Node *r = x->right;
Node *pr = x->parent;
if (l->key == NIL.key && r->key == NIL.key) {
if (pr->left == x) {
pr->left = &NIL;
} else
pr->right = &NIL;
} else if (l->key != NIL.key) {
if (pr->left == x) {
pr->left = l;
} else
pr->right = l;
l->parent = pr;
} else if (r->key != NIL.key) {
if (pr->left == x) {
pr->left = r;
} else
pr->right = r;
r->parent = pr;
}
}
Node *get_next(Node *k) {
if (k->key == NIL.key)
return &NIL;
Node *res = get_next(k->left);
if (res->key != NIL.key)
return res;
return k;
}
void del(Node *x) {
if (x->key == NIL.key)
return;
Node *l = x->left;
Node *r = x->right;
Node *pr = x->parent;
if (l->key != NIL.key && r->key != NIL.key) {
Node *nex = get_next(r);
x->key = nex->key;
delp12(nex);
} else {
delp12(x);
}
}
Node *rightRotate(Node *t) {
Node *s = t->left;
t->left = s->right;
s->right = t;
return s;
}
Node *leftRotate(Node *t) {
Node *s = t->right;
t->right = s->left;
s->left = t;
return s;
}
Node *_insert(Node *t, int key, int priority) {
if (t->key == NIL.key) {
return new Node(key, priority);
}
if (key == t->key) {
return t;
}
if (key < t->key) {
t->left = _insert(t->left, key, priority);
if (t->priority < t->left->priority) {
t = rightRotate(t);
}
} else {
t->right = _insert(t->right, key, priority);
if (t->priority < t->right->priority) {
t = leftRotate(t);
}
}
return t;
}
Node *delete1(Node *t, int key);
Node *_delete(Node *t, int key) {
if (t->left->key == NIL.key && t->right->key == NIL.key) {
return &NIL;
} else if (t->left->key == NIL.key) {
t = leftRotate(t);
} else if (t->right->key == NIL.key) {
t = rightRotate(t);
} else {
if (t->left->priority > t->right->priority) {
t = rightRotate(t);
} else
t = leftRotate(t);
}
return delete1(t, key);
}
Node *delete1(Node *t, int key) {
if (t->key == NIL.key) {
return &NIL;
}
if (key < t->key) {
t->left = delete1(t->left, key);
} else if (key > t->key) {
t->right = delete1(t->right, key);
} else
return _delete(t, key);
return t;
}
int H;
int left(int i) { return i * 2 + 1; }
int right(int i) { return i * 2 + 2; }
class edge {
public:
int from, to, i;
ll val;
edge() {}
edge(ll to) : to(to) {}
edge(ll to, ll i) : to(to), i(i) {}
edge(ll from, ll to, ll val) : from(from), to(to), val(val) {}
};
class LCA {
private:
vector<vector<edge>> v;
vector<vector<int>> parent;
vector<int> depth;
void dfs(int n, int m, int d) {
parent[0][n] = m;
depth[n] = d;
for (auto x : v[n]) {
if (x.to != m)
dfs(x.to, n, d + 1);
}
}
public:
LCA(ll N, ll root, vector<vector<edge>> &tree) {
v = tree;
parent = vector<vector<int>>(21, vector<int>(N + 1, 0));
depth = vector<int>(N + 1, 0);
dfs(root, -1, 0);
for (int j = 0; j + 1 < 20; j++) {
for (int i = 1; i <= N; i++) {
if (parent[j][i] < 0)
parent[j + 1][i] = -1;
else
parent[j + 1][i] = parent[j][parent[j][i]];
}
}
}
int lca(int n, int m) {
if (depth[n] > depth[m])
swap(n, m);
for (int j = 0; j < 20; j++) {
if ((depth[m] - depth[n]) >> j & 1)
m = parent[j][m];
}
if (n == m)
return n;
for (int j = 19; j >= 0; j--) {
if (parent[j][n] != parent[j][m]) {
n = parent[j][n];
m = parent[j][m];
}
}
return parent[0][n];
}
int dep(int n) { return depth[n]; }
};
ll k;
int _rank[1010];
int temp[1010];
bool compare_sa(int i, int j) {
if (_rank[i] != _rank[j])
return _rank[i] < _rank[j];
else {
int ri = i + k <= n ? _rank[i + k] : -1;
int rj = j + k <= n ? _rank[j + k] : -1;
return ri < rj;
}
}
void construct_sa(string S, int *sa) {
n = S.length();
for (size_t i = 0; i <= n; i++) {
sa[i] = i;
_rank[i] = i < n ? S[i] : -1;
}
for (k = 1; k <= n; k *= 2) {
sort(sa, sa + n + 1, compare_sa);
// saはソート後の接尾辞の並びになっている、rankは元の位置のindexを保持したまま、更新されている。
// ピンとこなかった部分
temp[sa[0]] = 0;
for (size_t i = 1; i <= n; i++) {
temp[sa[i]] = temp[sa[i - 1]] + (compare_sa(sa[i - 1], sa[i]) ? 1 : 0);
}
for (size_t i = 0; i <= n; i++) {
_rank[i] = temp[i];
}
}
}
bool contain(string S, int *sa, string T) {
int a = 0, b = S.length();
// sa は 接尾辞が辞書順に並んでいる、入っているのはその位置のインデックス
while (b - a > 1) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.length(), T) < 0)
a = c;
else
b = c;
}
return S.compare(sa[b], T.length(), T) == 0;
}
#define bit(x, v) ((ll)x << v)
class BIT {
static const int MAX_N = 500010;
public:
BIT() { memset(bit, 0, sizeof(bit)); }
ll bit[MAX_N + 1], n;
ll sum(int i) {
ll s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
};
struct UnionFind {
vector<int> A;
UnionFind(int n) : A(n, -1) {}
int find(int x) {
if (A[x] < 0)
return x;
return A[x] = find(A[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (A[x] > A[y])
swap(x, y);
A[x] += A[y];
A[y] = x;
}
int ngroups() {
int ans = 0;
for (auto a : A)
if (a < 0)
ans++;
return ans;
}
};
vector<ll> getp(ll n) {
vector<ll> res;
ll a = 2;
if (n % 2 == 0) {
res.push_back(2);
while (n % 2 == 0)
n /= 2;
}
for (ll i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
res.push_back(i);
while (n % i == 0)
n /= i;
}
}
if (n != 1)
res.push_back(n);
return res;
}
vector<ll> getp2(ll n) {
vector<ll> res;
ll a = 2;
if (n % 2 == 0) {
while (n % 2 == 0) {
n /= 2;
res.push_back(2);
}
}
for (ll i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
res.push_back(i);
}
}
}
if (n != 1)
res.push_back(n);
return res;
}
vector<pll> getp3(ll n) {
vector<pll> res;
ll a = 2;
int si = 0;
if (n % 2 == 0) {
res.push_back(make_pair(2, 0));
while (n % 2 == 0) {
n /= 2;
res[si].second++;
}
si++;
}
for (ll i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
res.push_back(make_pair(i, 0));
while (n % i == 0) {
n /= i;
res[si].second++;
}
si++;
}
}
if (n != 1) {
res.push_back(make_pair(n, 1));
}
return res;
}
vector<ll> getDivisors(ll n) {
vector<ll> res;
ll a = 2;
res.push_back(1);
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (n / i != i)
res.push_back(n / i);
}
}
return res;
}
struct ve {
public:
vector<ve> child;
int _t = INF;
ve(int t) : _t(t) {}
ve(ve _left, ve _right) {
_t = _left._t + _right._t;
child.push_back(_left);
child.push_back(_right);
}
bool operator<(const ve &t) const { return _t > t._t; }
};
vector<bool> elas(ll n) {
vector<bool> r(n);
fill(r.begin(), r.end(), 1);
r[0] = 0;
r[1] = 0;
for (ll i = 2; i * i < n; i++) {
if (!r[i])
continue;
ll ti = i * 2;
while (ti < n) {
r[ti] = false;
ti += i;
}
}
return r;
}
bool isPrime(ll v) {
for (ll i = 2; i * i <= v; i++) {
if (v % i == 0)
return false;
}
return true;
}
class SegTree {
public:
const static int MAX_N = 100010;
const static int DAT_SIZE = (1 << 18) - 1;
int N, Q;
int A[MAX_N];
ll data[DAT_SIZE], datb[DAT_SIZE];
void init(int _n) {
N = 1;
while (N < _n)
N <<= 1;
memset(data, 0, sizeof(data));
memset(datb, 0, sizeof(datb));
}
void init(int _n, ll iv) {
N = 1;
while (N < _n)
N <<= 1;
rep(i, DAT_SIZE) {
data[i] = iv;
datb[i] = iv;
}
}
void add(int a, int b, int x) { add(a, b + 1, x, 0, 0, N); }
void add(int a, int b, int x, int k, int l, int r) {
if (a <= l && r <= b) {
data[k] += x;
} else if (l < b && a < r) {
datb[k] += (min(b, r) - max(a, l)) * x;
add(a, b, x, k * 2 + 1, l, (l + r) / 2);
add(a, b, x, k * 2 + 2, (l + r) / 2, r);
}
}
void change(int a, int b, int x) { change(a, b + 1, x, 0, 0, N); }
void change(int a, int b, int x, int k, int l, int r) {
if (a <= l && r <= b) {
data[k] = x;
} else if (l < b && a < r) {
datb[k] = x;
change(a, b, x, k * 2 + 1, l, (l + r) / 2);
change(a, b, x, k * 2 + 2, (l + r) / 2, r);
}
}
ll sum(int a, int b) { return sum(a, b + 1, 0, 0, N); }
ll sum(int a, int b, int k, int l, int r) {
if (b <= l || r <= a) {
return 0;
}
if (a <= l && r <= b) {
return data[k] * (r - l) + datb[k];
}
ll res = (min(b, r) - max(a, l)) * data[k];
res += sum(a, b, k * 2 + 1, l, (l + r) / 2);
res += sum(a, b, k * 2 + 2, (l + r) / 2, r);
return res;
}
};
class Segment;
class Circle;
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
double abs() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
static double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
static double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
static bool isOrthogonal(Point a, Point b) { return EQ(dot(a, b), 0.0); }
static bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
return isOrthogonal(a1 - a2, b1 - b2);
}
static bool isOrthogonal(Segment s1, Segment s2);
static bool isPalallel(Point a, Point b) { return EQ(cross(a, b), 0.0); }
static bool isPalallel(Point a1, Point a2, Point b1, Point b2) {
return isPalallel(a1 - a2, b1 - b2);
}
static bool isPalallel(Segment s1, Segment s2);
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
static int ccw(Point p0, Point p1, Point p2) {
// 線分はp0とp1でp2がどこにあるかを探る
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (a.norm() < b.norm())
return ONLINE_FRONT;
return ON_SEGMENT;
}
static bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
static bool intersect(Segment s1, Segment s2);
static Point project(Segment s, Point p);
static Point reflect(Segment s, Point p);
static Point getDistance(Point a, Point b) { return (a - b).abs(); }
static double getDistanceLP(Segment s, Point p);
static double getDistanceSP(Segment s, Point p);
static double getDistance(Segment s1, Segment s2);
static Point getIntersection(Segment s1, Segment s2);
static pair<Point, Point> crossPoints(Circle c, Segment s);
static int contains(vector<Point> g, Point p) {
int n = g.size();
bool x = false;
rep(i, n) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
// 線の上に載っているか
if (std::abs(cross(a, b)) < EPS && dot(a, b) < EPS)
return 1;
// pを基準として上下にあるか
// または外積が正か?(→にあるか)
if (a.y > b.y)
swap(a, b);
if (a.y < EPS && EPS < b.y && cross(a, b) > EPS)
x = !x;
}
return x ? 2 : 0;
}
static vector<Point> andrewScan(vector<Point> s) {
vector<Point> u, l;
if (s.size() < 3)
return s;
sort(all(s));
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size() - 1]);
l.push_back(s[s.size() - 2]);
for (int i = 2; i < s.size(); i++) {
for (int _n = u.size();
_n >= 2 && ccw(u[_n - 2], u[_n - 1], s[i]) > CLOCKWISE; _n--) {
u.pop_back();
}
u.push_back(s[i]);
}
for (int i = s.size() - 3; i >= 0; i--) {
for (int _n = l.size();
_n >= 2 && ccw(l[_n - 2], l[_n - 1], s[i]) > CLOCKWISE; _n--) {
l.pop_back();
}
l.push_back(s[i]);
}
reverse(all(l));
for (int i = u.size() - 2; i >= 1; i--) {
l.push_back(u[i]);
}
return l;
}
void get_cin() { cin >> x >> y; }
};
class Segment {
public:
Point p1, p2;
Segment() {}
Segment(Point p1, Point p2) : p1(p1), p2(p2) {}
void get_cin() { cin >> p1.x >> p1.y >> p2.x >> p2.y; }
Point p1tp2() { return p2 - p1; }
Point p2tp1() { return p1 - p2; }
double abs() { return std::abs(norm()); }
double norm() { return (p2 - p1).norm(); }
};
bool Point::isOrthogonal(Segment s1, Segment s2) {
return EQ(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool Point::isPalallel(Segment s1, Segment s2) {
return EQ(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool Point::intersect(Segment s1, Segment s2) {
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
Point Point::project(Segment s, Point p) {
Point base = s.p2 - s.p1;
double r = Point::dot(p - s.p1, base) / base.norm();
return s.p1 + base * r;
}
Point Point::reflect(Segment s, Point p) { return (project(s, p) * 2) - p; }
double Point::getDistanceLP(Segment s, Point p) {
return std::abs(cross(s.p2 - s.p1, p - s.p1) / (s.p2 - s.p1).abs());
}
double Point::getDistanceSP(Segment s, Point p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
return (p - s.p1).abs();
if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
return (p - s.p2).abs();
return getDistanceLP(s, p);
}
double Point::getDistance(Segment s1, Segment s2) {
if (intersect(s1, s2))
return 0.0;
return min({getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2),
getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)});
}
Point Point::getIntersection(Segment s1, Segment s2) {
// (s1.p1 - s2.p1).norm()
auto bs = s1.p2 - s1.p1;
auto n1 = s2.p1 - s1.p1;
auto n2 = s2.p2 - s1.p1;
auto c1 = std::abs(cross(n1, bs)) / bs.norm();
auto c2 = std::abs(cross(n2, bs)) / bs.norm();
return s2.p1 + (s2.p2 - s2.p1) * (c1 / (c1 + c2));
// c1:c2=t:1-t
// c2t=(1-t)c1
// t/(1-t)=c1/(c1+c2)
//
}
double arg(Point p) { return atan2(p.y, p.x); }
Point polar(double a, double r) { return Point(cos(r) * a, sin(r) * a); }
class Circle {
public:
Point c;
double r;
Circle(Point c = Point(), double r = 0.0) : c(c), r(r) {}
void get_cin() { cin >> c.x >> c.y >> r; }
static pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
double d = (c1.c - c2.c).abs(); // 中心点どうしの距離
double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
double t = arg(c2.c - c1.c);
return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
};
pair<Point, Point> Point::crossPoints(Circle c, Segment s) {
auto pp = project(s, c.c);
auto f = (pp - c.c).norm();
auto mu = sqrt(c.r * c.r - f);
auto e = s.p1tp2() / s.p1tp2().abs();
return make_pair(pp + e * mu, pp - e * mu);
}
ll divRm(string s, ll x) {
ll r = 0;
for (ll i = 0; i < s.size(); i++) {
r *= 10;
r += s[i] - '0';
r %= x;
}
return r;
}
ll cmbi(ll x, ll b) {
ll res = 1;
for (size_t i = 0; i < b; i++) {
res *= x - i;
res %= INF;
res *= inv[b - i];
res %= INF;
}
return res;
}
double digsum(ll x) {
ll res = 0;
while (x > 0) {
res += x % 10;
x /= 10;
}
return res;
}
bool check_parindrome(string s) {
int n = s.size();
rep(i, n / 2) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
// ここまでライブラリ
// ここからコード
void solv() {
ll a, b, c;
cin >> n >> a >> b >> c;
ll res = 0;
ll at = inff(a * inv[a + b]);
ll bt = inff(b * inv[a + b]);
rep2(i, n, 2 * n) {
ll v = inff(getpow(at, n) * getpow(bt, i - n));
inf(v += inff(getpow(at, i - n) * getpow(bt, n)));
inf(v *= COM(i - 1, n - 1));
inf(v *= i);
inf(res += v);
}
inf(res *= inff(100 * inv[100 - c]));
cout << res << endl;
}
int main() {
COMinit();
solv();
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 836,216 | 836,217 | u224756887 | cpp |
p03025 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define int long long
#define double long double
#define mod 1000000007
#define P pair<long long, long long>
#define all(a) a.begin(), a.end()
#define INF 10000000000000000
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;
}
using namespace std;
// power_mod
inline int Pow_mod(int x, int pow) {
if (pow == 0)
return 1;
int a = Pow_mod(x, pow / 2);
a = a * a % mod;
if (pow % 2 == 1)
a *= x;
return a % mod;
}
// factorial_mod
int *fact_mod;
inline void init_fact_mod(int x) {
fact_mod = new int[x];
fact_mod[0] = 1;
rep(i, x - 1) fact_mod[i + 1] = fact_mod[i] * (i + 1) % mod;
}
// permutation_mod
inline int nPr_mod(int n, int r) {
return fact_mod[n] * Pow_mod(fact_mod[n - r] % mod, mod - 2) % mod;
}
// combination_mod
inline int nCr_mod(int n, int r) {
return fact_mod[n] * Pow_mod(fact_mod[n - r] * fact_mod[r] % mod, mod - 2) %
mod;
}
signed main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int N, a, b, c;
cin >> N >> a >> b >> c;
int A = a * Pow_mod(a + b, mod - 2);
int B = b * Pow_mod(a + b, mod - 2);
int C = 100 * Pow_mod(100 - c, mod - 2) % mod;
init_fact_mod(200010);
int ans = 0;
for (int i = N; i < N * 2; i++) {
int tmp = ((Pow_mod(A, N) * Pow_mod(B, i - N) % mod +
Pow_mod(B, N) * Pow_mod(A, i - N) % mod) %
mod) *
nCr_mod(i - 1, N - 1) % mod;
(ans += (tmp * i % mod) * C % mod) %= mod;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define int long long
#define double long double
#define mod 1000000007
#define P pair<long long, long long>
#define all(a) a.begin(), a.end()
#define INF 10000000000000000
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;
}
using namespace std;
// power_mod
inline int Pow_mod(int x, int pow) {
if (pow == 0)
return 1;
int a = Pow_mod(x, pow / 2);
a = a * a % mod;
if (pow % 2 == 1)
a *= x;
return a % mod;
}
// factorial_mod
int *fact_mod;
inline void init_fact_mod(int x) {
fact_mod = new int[x];
fact_mod[0] = 1;
rep(i, x - 1) fact_mod[i + 1] = fact_mod[i] * (i + 1) % mod;
}
// permutation_mod
inline int nPr_mod(int n, int r) {
return fact_mod[n] * Pow_mod(fact_mod[n - r] % mod, mod - 2) % mod;
}
// combination_mod
inline int nCr_mod(int n, int r) {
return fact_mod[n] * Pow_mod(fact_mod[n - r] * fact_mod[r] % mod, mod - 2) %
mod;
}
signed main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int N, a, b, c;
cin >> N >> a >> b >> c;
int A = a * Pow_mod(a + b, mod - 2) % mod;
int B = b * Pow_mod(a + b, mod - 2) % mod;
int C = 100 * Pow_mod(100 - c, mod - 2) % mod;
init_fact_mod(200010);
int ans = 0;
for (int i = N; i < N * 2; i++) {
int tmp = ((Pow_mod(A, N) * Pow_mod(B, i - N) % mod +
Pow_mod(B, N) * Pow_mod(A, i - N) % mod) %
mod) *
nCr_mod(i - 1, N - 1) % mod;
(ans += (tmp * i % mod) * C % mod) %= mod;
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 836,233 | 836,234 | u807998890 | cpp |
p03024 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
char S[99];
ll i, j, k;
int main() {
scanf("%lld", &S);
j = 7;
for (i = 0; S[i]; i++) {
if (S[i] == 'x') {
j--;
}
}
if (j < 0) {
printf("NO");
} else {
printf("YES");
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
char S[99];
ll i, j, k;
int main() {
scanf("%s", &S);
j = 7;
for (i = 0; S[i]; i++) {
if (S[i] == 'x') {
j--;
}
}
if (j < 0) {
printf("NO");
} else {
printf("YES");
}
return 0;
} | [
"literal.string.change",
"call.arguments.change"
] | 836,238 | 836,239 | u259396003 | cpp |
p03024 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned int UI;
#define rSort(a) sort(a.rbegin(), a.rend())
#define Sort(a) sort(a.begin(), a.end())
#define Reverse(a) reverse(a.begin(), a.end())
#define Sum(a) accumulate(a.begin(), a.end(), 0)
#define REP(i, n) for (UI i = 0; i < n; i++)
#define REPR(i, n) for (UI i = n; i >= 0; i--)
#define FOR(i, m, n) for (UI i = m; i < n; i++)
#define pb(i) push_back(i)
#define MOD (LL)1e9 + 7;
#define INF (LL)1 << 62;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
int cnt = 0;
cin >> S;
for (int i = 0; i < S.length(); i++) {
if (S[i] == 'o') {
cnt++;
}
}
if (cnt > 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned int UI;
#define rSort(a) sort(a.rbegin(), a.rend())
#define Sort(a) sort(a.begin(), a.end())
#define Reverse(a) reverse(a.begin(), a.end())
#define Sum(a) accumulate(a.begin(), a.end(), 0)
#define REP(i, n) for (UI i = 0; i < n; i++)
#define REPR(i, n) for (UI i = n; i >= 0; i--)
#define FOR(i, m, n) for (UI i = m; i < n; i++)
#define pb(i) push_back(i)
#define MOD (LL)1e9 + 7;
#define INF (LL)1 << 62;
int main(int argc, const char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
int cnt = 0;
cin >> S;
for (int i = 0; i < S.length(); i++) {
if (S[i] == 'x') {
cnt++;
}
}
if (cnt > 7) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} | [
"literal.string.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 836,242 | 836,243 | u335104842 | cpp |
p03024 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 100000000
#define MOD 1000000007
#define writeln(n) cout << n << endl
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
// vector<tuple<long long, long long, long long>>vec;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
const int inf = 100000000;
llong pownew(llong m, llong n) {
if (n == 0) {
return 1;
}
if (n % 2 == 0) {
return pow(m * m, n / 2);
}
return pow(m, n - 1) * m;
}
bool isprime(int p) {
if (p == 1)
return false;
for (int i = 2; i < p; i++) {
if (p % i == 0)
return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int k = s.size();
int a, b;
a = 0;
b = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o')
++a;
else if (s[i] == 'x')
++b;
}
if (15 - k + a >= 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 100000000
#define MOD 1000000007
#define writeln(n) cout << n << endl
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
// vector<tuple<long long, long long, long long>>vec;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
const int inf = 100000000;
llong pownew(llong m, llong n) {
if (n == 0) {
return 1;
}
if (n % 2 == 0) {
return pow(m * m, n / 2);
}
return pow(m, n - 1) * m;
}
bool isprime(int p) {
if (p == 1)
return false;
for (int i = 2; i < p; i++) {
if (p % i == 0)
return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int k = s.size();
int a, b;
a = 0;
b = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o')
++a;
else if (s[i] == 'x')
++b;
}
if (15 - k + a >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,250 | 836,251 | u511379665 | cpp |
p03024 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < 15; ++i) {
if (S[i] == 'o') {
++count;
}
}
if (count >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < 15; ++i) {
if (S[i] == 'x') {
++count;
}
}
if (count <= 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 836,254 | 836,255 | u701556979 | cpp |
p03024 | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF 1e18L
#define INF 1e9L
#define EPS 1e-9
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ALL(v) v.begin(), v.end()
#define FIND(v, x) (binary_search(ALL(v), (x)))
#define SORT(v) sort(ALL(v))
#define RSORT(v) \
sort(ALL(v)); \
reverse(ALL(v))
#define DEBUG(x) cerr << #x << ": " << x << endl;
#define DEBUG_VEC(v) \
cerr << #v << ":"; \
for (int i = 0; i < v.size(); i++) \
cerr << " " << v[i]; \
cerr << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define pb push_back
#define fi first
#define se second
using namespace std;
template <class A> void pr(A a) { cout << (a) << endl; }
template <class A, class B> void pr(A a, B b) {
cout << a << " ";
pr(b);
}
template <class A, class B, class C> void pr(A a, B b, C c) {
cout << a << " ";
pr(b, c);
}
template <class A, class B, class C, class D> void pr(A a, B b, C c, D d) {
cout << a << " ";
pr(b, c, d);
}
typedef long long ll;
typedef pair<int, int> pii;
int main(void) {
string s;
cin >> s;
int a;
REP(i, s.size()) {
if (s[i] == 'o')
a++;
}
a += 15 - s.size();
YES(a >= 8);
} | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
#define PI 3.14159265358979323846
#define MAXINF 1e18L
#define INF 1e9L
#define EPS 1e-9
#define REP(i, n) for (int i = 0; i < int(n); ++i)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define RREP(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ALL(v) v.begin(), v.end()
#define FIND(v, x) (binary_search(ALL(v), (x)))
#define SORT(v) sort(ALL(v))
#define RSORT(v) \
sort(ALL(v)); \
reverse(ALL(v))
#define DEBUG(x) cerr << #x << ": " << x << endl;
#define DEBUG_VEC(v) \
cerr << #v << ":"; \
for (int i = 0; i < v.size(); i++) \
cerr << " " << v[i]; \
cerr << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define pb push_back
#define fi first
#define se second
using namespace std;
template <class A> void pr(A a) { cout << (a) << endl; }
template <class A, class B> void pr(A a, B b) {
cout << a << " ";
pr(b);
}
template <class A, class B, class C> void pr(A a, B b, C c) {
cout << a << " ";
pr(b, c);
}
template <class A, class B, class C, class D> void pr(A a, B b, C c, D d) {
cout << a << " ";
pr(b, c, d);
}
typedef long long ll;
typedef pair<int, int> pii;
int main(void) {
string s;
cin >> s;
int a = 0;
REP(i, s.size()) {
if (s[i] == 'o')
a++;
}
a += 15 - s.size();
YES(a >= 8);
} | [
"variable_declaration.value.change"
] | 836,256 | 836,257 | u528720841 | cpp |
p03024 | #include <bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mp make_pair
#define pb push_back
using namespace std;
LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; }
LL lcm(LL a, LL b) { return a / gcd(a, b) * b; }
LL powmod(LL a, LL b, LL MOD) {
LL ans = 1;
while (b) {
if (b % 2)
ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
const int N = 2e5 + 11;
char a[N];
int main() {
ios::sync_with_stdio(false);
cin >> a + 1;
int cnt = 0;
int len = strlen(a + 1);
for (int i = 1; i <= len; i++)
cnt += a[i] == 'o';
if (cnt >= 8)
cout << "YES";
else
cout << "NO";
return 0;
} | #include <bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mp make_pair
#define pb push_back
using namespace std;
LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; }
LL lcm(LL a, LL b) { return a / gcd(a, b) * b; }
LL powmod(LL a, LL b, LL MOD) {
LL ans = 1;
while (b) {
if (b % 2)
ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
const int N = 2e5 + 11;
char a[N];
int main() {
ios::sync_with_stdio(false);
cin >> a + 1;
int cnt = 0;
int len = strlen(a + 1);
for (int i = 1; i <= len; i++)
cnt += a[i] == 'o';
if (cnt + (15 - len) >= 8)
cout << "YES";
else
cout << "NO";
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 836,262 | 836,263 | u862237347 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, x, y) for (int i = x; i < y; i++)
const int8_t INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
cnt += s[i] == 'o';
}
cnt += 15 - s.size();
cout << (cnt > 7 ? "Yes" : "No") << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, x, y) for (int i = x; i < y; i++)
const int8_t INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
cnt += s[i] == 'o';
}
cnt += 15 - s.size();
cout << (cnt > 7 ? "YES" : "NO") << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,268 | 836,269 | u908432409 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o')
cnt++;
}
if (cnt >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int cnt = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'x')
cnt++;
}
if (cnt >= 8)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| [
"literal.string.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 836,272 | 836,273 | u665871498 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define ll long long int
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
using namespace std;
int main() {
string S;
int cnt = 0;
cin >> S;
rep(i, 0, S.size()) {
if (S[0] == 'o') {
cnt++;
}
}
if (cnt + 15 - S.size() > 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define ll long long int
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
using namespace std;
int main() {
string S;
int cnt = 0;
cin >> S;
rep(i, 0, S.size()) {
if (S[i] == 'o') {
cnt++;
}
}
if (cnt + 15 - S.size() > 7) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 836,274 | 836,275 | u352200121 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int lose = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x')
lose++;
}
if (lose >= 8)
printf("No\n");
else
printf("Yes\n");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int lose = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x')
lose++;
}
if (lose >= 8)
printf("NO\n");
else
printf("YES\n");
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 836,276 | 836,277 | u429526425 | cpp |
p03024 | #include <bits/stdc++.h>
#define reps(i, a, b) for (long long int i = a; i < b; i++)
#define rep(i, a) for (long long int i = 0; i < a; i++)
typedef long long int ll;
using namespace std;
ll MOD = 1000000007;
const int MAX = 510000;
struct aaa {
aaa() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
int main() {
string S;
cin >> S;
int ans = 0;
rep(i, S.size()) {
if (S[i] == 'o') {
ans++;
}
}
if (ans + (15 - S.size()) >= 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define reps(i, a, b) for (long long int i = a; i < b; i++)
#define rep(i, a) for (long long int i = 0; i < a; i++)
typedef long long int ll;
using namespace std;
ll MOD = 1000000007;
const int MAX = 510000;
struct aaa {
aaa() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
};
} aaaaaaa;
int main() {
string S;
cin >> S;
int ans = 0;
rep(i, S.size()) {
if (S[i] == 'o') {
ans++;
}
}
if (ans + (15 - S.size()) >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,278 | 836,279 | u691174149 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o')
count++;
}
if (15 - S.size() + count >= 15)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'o')
count++;
}
if (15 - S.size() + count >= 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 836,283 | 836,284 | u239087789 | cpp |
p03024 | /*include*/
#include <bits/stdc++.h>
/*alias*/
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
using ll = long long;
using namespace std;
/*input*/
string s;
/*funcs*/
/*main*/
int main() {
cin >> s;
int k = s.length();
int rest = 15 - k;
int count = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o') {
count++;
}
}
if (count + rest >= 8) {
cout << "Yes";
} else {
cout << "No";
}
} | /*include*/
#include <bits/stdc++.h>
/*alias*/
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
using ll = long long;
using namespace std;
/*input*/
string s;
/*funcs*/
/*main*/
int main() {
cin >> s;
int k = s.length();
int rest = 15 - k;
int count = 0;
for (int i = 0; i < k; i++) {
if (s[i] == 'o') {
count++;
}
}
if (count + rest >= 8) {
cout << "YES";
} else {
cout << "NO";
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,287 | 836,288 | u629194491 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
#define ll long long
#define s second
#define f first
string s;
int main() {
cin >> s;
ll cnt = 0;
for (int i = 0; i < s.size(); ++i) {
cnt += (s[i] == 'o');
}
if (cnt + (15 - s.size()) >= 8) {
cout << "YES";
return 0;
}
cout << "N0";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
#define ll long long
#define s second
#define f first
string s;
int main() {
cin >> s;
ll cnt = 0;
for (int i = 0; i < s.size(); ++i) {
cnt += (s[i] == 'o');
}
if (cnt + (15 - s.size()) >= 8) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 836,289 | 836,290 | u522784682 | cpp |
p03024 | #include <iostream>
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == '×') {
count++;
}
}
if (count < 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <iostream>
using namespace std;
int main() {
string S;
cin >> S;
int count = 0;
for (int i = 0; i < S.size(); i++) {
if (S.at(i) == 'x') {
count++;
}
}
if (count < 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 836,291 | 836,292 | u322714721 | cpp |
p03024 | #include <bits/stdc++.h>
#define mod 1000000007
#define f first
#define s second
using namespace std;
/*int gcd(int a,int b){
if(b == 0)
return a;
return gcd(b,a%b);
}*/
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int win = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == 'o')
win++;
if (15 - s.size() + win > 8)
cout << "YES";
else
cout << "NO";
return 0;
} | #include <bits/stdc++.h>
#define mod 1000000007
#define f first
#define s second
using namespace std;
/*int gcd(int a,int b){
if(b == 0)
return a;
return gcd(b,a%b);
}*/
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int win = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == 'o')
win++;
if (15 - s.size() + win >= 8)
cout << "YES";
else
cout << "NO";
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 836,295 | 836,296 | u175695388 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
string S;
cin >> S;
int c = 0;
for (int i = 0; i < S.size(); i++)
if (S.at(i) == 'x')
c++;
if (c < 8)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
string S;
cin >> S;
int c = 0;
for (int i = 0; i < S.size(); i++)
if (S.at(i) == 'x')
c++;
if (c < 8)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,297 | 836,298 | u889812821 | cpp |
p03024 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, x) for (int i = 0; i < (int)(x); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = ((int)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define INF 2e9
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
typedef long double ld;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
using namespace std;
int main() {
string s;
cin >> s;
ll cnt = 0;
rep(i, s.size()) {
if (s[i] == 'o')
cnt++;
}
if (cnt + 15 - s.size() >= 8)
cout << "Yes";
else
cout << "No";
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, x) for (int i = 0; i < (int)(x); i++)
#define reps(i, x) for (int i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = ((int)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define INF 2e9
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
typedef long double ld;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
using namespace std;
int main() {
string s;
cin >> s;
ll cnt = 0;
rep(i, s.size()) {
if (s[i] == 'o')
cnt++;
}
if (cnt + 15 - s.size() >= 8)
cout << "YES";
else
cout << "NO";
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,299 | 836,300 | u150255544 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
using llint = long long;
#define LOG(x) cout << "# " << #x << " => " << (x) << endl
string s;
int w = 0, l = 0;
int main() {
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s.at(i) == 'o') {
++w;
}
}
if ((15 - s.size()) + w >= 8) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using llint = long long;
#define LOG(x) cout << "# " << #x << " => " << (x) << endl
string s;
int w = 0, l = 0;
int main() {
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s.at(i) == 'o') {
++w;
}
}
if ((15 - s.size()) + w >= 8) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,310 | 836,311 | u135954097 | cpp |
p03024 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pii pair<int, int>
#define ll long long
#define ff first
#define ss second
#define mp make_pair
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#define MOD 1000000007LL
#define N 200005
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
string s;
cin >> s;
int cnt = 0;
for (auto c : s) {
if (c == 'X')
cnt++;
}
if (cnt > 7)
cout << "YES";
else
cout << "NO";
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define pb push_back
#define pii pair<int, int>
#define ll long long
#define ff first
#define ss second
#define mp make_pair
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#define MOD 1000000007LL
#define N 200005
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
string s;
cin >> s;
int cnt = 0;
for (auto c : s) {
if (c == 'x')
cnt++;
}
if (cnt > 7)
cout << "NO";
else
cout << "YES";
}
| [
"literal.string.change",
"literal.string.case.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 836,314 | 836,315 | u322038235 | cpp |
p03024 | #include <bits/stdc++.h>
#define int long long
#define P pair<int, int>
#define PP pair<P, int>
#define F first
#define S second
#define f(i, n) for (int i = 0; i < (n); i++)
#define INF LLONG_MAX / 3
#define eps LDBL_EPSILON
#define mod (int)(1000000007)
#define pie 3.141592653589793238462643383279
#define Bpri priority_queue
#define Spri priority_queue<P, vector<P>, greater<P>>
using namespace std;
signed main() {
string s;
int sum = 0;
cin >> s;
f(i, s.size()) {
if (s[i] == 'x')
sum++;
}
if (sum > 8)
puts("NO");
else
puts("YES");
}
| #include <bits/stdc++.h>
#define int long long
#define P pair<int, int>
#define PP pair<P, int>
#define F first
#define S second
#define f(i, n) for (int i = 0; i < (n); i++)
#define INF LLONG_MAX / 3
#define eps LDBL_EPSILON
#define mod (int)(1000000007)
#define pie 3.141592653589793238462643383279
#define Bpri priority_queue
#define Spri priority_queue<P, vector<P>, greater<P>>
using namespace std;
signed main() {
string s;
int sum = 0;
cin >> s;
f(i, s.size()) {
if (s[i] == 'x')
sum++;
}
if (sum >= 8)
puts("NO");
else
puts("YES");
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 836,320 | 836,321 | u259210975 | cpp |
p03024 | #include <bits/stdc++.h>
using namespace std;
int main() {
int lcount = 0;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'x')
lcount++;
}
cout << (lcount < 8 ? "Yes" : "No") << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int lcount = 0;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'x')
lcount++;
}
cout << (lcount < 8 ? "YES" : "NO") << endl;
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 836,322 | 836,323 | u506320030 | cpp |
p03024 | #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
for (auto &i : v) {
stream >> i;
}
return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
stream >> p.first >> p.second;
return stream;
}
int main() {
std::string s;
std::cin >> s;
int p = 0;
for (const auto i : s) {
if (i == 'o') {
p++;
}
}
if (8 <= p + 15 - s.size()) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
return 0;
}
| #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
for (auto &i : v) {
stream >> i;
}
return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
stream >> p.first >> p.second;
return stream;
}
int main() {
std::string s;
std::cin >> s;
int p = 0;
for (const auto i : s) {
if (i == 'o') {
p++;
}
}
if (8 <= p + 15 - s.size()) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 836,324 | 836,325 | u438319362 | cpp |
p03025 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
const ll MOD = 1000000007;
const int N_MAX = 200001;
const long double EPS = 1e-10;
const int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
ll fact[N_MAX], rfact[N_MAX];
ll perm(ll n, ll r) { return (fact[n] * rfact[r]) % MOD; }
ll comb(ll n, ll r) { return (perm(n, r) * rfact[n - r]) % MOD; }
void init(ll n) {
fact[0] = fact[1] = 1;
rfact[0] = rfact[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = (fact[i - 1] * (ll)i) % MOD;
rfact[i] = 1;
ll k = MOD - 2;
ll a = fact[i];
while (k > 0) {
if (k & 1) {
rfact[i] *= a;
rfact[i] %= MOD;
}
a *= a;
a %= MOD;
k >>= 1;
}
}
}
ll modpow(ll a, ll t) {
ll ret = 1LL;
while (t) {
if (t & 1LL) {
ret *= a;
ret %= MOD;
}
a *= a;
a %= MOD;
t >>= 1;
}
return ret;
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
ll n, a, b, c;
cin >> n >> a >> b >> c;
init(2 * n);
vector<ll> pow_a(n + 1, 1), pow_b(n + 1, 1);
for (int i = 1; i <= n; ++i) {
pow_a[i] = (pow_a[i - 1] * a) % MOD;
pow_b[i] = (pow_b[i - 1] * b) % MOD;
}
ll ans = 0LL;
for (int i = n; i < 2 * n; ++i) {
ll tmp = (((pow_a[n] * pow_b[i - n]) % MOD) +
((pow_a[i - n] * pow_b[n]) % MOD)) %
MOD;
tmp = (((tmp * i) % MOD) * comb(i - 1, n - 1)) % MOD;
tmp = (tmp * modpow(modpow(a + b, i), MOD - 2)) % MOD;
ans = (ans + tmp) % MOD;
}
ans = (ans * 100 * modpow(100 - c, MOD - 2)) % MOD;
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
const ll MOD = 1000000007;
const int N_MAX = 200001;
const long double EPS = 1e-10;
const int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
ll fact[N_MAX], rfact[N_MAX];
ll perm(ll n, ll r) { return (fact[n] * rfact[r]) % MOD; }
ll comb(ll n, ll r) { return (perm(n, r) * rfact[n - r]) % MOD; }
void init(ll n) {
fact[0] = fact[1] = 1;
rfact[0] = rfact[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = (fact[i - 1] * (ll)i) % MOD;
rfact[i] = 1;
ll k = MOD - 2;
ll a = fact[i];
while (k > 0) {
if (k & 1) {
rfact[i] *= a;
rfact[i] %= MOD;
}
a *= a;
a %= MOD;
k >>= 1;
}
}
}
ll modpow(ll a, ll t) {
ll ret = 1LL;
while (t) {
if (t & 1LL) {
ret *= a;
ret %= MOD;
}
a *= a;
a %= MOD;
t >>= 1;
}
return ret;
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
ll n, a, b, c;
cin >> n >> a >> b >> c;
init(2 * n);
vector<ll> pow_a(n + 1, 1), pow_b(n + 1, 1);
for (int i = 1; i <= n; ++i) {
pow_a[i] = (pow_a[i - 1] * a) % MOD;
pow_b[i] = (pow_b[i - 1] * b) % MOD;
}
ll ans = 0LL;
for (int i = n; i < 2 * n; ++i) {
ll tmp = (((pow_a[n] * pow_b[i - n]) % MOD) +
((pow_a[i - n] * pow_b[n]) % MOD)) %
MOD;
tmp = (((tmp * i) % MOD) * comb(i - 1, n - 1)) % MOD;
tmp = (tmp * modpow(modpow(a + b, i), MOD - 2)) % MOD;
ans = (ans + tmp) % MOD;
}
ans = (((ans * 100) % MOD) * modpow(100 - c, MOD - 2)) % MOD;
cout << ans << endl;
}
| [] | 836,342 | 836,343 | u986399983 | cpp |
p03025 | // Optimise
#include <bits/stdc++.h>
using namespace std;
#define Online 1
// #define multitest 1
#define Debug 1
void ControlIO();
void TimerStart();
void TimerStop();
#ifdef Debug
#define db(...) ZZ(#__VA_ARGS__, __VA_ARGS__);
template <typename Arg1> void ZZ(const char *name, Arg1 &&arg1) {
std::cerr << name << " = " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void ZZ(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
#else
#define db(...)
#endif
typedef long long ll;
typedef long double ld;
#define f first
#define s second
#define pb push_back
const long long mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll power(int base, int index) {
if (index == 0)
return 1;
ll temp = power(base, index / 2);
temp = (temp * temp) % mod;
if (index & 1)
temp = (temp * base) % mod;
return temp;
}
int n, a, b, c;
int _n = 1e5 + 10;
vector<ll> Fact(_n), Inv(_n);
int kmod = 1000000007;
void pre() {
Fact[0] = 1;
for (int i = 1; i < _n; ++i)
Fact[i] = (Fact[i - 1] * i) % kmod;
Inv[_n - 1] = power(Fact[_n - 1], kmod - 2);
for (int i = _n - 2; i >= 0; --i)
Inv[i] = (Inv[i + 1] * (1 + i)) % kmod;
// db(Inv[2]*2%mod);
}
ll com(int m) {
// db(m, n);
ll x = (Fact[m - 1] * Inv[n - 1]) % mod;
x *= Inv[m - n];
x %= mod;
ll temp = (power(a, n) * power(b, m - n)) % mod +
(power(a, m - n) * power(b, n)) % mod;
// db(temp);
temp %= mod;
temp *= m;
// db(temp);
temp %= mod;
temp *= x;
// db(temp);
return temp % mod;
}
void solve() {
pre();
cin >> n >> a >> b >> c;
ll ans = 0;
ll div = power(a + b, mod - 2);
a = (a * div) % mod;
b = (b * div) % mod;
for (int i = n; i < 2 * n; ++i) {
ans += com(i);
ans %= mod;
}
ans *= power(100 - c, mod - 2);
ans %= mod;
ans *= 100;
cout << (ans % mod) << '\n';
}
int main() {
ControlIO();
int t = 1;
#ifdef multitest
cin >> t;
#endif
TimerStart();
while (t--)
solve();
TimerStop();
return 0;
}
void ControlIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifndef Online
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void TimerStart() {
#ifndef Online
TimeStart = chrono::steady_clock::now();
#endif
}
void TimerStop() {
#ifndef Online
TimeEnd = chrono::steady_clock::now();
auto ElapsedTime = TimeEnd - TimeStart;
cout << "\n\nTime elapsed: " << chrono::duration<double>(ElapsedTime).count()
<< " seconds.\n";
#endif
} | // Optimise
#include <bits/stdc++.h>
using namespace std;
#define Online 1
// #define multitest 1
#define Debug 1
void ControlIO();
void TimerStart();
void TimerStop();
#ifdef Debug
#define db(...) ZZ(#__VA_ARGS__, __VA_ARGS__);
template <typename Arg1> void ZZ(const char *name, Arg1 &&arg1) {
std::cerr << name << " = " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void ZZ(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
#else
#define db(...)
#endif
typedef long long ll;
typedef long double ld;
#define f first
#define s second
#define pb push_back
const long long mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll power(int base, int index) {
if (index == 0)
return 1;
ll temp = power(base, index / 2);
temp = (temp * temp) % mod;
if (index & 1)
temp = (temp * base) % mod;
return temp;
}
int n, a, b, c;
int _n = 2e5 + 10;
vector<ll> Fact(_n), Inv(_n);
int kmod = 1000000007;
void pre() {
Fact[0] = 1;
for (int i = 1; i < _n; ++i)
Fact[i] = (Fact[i - 1] * i) % kmod;
Inv[_n - 1] = power(Fact[_n - 1], kmod - 2);
for (int i = _n - 2; i >= 0; --i)
Inv[i] = (Inv[i + 1] * (1 + i)) % kmod;
// db(Inv[2]*2%mod);
}
ll com(int m) {
// db(m, n);
ll x = (Fact[m - 1] * Inv[n - 1]) % mod;
x *= Inv[m - n];
x %= mod;
ll temp = (power(a, n) * power(b, m - n)) % mod +
(power(a, m - n) * power(b, n)) % mod;
// db(temp);
temp %= mod;
temp *= m;
// db(temp);
temp %= mod;
temp *= x;
// db(temp);
return temp % mod;
}
void solve() {
pre();
cin >> n >> a >> b >> c;
ll ans = 0;
ll div = power(a + b, mod - 2);
a = (a * div) % mod;
b = (b * div) % mod;
for (int i = n; i < 2 * n; ++i) {
ans += com(i);
ans %= mod;
}
ans *= power(100 - c, mod - 2);
ans %= mod;
ans *= 100;
cout << (ans % mod) << '\n';
}
int main() {
ControlIO();
int t = 1;
#ifdef multitest
cin >> t;
#endif
TimerStart();
while (t--)
solve();
TimerStop();
return 0;
}
void ControlIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifndef Online
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void TimerStart() {
#ifndef Online
TimeStart = chrono::steady_clock::now();
#endif
}
void TimerStop() {
#ifndef Online
TimeEnd = chrono::steady_clock::now();
auto ElapsedTime = TimeEnd - TimeStart;
cout << "\n\nTime elapsed: " << chrono::duration<double>(ElapsedTime).count()
<< " seconds.\n";
#endif
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 836,347 | 836,348 | u467423063 | cpp |
p03025 | #include <bits/stdc++.h>
using namespace std;
#define dist2D(x1, y1, x2, y2) ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
#define dist3D(x1, y1, z1, x2, y2, z2) \
((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2))
#define EPS 1e-12
#define FastIO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define FI freopen("in.txt", "r", stdin)
#define FO freopen("out.txt", "w", stdout)
#define fap(x) cout << "WTH: " << x << endl
#define ff first
#define fof(i, x, y) for (int i = x; i < (int)y; i++)
#define fob(i, x, y) for (int i = x; i >= (int)y; i--)
#define INF 1000000000
#define ld long double
#define ll long long
#define mem(x, y) memset(x, y, sizeof x)
#define mp make_pair
#define msi map<string, int>
#define mii map<int, int>
#define mis map<int, string>
#define MOD 1000000007
#define PI acos(-1.0)
#define PQ priority_queue
#define pb push_back
#define pib pair<int, bool>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define sfi(x) scanf("%d", &x)
#define sfii(x, y) scanf("%d%d", &x, &y)
#define sfiii(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define siz(x) (int)x.size()
#define sortv(v) sort(v.begin(), v.end())
#define ss second
#define ull unsigned long long
#define umsi unordered_map<string, int>
#define umii unordered_map<int, int>
#define umis unordered_map<int, string>
#define vb vector<bool>
#define vi vector<int>
#define vvi vector<vi>
#define vii vector<pii>
#define vvii vector<vii>
#define vll vector<ll>
#define vpll vector<pll>
template <class T> class compare {
public:
bool operator()(pair<T, T> &x, pair<T, T> &y) {
if (x.first == y.first) {
return x.ss > y.ss;
}
return x.ff > y.ff;
}
};
template <class T> ostream &operator<<(ostream &os, const pair<T, T> &a) {
os << a.ff << " " << a.ss;
}
template <class T> void print(vector<T> &vec) {
for (int i = 1; i < siz(vec); i++)
cout << vec[i] << " ";
cout << endl;
}
template <class T> void print(set<T> &s) {
for (auto it : s)
cout << it << " ";
cout << endl;
}
template <class T> void print(list<T> &lst) {
for (auto it : lst)
cout << it << " ";
cout << endl;
}
template <class T> ll power(T a, int b) {
ll po = 1;
while (b--)
po *= a;
return po;
}
template <class T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff + b.ff, a.ss + b.ss};
}
template <class T>
pair<T, T> operator-(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff - b.ff, a.ss - b.ss};
}
template <class T>
pair<T, T> operator*(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff * b.ff, a.ss * b.ss};
}
template <class T>
pair<T, T> operator%(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff % b.ff, a.ss % b.ss};
}
template <class T, class U>
pair<T, T> operator+(const pair<T, T> &a, const U &b) {
return {a.ff + b, a.ss + b};
}
template <class T, class U>
pair<T, T> operator*(const pair<T, T> &a, const U &b) {
return {a.ff * b, a.ss * b};
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
///=======================================template=======================================//
const int maxn = 200005;
ll fact[maxn], fact_inv[maxn];
ll bigmod(ll a, ll b, ll p) {
if (b == 0)
return 1;
ll temp = bigmod(a, b / 2, p);
temp = (temp * temp) % p;
if (b & 1)
temp = temp * a % p;
return temp;
}
void precalc() {
fact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = i * fact[i - 1] % MOD;
}
fact_inv[maxn - 1] = bigmod(fact[maxn - 1], MOD - 2, MOD);
for (int i = maxn - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD;
}
}
ll nCr(ll n, ll r) {
return ((fact[n] * fact_inv[r]) % MOD * fact_inv[n - r]) % MOD;
}
int main() {
// FI;FO;
FastIO;
ll n, a, b, c;
cin >> n >> a >> b >> c;
precalc();
ll ans = 0;
for (int i = n; i < 2 * n; i++) {
ans += ((i * nCr(i - 1, n - 1) % MOD) *
((bigmod(a * bigmod(a + b, MOD - 2, MOD) % MOD, n, MOD) *
bigmod(b * bigmod(a + b, MOD - 2, MOD) % MOD, i - n, MOD) +
bigmod(b * bigmod(a + b, MOD - 2, MOD) % MOD, n, MOD) *
bigmod(a * bigmod(a + b, MOD - 2, MOD), i - n, MOD)) %
MOD)) %
MOD;
ans %= MOD;
}
if (c != 0) {
ans = ((ans * 100) % MOD * bigmod(100 - c, MOD - 2, MOD)) % MOD;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define dist2D(x1, y1, x2, y2) ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
#define dist3D(x1, y1, z1, x2, y2, z2) \
((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2))
#define EPS 1e-12
#define FastIO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define FI freopen("in.txt", "r", stdin)
#define FO freopen("out.txt", "w", stdout)
#define fap(x) cout << "WTH: " << x << endl
#define ff first
#define fof(i, x, y) for (int i = x; i < (int)y; i++)
#define fob(i, x, y) for (int i = x; i >= (int)y; i--)
#define INF 1000000000
#define ld long double
#define ll long long
#define mem(x, y) memset(x, y, sizeof x)
#define mp make_pair
#define msi map<string, int>
#define mii map<int, int>
#define mis map<int, string>
#define MOD 1000000007
#define PI acos(-1.0)
#define PQ priority_queue
#define pb push_back
#define pib pair<int, bool>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define sfi(x) scanf("%d", &x)
#define sfii(x, y) scanf("%d%d", &x, &y)
#define sfiii(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define siz(x) (int)x.size()
#define sortv(v) sort(v.begin(), v.end())
#define ss second
#define ull unsigned long long
#define umsi unordered_map<string, int>
#define umii unordered_map<int, int>
#define umis unordered_map<int, string>
#define vb vector<bool>
#define vi vector<int>
#define vvi vector<vi>
#define vii vector<pii>
#define vvii vector<vii>
#define vll vector<ll>
#define vpll vector<pll>
template <class T> class compare {
public:
bool operator()(pair<T, T> &x, pair<T, T> &y) {
if (x.first == y.first) {
return x.ss > y.ss;
}
return x.ff > y.ff;
}
};
template <class T> ostream &operator<<(ostream &os, const pair<T, T> &a) {
os << a.ff << " " << a.ss;
}
template <class T> void print(vector<T> &vec) {
for (int i = 1; i < siz(vec); i++)
cout << vec[i] << " ";
cout << endl;
}
template <class T> void print(set<T> &s) {
for (auto it : s)
cout << it << " ";
cout << endl;
}
template <class T> void print(list<T> &lst) {
for (auto it : lst)
cout << it << " ";
cout << endl;
}
template <class T> ll power(T a, int b) {
ll po = 1;
while (b--)
po *= a;
return po;
}
template <class T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff + b.ff, a.ss + b.ss};
}
template <class T>
pair<T, T> operator-(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff - b.ff, a.ss - b.ss};
}
template <class T>
pair<T, T> operator*(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff * b.ff, a.ss * b.ss};
}
template <class T>
pair<T, T> operator%(const pair<T, T> &a, const pair<T, T> &b) {
return {a.ff % b.ff, a.ss % b.ss};
}
template <class T, class U>
pair<T, T> operator+(const pair<T, T> &a, const U &b) {
return {a.ff + b, a.ss + b};
}
template <class T, class U>
pair<T, T> operator*(const pair<T, T> &a, const U &b) {
return {a.ff * b, a.ss * b};
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
///=======================================template=======================================//
const int maxn = 200005;
ll fact[maxn], fact_inv[maxn];
ll bigmod(ll a, ll b, ll p) {
if (b == 0)
return 1;
ll temp = bigmod(a, b / 2, p);
temp = (temp * temp) % p;
if (b & 1)
temp = temp * a % p;
return temp;
}
void precalc() {
fact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = i * fact[i - 1] % MOD;
}
fact_inv[maxn - 1] = bigmod(fact[maxn - 1], MOD - 2, MOD);
for (int i = maxn - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD;
}
}
ll nCr(ll n, ll r) {
return ((fact[n] * fact_inv[r]) % MOD * fact_inv[n - r]) % MOD;
}
int main() {
// FI;FO;
FastIO;
ll n, a, b, c;
cin >> n >> a >> b >> c;
precalc();
ll ans = 0;
for (int i = n; i < 2 * n; i++) {
ans += ((i * nCr(i - 1, n - 1) % MOD) *
((bigmod(a * bigmod(a + b, MOD - 2, MOD) % MOD, n, MOD) *
bigmod(b * bigmod(a + b, MOD - 2, MOD) % MOD, i - n, MOD) +
bigmod(b * bigmod(a + b, MOD - 2, MOD) % MOD, n, MOD) *
bigmod(a * bigmod(a + b, MOD - 2, MOD) % MOD, i - n, MOD)) %
MOD)) %
MOD;
ans %= MOD;
}
if (c != 0) {
ans = ((ans * 100) % MOD * bigmod(100 - c, MOD - 2, MOD)) % MOD;
}
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 836,357 | 836,358 | u971626508 | cpp |
p03025 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a), i##formax = (b); i < i##formax; i++)
#define FORR(i, a, b) for (int i = (a), i##formax = (b); i >= i##formax; i--)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define pcnt __builtin_popcount
#define sz(x) (int)(x).size()
#define maxs(x, y) x = max(x, y)
#define mins(x, y) x = min(x, y)
#define show(x) cout << #x << " = " << x << endl;
#define all(a) (a.begin()), (a.end())
#define each(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
#define bitComb(a, n, k) \
for (int a##x, a##y, a = (1 << k) - 1; a < (1 << n); \
a##x = a & -a, a##y = a + a##x, a = (((a & ~a##y) / a##x) >> 1) | a##y)
#define uniq(v) \
sort(all(v)); \
v.erase(unique(all(v)), v.end())
#define bit(n) (1LL << (n))
#define randInt(l, r) (uniform_int_distribution<ll>(l, r)(rnd))
#define randDouble(l, r) (uniform_real_distribution<double>(l, r)(rnd))
#define dout(d) printf("%.12f\n", d)
typedef long long ll;
typedef __int128_t lll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T, class Y>
ostream &operator<<(ostream &o, const pair<T, Y> &p) {
return o << "(" << p.fi << ", " << p.se << ")";
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &v) {
fill((T *)array, (T *)(array + N), v);
}
lll gcd(lll a, lll b, lll &x, lll &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
lll d = gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
ll gcd(ll a, ll b) {
lll x = 0, y = 0;
return gcd(a, b, x, y);
}
ll modInv(ll a, ll m) {
lll x, y;
gcd(a, m, x, y);
return (x % m + m) % m;
}
ll modPow(lll a, lll n, ll m) {
if (!a)
return a;
lll p = 1;
for (; n > 0; n >>= 1, a = a * a % m)
if (n & 1)
p = p * a % m;
return (ll)p;
}
bool isPrime(ll n) {
if (n < 2 || n % 2 == 0)
return n == 2;
lll t = n - 1, d = t / (t & -t);
for (lll a : {2, 325, 9375, 28178, 450775, 9780504, 1795265022})
if (a % n) {
for (t = d, a = modPow(a, t, n); t != n - 1 && a != 1 && a != n - 1;
a = a * a % n, t = t * 2 % n)
;
if (a != n - 1 && t % 2 == 0)
return 0;
}
return 1;
}
const int IINF = 1e9 + 6;
const ll LINF = 1e18;
const int MOD = 1e9 + 7;
const double PI = acos(-1);
const double EPS = 1e-10;
static random_device rd;
static mt19937 rnd(rd());
const int N = 2e5 + 100;
ll f[N], r[N];
ll comb(ll a, ll b) { return f[a] * r[b] % MOD * r[a - b] % MOD; }
main() {
cin.tie(0);
ios::sync_with_stdio(false);
f[0] = 1;
FOR(i, 1, N) f[i] = f[i - 1] * i % MOD;
r[N - 1] = modInv(f[N - 1], MOD);
FORR(i, N - 1, 1) r[i - 1] = r[i] * i % MOD;
ll n, a, b, c, _ab;
cin >> n >> a >> b >> c;
ll ans = 0;
_ab = modInv(a + b, MOD);
if (a && b) {
FOR(i, 0, n)
ans += (modPow(a, n, MOD) * modPow(b, i, MOD) % MOD +
modPow(b, n, MOD) * modPow(a, i, MOD) % MOD) %
MOD * comb(i + n - 1, i) % MOD * modPow(_ab, n + i, MOD) % MOD *
(n + i) % MOD;
} else {
ans = 1;
}
cout << ans % MOD * _ab % MOD * 100 % MOD << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a), i##formax = (b); i < i##formax; i++)
#define FORR(i, a, b) for (int i = (a), i##formax = (b); i >= i##formax; i--)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define pcnt __builtin_popcount
#define sz(x) (int)(x).size()
#define maxs(x, y) x = max(x, y)
#define mins(x, y) x = min(x, y)
#define show(x) cout << #x << " = " << x << endl;
#define all(a) (a.begin()), (a.end())
#define each(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
#define bitComb(a, n, k) \
for (int a##x, a##y, a = (1 << k) - 1; a < (1 << n); \
a##x = a & -a, a##y = a + a##x, a = (((a & ~a##y) / a##x) >> 1) | a##y)
#define uniq(v) \
sort(all(v)); \
v.erase(unique(all(v)), v.end())
#define bit(n) (1LL << (n))
#define randInt(l, r) (uniform_int_distribution<ll>(l, r)(rnd))
#define randDouble(l, r) (uniform_real_distribution<double>(l, r)(rnd))
#define dout(d) printf("%.12f\n", d)
typedef long long ll;
typedef __int128_t lll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T, class Y>
ostream &operator<<(ostream &o, const pair<T, Y> &p) {
return o << "(" << p.fi << ", " << p.se << ")";
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &v) {
fill((T *)array, (T *)(array + N), v);
}
lll gcd(lll a, lll b, lll &x, lll &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
lll d = gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
ll gcd(ll a, ll b) {
lll x = 0, y = 0;
return gcd(a, b, x, y);
}
ll modInv(ll a, ll m) {
lll x, y;
gcd(a, m, x, y);
return (x % m + m) % m;
}
ll modPow(lll a, lll n, ll m) {
if (!a)
return a;
lll p = 1;
for (; n > 0; n >>= 1, a = a * a % m)
if (n & 1)
p = p * a % m;
return (ll)p;
}
bool isPrime(ll n) {
if (n < 2 || n % 2 == 0)
return n == 2;
lll t = n - 1, d = t / (t & -t);
for (lll a : {2, 325, 9375, 28178, 450775, 9780504, 1795265022})
if (a % n) {
for (t = d, a = modPow(a, t, n); t != n - 1 && a != 1 && a != n - 1;
a = a * a % n, t = t * 2 % n)
;
if (a != n - 1 && t % 2 == 0)
return 0;
}
return 1;
}
const int IINF = 1e9 + 6;
const ll LINF = 1e18;
const int MOD = 1e9 + 7;
const double PI = acos(-1);
const double EPS = 1e-10;
static random_device rd;
static mt19937 rnd(rd());
const int N = 2e5 + 100;
ll f[N], r[N];
ll comb(ll a, ll b) { return f[a] * r[b] % MOD * r[a - b] % MOD; }
main() {
cin.tie(0);
ios::sync_with_stdio(false);
f[0] = 1;
FOR(i, 1, N) f[i] = f[i - 1] * i % MOD;
r[N - 1] = modInv(f[N - 1], MOD);
FORR(i, N - 1, 1) r[i - 1] = r[i] * i % MOD;
ll n, a, b, c, _ab;
cin >> n >> a >> b >> c;
ll ans = 0;
_ab = modInv(a + b, MOD);
if (a && b) {
FOR(i, 0, n)
ans += (modPow(a, n, MOD) * modPow(b, i, MOD) % MOD +
modPow(b, n, MOD) * modPow(a, i, MOD) % MOD) %
MOD * comb(i + n - 1, i) % MOD * modPow(_ab, n + i, MOD) % MOD *
(n + i) % MOD;
} else {
ans = n;
}
cout << ans % MOD * _ab % MOD * 100 % MOD << endl;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 836,363 | 836,364 | u976045235 | cpp |
p03025 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<pll, ll>;
template <class T> using pq = priority_queue<T, vector<T>, greater<T>>;
const ll LINF = 0x1fffffffffffffff;
const int INF = 0x3fffffff;
const ll MOD = 1000000007;
const ll MODD = 998244353;
const ld DINF = numeric_limits<ld>::infinity();
const ld EPS = 1e-9;
const vector<ll> four{0, 1, 0, -1, 0};
#define _overload4(_1, _2, _3, _4, name, ...) name
#define _overload3(_1, _2, _3, name, ...) name
#define _rep1(n) for (ll i = 0; i < n; ++i)
#define _rep2(i, n) for (ll i = 0; i < n; ++i)
#define _rep3(i, a, b) for (ll i = a; i < b; ++i)
#define _rep4(i, a, b, c) for (ll i = a; i < b; i += c)
#define rep(...) \
_overload4(__VA_ARGS__, _rep4, _rep3, _rep2, _rep1)(__VA_ARGS__)
#define _rrep1(n) for (ll i = n - 1; i >= 0; i--)
#define _rrep2(i, n) for (ll i = n - 1; i >= 0; i--)
#define _rrep3(i, a, b) for (ll i = b - 1; i >= a; i--)
#define _rrep4(i, a, b, c) for (ll i = a + (b - a - 1) / c * c; i >= a; i -= c)
#define rrep(...) \
_overload4(__VA_ARGS__, _rrep4, _rrep3, _rrep2, _rrep1)(__VA_ARGS__)
#define each(i, a) for (auto &i : a)
#define sum(...) accumulate(range(__VA_ARGS__), 0LL)
#define dsum(...) accumulate(range(__VA_ARGS__), double(0))
#define _range(i) (i).begin(), (i).end()
#define _range2(i, k) (i).begin(), (i).begin() + k
#define _range3(i, a, b) (i).begin() + a, (i).begin() + b
#define range(...) \
_overload3(__VA_ARGS__, _range3, _range2, _range)(__VA_ARGS__)
#define _rrange(i) (i).rbegin(), (i).rend()
#define _rrange2(i, k) (i).rbegin(), (i).rbegin() + k
#define _rrange3(i, a, b) (i).rbegin() + a, (i).rbegin() + b
#define rrange(...) \
_overload3(__VA_ARGS__, _rrange3, _rrange2, _rrange)(__VA_ARGS__)
#define elif else if
#define unless(a) if (!(a))
#define mp make_pair
#define mt make_tuple
#define INT(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
in(__VA_ARGS__)
#define ULL(...) \
ull __VA_ARGS__; \
in(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
in(__VA_ARGS__)
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
in(name)
#define vv(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__)); \
in(name)
#define vvv(type, name, h, w, ...) \
vector<vector<vector<type>>> name( \
h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
inline constexpr ll gcd(ll a, ll b) {
if (!a || !b)
return 0;
while (b) {
ll c = b;
b = a % b;
a = c;
}
return a;
}
inline constexpr ll lcm(ll a, ll b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
template <class T> inline constexpr T min(vector<T> &v) {
return *min_element(range(v));
}
inline char min(string &v) { return *min_element(range(v)); }
template <class T> inline constexpr T max(vector<T> &v) {
return *max_element(range(v));
}
inline char max(string &v) { return *max_element(range(v)); }
inline constexpr ll intpow(ll a, ll b) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
}
a *= a;
}
return ans;
}
inline constexpr ll modpow(ll a, ll b, ll mod = MOD) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
}
return ans;
}
template <typename T> inline constexpr bool update_min(T &mn, const T &cnt) {
if (mn > cnt) {
mn = cnt;
return 1;
} else
return 0;
}
template <typename T> inline constexpr bool update_max(T &mx, const T &cnt) {
if (mx < cnt) {
mx = cnt;
return 1;
} else
return 0;
}
inline int scan() { return getchar(); }
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(unsigned &a) { scanf("%u", &a); }
inline void scan(long &a) { scanf("%ld", &a); }
inline void scan(long long &a) { scanf("%lld", &a); }
inline void scan(unsigned long long &a) { scanf("%llu", &a); }
inline void scan(char &a) { cin >> a; }
inline void scan(float &a) { scanf("%f", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(long double &a) { scanf("%Lf", &a); }
inline void scan(vector<bool> &vec) {
for (unsigned i = 0; i < vec.size(); i++) {
int a;
scan(a);
vec[i] = a;
}
}
inline void scan(string &a) { cin >> a; }
template <class T> inline void scan(vector<T> &vec);
template <class T, size_t size> inline void scan(array<T, size> &vec);
template <class T, class L> inline void scan(pair<T, L> &p);
template <class T, size_t size> inline void scan(T (&vec)[size]);
template <class T> inline void scan(vector<T> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, size_t size> inline void scan(array<T, size> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, class L> inline void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T, size_t size> inline void scan(T (&vec)[size]) {
for (auto &i : vec)
scan(i);
}
template <class T> inline void scan(T &a) { cin >> a; }
inline void in() {}
template <class Head, class... Tail> inline void in(Head &head, Tail &...tail) {
scan(head);
in(tail...);
}
inline void print() { putchar('\n'); }
inline void print(const bool &a) { printf("%d", a); }
inline void print(const int &a) { printf("%d", a); }
inline void print(const unsigned &a) { printf("%u", a); }
inline void print(const long &a) { printf("%ld", a); }
inline void print(const long long &a) { printf("%lld", a); }
inline void print(const unsigned long long &a) { printf("%llu", a); }
inline void print(const char &a) { printf("%c", a); }
inline void print(const char a[]) { printf("%s", a); }
inline void print(const float &a) { printf("%.10f", a); }
inline void print(const double &a) { printf("%.10f", a); }
inline void print(const long double &a) { printf("%.10Lf", a); }
template <class T> void print(const vector<T> &vec);
template <class T, size_t size> void print(const array<T, size> &vec);
template <class T, class L> void print(const pair<T, L> &p);
template <class T, size_t size> inline void print(const T (&vec)[size]);
template <class T> void print(const vector<T> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, size_t size> void print(const array<T, size> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, class L> void print(const pair<T, L> &p) {
print(p.first);
putchar(' ');
print(p.second);
}
template <class T, size_t size> inline void print(const T (&vec)[size]) {
print(vec[0]);
for (auto i = vec; ++i != end(vec);) {
putchar(' ');
print(*i);
}
}
template <class T> inline void print(const T &a) { cout << a; }
inline int out() {
putchar('\n');
return 0;
}
template <class T> inline int out(const T &t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
inline int out(const Head &head, const Tail &...tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
template <class T> inline void err(T t) { cerr << t << '\n'; }
inline void err() { cerr << '\n'; }
inline int yes(const bool &i) { return out(i ? "yes" : "no"); }
inline int Yes(const bool &i) { return out(i ? "Yes" : "No"); }
inline int YES(const bool &i) { return out(i ? "YES" : "NO"); }
inline int Yay(const bool &i) { return out(i ? "Yay!" : ":("); }
inline int Possible(const bool &i) {
return out(i ? "Possible" : "Impossible");
}
inline int POSSIBLE(const bool &i) {
return out(i ? "POSSIBLE" : "IMPOSSIBLE");
}
inline void Case(ll i) { printf("Case #%lld: ", i); }
const ll mod = MOD;
inline constexpr ll extgcd(ll a, ll b, ll &x, ll &y) {
ll g = a;
x = 1;
y = 0;
if (b) {
g = extgcd(b, a % b, y, x);
y -= a / b * x;
}
return g;
}
inline constexpr ll invmod(ll a, ll m = mod) {
ll x = 0, y = 0;
extgcd(a, m, x, y);
return (x + m) % m;
}
struct Modint {
ll _num;
constexpr Modint() : _num() { _num = 0; }
constexpr Modint(ll x) : _num() {
_num = x % mod;
if (_num < 0)
_num += mod;
}
inline constexpr Modint operator=(ll x) {
_num = x % mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator+(ll x) { return Modint(_num + x); }
inline constexpr Modint operator+(Modint x) {
ll a = _num + x._num;
if (a >= mod)
a -= mod;
return Modint{a};
}
inline constexpr Modint operator+=(ll x) {
_num += x;
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator+=(Modint x) {
_num += x._num;
if (_num >= mod)
_num -= mod;
return *this;
}
inline constexpr Modint operator-(ll x) { return Modint(_num - x); }
inline constexpr Modint operator-(Modint x) {
ll a = _num - x._num;
if (a < 0)
a += mod;
return Modint{a};
}
inline constexpr Modint operator-=(ll x) {
_num -= x;
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator-=(Modint x) {
_num -= x._num;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator*(ll x) { return Modint(_num * (x % mod)); }
inline constexpr Modint operator*(Modint x) {
return Modint{_num * x._num % mod};
}
inline constexpr Modint operator*=(ll x) {
x %= mod;
_num *= x;
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator*=(Modint x) {
_num *= x._num;
_num %= mod;
return *this;
}
inline constexpr Modint operator/(ll x) {
return Modint(_num * invmod(x % mod, mod));
}
inline constexpr Modint operator/(Modint x) {
return Modint{_num * invmod(x._num, mod) % mod};
}
inline constexpr Modint operator/=(ll x) {
_num *= invmod(x % mod, mod);
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator/=(Modint x) {
_num *= invmod(x._num, mod);
_num %= mod;
return *this;
}
inline constexpr Modint pow(ll x) {
ll i = 1;
Modint ans = 1, cnt = *this;
while (i <= x) {
if (x & i) {
ans *= cnt;
x ^= i;
}
cnt *= cnt;
i *= 2;
}
return ans;
}
operator ll() const { return _num; }
};
vector<Modint> fac(1, 1), inv(1, 1);
inline void reserve(ll a) {
if (fac.size() >= a)
return;
if (a < fac.size() * 2)
a = fac.size() * 2;
while (fac.size() < a)
fac.push_back(fac.back() * ll(fac.size()));
inv.resize(fac.size());
inv.back() = Modint(1) / fac.back();
for (ll i = inv.size() - 1; !inv[i - 1]; i--)
inv[i - 1] = inv[i] * i;
}
inline Modint fact(ll n) {
reserve(n + 1);
return fac[n];
}
inline Modint perm(ll n, ll r) {
reserve(n + 1);
return fac[n] * inv[n - r];
}
inline Modint comb(ll n, ll r) {
reserve(n + 1);
return fac[n] * inv[r] * inv[n - r];
}
inline Modint Mcomb(ll n, ll r) {
return comb(n + r - 1, n - 1);
} // r個をn部屋に分ける
int main() {
LL(n, _a, _b, _c);
Modint ans = 0, p = Modint(1) / 100ll, a = Modint(_a) / (_a + _b),
b = Modint(_b) / (_a + _b), c = p * _c;
rep(n) {
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i);
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i) *
c / (1 - c);
}
swap(a, b);
rep(n) {
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i);
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i) *
c / (1 - c);
}
out(ans);
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uint = unsigned int;
using pcc = pair<char, char>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using tuplis = pair<ll, pll>;
using tuplis2 = pair<pll, ll>;
template <class T> using pq = priority_queue<T, vector<T>, greater<T>>;
const ll LINF = 0x1fffffffffffffff;
const int INF = 0x3fffffff;
const ll MOD = 1000000007;
const ll MODD = 998244353;
const ld DINF = numeric_limits<ld>::infinity();
const ld EPS = 1e-9;
const vector<ll> four{0, 1, 0, -1, 0};
#define _overload4(_1, _2, _3, _4, name, ...) name
#define _overload3(_1, _2, _3, name, ...) name
#define _rep1(n) for (ll i = 0; i < n; ++i)
#define _rep2(i, n) for (ll i = 0; i < n; ++i)
#define _rep3(i, a, b) for (ll i = a; i < b; ++i)
#define _rep4(i, a, b, c) for (ll i = a; i < b; i += c)
#define rep(...) \
_overload4(__VA_ARGS__, _rep4, _rep3, _rep2, _rep1)(__VA_ARGS__)
#define _rrep1(n) for (ll i = n - 1; i >= 0; i--)
#define _rrep2(i, n) for (ll i = n - 1; i >= 0; i--)
#define _rrep3(i, a, b) for (ll i = b - 1; i >= a; i--)
#define _rrep4(i, a, b, c) for (ll i = a + (b - a - 1) / c * c; i >= a; i -= c)
#define rrep(...) \
_overload4(__VA_ARGS__, _rrep4, _rrep3, _rrep2, _rrep1)(__VA_ARGS__)
#define each(i, a) for (auto &i : a)
#define sum(...) accumulate(range(__VA_ARGS__), 0LL)
#define dsum(...) accumulate(range(__VA_ARGS__), double(0))
#define _range(i) (i).begin(), (i).end()
#define _range2(i, k) (i).begin(), (i).begin() + k
#define _range3(i, a, b) (i).begin() + a, (i).begin() + b
#define range(...) \
_overload3(__VA_ARGS__, _range3, _range2, _range)(__VA_ARGS__)
#define _rrange(i) (i).rbegin(), (i).rend()
#define _rrange2(i, k) (i).rbegin(), (i).rbegin() + k
#define _rrange3(i, a, b) (i).rbegin() + a, (i).rbegin() + b
#define rrange(...) \
_overload3(__VA_ARGS__, _rrange3, _rrange2, _rrange)(__VA_ARGS__)
#define elif else if
#define unless(a) if (!(a))
#define mp make_pair
#define mt make_tuple
#define INT(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
in(__VA_ARGS__)
#define ULL(...) \
ull __VA_ARGS__; \
in(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
in(__VA_ARGS__)
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
in(name)
#define vv(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, ...) \
vector<vector<type>> name(h, vector<type>(__VA_ARGS__)); \
in(name)
#define vvv(type, name, h, w, ...) \
vector<vector<vector<type>>> name( \
h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
inline constexpr ll gcd(ll a, ll b) {
if (!a || !b)
return 0;
while (b) {
ll c = b;
b = a % b;
a = c;
}
return a;
}
inline constexpr ll lcm(ll a, ll b) {
if (!a || !b)
return 0;
return a * b / gcd(a, b);
}
template <class T> inline constexpr T min(vector<T> &v) {
return *min_element(range(v));
}
inline char min(string &v) { return *min_element(range(v)); }
template <class T> inline constexpr T max(vector<T> &v) {
return *max_element(range(v));
}
inline char max(string &v) { return *max_element(range(v)); }
inline constexpr ll intpow(ll a, ll b) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
}
a *= a;
}
return ans;
}
inline constexpr ll modpow(ll a, ll b, ll mod = MOD) {
ll ans = 1;
for (ll i = 1; b; i *= 2) {
if (b & i) {
b ^= i;
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
}
return ans;
}
template <typename T> inline constexpr bool update_min(T &mn, const T &cnt) {
if (mn > cnt) {
mn = cnt;
return 1;
} else
return 0;
}
template <typename T> inline constexpr bool update_max(T &mx, const T &cnt) {
if (mx < cnt) {
mx = cnt;
return 1;
} else
return 0;
}
inline int scan() { return getchar(); }
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(unsigned &a) { scanf("%u", &a); }
inline void scan(long &a) { scanf("%ld", &a); }
inline void scan(long long &a) { scanf("%lld", &a); }
inline void scan(unsigned long long &a) { scanf("%llu", &a); }
inline void scan(char &a) { cin >> a; }
inline void scan(float &a) { scanf("%f", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(long double &a) { scanf("%Lf", &a); }
inline void scan(vector<bool> &vec) {
for (unsigned i = 0; i < vec.size(); i++) {
int a;
scan(a);
vec[i] = a;
}
}
inline void scan(string &a) { cin >> a; }
template <class T> inline void scan(vector<T> &vec);
template <class T, size_t size> inline void scan(array<T, size> &vec);
template <class T, class L> inline void scan(pair<T, L> &p);
template <class T, size_t size> inline void scan(T (&vec)[size]);
template <class T> inline void scan(vector<T> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, size_t size> inline void scan(array<T, size> &vec) {
for (auto &i : vec)
scan(i);
}
template <class T, class L> inline void scan(pair<T, L> &p) {
scan(p.first);
scan(p.second);
}
template <class T, size_t size> inline void scan(T (&vec)[size]) {
for (auto &i : vec)
scan(i);
}
template <class T> inline void scan(T &a) { cin >> a; }
inline void in() {}
template <class Head, class... Tail> inline void in(Head &head, Tail &...tail) {
scan(head);
in(tail...);
}
inline void print() { putchar('\n'); }
inline void print(const bool &a) { printf("%d", a); }
inline void print(const int &a) { printf("%d", a); }
inline void print(const unsigned &a) { printf("%u", a); }
inline void print(const long &a) { printf("%ld", a); }
inline void print(const long long &a) { printf("%lld", a); }
inline void print(const unsigned long long &a) { printf("%llu", a); }
inline void print(const char &a) { printf("%c", a); }
inline void print(const char a[]) { printf("%s", a); }
inline void print(const float &a) { printf("%.10f", a); }
inline void print(const double &a) { printf("%.10f", a); }
inline void print(const long double &a) { printf("%.10Lf", a); }
template <class T> void print(const vector<T> &vec);
template <class T, size_t size> void print(const array<T, size> &vec);
template <class T, class L> void print(const pair<T, L> &p);
template <class T, size_t size> inline void print(const T (&vec)[size]);
template <class T> void print(const vector<T> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, size_t size> void print(const array<T, size> &vec) {
print(vec[0]);
for (auto i = vec.begin(); ++i != vec.end();) {
putchar(' ');
print(*i);
}
}
template <class T, class L> void print(const pair<T, L> &p) {
print(p.first);
putchar(' ');
print(p.second);
}
template <class T, size_t size> inline void print(const T (&vec)[size]) {
print(vec[0]);
for (auto i = vec; ++i != end(vec);) {
putchar(' ');
print(*i);
}
}
template <class T> inline void print(const T &a) { cout << a; }
inline int out() {
putchar('\n');
return 0;
}
template <class T> inline int out(const T &t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
inline int out(const Head &head, const Tail &...tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
template <class T> inline void err(T t) { cerr << t << '\n'; }
inline void err() { cerr << '\n'; }
inline int yes(const bool &i) { return out(i ? "yes" : "no"); }
inline int Yes(const bool &i) { return out(i ? "Yes" : "No"); }
inline int YES(const bool &i) { return out(i ? "YES" : "NO"); }
inline int Yay(const bool &i) { return out(i ? "Yay!" : ":("); }
inline int Possible(const bool &i) {
return out(i ? "Possible" : "Impossible");
}
inline int POSSIBLE(const bool &i) {
return out(i ? "POSSIBLE" : "IMPOSSIBLE");
}
inline void Case(ll i) { printf("Case #%lld: ", i); }
const ll mod = MOD;
inline constexpr ll extgcd(ll a, ll b, ll &x, ll &y) {
ll g = a;
x = 1;
y = 0;
if (b) {
g = extgcd(b, a % b, y, x);
y -= a / b * x;
}
return g;
}
inline constexpr ll invmod(ll a, ll m = mod) {
ll x = 0, y = 0;
extgcd(a, m, x, y);
return (x + m) % m;
}
struct Modint {
ll _num;
constexpr Modint() : _num() { _num = 0; }
constexpr Modint(ll x) : _num() {
_num = x % mod;
if (_num < 0)
_num += mod;
}
inline constexpr Modint operator=(ll x) {
_num = x % mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator+(ll x) { return Modint(_num + x); }
inline constexpr Modint operator+(Modint x) {
ll a = _num + x._num;
if (a >= mod)
a -= mod;
return Modint{a};
}
inline constexpr Modint operator+=(ll x) {
_num += x;
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator+=(Modint x) {
_num += x._num;
if (_num >= mod)
_num -= mod;
return *this;
}
inline constexpr Modint operator-(ll x) { return Modint(_num - x); }
inline constexpr Modint operator-(Modint x) {
ll a = _num - x._num;
if (a < 0)
a += mod;
return Modint{a};
}
inline constexpr Modint operator-=(ll x) {
_num -= x;
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator-=(Modint x) {
_num -= x._num;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator*(ll x) { return Modint(_num * (x % mod)); }
inline constexpr Modint operator*(Modint x) {
return Modint{_num * x._num % mod};
}
inline constexpr Modint operator*=(ll x) {
x %= mod;
_num *= x;
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator*=(Modint x) {
_num *= x._num;
_num %= mod;
return *this;
}
inline constexpr Modint operator/(ll x) {
return Modint(_num * invmod(x % mod, mod));
}
inline constexpr Modint operator/(Modint x) {
return Modint{_num * invmod(x._num, mod) % mod};
}
inline constexpr Modint operator/=(ll x) {
_num *= invmod(x % mod, mod);
_num %= mod;
if (_num < 0)
_num += mod;
return *this;
}
inline constexpr Modint operator/=(Modint x) {
_num *= invmod(x._num, mod);
_num %= mod;
return *this;
}
inline constexpr Modint pow(ll x) {
ll i = 1;
Modint ans = 1, cnt = *this;
while (i <= x) {
if (x & i) {
ans *= cnt;
x ^= i;
}
cnt *= cnt;
i *= 2;
}
return ans;
}
operator ll() const { return _num; }
};
vector<Modint> fac(1, 1), inv(1, 1);
inline void reserve(ll a) {
if (fac.size() >= a)
return;
if (a < fac.size() * 2)
a = fac.size() * 2;
while (fac.size() < a)
fac.push_back(fac.back() * ll(fac.size()));
inv.resize(fac.size());
inv.back() = Modint(1) / fac.back();
for (ll i = inv.size() - 1; !inv[i - 1]; i--)
inv[i - 1] = inv[i] * i;
}
inline Modint fact(ll n) {
reserve(n + 1);
return fac[n];
}
inline Modint perm(ll n, ll r) {
reserve(n + 1);
return fac[n] * inv[n - r];
}
inline Modint comb(ll n, ll r) {
reserve(n + 1);
return fac[n] * inv[r] * inv[n - r];
}
inline Modint Mcomb(ll n, ll r) {
return comb(n + r - 1, n - 1);
} // r個をn部屋に分ける
int main() {
LL(n, _a, _b, _c);
Modint ans = 0, p = Modint(1) / 100ll, a = Modint(_a) / (_a + _b),
b = Modint(_b) / (_a + _b), c = p * _c;
rep(n) {
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i);
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i) *
c / Modint(1 - c);
}
swap(a, b);
rep(n) {
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i);
ans += Modint(a).pow(n) * Modint(b).pow(i) * comb(n + i - 1, i) * (n + i) *
c / Modint(1 - c);
}
out(ans);
}
| [
"call.add"
] | 836,369 | 836,370 | u874644572 | cpp |
p03025 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
ll modpow(ll a, ll b) {
ll ret = 1, kakeru = a;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
return ret;
}
ll fact[200000 + 100];
ll fact_inv[200000 + 100];
void calc_inv() {
fact[0] = 1, fact[1] = 1;
for (int i = 2; i <= 200000 + 10; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
fact_inv[200000 + 10] = modpow(fact[200000 + 10], MOD - 2);
for (int i = 200000 + 9; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1);
fact_inv[i] %= MOD;
}
}
ll comb(int a, int b) {
ll ret = fact[a] * fact_inv[b] % MOD;
ret = ret * fact_inv[a - b] % MOD;
return ret;
}
ll N, A, B, C;
int main() {
calc_inv();
cin >> N >> A >> B >> C;
ll ans_bunshi = 0;
//分母はこの場合だと、100^(2N-1)でいく。
// 100/100-C
// CとA,Bの試行は独立なので、独立な期待値の積となる。よってかけちゃっていい。
//これは最後にかける
ll apb = A + B;
for (int i = N; i <= 2 * N - 1; i++) {
// i回目は
// comb(i - 1, N - 1) * ((A/100)^N * (B/100)^(i - N) + (A/100)^(i - N) *
// (B/100)^N) * i
ll tmp = ((comb(i - 1, N - 1) * (modpow(A, N) * modpow(B, i - N) % MOD) +
(modpow(A, i - N) * modpow(B, N) % MOD) % MOD) *
modpow(apb, 2 * N - 1 - i) % MOD);
tmp *= i, tmp %= MOD;
ans_bunshi += tmp;
ans_bunshi %= MOD;
}
//ここでCによる期待値補正をかける。
ans_bunshi *= 100, ans_bunshi %= MOD;
//分母は100^(2N-1)*(100-C)である。
cout << (modpow(((modpow(apb, 2 * N - 1) * (100 - C)) % MOD), MOD - 2) *
ans_bunshi) %
MOD
<< endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
ll modpow(ll a, ll b) {
ll ret = 1, kakeru = a;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
return ret;
}
ll fact[200000 + 100];
ll fact_inv[200000 + 100];
void calc_inv() {
fact[0] = 1, fact[1] = 1;
for (int i = 2; i <= 200000 + 10; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
fact_inv[200000 + 10] = modpow(fact[200000 + 10], MOD - 2);
for (int i = 200000 + 9; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1);
fact_inv[i] %= MOD;
}
}
ll comb(int a, int b) {
ll ret = fact[a] * fact_inv[b] % MOD;
ret = ret * fact_inv[a - b] % MOD;
return ret;
}
ll N, A, B, C;
int main() {
calc_inv();
cin >> N >> A >> B >> C;
ll ans_bunshi = 0;
//分母はこの場合だと、100^(2N-1)でいく。
// 100/100-C
// CとA,Bの試行は独立なので、独立な期待値の積となる。よってかけちゃっていい。
//これは最後にかける
ll apb = A + B;
for (int i = N; i <= 2 * N - 1; i++) {
// i回目は
// comb(i - 1, N - 1) * ((A/100)^N * (B/100)^(i - N) + (A/100)^(i - N) *
// (B/100)^N) * i
ll tmp = ((comb(i - 1, N - 1) *
((modpow(A, N) * modpow(B, i - N) % MOD) +
(modpow(A, i - N) * modpow(B, N) % MOD)) %
MOD) *
modpow(apb, 2 * N - 1 - i) % MOD);
tmp *= i, tmp %= MOD;
ans_bunshi += tmp;
ans_bunshi %= MOD;
}
//ここでCによる期待値補正をかける。
ans_bunshi *= 100, ans_bunshi %= MOD;
//分母は100^(2N-1)*(100-C)である。
cout << (modpow(((modpow(apb, 2 * N - 1) * (100 - C)) % MOD), MOD - 2) *
ans_bunshi) %
MOD
<< endl;
return 0;
} | [] | 836,371 | 836,372 | u107077805 | cpp |
p03025 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
ll modpow(ll a, ll b) {
ll ret = 1, kakeru = a;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
return ret;
}
ll fact[100000 + 100];
ll fact_inv[100000 + 100];
void calc_inv() {
fact[0] = 1, fact[1] = 1;
for (int i = 2; i <= 100000 + 10; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
fact_inv[100000 + 10] = modpow(fact[100000 + 10], MOD - 2);
for (int i = 100000 + 9; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1);
fact_inv[i] %= MOD;
}
}
ll comb(int a, int b) {
ll ret = fact[a] * fact_inv[b] % MOD;
ret = ret * fact_inv[a - b] % MOD;
return ret;
}
ll N, A, B, C;
int main() {
calc_inv();
cin >> N >> A >> B >> C;
ll ans_bunshi = 0;
//分母はこの場合だと、100^(2N-1)でいく。
// 100/100-C
// CとA,Bの試行は独立なので、独立な期待値の積となる。よってかけちゃっていい。
//これは最後にかける
ll apb = A + B;
for (int i = N; i <= 2 * N - 1; i++) {
// i回目は
// comb(i - 1, N - 1) * ((A/100)^N * (B/100)^(i - N) + (A/100)^(i - N) *
// (B/100)^N) * i
ll tmp = ((comb(i - 1, N - 1) *
((modpow(A, N) * modpow(B, i - N) % MOD) +
(modpow(A, i - N) * modpow(B, N) % MOD)) %
MOD) *
modpow(apb, 2 * N - 1 - i) % MOD);
tmp *= i, tmp %= MOD;
ans_bunshi += tmp;
ans_bunshi %= MOD;
}
//ここでCによる期待値補正をかける。
ans_bunshi *= 100, ans_bunshi %= MOD;
//分母は100^(2N-1)*(100-C)である。
cout << (modpow(((modpow(apb, 2 * N - 1) * (100 - C)) % MOD), MOD - 2) *
ans_bunshi) %
MOD
<< endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
ll modpow(ll a, ll b) {
ll ret = 1, kakeru = a;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
return ret;
}
ll fact[200000 + 100];
ll fact_inv[200000 + 100];
void calc_inv() {
fact[0] = 1, fact[1] = 1;
for (int i = 2; i <= 200000 + 10; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
fact_inv[200000 + 10] = modpow(fact[200000 + 10], MOD - 2);
for (int i = 200000 + 9; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1);
fact_inv[i] %= MOD;
}
}
ll comb(int a, int b) {
ll ret = fact[a] * fact_inv[b] % MOD;
ret = ret * fact_inv[a - b] % MOD;
return ret;
}
ll N, A, B, C;
int main() {
calc_inv();
cin >> N >> A >> B >> C;
ll ans_bunshi = 0;
//分母はこの場合だと、100^(2N-1)でいく。
// 100/100-C
// CとA,Bの試行は独立なので、独立な期待値の積となる。よってかけちゃっていい。
//これは最後にかける
ll apb = A + B;
for (int i = N; i <= 2 * N - 1; i++) {
// i回目は
// comb(i - 1, N - 1) * ((A/100)^N * (B/100)^(i - N) + (A/100)^(i - N) *
// (B/100)^N) * i
ll tmp = ((comb(i - 1, N - 1) *
((modpow(A, N) * modpow(B, i - N) % MOD) +
(modpow(A, i - N) * modpow(B, N) % MOD)) %
MOD) *
modpow(apb, 2 * N - 1 - i) % MOD);
tmp *= i, tmp %= MOD;
ans_bunshi += tmp;
ans_bunshi %= MOD;
}
//ここでCによる期待値補正をかける。
ans_bunshi *= 100, ans_bunshi %= MOD;
//分母は100^(2N-1)*(100-C)である。
cout << (modpow(((modpow(apb, 2 * N - 1) * (100 - C)) % MOD), MOD - 2) *
ans_bunshi) %
MOD
<< endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"control_flow.loop.for.initializer.change"
] | 836,373 | 836,372 | u107077805 | cpp |
p03025 | #include <stdio.h>
#include <stdlib.h>
#define MAX_N (100000L)
#define MAX_FACT (MAX_N)
#define NUM_MOD (1000000007L)
long fs[MAX_FACT + 1], finvs[MAX_FACT + 1], invs[MAX_FACT + 1];
void combination_init() {
fs[0] = fs[1] = 1;
finvs[0] = finvs[1] = 1;
invs[1] = 1;
for (long i = 2; i <= MAX_FACT; i++) {
fs[i] = fs[i - 1] * i % NUM_MOD;
invs[i] = NUM_MOD - invs[NUM_MOD % i] * (NUM_MOD / i) % NUM_MOD;
finvs[i] = finvs[i - 1] * invs[i] % NUM_MOD;
}
}
long combination(long n, long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fs[n] * (finvs[k] * finvs[n - k] % NUM_MOD) % NUM_MOD;
}
long mod(long n, long k) { return n % k >= 0 ? n % k : n % k + k; }
long pow_mod(long x, long k, long mod) {
long ret = 1, p = x;
while (k > 0) {
if (k & 1) {
ret = (ret * p) % mod;
}
p = (p * p) % mod;
k /= 2;
}
return ret;
}
int main(int argc, char *argv[]) {
// read inputs
long N, A, B, C;
scanf("%ld %ld %ld %ld", &N, &A, &B, &C);
// solve
long ans = 0;
combination_init();
// part1
long x1 = 0;
for (long k = 0; k <= N - 1; k++) {
x1 = mod(mod(mod(pow_mod(mod(A * invs[A + B], NUM_MOD), N, NUM_MOD) *
pow_mod(mod(B * invs[A + B], NUM_MOD), k, NUM_MOD),
NUM_MOD) *
combination(N + k, k),
NUM_MOD) +
x1,
NUM_MOD);
}
x1 = mod(N * x1, NUM_MOD);
// part2
long x2 = 0;
for (long k = 0; k <= N - 1; k++) {
x2 = mod(mod(mod(pow_mod(mod(A * invs[A + B], NUM_MOD), k, NUM_MOD) *
pow_mod(mod(B * invs[A + B], NUM_MOD), N, NUM_MOD),
NUM_MOD) *
combination(N + k, k),
NUM_MOD) +
x2,
NUM_MOD);
}
x2 = mod(N * x2, NUM_MOD);
printf("%ld\n",
mod(mod(mod(x1 + x2, NUM_MOD) * 100, NUM_MOD) * invs[A + B], NUM_MOD));
return 0;
}
| #include <stdio.h>
#include <stdlib.h>
#define MAX_N (300000L)
#define MAX_FACT (MAX_N)
#define NUM_MOD (1000000007L)
long fs[MAX_FACT + 1], finvs[MAX_FACT + 1], invs[MAX_FACT + 1];
void combination_init() {
fs[0] = fs[1] = 1;
finvs[0] = finvs[1] = 1;
invs[1] = 1;
for (long i = 2; i <= MAX_FACT; i++) {
fs[i] = fs[i - 1] * i % NUM_MOD;
invs[i] = NUM_MOD - invs[NUM_MOD % i] * (NUM_MOD / i) % NUM_MOD;
finvs[i] = finvs[i - 1] * invs[i] % NUM_MOD;
}
}
long combination(long n, long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fs[n] * (finvs[k] * finvs[n - k] % NUM_MOD) % NUM_MOD;
}
long mod(long n, long k) { return n % k >= 0 ? n % k : n % k + k; }
long pow_mod(long x, long k, long mod) {
long ret = 1, p = x;
while (k > 0) {
if (k & 1) {
ret = (ret * p) % mod;
}
p = (p * p) % mod;
k /= 2;
}
return ret;
}
int main(int argc, char *argv[]) {
// read inputs
long N, A, B, C;
scanf("%ld %ld %ld %ld", &N, &A, &B, &C);
// solve
long ans = 0;
combination_init();
// part1
long x1 = 0;
for (long k = 0; k <= N - 1; k++) {
x1 = mod(mod(mod(pow_mod(mod(A * invs[A + B], NUM_MOD), N, NUM_MOD) *
pow_mod(mod(B * invs[A + B], NUM_MOD), k, NUM_MOD),
NUM_MOD) *
combination(N + k, k),
NUM_MOD) +
x1,
NUM_MOD);
}
x1 = mod(N * x1, NUM_MOD);
// part2
long x2 = 0;
for (long k = 0; k <= N - 1; k++) {
x2 = mod(mod(mod(pow_mod(mod(A * invs[A + B], NUM_MOD), k, NUM_MOD) *
pow_mod(mod(B * invs[A + B], NUM_MOD), N, NUM_MOD),
NUM_MOD) *
combination(N + k, k),
NUM_MOD) +
x2,
NUM_MOD);
}
x2 = mod(N * x2, NUM_MOD);
printf("%ld\n",
mod(mod(mod(x1 + x2, NUM_MOD) * 100, NUM_MOD) * invs[A + B], NUM_MOD));
return 0;
}
| [
"preprocessor.define.value.change",
"literal.integer.change"
] | 836,380 | 836,381 | u359413838 | cpp |
p03017 | // A - Kenken Race
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--, b--, c--, d--;
string s;
cin >> s;
bool ans = true;
if (c > d) {
ans = false;
for (int i = a; i < d; i++)
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
ans = true;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
} else {
for (int i = b; i < d - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| // A - Kenken Race
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--, b--, c--, d--;
string s;
cin >> s;
bool ans = true;
if (c > d) {
ans = false;
for (int i = b - 1; i < d; i++)
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
ans = true;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
} else {
for (int i = b; i < d - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 836,431 | 836,432 | u839953699 | cpp |
p03017 | // A - Kenken Race
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--, b--, c--, d--;
string s;
cin >> s;
bool ans = true;
if (c > d) {
ans = false;
for (int i = a; i < d - 1; i++)
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
ans = true;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
} else {
for (int i = b; i < d - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| // A - Kenken Race
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--, b--, c--, d--;
string s;
cin >> s;
bool ans = true;
if (c > d) {
ans = false;
for (int i = b - 1; i < d; i++)
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
ans = true;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
} else {
for (int i = b; i < d - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
for (int i = a; i < c - 1; i++)
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 836,433 | 836,432 | u839953699 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
string s;
int n, a, b, c, d;
bool check1() {
FOR(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#')
return false;
}
return true;
}
bool check2() {
if (c < d)
return true;
else if (c == d)
return false;
else {
FOR(i, b, min(d, n - 2)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
bool ans = true;
ans &= check1();
ans &= check2();
Yes(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
string s;
int n, a, b, c, d;
bool check1() {
FOR(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#')
return false;
}
return true;
}
bool check2() {
if (c < d)
return true;
else if (c == d)
return false;
else {
FOR(i, b - 1, min(d, n - 2)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
bool ans = true;
ans &= check1();
ans &= check2();
Yes(ans);
return 0;
}
| [
"expression.operation.binary.add"
] | 836,434 | 836,435 | u007637377 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
string s;
int n, a, b, c, d;
bool check1() {
FOR(i, min(a, b), max(c, d) - 1) {
if (s[i] == '#' && s[i + 1] == '#')
return false;
}
return true;
}
bool check2() {
if (c < d)
return true;
else if (c == d)
return false;
else {
FOR(i, b, min(d, n - 2)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
bool ans = true;
ans &= check1();
ans &= check2();
Yes(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
string s;
int n, a, b, c, d;
bool check1() {
FOR(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#')
return false;
}
return true;
}
bool check2() {
if (c < d)
return true;
else if (c == d)
return false;
else {
FOR(i, b - 1, min(d, n - 2)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
bool ans = true;
ans &= check1();
ans &= check2();
Yes(ans);
return 0;
}
| [
"expression.operation.binary.remove"
] | 836,436 | 836,435 | u007637377 | cpp |
p03017 | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i <= C; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i <= D + 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,459 | 836,460 | u134857688 | cpp |
p03017 | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i <= D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i <= D + 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,461 | 836,460 | u134857688 | cpp |
p03017 | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i < end - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i < D - 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i <= D + 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 836,462 | 836,460 | u134857688 | cpp |
p03017 | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i < end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i < D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int N, A, B, C, D;
string S;
bool canReach(int begin, int end) {
for (int i = begin + 1; i <= end; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
}
int main() {
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S = "#" + S + "#";
if (canReach(A, C) == false || canReach(B, D) == false) {
cout << "No" << endl;
return 0;
}
if (C > D) {
for (int i = B + 1; i <= D + 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 836,463 | 836,460 | u134857688 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define mod 1000000007
#define inf 1000000000000000007
#define eps 0.00000001
#define pi 3.141592653589793
#define pii pair<int, int>
#define pdd pair<ld, ld>
#define pll pair<ll, ll>
#define ff first
#define ss second
#define vii vector<int>
#define vpl vector<pll>
#define vll vector<ll>
#define sti stack<int>
#define stll stack<ll>
#define mseti multiset<ll>
#define msetd multiset<ll, greater<ll>>
#define mp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define stp setprecision(20) // use fixed before stp
#define endl '\n'
int main() {
FAST ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
s = " " + s;
n++;
ll f1 = 1, f2 = 1;
for (ll i = b + 1; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#')
f1 = 0;
}
for (ll i = a + 1; i < c; i++) {
if (s[i] == '#' && s[i - 1] == '#')
f1 = 0;
}
if (c > d) {
f2 = 0;
for (ll i = b; i <= (c - 2); i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
f2 = 1;
}
}
if (f1 && f2)
cout << "Yes";
else
cout << "No";
} | #include <bits/stdc++.h>
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define mod 1000000007
#define inf 1000000000000000007
#define eps 0.00000001
#define pi 3.141592653589793
#define pii pair<int, int>
#define pdd pair<ld, ld>
#define pll pair<ll, ll>
#define ff first
#define ss second
#define vii vector<int>
#define vpl vector<pll>
#define vll vector<ll>
#define sti stack<int>
#define stll stack<ll>
#define mseti multiset<ll>
#define msetd multiset<ll, greater<ll>>
#define mp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define stp setprecision(20) // use fixed before stp
#define endl '\n'
int main() {
FAST ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
s = " " + s;
n++;
ll f1 = 1, f2 = 1;
for (ll i = b + 1; i < d; i++) {
if (s[i] == '#' && s[i - 1] == '#')
f1 = 0;
}
for (ll i = a + 1; i < c; i++) {
if (s[i] == '#' && s[i - 1] == '#')
f1 = 0;
}
if (c > d) {
f2 = 0;
for (ll i = b - 1; i <= (d - 1); i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
f2 = 1;
}
}
if (f1 && f2)
cout << "Yes";
else
cout << "No";
} | [
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 836,465 | 836,466 | u002419600 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else {
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else {
for (int i = b - 1; i <= d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 836,467 | 836,468 | u543657872 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else {
for (int i = b; i < d - 2; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else {
for (int i = b - 1; i <= d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 836,469 | 836,468 | u543657872 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else {
for (int i = a; i < c - 2; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else {
for (int i = b - 1; i <= d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 836,470 | 836,468 | u543657872 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int INF = 1e9 + 101;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define reps(i, j, k) for (ll i = (j); i < (k); ++i)
#define rep(i, j) reps(i, 0, j)
#define all(a) (a).begin(), (a).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> Pii;
typedef pair<Pii, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
rep(i, v.size()) { out << v[i] << ", "; }
return out << "}" << endl;
}
void Yes(bool f) { puts(f ? "Yes" : "No"); }
bool solve() {
int N;
int A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string str;
cin >> str;
reps(i, A, max(D, C) - 1) {
if (str[i] == '#' && str[i + 1] == '#') {
return false;
}
}
if (D < C) {
reps(i, B - 1, D - 2) {
if (str[i] == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
return true;
}
}
return false;
}
return true;
}
int main() {
Yes(solve());
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int INF = 1e9 + 101;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define reps(i, j, k) for (ll i = (j); i < (k); ++i)
#define rep(i, j) reps(i, 0, j)
#define all(a) (a).begin(), (a).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> Pii;
typedef pair<Pii, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
rep(i, v.size()) { out << v[i] << ", "; }
return out << "}" << endl;
}
void Yes(bool f) { puts(f ? "Yes" : "No"); }
bool solve() {
int N;
int A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string str;
cin >> str;
reps(i, A, max(D, C)) {
if (str[i] == '#' && str[i + 1] == '#') {
return false;
}
}
if (D < C) {
reps(i, B - 1, D) {
if (str[i] == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
return true;
}
}
return false;
}
return true;
}
int main() {
Yes(solve());
return 0;
} | [
"expression.operation.binary.remove"
] | 836,476 | 836,477 | u406423757 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int INF = 1e9 + 101;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define reps(i, j, k) for (ll i = (j); i < (k); ++i)
#define rep(i, j) reps(i, 0, j)
#define all(a) (a).begin(), (a).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> Pii;
typedef pair<Pii, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
rep(i, v.size()) { out << v[i] << ", "; }
return out << "}" << endl;
}
void Yes(bool f) { puts(f ? "Yes" : "No"); }
bool solve() {
int N;
int A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string str;
cin >> str;
reps(i, A, max(D, C)) {
if (str[i] == '#' && str[i + 1] == '#') {
return false;
}
}
if (D < C) {
reps(i, B - 1, D - 2) {
if (str[i] == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
return true;
}
}
return false;
}
return true;
}
int main() {
Yes(solve());
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int INF = 1e9 + 101;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define reps(i, j, k) for (ll i = (j); i < (k); ++i)
#define rep(i, j) reps(i, 0, j)
#define all(a) (a).begin(), (a).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> Pii;
typedef pair<Pii, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
rep(i, v.size()) { out << v[i] << ", "; }
return out << "}" << endl;
}
void Yes(bool f) { puts(f ? "Yes" : "No"); }
bool solve() {
int N;
int A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string str;
cin >> str;
reps(i, A, max(D, C)) {
if (str[i] == '#' && str[i + 1] == '#') {
return false;
}
}
if (D < C) {
reps(i, B - 1, D) {
if (str[i] == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
return true;
}
}
return false;
}
return true;
}
int main() {
Yes(solve());
return 0;
} | [
"expression.operation.binary.remove"
] | 836,478 | 836,477 | u406423757 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int INF = 1e9 + 101;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define reps(i, j, k) for (ll i = (j); i < (k); ++i)
#define rep(i, j) reps(i, 0, j)
#define all(a) (a).begin(), (a).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> Pii;
typedef pair<Pii, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
rep(i, v.size()) { out << v[i] << ", "; }
return out << "}" << endl;
}
void Yes(bool f) { puts(f ? "Yes" : "No"); }
bool solve() {
int N;
int A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string str;
cin >> str;
reps(i, A, max(D, C)) {
if (str[i] == '#' && str[i + 1] == '#') {
return false;
}
}
if (D < C) {
reps(i, B - 1, C - 2) {
if (str[i] == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
return true;
}
}
return false;
}
return true;
}
int main() {
Yes(solve());
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int INF = 1e9 + 101;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define reps(i, j, k) for (ll i = (j); i < (k); ++i)
#define rep(i, j) reps(i, 0, j)
#define all(a) (a).begin(), (a).end()
#define MOD 1000000007
typedef long long ll;
typedef pair<ll, ll> Pii;
typedef pair<Pii, int> P;
typedef vector<int> vi;
typedef vector<ll> vll;
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
rep(i, v.size()) { out << v[i] << ", "; }
return out << "}" << endl;
}
void Yes(bool f) { puts(f ? "Yes" : "No"); }
bool solve() {
int N;
int A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string str;
cin >> str;
reps(i, A, max(D, C)) {
if (str[i] == '#' && str[i + 1] == '#') {
return false;
}
}
if (D < C) {
reps(i, B - 1, D) {
if (str[i] == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
return true;
}
}
return false;
}
return true;
}
int main() {
Yes(solve());
return 0;
} | [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 836,479 | 836,477 | u406423757 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unistd.h>
#include <vector>
#define ALL(a) (a).begin(), (a).end()
const long long MOD = 1000003;
//いろんなstlの使い方 https://qiita.com/tukejonny/items/f4013547df761a0b3523
// http://y-mazun.hatenablog.com/entry/20111202/1322840281
using namespace std;
struct point {
int x;
int y;
};
long long gcd(long long a, long long b) {
if (a > b) {
return gcd(b, a);
}
return a == 0 ? b : gcd(b % a, a);
}
int lcm(int m, int n) {
// 引数に０がある場合は０を返す
if ((0 == m) || (0 == n))
return 0;
return ((m / gcd(m, n)) * n); // lcm = m * n / gcd(m,n)
} // lcm
int input() {
int x;
cin >> x;
return x;
}
int moji(char in) {
int ans = (int)in - (int)'a';
if ((ans < 0) || (ans > 25)) {
ans = 26;
}
return ans;
}
const int VV = 1; //場合に応じてVVの値のみ変更する必要あり
// dijkstra(s)sがスタート地点でそこからの最短距離を配列dで表す。正の重みのみ使用可能
int cost[VV][VV];
int d[VV];
bool used[VV];
void dijkstra(int s) {
fill(d, d + VV, 100000);
fill(used, used + VV, false);
d[s] = 0;
while (true) {
cout << "Hello" << endl;
int v = -1;
for (int u = 0; u < VV; u++) {
if (!used[u] && (v == -1 || d[u] < d[v]))
v = u;
}
if (v == -1)
break;
used[v] = true;
for (int u = 0; u < VV; u++) {
d[u] = min(d[u], d[v] + cost[v][u]);
}
}
}
int compare_int(const void *a, const void *b) // qsort(quick sort利用時に使用)
{
return *(int *)a - *(int *)b;
}
int binary_searchh(long long x, long long k[], int n) {
int l = 0;
int r = n;
while (r - l >= 1) {
int i = (l + r) / 2;
if (k[i] == x)
return i;
else if (k[i] < x)
l = i + 1;
else
r = i;
}
return -1;
}
struct File {
int aa;
int bb;
File(const int &aa, const int &bb) : aa(aa), bb(bb) {}
};
/*bool operator<(const File& a, const File& b)
{
// ファイル種別、ファイル名の順番で優先順位を付けて比較
return std::tie(a.aa, a.bb) < std::tie(b.aa, b.bb);
}*/
long long kaijo(long long x) {
long long l = 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7;
long long sum = 1;
for (int i = x; i > 0; i--) {
sum *= i;
if (sum > l) {
sum %= l;
}
}
return sum;
}
template <class T> void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
// formerは前方のindex(自分自身を含んで良い)
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
// latterは後方のindex(自分自身を含んで良い)
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
struct UnionFind {
// par[i]データiの属する木の親の番号。i==par[i]のときデータiは木の根ノードである
vector<int> par;
// sizes[i]:根ノードiの木に含まれるデータ数、iが根ノードでないときは無意味な値になる
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
//最初は全てのデータiがグループiに存在するものとして初期化
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
//データxが属する木の根を得る
int find(int x) {
if (x == par[x]) {
return x;
}
return par[x] = find(par[x]);
}
// 2つのデータx,yが属する木をマージする
void unite(int x, int y) {
//データの根ノードを得る
x = find(x);
y = find(y);
//もしすでに同じ木に属しているならマージの必要はない
if (x == y) {
return;
}
// xの木がyの木よりも大きくなるようにする
if (sizes[x] < sizes[y]) {
swap(x, y);
}
// xがyの親になるように連結する
par[y] = x;
sizes[x] += sizes[y];
}
// 2つのデータx,yが属する木が同じならtrueを返す
bool same(int x, int y) { return find(x) == find(y); }
//データxが含まれる木の大きさを返す
int size(int x) { return sizes[find(x)]; }
};
//クラスカル法
//頂点a,bをつなぐコストcostの（無向）辺
struct Edge {
int a, b, cost;
//コストの大小で順序定義
bool operator<(const Edge &o) const { return cost < o.cost; }
};
//頂点数と辺集合の組として定義したグラフ
struct Graph {
int n; //頂点数
vector<Edge> es; //辺集合
//クラスカル法で無向最小全域木のコストの和を計算する
//グラフが非連結の時は最小全域森のコストの和になる
//使い方http://dai1741.github.io/maximum-algo-2012/docs/minimum-spanning-tree/
int kruskal() {
//コストが小さい順にソーと
sort(es.begin(), es.end());
UnionFind uf(n);
int min_cost = 0;
for (int ei = 0; ei < es.size(); ei++) {
Edge &e = es[ei];
if (!uf.same(e.a, e.b)) {
//その辺によって2つの木が連結される
min_cost += e.cost;
uf.unite(e.a, e.b);
}
}
return min_cost;
}
};
//標準入力からグラフを読み込む
Graph input_graph() {
Graph g;
int m;
cin >> g.n >> m;
for (int i = 0; i < m; i++) {
Edge e;
cin >> e.a >> e.b >> e.cost;
g.es.push_back(e);
}
return g;
}
long long labs(long long x) {
if (x < 0) {
return -x;
}
return x;
}
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// indexを用いてvectorから要素削除
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool ok = true;
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
ok = false;
}
}
bool sonzai = false;
for (int i = B - 1; i < D - 1; i++) {
if (i + 2 < N) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
sonzai = true;
}
}
}
if (ok && C < D) {
cout << "Yes" << endl;
} else if (ok && sonzai) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <algorithm>
#include <array>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unistd.h>
#include <vector>
#define ALL(a) (a).begin(), (a).end()
const long long MOD = 1000003;
//いろんなstlの使い方 https://qiita.com/tukejonny/items/f4013547df761a0b3523
// http://y-mazun.hatenablog.com/entry/20111202/1322840281
using namespace std;
struct point {
int x;
int y;
};
long long gcd(long long a, long long b) {
if (a > b) {
return gcd(b, a);
}
return a == 0 ? b : gcd(b % a, a);
}
int lcm(int m, int n) {
// 引数に０がある場合は０を返す
if ((0 == m) || (0 == n))
return 0;
return ((m / gcd(m, n)) * n); // lcm = m * n / gcd(m,n)
} // lcm
int input() {
int x;
cin >> x;
return x;
}
int moji(char in) {
int ans = (int)in - (int)'a';
if ((ans < 0) || (ans > 25)) {
ans = 26;
}
return ans;
}
const int VV = 1; //場合に応じてVVの値のみ変更する必要あり
// dijkstra(s)sがスタート地点でそこからの最短距離を配列dで表す。正の重みのみ使用可能
int cost[VV][VV];
int d[VV];
bool used[VV];
void dijkstra(int s) {
fill(d, d + VV, 100000);
fill(used, used + VV, false);
d[s] = 0;
while (true) {
cout << "Hello" << endl;
int v = -1;
for (int u = 0; u < VV; u++) {
if (!used[u] && (v == -1 || d[u] < d[v]))
v = u;
}
if (v == -1)
break;
used[v] = true;
for (int u = 0; u < VV; u++) {
d[u] = min(d[u], d[v] + cost[v][u]);
}
}
}
int compare_int(const void *a, const void *b) // qsort(quick sort利用時に使用)
{
return *(int *)a - *(int *)b;
}
int binary_searchh(long long x, long long k[], int n) {
int l = 0;
int r = n;
while (r - l >= 1) {
int i = (l + r) / 2;
if (k[i] == x)
return i;
else if (k[i] < x)
l = i + 1;
else
r = i;
}
return -1;
}
struct File {
int aa;
int bb;
File(const int &aa, const int &bb) : aa(aa), bb(bb) {}
};
/*bool operator<(const File& a, const File& b)
{
// ファイル種別、ファイル名の順番で優先順位を付けて比較
return std::tie(a.aa, a.bb) < std::tie(b.aa, b.bb);
}*/
long long kaijo(long long x) {
long long l = 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7;
long long sum = 1;
for (int i = x; i > 0; i--) {
sum *= i;
if (sum > l) {
sum %= l;
}
}
return sum;
}
template <class T> void chmin(T &a, T b) {
if (a > b) {
a = b;
}
}
// formerは前方のindex(自分自身を含んで良い)
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
// latterは後方のindex(自分自身を含んで良い)
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
struct UnionFind {
// par[i]データiの属する木の親の番号。i==par[i]のときデータiは木の根ノードである
vector<int> par;
// sizes[i]:根ノードiの木に含まれるデータ数、iが根ノードでないときは無意味な値になる
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
//最初は全てのデータiがグループiに存在するものとして初期化
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
//データxが属する木の根を得る
int find(int x) {
if (x == par[x]) {
return x;
}
return par[x] = find(par[x]);
}
// 2つのデータx,yが属する木をマージする
void unite(int x, int y) {
//データの根ノードを得る
x = find(x);
y = find(y);
//もしすでに同じ木に属しているならマージの必要はない
if (x == y) {
return;
}
// xの木がyの木よりも大きくなるようにする
if (sizes[x] < sizes[y]) {
swap(x, y);
}
// xがyの親になるように連結する
par[y] = x;
sizes[x] += sizes[y];
}
// 2つのデータx,yが属する木が同じならtrueを返す
bool same(int x, int y) { return find(x) == find(y); }
//データxが含まれる木の大きさを返す
int size(int x) { return sizes[find(x)]; }
};
//クラスカル法
//頂点a,bをつなぐコストcostの（無向）辺
struct Edge {
int a, b, cost;
//コストの大小で順序定義
bool operator<(const Edge &o) const { return cost < o.cost; }
};
//頂点数と辺集合の組として定義したグラフ
struct Graph {
int n; //頂点数
vector<Edge> es; //辺集合
//クラスカル法で無向最小全域木のコストの和を計算する
//グラフが非連結の時は最小全域森のコストの和になる
//使い方http://dai1741.github.io/maximum-algo-2012/docs/minimum-spanning-tree/
int kruskal() {
//コストが小さい順にソーと
sort(es.begin(), es.end());
UnionFind uf(n);
int min_cost = 0;
for (int ei = 0; ei < es.size(); ei++) {
Edge &e = es[ei];
if (!uf.same(e.a, e.b)) {
//その辺によって2つの木が連結される
min_cost += e.cost;
uf.unite(e.a, e.b);
}
}
return min_cost;
}
};
//標準入力からグラフを読み込む
Graph input_graph() {
Graph g;
int m;
cin >> g.n >> m;
for (int i = 0; i < m; i++) {
Edge e;
cin >> e.a >> e.b >> e.cost;
g.es.push_back(e);
}
return g;
}
long long labs(long long x) {
if (x < 0) {
return -x;
}
return x;
}
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// indexを用いてvectorから要素削除
template <typename T> void remove(std::vector<T> &vector, unsigned int index) {
vector.erase(vector.begin() + index);
}
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool ok = true;
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
ok = false;
}
}
bool sonzai = false;
for (int i = B - 2; i < D - 1; i++) {
if (i + 2 < N && i >= 0) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
sonzai = true;
}
}
}
if (ok && C < D) {
cout << "Yes" << endl;
} else if (ok && sonzai) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 836,495 | 836,496 | u334656323 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
if (c < d) {
bool ans = true;
int cnt = 0;
for (int i = b; i <= d; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
cnt = 0;
for (int i = a; i <= c; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
if (ans) {
cout << "Yes\n";
} else {
cout << "No\n";
}
} else {
bool ans = true;
int cnt = 0;
for (int i = b; i <= d; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
cnt = 0;
for (int i = a; i <= c; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
bool flag = false;
int blank = 0;
for (int i = b; i <= d; i++) {
if (s[i] == '.') {
blank++;
if (blank >= 3) {
flag = true;
}
} else {
blank = 0;
}
}
if (!flag)
ans = false;
if (ans) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
if (c < d) {
bool ans = true;
int cnt = 0;
for (int i = b; i <= d; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
cnt = 0;
for (int i = a; i <= c; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
if (ans) {
cout << "Yes\n";
} else {
cout << "No\n";
}
} else {
bool ans = true;
int cnt = 0;
for (int i = b; i <= d; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
cnt = 0;
for (int i = a; i <= c; i++) {
if (s[i] == '#') {
cnt++;
if (cnt >= 2) {
ans = false;
}
} else {
cnt = 0;
}
}
bool flag = false;
int blank = 0;
for (int i = b - 1; i <= d + 1; i++) {
if (s[i] == '.') {
blank++;
if (blank >= 3) {
flag = true;
}
} else {
blank = 0;
}
}
if (!flag)
ans = false;
if (ans) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
} | [
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,497 | 836,498 | u334624175 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define MAXN 10000010
char s[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, c, d, n, i, j, k = 0;
cin >> n >> a >> b >> c >> d;
for (i = 1; i <= n; i++)
cin >> s[i];
for (i = a + 1; i < c; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b + 1; i < d; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b - 1; i < d - 1; i++)
if ((s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') && i - 1 != d)
k = 1;
if (d > c)
k = 1;
if (k == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define MAXN 10000010
char s[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, c, d, n, i, j, k = 0;
cin >> n >> a >> b >> c >> d;
for (i = 1; i <= n; i++)
cin >> s[i];
for (i = a + 1; i < c; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b + 1; i < d; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b - 1; i < d; i++)
if ((s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') && i - 1 != d)
k = 1;
if (d > c)
k = 1;
if (k == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 836,503 | 836,504 | u100434304 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define MAXN 10000010
char s[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, c, d, n, i, j, k = 0;
cin >> n >> a >> b >> c >> d;
for (i = 1; i <= n; i++)
cin >> s[i];
for (i = a + 1; i < c; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b + 1; i < d; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b - 1; i < c - 1; i++)
if ((s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') && i - 1 != d)
k = 1;
if (d > c)
k = 1;
if (k == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define MAXN 10000010
char s[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, c, d, n, i, j, k = 0;
cin >> n >> a >> b >> c >> d;
for (i = 1; i <= n; i++)
cin >> s[i];
for (i = a + 1; i < c; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b + 1; i < d; i++)
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
for (i = b - 1; i < d; i++)
if ((s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') && i - 1 != d)
k = 1;
if (d > c)
k = 1;
if (k == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 836,505 | 836,504 | u100434304 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
using ll = long long;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
auto can_reach = [&](int s, int e) {
for (int i = s; i + 1 <= e; ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
return true;
}
};
if (!can_reach(A, C) || !can_reach(B, D)) {
cout << "No" << endl;
return 0;
}
if (C > D) {
bool snuke_can_over = false;
for (int i = B; i <= D; ++i) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.')
snuke_can_over = true;
}
if (!snuke_can_over) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
using ll = long long;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
auto can_reach = [&](int s, int e) {
for (int i = s; i + 1 <= e; ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
return false;
}
}
return true;
};
if (!can_reach(A, C) || !can_reach(B, D)) {
cout << "No" << endl;
return 0;
}
if (C > D) {
bool snuke_can_over = false;
for (int i = B; i <= D; ++i) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.')
snuke_can_over = true;
}
if (!snuke_can_over) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | [] | 836,514 | 836,515 | u318727472 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const ll MOD = (ll)(1e9 + 7);
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbg2(x_) \
for (auto a_ : x_) \
cerr << a_ << " "; \
cerr << endl;
#define dbg3(x_, sx_) \
rep(i, sx_) cerr << x_[i] << " "; \
cerr << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
//------------------------------------------------------
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--, b--, c--, d--;
bool can = true;
REP(i, a, c) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
REP(i, b, d) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
if (c > d) {
bool space = false;
for (int i = b; i <= min(d - 1, n - 3); ++i) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
space = true;
}
if (!space)
can = false;
}
Yes(can);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const ll MOD = (ll)(1e9 + 7);
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbg2(x_) \
for (auto a_ : x_) \
cerr << a_ << " "; \
cerr << endl;
#define dbg3(x_, sx_) \
rep(i, sx_) cerr << x_[i] << " "; \
cerr << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
//------------------------------------------------------
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--, b--, c--, d--;
bool can = true;
REP(i, a, c) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
REP(i, b, d) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
if (c > d) {
bool space = false;
for (int i = b - 1; i <= min(d - 1, n - 3); ++i) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
space = true;
}
if (!space)
can = false;
}
Yes(can);
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 836,528 | 836,529 | u878615689 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const ll MOD = (ll)(1e9 + 7);
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbg2(x_) \
for (auto a_ : x_) \
cerr << a_ << " "; \
cerr << endl;
#define dbg3(x_, sx_) \
rep(i, sx_) cerr << x_[i] << " "; \
cerr << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
//------------------------------------------------------
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--, b--, c--, d--;
bool can = true;
REP(i, a, c) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
REP(i, b, d) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
if (c > d) {
bool space = false;
for (int i = b; i <= min(d - 1, n - 2); ++i) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
space = true;
}
if (!space)
can = false;
}
Yes(can);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const ll MOD = (ll)(1e9 + 7);
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbg2(x_) \
for (auto a_ : x_) \
cerr << a_ << " "; \
cerr << endl;
#define dbg3(x_, sx_) \
rep(i, sx_) cerr << x_[i] << " "; \
cerr << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
//------------------------------------------------------
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--, b--, c--, d--;
bool can = true;
REP(i, a, c) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
REP(i, b, d) {
if (s[i] == '#' && s[i + 1] == '#')
can = false;
}
if (c > d) {
bool space = false;
for (int i = b - 1; i <= min(d - 1, n - 3); ++i) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
space = true;
}
if (!space)
can = false;
}
Yes(can);
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 836,530 | 836,529 | u878615689 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (c > d) {
for (int i = b + 2; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (ans == "No") {
for (int i = b + 1; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 836,531 | 836,532 | u652662440 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (ans == "No") {
for (int i = b + 2; i <= c; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (ans == "No") {
for (int i = b + 1; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 836,533 | 836,532 | u652662440 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (ans == "No") {
for (int i = b + 2; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (ans == "No") {
for (int i = b + 1; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 836,534 | 836,532 | u652662440 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (c > d) {
for (int i = b + 2; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (c > d) {
for (int i = b + 1; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 836,531 | 836,535 | u652662440 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (ans == "No") {
for (int i = b + 2; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
string ans = "Yes";
a--;
b--;
c--;
d--;
for (int i = b + 2; i <= d; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '#';
for (int i = a + 2; i <= c; i++) {
if (s[i] == s[i - 1] && s[i] == '#')
ans = "No";
}
s[d] = '.';
if (c > d) {
for (int i = b + 1; i <= d; i++) {
if (s[i - 2] == '.' && s[i - 1] == '.' && s[i] == '.')
ans = "Yes";
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 836,534 | 836,535 | u652662440 | cpp |
p03017 | #include <bits/stdc++.h>
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define mod 1000000007
using namespace std;
int main() {
IOS;
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
for (int y = a; y < c; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
for (int y = b; y < d; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
if (c > d) {
for (int y = b; y < d; y++) {
if (s[y + 2] == '.' && s[y + 1] == '.' && s[y] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
cout << "Yes\n";
return 0;
}
| #include <bits/stdc++.h>
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define mod 1000000007
using namespace std;
int main() {
IOS;
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
for (int y = a; y < c; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
for (int y = b; y < d; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
if (c > d) {
for (int y = b; y <= d; y++) {
if (s[y - 1] == '.' && s[y + 1] == '.' && s[y] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
cout << "Yes\n";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 836,536 | 836,537 | u470437951 | cpp |
p03017 | #include <bits/stdc++.h>
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define mod 1000000007
using namespace std;
int main() {
IOS;
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
for (int y = a; y < c; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
for (int y = b; y < d; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
if (c > d) {
for (int y = b; y < d; y++) {
if (s[y] == '.' && s[y + 1] == '.' && s[y + 2] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
cout << "Yes\n";
return 0;
}
| #include <bits/stdc++.h>
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define mod 1000000007
using namespace std;
int main() {
IOS;
int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
for (int y = a; y < c; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
for (int y = b; y < d; y++) {
if (s[y] == '#' && s[y + 1] == '#') {
cout << "No\n";
return 0;
}
}
if (c > d) {
for (int y = b; y <= d; y++) {
if (s[y - 1] == '.' && s[y + 1] == '.' && s[y] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
cout << "Yes\n";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operation.binary.remove"
] | 836,538 | 836,537 | u470437951 | cpp |
p03017 | #include <algorithm>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ass 1e18
#define MOD 1000000007
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define debug(x) cout << #x << ": " << x << endl;
#define debug2(x, y) cout << #x << ": " << x << ", " << #y << ": " << y << endl;
#define debug3(x, y, z) \
cout << #x << ": " << x << ", " << #y << ": " << y << " " << #z << " : " \
<< z << endl;
using namespace std;
typedef long long int ll;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
ll arr[200005];
string str;
int main() {
ll n, a, b, c, d, i, flag = -1, inde = -1, cnt = 0;
cin >> n >> a >> b >> c >> d;
cin >> str;
for (i = a - 1; i < max(c, d); i++) {
if (str[i] == '#' && str[i + 1] == '#') {
flag = i;
break;
}
}
if (flag != -1) {
cout << "No";
return 0;
}
for (i = b - 1; i <= d - 1; i++) {
if (str[i - 1] == '.' && str[i] == '.' && str[i] == '.') {
inde = i;
break;
}
}
if (c > d) {
if (inde != -1)
cout << "Yes";
else
cout << "No";
} else
cout << "Yes";
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ass 1e18
#define MOD 1000000007
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define debug(x) cout << #x << ": " << x << endl;
#define debug2(x, y) cout << #x << ": " << x << ", " << #y << ": " << y << endl;
#define debug3(x, y, z) \
cout << #x << ": " << x << ", " << #y << ": " << y << " " << #z << " : " \
<< z << endl;
using namespace std;
typedef long long int ll;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
ll arr[200005];
string str;
int main() {
ll n, a, b, c, d, i, flag = -1, inde = -1, cnt = 0;
cin >> n >> a >> b >> c >> d;
cin >> str;
for (i = a - 1; i < max(c, d); i++) {
if (str[i] == '#' && str[i + 1] == '#') {
flag = i;
break;
}
}
if (flag != -1) {
cout << "No";
return 0;
}
for (i = b - 1; i <= d - 1; i++) {
if (str[i - 1] == '.' && str[i] == '.' && str[i + 1] == '.') {
inde = i;
break;
}
}
if (c > d) {
if (inde != -1)
cout << "Yes";
else
cout << "No";
} else
cout << "Yes";
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,543 | 836,544 | u902456829 | cpp |
p03017 | #include <algorithm>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ass 1e18
#define MOD 1000000007
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define debug(x) cout << #x << ": " << x << endl;
#define debug2(x, y) cout << #x << ": " << x << ", " << #y << ": " << y << endl;
#define debug3(x, y, z) \
cout << #x << ": " << x << ", " << #y << ": " << y << " " << #z << " : " \
<< z << endl;
using namespace std;
typedef long long int ll;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
ll arr[200005];
string str;
int main() {
ll n, a, b, c, d, i, flag = -1, inde = -1, cnt = 0;
cin >> n >> a >> b >> c >> d;
cin >> str;
for (i = a - 1; i < max(c, d); i++) {
if (str[i] == '#' && str[i - 1] == '#') {
flag = i;
break;
}
}
if (flag != -1) {
cout << "No";
return 0;
}
for (i = b - 1; i <= d - 1; i++) {
if (str[i - 1] == '.' && str[i] == '.' && str[i] == '.') {
inde = i;
break;
}
}
if (c > d) {
if (inde != -1)
cout << "Yes";
else
cout << "No";
} else
cout << "Yes";
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ass 1e18
#define MOD 1000000007
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define debug(x) cout << #x << ": " << x << endl;
#define debug2(x, y) cout << #x << ": " << x << ", " << #y << ": " << y << endl;
#define debug3(x, y, z) \
cout << #x << ": " << x << ", " << #y << ": " << y << " " << #z << " : " \
<< z << endl;
using namespace std;
typedef long long int ll;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
ll arr[200005];
string str;
int main() {
ll n, a, b, c, d, i, flag = -1, inde = -1, cnt = 0;
cin >> n >> a >> b >> c >> d;
cin >> str;
for (i = a - 1; i < max(c, d); i++) {
if (str[i] == '#' && str[i + 1] == '#') {
flag = i;
break;
}
}
if (flag != -1) {
cout << "No";
return 0;
}
for (i = b - 1; i <= d - 1; i++) {
if (str[i - 1] == '.' && str[i] == '.' && str[i + 1] == '.') {
inde = i;
break;
}
}
if (c > d) {
if (inde != -1)
cout << "Yes";
else
cout << "No";
} else
cout << "Yes";
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,545 | 836,544 | u902456829 | cpp |
p03017 | #include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <bits/stdc++.h>
#include <stdio.h>
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(), x.end()
#define F first
#define S second
#define For(i, x, y) for (ll i = x; i <= y; i++)
#define FOr(i, x, y) for (ll i = x; i >= y; i--)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
// ROAD to... Red
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, a[2], b[2];
string s;
int u[N];
bool can(int a, int b) {
for (int i = a; i <= b - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return 0;
}
}
return 1;
}
int main() {
SpeedForce;
cin >> n >> a[0] >> b[0] >> a[1] >> b[1];
cin >> s;
s = '#' + s;
bool has = 0;
for (int c = b[0]; c <= b[1] - 2; c++) {
if (s[c] == '.' && s[c] == s[c + 1] && s[c] == s[c + 2])
has = 1;
}
if (!can(a[0], a[1])) {
cout << "No\n";
exit(0);
}
if (a[1] > b[1] && !has) {
cout << "No\n";
exit(0);
}
if (!can(b[0], b[1])) {
cout << "No\n";
exit(0);
}
cout << "Yes\n";
return Accepted;
}
// B...a | #include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <bits/stdc++.h>
#include <stdio.h>
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(), x.end()
#define F first
#define S second
#define For(i, x, y) for (ll i = x; i <= y; i++)
#define FOr(i, x, y) for (ll i = x; i >= y; i--)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
// ROAD to... Red
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, a[2], b[2];
string s;
int u[N];
bool can(int a, int b) {
for (int i = a; i <= b - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return 0;
}
}
return 1;
}
int main() {
SpeedForce;
cin >> n >> a[0] >> b[0] >> a[1] >> b[1];
cin >> s;
s = '#' + s;
bool has = 0;
for (int c = b[0] - 1; c <= b[1] - 1; c++) {
if (s[c] == '.' && s[c] == s[c + 1] && s[c] == s[c + 2])
has = 1;
}
if (!can(a[0], a[1])) {
cout << "No\n";
exit(0);
}
if (a[1] > b[1] && !has) {
cout << "No\n";
exit(0);
}
if (!can(b[0], b[1])) {
cout << "No\n";
exit(0);
}
cout << "Yes\n";
return Accepted;
}
// B...a | [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 836,546 | 836,547 | u202370403 | cpp |
p03017 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define pb(a) push_back(a)
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
typedef long long unsigned int ll;
typedef pair<ll, ll> P;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
int rock = 0;
int possible = 1;
int res;
if (c < d) {
for (int i = b; i < d; i++) {
if (s[i] == '#') {
if (rock == 1) {
possible = 0;
}
rock = 1;
} else {
rock = 0;
}
}
res = possible;
possible = 1;
rock = 0;
for (int i = a; i < c; i++) {
if (s[i] == '#') {
if (rock == 1) {
possible = 0;
}
rock = 1;
} else {
rock = 0;
}
}
res *= possible;
} else {
int none = 0;
int beyond = 0;
for (int i = b - 2; i < d; i++) {
if (s[i] == '#') {
none = 0;
if (rock == 1) {
possible = 0;
}
rock = 1;
} else if (s[i] == '.') {
none++;
if (none == 3)
beyond = 1;
rock = 0;
}
}
res = possible;
possible = 1;
rock = 0;
for (int i = a; i < c; i++) {
if (s[i] == '#') {
if (rock == 1) {
possible = 0;
}
rock = 1;
} else {
rock = 0;
}
}
res *= possible;
res *= beyond;
}
if (res) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define pb(a) push_back(a)
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
typedef long long unsigned int ll;
typedef pair<ll, ll> P;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
int rock = 0;
int possible = 1;
int res;
if (c < d) {
for (int i = b; i < d; i++) {
if (s[i] == '#') {
if (rock == 1) {
possible = 0;
}
rock = 1;
} else {
rock = 0;
}
}
res = possible;
possible = 1;
rock = 0;
for (int i = a; i < c; i++) {
if (s[i] == '#') {
if (rock == 1) {
possible = 0;
}
rock = 1;
} else {
rock = 0;
}
}
res *= possible;
} else {
int none = 0;
int beyond = 0;
for (int i = b - 2; i < d + 1; i++) {
if (s[i] == '#') {
none = 0;
if (rock == 1) {
possible = 0;
}
rock = 1;
} else if (s[i] == '.') {
none++;
if (none == 3)
beyond = 1;
rock = 0;
}
}
res = possible;
possible = 1;
rock = 0;
for (int i = a; i < c; i++) {
if (s[i] == '#') {
if (rock == 1) {
possible = 0;
}
rock = 1;
} else {
rock = 0;
}
}
res *= possible;
res *= beyond;
}
if (res) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,555 | 836,556 | u686099444 | cpp |
p03017 | #include <iostream>
using namespace std;
bool isseries(string S, int n, int l, int u) {
for (int i = l; i < u; ++i) {
if (S[i - 1] == '#') {
for (int j = 1; j < n; ++j) {
if ((i - j > l) && (S[i - 1 - j] == '#'))
return true;
}
}
}
return false;
}
bool issparse(string S, int n, int l, int u) {
for (; l < u; l++) {
if ((S[l - 1] != '#') && (S[l - 1 + 1] != '#') && (S[l - 1 - 1] != '#'))
return true;
}
return false;
}
int No() {
cout << "No";
return 0;
}
signed main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
if (isseries(S, 2, min(A, B), max(C, D)))
return No();
if ((A < B) && (C > D)) {
if (!issparse(S, 3, B, D))
return No();
}
if ((A > B) && (C < D)) {
if (!issparse(S, 3, A, C))
return No();
}
cout << "Yes";
return 0;
}
| #include <iostream>
using namespace std;
bool isseries(string S, int n, int l, int u) {
for (int i = l; i < u; ++i) {
if (S[i - 1] == '#') {
for (int j = 1; j < n; ++j) {
if ((i - j - 1 > l) && (S[i - 1 - j] == '#'))
return true;
}
}
}
return false;
}
bool issparse(string S, int n, int l, int u) {
for (; l <= u; ++l) {
if ((S[l - 1] != '#') && (S[l - 1 + 1] != '#') && (S[l - 1 - 1] != '#'))
return true;
}
return false;
}
int No() {
cout << "No";
return 0;
}
signed main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
if (isseries(S, 2, min(A, B), max(C, D)))
return No();
if ((A < B) && (C > D)) {
if (!issparse(S, 3, B, D))
return No();
}
if ((A > B) && (C < D)) {
if (!issparse(S, 3, A, C))
return No();
}
cout << "Yes";
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operator.compare.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 836,582 | 836,583 | u969236097 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
int main(int argc, char const *argv[]) {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
a--;
b--;
c--;
d--;
cin >> s;
ll i = b;
int num = 0;
bool ans = true;
while (i < d) {
i++;
if (s[i] == '#')
num++;
else
num = 0;
if (num == 2) {
ans = false;
break;
}
}
if (!ans) {
cout << "No" << endl;
return 0;
}
i = a;
num = 0;
while (i < c) {
i++;
if (s[i] == '#')
num++;
else
num = 0;
if (num == 2) {
ans = false;
break;
}
}
if (!ans) {
cout << "No" << endl;
return 0;
}
if (c > d) {
ll cnt = 0;
ans = false;
ll hoge = min(d + 1, (ll)s.size() - 1);
for (ll i = b; i <= hoge; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
if (cnt == 3) {
ans = true;
break;
}
}
}
if (!ans) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
};
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
int main(int argc, char const *argv[]) {
ll n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
a--;
b--;
c--;
d--;
cin >> s;
ll i = b;
int num = 0;
bool ans = true;
while (i < d) {
i++;
if (s[i] == '#')
num++;
else
num = 0;
if (num == 2) {
ans = false;
break;
}
}
if (!ans) {
cout << "No" << endl;
return 0;
}
i = a;
num = 0;
while (i < c) {
i++;
if (s[i] == '#')
num++;
else
num = 0;
if (num == 2) {
ans = false;
break;
}
}
if (!ans) {
cout << "No" << endl;
return 0;
}
if (c > d) {
ll cnt = 0;
ans = false;
ll hoge = min(d + 1, (ll)s.size() - 1);
for (ll i = b - 1; i <= hoge; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
if (cnt == 3) {
ans = true;
break;
}
}
}
if (!ans) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
};
| [
"control_flow.loop.for.initializer.change"
] | 836,584 | 836,585 | u507128581 | cpp |
p03017 | #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;
/*
__attribute__((constructor))
void initial()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
}
*/
void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
bool can_reach(int start, int end, string s) {
for (int i = start; i <= end - 1; i++) {
if ((s[i] == '#') && (s[i + 1] == '#')) {
return false;
}
}
return true;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string s;
cin >> s;
/*
if (A > C)
{
swap(A,C);
}
if (B > D)
{
swap(B, D);
}
if (A > B)
{
swap(A, B);
swap(C, D);
}
*/
int nn = 0;
bool y = false;
int c = 0;
int d = 0;
if (!can_reach(A, C, s) || !can_reach(B, D, s)) {
cout << "No" << endl;
return 0;
}
if (D < C) {
for (int i = B - 1; i <= D; i++) {
if (s[i] == '.') {
c++;
if (c >= 3) {
y = true;
break;
}
} else {
c = 0;
}
}
if (!y) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;
/*
__attribute__((constructor))
void initial()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
}
*/
void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
bool can_reach(int start, int end, string s) {
for (int i = start; i <= end - 1; i++) {
if ((s[i] == '#') && (s[i + 1] == '#')) {
return false;
}
}
return true;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string s;
cin >> s;
/*
if (A > C)
{
swap(A,C);
}
if (B > D)
{
swap(B, D);
}
if (A > B)
{
swap(A, B);
swap(C, D);
}
*/
int nn = 0;
bool y = false;
int c = 0;
int d = 0;
if (!can_reach(A, C, s) || !can_reach(B, D, s)) {
cout << "No" << endl;
return 0;
}
if (D < C) {
for (int i = B - 1; i <= D + 1; i++) {
if (s[i] == '.') {
c++;
if (c >= 3) {
y = true;
break;
}
} else {
c = 0;
}
/*
if ((s[i] == '.') && (s[i+1] == '.') && (s[i+2] == '.'))
{
y = true;
break;
}
*/
}
if (!y) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,586 | 836,587 | u528744583 | cpp |
p03017 | #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;
/*
__attribute__((constructor))
void initial()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
}
*/
void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
bool can_reach(int start, int end, string s) {
for (int i = start; i <= end - 1; i++) {
if ((s[i] == '#') && (s[i + 1] == '#')) {
return false;
}
}
return true;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string s;
cin >> s;
/*
if (A > C)
{
swap(A,C);
}
if (B > D)
{
swap(B, D);
}
if (A > B)
{
swap(A, B);
swap(C, D);
}
*/
int nn = 0;
bool y = false;
int c = 0;
int d = 0;
if (!can_reach(A, C, s) || !can_reach(B, D, s)) {
cout << "No" << endl;
return 0;
}
if (D < C) {
for (int i = B - 1; i <= D + 2; i++) {
if (s[i] == '.') {
c++;
if (c >= 3) {
y = true;
break;
}
} else {
c = 0;
}
}
if (!y) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;
/*
__attribute__((constructor))
void initial()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
}
*/
void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
bool can_reach(int start, int end, string s) {
for (int i = start; i <= end - 1; i++) {
if ((s[i] == '#') && (s[i + 1] == '#')) {
return false;
}
}
return true;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string s;
cin >> s;
/*
if (A > C)
{
swap(A,C);
}
if (B > D)
{
swap(B, D);
}
if (A > B)
{
swap(A, B);
swap(C, D);
}
*/
int nn = 0;
bool y = false;
int c = 0;
int d = 0;
if (!can_reach(A, C, s) || !can_reach(B, D, s)) {
cout << "No" << endl;
return 0;
}
if (D < C) {
for (int i = B - 1; i <= D + 1; i++) {
if (s[i] == '.') {
c++;
if (c >= 3) {
y = true;
break;
}
} else {
c = 0;
}
/*
if ((s[i] == '.') && (s[i+1] == '.') && (s[i+2] == '.'))
{
y = true;
break;
}
*/
}
if (!y) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 836,588 | 836,587 | u528744583 | cpp |
p03017 | #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;
/*
__attribute__((constructor))
void initial()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
}
*/
void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
bool can_reach(int start, int end, string s) {
for (int i = start; i <= end - 1; i++) {
if ((s[i] == '#') && (s[i + 1] == '#')) {
return false;
}
}
return true;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string s;
cin >> s;
/*
if (A > C)
{
swap(A,C);
}
if (B > D)
{
swap(B, D);
}
if (A > B)
{
swap(A, B);
swap(C, D);
}
*/
int nn = 0;
bool y = false;
int c = 0;
int d = 0;
if (!can_reach(A, C, s) || !can_reach(B, D, s)) {
cout << "No" << endl;
return 0;
}
if (D < C) {
for (int i = B; i <= D + 2; i++) {
if (s[i] == '.') {
c++;
if (c >= 3) {
y = true;
break;
}
} else {
c = 0;
}
}
if (!y) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| #ifdef LOCAL
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#else
#include <bits/stdc++.h>
#endif
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;
/*
__attribute__((constructor))
void initial()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
}
*/
void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
bool can_reach(int start, int end, string s) {
for (int i = start; i <= end - 1; i++) {
if ((s[i] == '#') && (s[i + 1] == '#')) {
return false;
}
}
return true;
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string s;
cin >> s;
/*
if (A > C)
{
swap(A,C);
}
if (B > D)
{
swap(B, D);
}
if (A > B)
{
swap(A, B);
swap(C, D);
}
*/
int nn = 0;
bool y = false;
int c = 0;
int d = 0;
if (!can_reach(A, C, s) || !can_reach(B, D, s)) {
cout << "No" << endl;
return 0;
}
if (D < C) {
for (int i = B - 1; i <= D + 1; i++) {
if (s[i] == '.') {
c++;
if (c >= 3) {
y = true;
break;
}
} else {
c = 0;
}
/*
if ((s[i] == '.') && (s[i+1] == '.') && (s[i+2] == '.'))
{
y = true;
break;
}
*/
}
if (!y) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 836,589 | 836,587 | u528744583 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = (1000000000 + 7);
int max_count(string &s, int b, int d) {
int cnt = 0;
int max_cnt = 0;
int i;
for (i = b; i <= d; i++) {
if (s[i - 1] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
return max_cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string ss, s;
cin >> ss;
s = " " + ss;
int cnt = 0;
int blk = 0;
int max_cnt = 0;
int max_blk = 0;
int i;
if (c < d) {
for (i = a; i <= d; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
cout << ((max_blk < 2) ? "Yes" : "No") << endl;
} else {
for (i = a; i <= c; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
for (i = b - 1; i <= d; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
cout << ((max_blk < 2 && 3 <= max_cnt) ? "Yes" : "No") << endl;
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = (1000000000 + 7);
int max_count(string &s, int b, int d) {
int cnt = 0;
int max_cnt = 0;
int i;
for (i = b; i <= d; i++) {
if (s[i - 1] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
return max_cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string ss, s;
cin >> ss;
s = " " + ss;
int cnt = 0;
int blk = 0;
int max_cnt = 0;
int max_blk = 0;
int i;
if (c < d) {
for (i = a; i <= d; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
cout << ((max_blk < 2) ? "Yes" : "No") << endl;
} else {
for (i = a; i <= c; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
for (i = b - 1; i <= d + 1; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
cout << ((max_blk < 2 && 3 <= max_cnt) ? "Yes" : "No") << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,598 | 836,599 | u147305315 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = (1000000000 + 7);
int max_count(string &s, int b, int d) {
int cnt = 0;
int max_cnt = 0;
int i;
for (i = b; i <= d; i++) {
if (s[i - 1] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
return max_cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string ss, s;
cin >> ss;
s = " " + ss;
int cnt = 0;
int blk = 0;
int max_cnt = 0;
int max_blk = 0;
int i;
if (c < d) {
for (i = a; i <= d; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
cout << ((max_blk < 2) ? "Yes" : "No") << endl;
} else {
for (i = a; i <= c; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
for (i = b - 1; i <= c; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
cout << ((max_blk < 2 && 3 <= max_cnt) ? "Yes" : "No") << endl;
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = (1000000000 + 7);
int max_count(string &s, int b, int d) {
int cnt = 0;
int max_cnt = 0;
int i;
for (i = b; i <= d; i++) {
if (s[i - 1] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
return max_cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string ss, s;
cin >> ss;
s = " " + ss;
int cnt = 0;
int blk = 0;
int max_cnt = 0;
int max_blk = 0;
int i;
if (c < d) {
for (i = a; i <= d; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
cout << ((max_blk < 2) ? "Yes" : "No") << endl;
} else {
for (i = a; i <= c; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
for (i = b - 1; i <= d + 1; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
cout << ((max_blk < 2 && 3 <= max_cnt) ? "Yes" : "No") << endl;
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,600 | 836,599 | u147305315 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = (1000000000 + 7);
int max_count(string &s, int b, int d) {
int cnt = 0;
int max_cnt = 0;
int i;
for (i = b; i <= d; i++) {
if (s[i - 1] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
return max_cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string ss, s;
cin >> ss;
s = " " + ss;
int cnt = 0;
int blk = 0;
int max_cnt = 0;
int max_blk = 0;
int i;
if (c < d) {
for (i = a; i <= d; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
cout << ((max_blk < 2) ? "Yes" : "No") << endl;
} else {
for (i = a; i <= c; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
for (i = a; i <= c; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
cout << ((max_blk < 2 && 3 <= max_cnt) ? "Yes" : "No") << endl;
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = (1000000000 + 7);
int max_count(string &s, int b, int d) {
int cnt = 0;
int max_cnt = 0;
int i;
for (i = b; i <= d; i++) {
if (s[i - 1] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
return max_cnt;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string ss, s;
cin >> ss;
s = " " + ss;
int cnt = 0;
int blk = 0;
int max_cnt = 0;
int max_blk = 0;
int i;
if (c < d) {
for (i = a; i <= d; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
cout << ((max_blk < 2) ? "Yes" : "No") << endl;
} else {
for (i = a; i <= c; i++) {
if (s[i] == '#')
blk++;
else
blk = 0;
max_blk = max(max_blk, blk);
}
for (i = b - 1; i <= d + 1; i++) {
if (s[i] == '.')
cnt++;
else
cnt = 0;
max_cnt = max(max_cnt, cnt);
}
cout << ((max_blk < 2 && 3 <= max_cnt) ? "Yes" : "No") << endl;
}
return 0;
} | [
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"assignment.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,601 | 836,599 | u147305315 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
bool ok = false;
if (c < d) {
if (c < b) {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
}
ok = true;
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b - 1; i < d - 1; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.')
ok = true;
}
}
cout << (ok ? "Yes" : "No") << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
bool ok = false;
if (c < d) {
if (c < b) {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
}
ok = true;
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b - 1; i < d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.')
ok = true;
}
}
cout << (ok ? "Yes" : "No") << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 836,602 | 836,603 | u874723578 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
bool ok = false;
if (c < d) {
if (c < b) {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
}
ok = true;
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b - 1; i < d - 2; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.')
ok = true;
}
}
cout << (ok ? "Yes" : "No") << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
bool ok = false;
if (c < d) {
if (c < b) {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
}
ok = true;
} else {
for (int i = a; i < c - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
for (int i = b - 1; i < d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.')
ok = true;
}
}
cout << (ok ? "Yes" : "No") << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 836,604 | 836,603 | u874723578 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d, e = 0, f = 0, g = 0;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
e++;
}
}
if (e == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else {
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
f++;
}
}
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
g++;
}
}
if (f > 0 && g == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d, e = 0, f = 0, g = 0;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
e++;
}
}
if (e == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else {
for (int i = b - 2; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
f++;
}
}
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
g++;
}
}
if (f != 0 && g == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operator.compare.change"
] | 836,610 | 836,611 | u883323885 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d, e = 0, f = 0, g = 0;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
e++;
}
}
if (e == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else {
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
f++;
}
}
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
g++;
}
}
if (f == 0 && g == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d, e = 0, f = 0, g = 0;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
e++;
}
}
if (e == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else {
for (int i = b - 2; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
f++;
}
}
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
g++;
}
}
if (f != 0 && g == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"misc.opposites",
"expression.operator.compare.change"
] | 836,612 | 836,611 | u883323885 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d, e = 0, f = 0, g = 0;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
e++;
}
}
if (e == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else {
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
f++;
}
}
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
g++;
}
}
if (f > 0 && g == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d, e = 0, f = 0, g = 0;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
if (c < d) {
for (int i = a; i < d - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
e++;
}
}
if (e == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
} else {
for (int i = b - 2; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
f++;
}
}
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
g++;
}
}
if (f > 0 && g == 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 836,610 | 836,613 | u883323885 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.