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 |
|---|---|---|---|---|---|---|---|
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
string s;
int dem;
int main() {
cin >> n >> a >> b >> c >> d;
cin >> s;
s = " " + s;
if (c < d) {
for (int i = a; i <= d - 1; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
cout << "Yes";
} else {
for (int i = a; i < c; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = a; i <= min(d - 1, n - 2); i++) {
if (s[i] == s[i + 1] && s[i + 2] == s[i] && s[i] == '.') {
dem++;
}
}
if (dem > 0) {
cout << "Yes";
return 0;
}
cout << "No";
}
} | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
string s;
int dem;
int main() {
cin >> n >> a >> b >> c >> d;
cin >> s;
s = " " + s;
if (c < d) {
for (int i = a; i <= d - 1; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
cout << "Yes";
} else {
for (int i = a; i < c; i++) {
if (s[i] == s[i + 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = b - 1; i <= min(d - 1, n - 2); i++) {
if (s[i] == s[i + 1] && s[i + 2] == s[i] && s[i] == '.') {
dem++;
}
}
if (dem > 0) {
cout << "Yes";
return 0;
}
cout << "No";
}
} | [
"control_flow.loop.for.initializer.change"
] | 831,326 | 831,325 | u185917548 | cpp |
p03017 | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d) - 1; i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,330 | 831,331 | u108124198 | cpp |
p03017 | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d) - 2; i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,332 | 831,331 | u108124198 | cpp |
p03017 | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < max(c, d) - 2; i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,333 | 831,331 | u108124198 | cpp |
p03017 | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < max(c, d) - 1; i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,334 | 831,331 | u108124198 | cpp |
p03017 | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b + 1; i < max(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"identifier.change",
"call.function.change"
] | 831,335 | 831,331 | u108124198 | cpp |
p03017 | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = 1; i < max(c, d); i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = 1; i < max(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | //#include<stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f_(i, a, b) for (int i = a; i >= b; i--)
#define f(i, a, b) for (int i = a; i <= b; i++)
int n, a, b, c, d;
string s;
int main() {
// freopen("","r",stdin);
// freopen("","w",stdout);
// scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
cin >> n >> a >> b >> c >> d >> s;
for (int i = a; i < max(c, d) - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
printf("No");
return 0;
}
}
if (s[c - 1] == '#' || s[d - 1] == '#') {
printf("No");
return 0;
}
if (c < d) {
printf("Yes");
return 0;
}
for (int i = b - 1; i < min(c, d); i++) {
if (s[i] == '.' && s[i] == s[i - 1] && s[i] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"misc.opposites",
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 831,336 | 831,331 | u108124198 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end() // begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++) // repeat
#define repr(i, begin, end) \
for (ll i = begin - 1; end <= i; i--) // repeat reverse
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
class AGC034A {
public:
AGC034A() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
}
void Run(void) {
bool ans = true;
CheckFalse(ans);
if (ans)
cout << "Yes";
else
cout << "No";
}
private:
void CheckFalse(bool &ans) {
if (d < c)
if (!CheckSpace3(a, d))
ans = false;
if (CheckIwa2(a, c))
ans = false;
else if (CheckIwa2(b, d))
ans = false;
}
bool CheckSpace3(ll l, ll r) {
rep(i, l, r) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
return true;
}
}
return false;
}
bool CheckIwa2(ll l, ll r) {
rep(i, l + 1, r - 1) {
if (s[i] == '#' && s[i + 1] == '#') {
return true;
}
}
return false;
}
ll n;
ll a;
ll b;
ll c;
ll d;
string s;
};
int main(void) {
AGC034A agc034a;
agc034a.Run();
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end() // begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++) // repeat
#define repr(i, begin, end) \
for (ll i = begin - 1; end <= i; i--) // repeat reverse
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
class AGC034A {
public:
AGC034A() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
}
void Run(void) {
bool ans = true;
CheckFalse(ans);
if (ans)
cout << "Yes";
else
cout << "No";
}
private:
void CheckFalse(bool &ans) {
if (d < c)
if (!CheckSpace3(b - 1, d))
ans = false;
if (CheckIwa2(a, c))
ans = false;
else if (CheckIwa2(b, d))
ans = false;
}
bool CheckSpace3(ll l, ll r) {
rep(i, l, r) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
return true;
}
}
return false;
}
bool CheckIwa2(ll l, ll r) {
rep(i, l + 1, r - 1) {
if (s[i] == '#' && s[i + 1] == '#') {
return true;
}
}
return false;
}
ll n;
ll a;
ll b;
ll c;
ll d;
string s;
};
int main(void) {
AGC034A agc034a;
agc034a.Run();
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 831,346 | 831,347 | u153390822 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end() // begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++) // repeat
#define repr(i, begin, end) \
for (ll i = begin - 1; end <= i; i--) // repeat reverse
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
class AGC034A {
public:
AGC034A() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
}
void Run(void) {
bool ans = true;
CheckFalse(ans);
if (ans)
cout << "Yes";
else
cout << "No";
}
private:
void CheckFalse(bool &ans) {
if (d < c && !CheckSpace3(a, d))
ans = false;
if (CheckIwa2(a, c))
ans = false;
else if (CheckIwa2(b, d))
ans = false;
}
bool CheckSpace3(ll l, ll r) {
rep(i, l, r) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
return true;
}
}
return false;
}
bool CheckIwa2(ll l, ll r) {
rep(i, l + 1, r - 1) {
if (s[i] == '#' && s[i + 1] == '#') {
return true;
}
}
return false;
}
ll n;
ll a;
ll b;
ll c;
ll d;
string s;
};
int main(void) {
AGC034A agc034a;
agc034a.Run();
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end() // begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++) // repeat
#define repr(i, begin, end) \
for (ll i = begin - 1; end <= i; i--) // repeat reverse
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
class AGC034A {
public:
AGC034A() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
}
void Run(void) {
bool ans = true;
CheckFalse(ans);
if (ans)
cout << "Yes";
else
cout << "No";
}
private:
void CheckFalse(bool &ans) {
if (d < c)
if (!CheckSpace3(b - 1, d))
ans = false;
if (CheckIwa2(a, c))
ans = false;
else if (CheckIwa2(b, d))
ans = false;
}
bool CheckSpace3(ll l, ll r) {
rep(i, l, r) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
return true;
}
}
return false;
}
bool CheckIwa2(ll l, ll r) {
rep(i, l + 1, r - 1) {
if (s[i] == '#' && s[i + 1] == '#') {
return true;
}
}
return false;
}
ll n;
ll a;
ll b;
ll c;
ll d;
string s;
};
int main(void) {
AGC034A agc034a;
agc034a.Run();
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add"
] | 831,348 | 831,347 | u153390822 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end() // begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++) // repeat
#define repr(i, begin, end) \
for (ll i = begin - 1; end <= i; i--) // repeat reverse
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
class AGC034A {
public:
AGC034A() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
}
void Run(void) {
bool ans = true;
CheckFalse(ans);
if (ans)
cout << "Yes";
else
cout << "No";
}
private:
void CheckFalse(bool &ans) {
if (d < c && !CheckSpace3(b, d))
ans = false;
if (CheckIwa2(a, c))
ans = false;
else if (CheckIwa2(b, d))
ans = false;
}
bool CheckSpace3(ll l, ll r) {
rep(i, l, r) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
return true;
}
}
return false;
}
bool CheckIwa2(ll l, ll r) {
rep(i, l + 1, r - 1) {
if (s[i] == '#' && s[i + 1] == '#') {
return true;
}
}
return false;
}
ll n;
ll a;
ll b;
ll c;
ll d;
string s;
};
int main(void) {
AGC034A agc034a;
agc034a.Run();
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <ccomplex>
#include <cctype>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <condition_variable>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctgmath>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#ifndef __MACRO_H__
#define __MACRO_H__
#define all(collection) (collection).begin(), (collection).end() // begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++) // repeat
#define repr(i, begin, end) \
for (ll i = begin - 1; end <= i; i--) // repeat reverse
std::chrono::system_clock::time_point start;
void TimeStart(void) { start = std::chrono::system_clock::now(); }
void TimeEnd(void) {
auto time = std::chrono::system_clock::now() - start;
auto msec =
std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
cerr << endl << msec << " msec " << endl;
}
#endif
class AGC034A {
public:
AGC034A() {
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
}
void Run(void) {
bool ans = true;
CheckFalse(ans);
if (ans)
cout << "Yes";
else
cout << "No";
}
private:
void CheckFalse(bool &ans) {
if (d < c)
if (!CheckSpace3(b - 1, d))
ans = false;
if (CheckIwa2(a, c))
ans = false;
else if (CheckIwa2(b, d))
ans = false;
}
bool CheckSpace3(ll l, ll r) {
rep(i, l, r) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
return true;
}
}
return false;
}
bool CheckIwa2(ll l, ll r) {
rep(i, l + 1, r - 1) {
if (s[i] == '#' && s[i + 1] == '#') {
return true;
}
}
return false;
}
ll n;
ll a;
ll b;
ll c;
ll d;
string s;
};
int main(void) {
AGC034A agc034a;
agc034a.Run();
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add"
] | 831,349 | 831,347 | u153390822 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
long long int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A; i < C; i++) {
if (S[i] == S[i + 1] && S[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = B; i < D; i++) {
if (S[i] == S[i + 1] && S[i] == '#') {
cout << "No";
return 0;
}
}
if (C < D)
cout << "Yes";
if (C > D) {
bool flag = false;
for (int i = B - 1; i < D; i++) {
if (S[i] == S[i - 1] && S[i] == S[i + 1] && S[i] == '.')
flag = true;
}
if (flag)
cout << "Yes";
else
cout << "No";
}
cout << "No";
return 0;
}
| #include <iostream>
using namespace std;
int main() {
long long int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A; i < C; i++) {
if (S[i] == S[i + 1] && S[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = B; i < D; i++) {
if (S[i] == S[i + 1] && S[i] == '#') {
cout << "No";
return 0;
}
}
if (C < D)
cout << "Yes";
else if (C > D) {
bool flag = false;
for (int i = B - 1; i < D; i++) {
if (S[i] == S[i - 1] && S[i] == S[i + 1] && S[i] == '.')
flag = true;
}
if (flag)
cout << "Yes";
else
cout << "No";
} else
cout << "No";
return 0;
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 831,357 | 831,358 | u773499055 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = a; i < c; i++) {
if (s[i] == s[i + 1] and s[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == s[i + 1] and s[i] == '#') {
cout << "No";
return 0;
}
}
if (c < d)
cout << "Yes";
else if (c > d) {
bool ok = 0;
for (int i = b; i < d; i++) {
if (s[i] == s[i - 1] and s[i] == s[i + 1] and s[i] == '.')
ok = 1;
}
if (ok)
cout << "Yes";
else
cout << "No";
} else
cout << "No";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = a; i < c; i++) {
if (s[i] == s[i + 1] and s[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = b; i < d; i++) {
if (s[i] == s[i + 1] and s[i] == '#') {
cout << "No";
return 0;
}
}
if (c < d)
cout << "Yes";
else if (c > d) {
bool ok = 0;
for (int i = b - 1; i < d; i++) {
if (s[i] == s[i - 1] and s[i] == s[i + 1] and s[i] == '.')
ok = 1;
}
if (ok)
cout << "Yes";
else
cout << "No";
} else
cout << "No";
} | [
"control_flow.loop.for.initializer.change"
] | 831,359 | 831,360 | u799165954 | cpp |
p03017 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair
#define fastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
mt19937 rnd(chrono::steady_clock().now().time_since_epoch().count());
const int N = (int)2e5 + 9;
char s[N];
void NO() {
cout << "No\n";
exit(0);
}
bool check(int i, int j) {
for (int t = i; t < j; t++) {
if (s[t] == '#' && s[t + 1] == '#')
return false;
}
return true;
}
int main() {
fastIO;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
if (!check(a, c) || !check(b, d))
NO();
if (c < d) {
cout << "Yes\n";
} else {
for (int i = max(b, 2); i <= d - 1; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i + 1] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
}
return 0;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair
#define fastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
mt19937 rnd(chrono::steady_clock().now().time_since_epoch().count());
const int N = (int)2e5 + 9;
char s[N];
void NO() {
cout << "No\n";
exit(0);
}
bool check(int i, int j) {
for (int t = i; t < j; t++) {
if (s[t] == '#' && s[t + 1] == '#')
return false;
}
return true;
}
int main() {
fastIO;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
if (!check(a, c) || !check(b, d))
NO();
if (c < d) {
cout << "Yes\n";
} else {
for (int i = max(b, 2); i <= d; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i + 1] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
}
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,361 | 831,362 | u722777218 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
int const MAXN = 2e5 + 10;
char arr[MAXN];
bool move_check(int init, int ending) {
if (init == ending)
return true;
while (true) {
init++;
if (init == ending)
break;
if (arr[init] != '#')
continue;
init++;
if (init == ending)
break;
if (arr[init] == '#')
return false;
}
return true;
}
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
for (int i = 0; i < n; ++i)
cin >> arr[i];
if (c > d) {
bool possible = false;
int new_pos = 0;
for (int i = 1; i < n - 1; ++i) {
if (i < b)
continue;
if (arr[i - 1] == '.' and arr[i] == '.' and arr[i + 1] == '.' and
i <= d) {
possible = true;
arr[i] = '#';
new_pos = i;
break;
}
}
if (!possible or !move_check(a, c) or
!(move_check(b, new_pos) and move_check(new_pos, d))) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} else {
if (!move_check(b, d) or !move_check(a, c))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
int const MAXN = 2e5 + 10;
char arr[MAXN];
bool move_check(int init, int ending) {
if (init == ending)
return true;
while (true) {
init++;
if (init == ending)
break;
if (arr[init] != '#')
continue;
init++;
if (init == ending)
break;
if (arr[init] == '#')
return false;
}
return true;
}
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
for (int i = 0; i < n; ++i)
cin >> arr[i];
if (c > d) {
bool possible = false;
int new_pos = 0;
for (int i = 1; i < n - 1; ++i) {
if (i < b)
continue;
if (arr[i - 1] == '.' and arr[i] == '.' and arr[i + 1] == '.' and
i <= d) {
possible = true;
arr[i] = '#';
new_pos = i;
break;
}
}
if (!possible or !move_check(a, c) or
!(move_check(b, new_pos) and move_check(new_pos, d))) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
} else {
if (!move_check(b, d) or !move_check(a, c))
cout << "No" << endl;
else
cout << "Yes" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 831,374 | 831,375 | u562777854 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, startA, startB, endA, endB;
string str;
cin >> n >> startA >> startB >> endA >> endB;
cin >> str;
string result = "YES";
if (endB < endA) {
int point = str.find("...", startB - 2);
if (point == -1 || point > endB - 2)
result = "NO";
}
int point = str.find("##", startA);
if (point != -1 && (point < endA || point < endB))
result = "NO";
cout << result << endl;
/*
endA < endBなら
*/
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int n, startA, startB, endA, endB;
string str;
cin >> n >> startA >> startB >> endA >> endB;
cin >> str;
string result = "Yes";
if (endB < endA) {
int point = str.find("...", startB - 2);
if (point == -1 || point > endB - 2)
result = "No";
}
int point = str.find("##", startA);
if (point != -1 && (point < endA || point < endB))
result = "No";
cout << result << endl;
/*
endA < endBなら
*/
}
| [
"literal.string.change",
"literal.string.case.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 831,376 | 831,377 | u914384129 | cpp |
p03017 | #define NOMINMAX
#define TEST_MODE true
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#include <random>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rrep2(i, a, b) for (int i = (a)-1; i >= (int)b; --i)
#define range(i, a, b, c) for (int i = a; c > 0 ? i < b : i > b; i += c)
#define chmax(a, b) (a = (a) < (b) ? (b) : (a))
#define chmin(a, b) (a = (a) > (b) ? (b) : (a))
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define all(a) begin(a), end(a)
#define ifnot(a) if (not(a))
#define int long long
#ifdef LOCAL_ENV
#if TEST_MODE == true
const bool test = true;
#define dump(x) cerr << #x << " : " << (x) << " "
#define dumpl(x) dump(x) << endl
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int inf = (int)1 << 60;
const int undefined = inf;
const ll INFL = (ll)1 << 60;
ll mod_n = (int)1e9 + 7;
const double eps = 1e-10;
typedef long double Real;
// return -1, 0, 1
int sgn(const Real &r) { return (r > eps) - (r < -eps); }
int sgn(const Real &a, const Real &b) { return sgn(a - b); }
//.....................
const int MAX = (int)2e5 + 5;
vector<string> split(const string &str, char sep) {
vector<string> v;
stringstream ss(str);
string buffer;
while (getline(ss, buffer, sep)) {
v.push_back(buffer);
}
return v;
}
string join(const vector<string> &v, const string delim = 0) {
string s;
if (!v.empty()) {
s += v[0];
for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i) {
if (delim != "")
s += delim;
s += v[i];
}
}
return s;
}
string operator*(const string &s, const int &n) {
string res = "";
rep(i, n) res += s;
return res;
}
template <class InputIterator> int sum(InputIterator begin, InputIterator end) {
return accumulate(begin, end, 0ll);
}
template <typename T> T gcd(T a, T b) {
if (a == inf)
return b;
if (b == inf)
return a;
T c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
template <typename T> T bit_count(T N) {
T cnt = 0;
while (N) {
if (N & 1)
cnt++;
N >>= 1;
}
return cnt;
}
template <typename T> void print_vec(ostream &ostream, vector<T> a) {
rep(i, a.size() - 1) ostream << a[i] << " ";
ostream << a.back() << endl;
}
ll pow_n(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
template <class T, class U> T mod_pow(T x, U n) {
T res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
x %= mod_n;
n >>= 1;
res %= mod_n;
}
return res;
}
template <class T> T mod_rev(T a) {
T res = 1;
return mod_pow(a, mod_n - 2);
}
int H, W;
bool grid_ng(int y, int x) { return y < 0 || y >= H || x < 0 || x >= W; }
struct Point {
int x, y;
Point(int y_, int x_) : y(y_), x(x_) {}
bool operator<(const Point &r) const {
if (y != r.y)
return y < r.y;
return x < r.x;
}
};
struct Vertex {
int id, dist;
bool operator>(const Vertex &r) const { return dist > r.dist; }
};
struct Edge {
int to, weight;
Edge(int to, int weight) : to(to), weight(weight) {}
};
using Graph = vector<vector<Edge>>;
Graph g;
int n, m;
int a, b, c, d;
string s;
class Solver {
public:
// bool ok() {
// //int first = (place[0] < place[1] ? 0 : 1);
// int first = 1;
// rep(i, 2) {
// //int i = first ^ loop;
// int cur = place[i];
// while (true) {
// if (cur + 2 <= goal[i] &&
// s[cur + 2] == '.') {
// cur += 2;
// }
// else if (cur + 1 <= goal[i] &&
// s[cur + 1] == '.') {
// cur += 1;
// }
// else return false;
// if (cur == goal[i]) break;
// }
// }
// return true;
//}
bool ok1() {
int rock_n = 0;
rep2(i, a, max(c, d) + 1) {
if (s[i] == '#') {
rock_n += 1;
} else
rock_n = 0;
if (rock_n >= 2)
return false;
}
return true;
}
bool ok2() {
int none_n = 0;
rep2(i, b, d + 2) {
if (s[i] == '.') {
none_n += 1;
} else
none_n = 0;
if (none_n >= 3) {
return true;
}
}
return false;
}
bool ok() {
bool res = ok1();
dumpl(ok1());
if (c > d) {
res = res && ok2();
dumpl(ok2());
}
return res;
}
void solve() {
cin >> n;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
cout << (ok() ? "Yes" : "No") << endl;
}
};
signed main() {
srand((unsigned int)time(NULL));
cout << fixed << setprecision(20);
auto ptr = new Solver();
ptr->solve();
delete ptr;
// while(true) {
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
// while (true) {
// if (cin.eof() == true) break;
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
return 0;
}
| #define NOMINMAX
#define TEST_MODE true
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#include <random>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rrep2(i, a, b) for (int i = (a)-1; i >= (int)b; --i)
#define range(i, a, b, c) for (int i = a; c > 0 ? i < b : i > b; i += c)
#define chmax(a, b) (a = (a) < (b) ? (b) : (a))
#define chmin(a, b) (a = (a) > (b) ? (b) : (a))
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define all(a) begin(a), end(a)
#define ifnot(a) if (not(a))
#define int long long
#ifdef LOCAL_ENV
#if TEST_MODE == true
const bool test = true;
#define dump(x) cerr << #x << " : " << (x) << " "
#define dumpl(x) dump(x) << endl
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int inf = (int)1 << 60;
const int undefined = inf;
const ll INFL = (ll)1 << 60;
ll mod_n = (int)1e9 + 7;
const double eps = 1e-10;
typedef long double Real;
// return -1, 0, 1
int sgn(const Real &r) { return (r > eps) - (r < -eps); }
int sgn(const Real &a, const Real &b) { return sgn(a - b); }
//.....................
const int MAX = (int)2e5 + 5;
vector<string> split(const string &str, char sep) {
vector<string> v;
stringstream ss(str);
string buffer;
while (getline(ss, buffer, sep)) {
v.push_back(buffer);
}
return v;
}
string join(const vector<string> &v, const string delim = 0) {
string s;
if (!v.empty()) {
s += v[0];
for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i) {
if (delim != "")
s += delim;
s += v[i];
}
}
return s;
}
string operator*(const string &s, const int &n) {
string res = "";
rep(i, n) res += s;
return res;
}
template <class InputIterator> int sum(InputIterator begin, InputIterator end) {
return accumulate(begin, end, 0ll);
}
template <typename T> T gcd(T a, T b) {
if (a == inf)
return b;
if (b == inf)
return a;
T c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
template <typename T> T bit_count(T N) {
T cnt = 0;
while (N) {
if (N & 1)
cnt++;
N >>= 1;
}
return cnt;
}
template <typename T> void print_vec(ostream &ostream, vector<T> a) {
rep(i, a.size() - 1) ostream << a[i] << " ";
ostream << a.back() << endl;
}
ll pow_n(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
template <class T, class U> T mod_pow(T x, U n) {
T res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
x %= mod_n;
n >>= 1;
res %= mod_n;
}
return res;
}
template <class T> T mod_rev(T a) {
T res = 1;
return mod_pow(a, mod_n - 2);
}
int H, W;
bool grid_ng(int y, int x) { return y < 0 || y >= H || x < 0 || x >= W; }
struct Point {
int x, y;
Point(int y_, int x_) : y(y_), x(x_) {}
bool operator<(const Point &r) const {
if (y != r.y)
return y < r.y;
return x < r.x;
}
};
struct Vertex {
int id, dist;
bool operator>(const Vertex &r) const { return dist > r.dist; }
};
struct Edge {
int to, weight;
Edge(int to, int weight) : to(to), weight(weight) {}
};
using Graph = vector<vector<Edge>>;
Graph g;
int n, m;
int a, b, c, d;
string s;
class Solver {
public:
// bool ok() {
// //int first = (place[0] < place[1] ? 0 : 1);
// int first = 1;
// rep(i, 2) {
// //int i = first ^ loop;
// int cur = place[i];
// while (true) {
// if (cur + 2 <= goal[i] &&
// s[cur + 2] == '.') {
// cur += 2;
// }
// else if (cur + 1 <= goal[i] &&
// s[cur + 1] == '.') {
// cur += 1;
// }
// else return false;
// if (cur == goal[i]) break;
// }
// }
// return true;
//}
bool ok1() {
int rock_n = 0;
rep2(i, a, max(c, d) + 1) {
if (s[i] == '#') {
rock_n += 1;
} else
rock_n = 0;
if (rock_n >= 2)
return false;
}
return true;
}
bool ok2() {
int none_n = 0;
rep2(i, b - 1, d + 2) {
if (s[i] == '.') {
none_n += 1;
} else
none_n = 0;
if (none_n >= 3) {
return true;
}
}
return false;
}
bool ok() {
bool res = ok1();
dumpl(ok1());
if (c > d) {
res = res && ok2();
dumpl(ok2());
}
return res;
}
void solve() {
cin >> n;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
cout << (ok() ? "Yes" : "No") << endl;
}
};
signed main() {
srand((unsigned int)time(NULL));
cout << fixed << setprecision(20);
auto ptr = new Solver();
ptr->solve();
delete ptr;
// while(true) {
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
// while (true) {
// if (cin.eof() == true) break;
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
return 0;
}
| [
"expression.operation.binary.add"
] | 831,380 | 831,381 | u495267515 | cpp |
p03017 | #define NOMINMAX
#define TEST_MODE true
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#include <random>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rrep2(i, a, b) for (int i = (a)-1; i >= (int)b; --i)
#define range(i, a, b, c) for (int i = a; c > 0 ? i < b : i > b; i += c)
#define chmax(a, b) (a = (a) < (b) ? (b) : (a))
#define chmin(a, b) (a = (a) > (b) ? (b) : (a))
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define all(a) begin(a), end(a)
#define ifnot(a) if (not(a))
#define int long long
#ifdef LOCAL_ENV
#if TEST_MODE == true
const bool test = true;
#define dump(x) cerr << #x << " : " << (x) << " "
#define dumpl(x) dump(x) << endl
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int inf = (int)1 << 60;
const int undefined = inf;
const ll INFL = (ll)1 << 60;
ll mod_n = (int)1e9 + 7;
const double eps = 1e-10;
typedef long double Real;
// return -1, 0, 1
int sgn(const Real &r) { return (r > eps) - (r < -eps); }
int sgn(const Real &a, const Real &b) { return sgn(a - b); }
//.....................
const int MAX = (int)2e5 + 5;
vector<string> split(const string &str, char sep) {
vector<string> v;
stringstream ss(str);
string buffer;
while (getline(ss, buffer, sep)) {
v.push_back(buffer);
}
return v;
}
string join(const vector<string> &v, const string delim = 0) {
string s;
if (!v.empty()) {
s += v[0];
for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i) {
if (delim != "")
s += delim;
s += v[i];
}
}
return s;
}
string operator*(const string &s, const int &n) {
string res = "";
rep(i, n) res += s;
return res;
}
template <class InputIterator> int sum(InputIterator begin, InputIterator end) {
return accumulate(begin, end, 0ll);
}
template <typename T> T gcd(T a, T b) {
if (a == inf)
return b;
if (b == inf)
return a;
T c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
template <typename T> T bit_count(T N) {
T cnt = 0;
while (N) {
if (N & 1)
cnt++;
N >>= 1;
}
return cnt;
}
template <typename T> void print_vec(ostream &ostream, vector<T> a) {
rep(i, a.size() - 1) ostream << a[i] << " ";
ostream << a.back() << endl;
}
ll pow_n(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
template <class T, class U> T mod_pow(T x, U n) {
T res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
x %= mod_n;
n >>= 1;
res %= mod_n;
}
return res;
}
template <class T> T mod_rev(T a) {
T res = 1;
return mod_pow(a, mod_n - 2);
}
int H, W;
bool grid_ng(int y, int x) { return y < 0 || y >= H || x < 0 || x >= W; }
struct Point {
int x, y;
Point(int y_, int x_) : y(y_), x(x_) {}
bool operator<(const Point &r) const {
if (y != r.y)
return y < r.y;
return x < r.x;
}
};
struct Vertex {
int id, dist;
bool operator>(const Vertex &r) const { return dist > r.dist; }
};
struct Edge {
int to, weight;
Edge(int to, int weight) : to(to), weight(weight) {}
};
using Graph = vector<vector<Edge>>;
Graph g;
int n, m;
int a, b, c, d;
string s;
class Solver {
public:
// bool ok() {
// //int first = (place[0] < place[1] ? 0 : 1);
// int first = 1;
// rep(i, 2) {
// //int i = first ^ loop;
// int cur = place[i];
// while (true) {
// if (cur + 2 <= goal[i] &&
// s[cur + 2] == '.') {
// cur += 2;
// }
// else if (cur + 1 <= goal[i] &&
// s[cur + 1] == '.') {
// cur += 1;
// }
// else return false;
// if (cur == goal[i]) break;
// }
// }
// return true;
//}
bool ok1() {
int rock_n = 0;
rep2(i, a, max(c, d) + 1) {
if (s[i] == '#') {
rock_n += 1;
} else
rock_n = 0;
if (rock_n >= 2)
return false;
}
return true;
}
bool ok2() {
int none_n = 0;
rep2(i, b, d) {
if (s[i] == '.') {
none_n += 1;
} else
none_n = 0;
if (none_n >= 3) {
return true;
}
}
return false;
}
bool ok() {
bool res = ok1();
dumpl(ok1());
if (c > d) {
res = res && ok2();
dumpl(ok2());
}
return res;
}
void solve() {
cin >> n;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
cout << (ok() ? "Yes" : "No") << endl;
}
};
signed main() {
srand((unsigned int)time(NULL));
cout << fixed << setprecision(20);
auto ptr = new Solver();
ptr->solve();
delete ptr;
// while(true) {
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
// while (true) {
// if (cin.eof() == true) break;
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
return 0;
}
| #define NOMINMAX
#define TEST_MODE true
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#include <random>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rrep2(i, a, b) for (int i = (a)-1; i >= (int)b; --i)
#define range(i, a, b, c) for (int i = a; c > 0 ? i < b : i > b; i += c)
#define chmax(a, b) (a = (a) < (b) ? (b) : (a))
#define chmin(a, b) (a = (a) > (b) ? (b) : (a))
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define all(a) begin(a), end(a)
#define ifnot(a) if (not(a))
#define int long long
#ifdef LOCAL_ENV
#if TEST_MODE == true
const bool test = true;
#define dump(x) cerr << #x << " : " << (x) << " "
#define dumpl(x) dump(x) << endl
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
#else
const bool test = false;
#define dump(x)
#define dumpl(x)
#endif
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int inf = (int)1 << 60;
const int undefined = inf;
const ll INFL = (ll)1 << 60;
ll mod_n = (int)1e9 + 7;
const double eps = 1e-10;
typedef long double Real;
// return -1, 0, 1
int sgn(const Real &r) { return (r > eps) - (r < -eps); }
int sgn(const Real &a, const Real &b) { return sgn(a - b); }
//.....................
const int MAX = (int)2e5 + 5;
vector<string> split(const string &str, char sep) {
vector<string> v;
stringstream ss(str);
string buffer;
while (getline(ss, buffer, sep)) {
v.push_back(buffer);
}
return v;
}
string join(const vector<string> &v, const string delim = 0) {
string s;
if (!v.empty()) {
s += v[0];
for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i) {
if (delim != "")
s += delim;
s += v[i];
}
}
return s;
}
string operator*(const string &s, const int &n) {
string res = "";
rep(i, n) res += s;
return res;
}
template <class InputIterator> int sum(InputIterator begin, InputIterator end) {
return accumulate(begin, end, 0ll);
}
template <typename T> T gcd(T a, T b) {
if (a == inf)
return b;
if (b == inf)
return a;
T c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
template <typename T> T bit_count(T N) {
T cnt = 0;
while (N) {
if (N & 1)
cnt++;
N >>= 1;
}
return cnt;
}
template <typename T> void print_vec(ostream &ostream, vector<T> a) {
rep(i, a.size() - 1) ostream << a[i] << " ";
ostream << a.back() << endl;
}
ll pow_n(ll x, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
template <class T, class U> T mod_pow(T x, U n) {
T res = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
x %= mod_n;
n >>= 1;
res %= mod_n;
}
return res;
}
template <class T> T mod_rev(T a) {
T res = 1;
return mod_pow(a, mod_n - 2);
}
int H, W;
bool grid_ng(int y, int x) { return y < 0 || y >= H || x < 0 || x >= W; }
struct Point {
int x, y;
Point(int y_, int x_) : y(y_), x(x_) {}
bool operator<(const Point &r) const {
if (y != r.y)
return y < r.y;
return x < r.x;
}
};
struct Vertex {
int id, dist;
bool operator>(const Vertex &r) const { return dist > r.dist; }
};
struct Edge {
int to, weight;
Edge(int to, int weight) : to(to), weight(weight) {}
};
using Graph = vector<vector<Edge>>;
Graph g;
int n, m;
int a, b, c, d;
string s;
class Solver {
public:
// bool ok() {
// //int first = (place[0] < place[1] ? 0 : 1);
// int first = 1;
// rep(i, 2) {
// //int i = first ^ loop;
// int cur = place[i];
// while (true) {
// if (cur + 2 <= goal[i] &&
// s[cur + 2] == '.') {
// cur += 2;
// }
// else if (cur + 1 <= goal[i] &&
// s[cur + 1] == '.') {
// cur += 1;
// }
// else return false;
// if (cur == goal[i]) break;
// }
// }
// return true;
//}
bool ok1() {
int rock_n = 0;
rep2(i, a, max(c, d) + 1) {
if (s[i] == '#') {
rock_n += 1;
} else
rock_n = 0;
if (rock_n >= 2)
return false;
}
return true;
}
bool ok2() {
int none_n = 0;
rep2(i, b - 1, d + 2) {
if (s[i] == '.') {
none_n += 1;
} else
none_n = 0;
if (none_n >= 3) {
return true;
}
}
return false;
}
bool ok() {
bool res = ok1();
dumpl(ok1());
if (c > d) {
res = res && ok2();
dumpl(ok2());
}
return res;
}
void solve() {
cin >> n;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
cout << (ok() ? "Yes" : "No") << endl;
}
};
signed main() {
srand((unsigned int)time(NULL));
cout << fixed << setprecision(20);
auto ptr = new Solver();
ptr->solve();
delete ptr;
// while(true) {
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
// while (true) {
// if (cin.eof() == true) break;
// auto ptr = new Solver();
// ptr->solve();
// delete ptr;
//}
return 0;
}
| [
"expression.operation.binary.add"
] | 831,383 | 831,381 | u495267515 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MIN(a) *min_element(all(a))
#define MAX(a) *max_element(all(a))
#define SUM(a, b) accumulate(all(a), b)
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); i++)
#define FORR(i, m, n) for (int(i) = (n)-1; (i) >= (m); i--)
#define ios() cin.tie(0), ios::sync_with_stdio(false)
#define debug(x) cerr << #x << " = " << x << endl
//#define int long long
typedef long long ll;
typedef unsigned long long ull;
// ll const MOD = 998244353;
ll const MOD = 1e9 + 7;
ll const INF = 1e18;
template <typename T> int size(const T &a) { return (int)a.size(); }
template <typename T> T Div(T a, T b) { return (a + b - 1) / b; }
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
signed main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
a--;
b--;
c--;
d--;
bool ans = true;
FOR(i, a, c) {
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
FOR(i, b, d) {
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
bool flag = (c < d ? true : false);
FOR(i, b, d) {
if (flag)
break;
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.')
flag = true;
}
cout << (ans && flag ? "Yes" : "No") << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MIN(a) *min_element(all(a))
#define MAX(a) *max_element(all(a))
#define SUM(a, b) accumulate(all(a), b)
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); i++)
#define FORR(i, m, n) for (int(i) = (n)-1; (i) >= (m); i--)
#define ios() cin.tie(0), ios::sync_with_stdio(false)
#define debug(x) cerr << #x << " = " << x << endl
//#define int long long
typedef long long ll;
typedef unsigned long long ull;
// ll const MOD = 998244353;
ll const MOD = 1e9 + 7;
ll const INF = 1e18;
template <typename T> int size(const T &a) { return (int)a.size(); }
template <typename T> T Div(T a, T b) { return (a + b - 1) / b; }
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
signed main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
a--;
b--;
c--;
d--;
bool ans = true;
FOR(i, a, c) {
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
FOR(i, b, d) {
if (s[i] == '#' && s[i + 1] == '#')
ans = false;
}
bool flag = (c < d ? true : false);
FOR(i, b, d + 1) {
if (flag)
break;
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.')
flag = true;
}
cout << (ans && flag ? "Yes" : "No") << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 831,397 | 831,398 | u994831328 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d, e;
string s;
bool ok = true;
int main() {
cin >> n >> a >> b >> c >> d >> s;
e = max(c, d) - 1;
for (int i = a; i < e; i++) {
if (s[i] == '#' && s[i + 1] == '#')
ok = false;
}
if (c > d) {
ok = false;
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
ok = true;
}
}
puts(ok ? "Yes" : "No");
} | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d, e;
string s;
bool ok = true;
int main() {
cin >> n >> a >> b >> c >> d >> s;
e = max(c, d) - 1;
for (int i = a; i < e; i++) {
if (s[i] == '#' && s[i + 1] == '#')
ok = false;
}
if (c > d) {
ok = false;
for (int i = b - 2; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
ok = true;
}
}
puts(ok ? "Yes" : "No");
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,408 | 831,409 | u309985845 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (long long i = 0; i < n; i++)
#define REP1(i, n) for (long long i = 1; i <= n; i++)
#define REPB(i, n) for (long long i = ((n)-1); i >= 0; i--)
#define REPB1(i, n) for (long long i = (n); i > 0; i--)
#define ITE(arr) for (auto ite = (arr).begin(); ite != (arr).end(); ite++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define YNPRT(b) cout << ((b) ? "Yes" : "No") << endl
#define REV(arr) reverse(ALL(arr))
typedef long long ll;
typedef pair<int, int> pii;
//---------------------
#define MAXN 200000
//---------------------
string s;
ll a, b, c, d, n;
int main() {
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
bool flag = true;
int num = 0;
for (int i = a; i < max(c, d); i++) {
char c = s[i];
if (c == '#') {
num++;
if (num == 2) {
flag = false;
break;
}
} else
num = 0;
}
if (flag) {
if (d < c) {
int num = 0;
flag = false;
for (int i = b; i <= min(n - 1, d + 1); i++) {
char c = s[i];
if (c == '.') {
num++;
if (num == 3) {
flag = true;
break;
}
} else
num = 0;
}
}
}
YNPRT(flag);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (long long i = 0; i < n; i++)
#define REP1(i, n) for (long long i = 1; i <= n; i++)
#define REPB(i, n) for (long long i = ((n)-1); i >= 0; i--)
#define REPB1(i, n) for (long long i = (n); i > 0; i--)
#define ITE(arr) for (auto ite = (arr).begin(); ite != (arr).end(); ite++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define YNPRT(b) cout << ((b) ? "Yes" : "No") << endl
#define REV(arr) reverse(ALL(arr))
typedef long long ll;
typedef pair<int, int> pii;
//---------------------
#define MAXN 200000
//---------------------
string s;
ll a, b, c, d, n;
int main() {
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
bool flag = true;
int num = 0;
for (int i = a; i < max(c, d); i++) {
char c = s[i];
if (c == '#') {
num++;
if (num == 2) {
flag = false;
break;
}
} else
num = 0;
}
if (flag) {
if (d < c) {
int num = 0;
flag = false;
for (int i = b - 1; i <= min(n - 1, d + 1); i++) {
char c = s[i];
if (c == '.') {
num++;
if (num == 3) {
flag = true;
break;
}
} else
num = 0;
}
}
}
YNPRT(flag);
return 0;
} | [
"control_flow.loop.for.initializer.change"
] | 831,417 | 831,418 | u786318703 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D - 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = A - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = A - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,435 | 831,436 | u728702354 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D - 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = A - 1; i < D - 1; i++) {
if (S[i - 1] == '#' && S[i] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = A - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 831,437 | 831,436 | u728702354 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D - 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = A - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 831,438 | 831,436 | u728702354 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < C - 1; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
bool judge(bool AC, bool BD) {
if (AC && BD)
return true;
else
return false;
}
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
bool flagAC = true;
bool flagBD = true;
if (C < B) {
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (C < D) {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagBD = false;
break;
}
}
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagAC = false;
break;
}
}
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = B - 1; i < D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
bool flagmentAC = true;
bool flagmentBD = true;
for (int j = i + 1; j < C - 1; j++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentAC = false;
break;
}
}
for (int i = A - 1; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
flagmentBD = false;
break;
}
}
if (flagmentAC && flagmentBD) {
flagAC = true;
flagBD = true;
goto label;
} else {
flagAC = false;
flagBD = false;
}
} else {
flagAC = false;
flagBD = false;
}
}
label:
if (judge(flagAC, flagBD))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 831,439 | 831,436 | u728702354 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
string S;
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D >> S;
A--, B--, C--, D--;
// snuke able
int cnt = 0;
for (int i = A; i <= C; i++) {
if (S[i] == '#') {
cnt++;
} else
cnt = 0;
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
cnt = 0;
// fnuke able
for (int i = B; i <= D; i++) {
if (S[i] == '#') {
cnt++;
} else
cnt = 0;
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
return 0;
} else {
cnt = 0;
for (int i = B; i <= D; i++) {
if (S[i] == '.') {
cnt++;
} else
cnt = 0;
if (cnt >= 3) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
string S;
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D >> S;
A--, B--, C--, D--;
// snuke able
int cnt = 0;
for (int i = A; i <= C; i++) {
if (S[i] == '#') {
cnt++;
} else
cnt = 0;
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
cnt = 0;
// fnuke able
for (int i = B; i <= D; i++) {
if (S[i] == '#') {
cnt++;
} else
cnt = 0;
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
return 0;
} else {
cnt = 0;
for (int i = B - 1; i <= D + 1; i++) {
if (S[i] == '.') {
cnt++;
} else
cnt = 0;
if (cnt >= 3) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,452 | 831,453 | u107077805 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
vector<string> split(string s, char delim) {
int len = s.length();
string currStr = "";
vector<string> retVec;
for (int i = 0; i < len; i++) {
char ch = s[i];
if (ch == delim) {
retVec.push_back(currStr);
currStr = "";
} else {
currStr += ch;
}
}
retVec.push_back(currStr);
return retVec;
}
vector<int> strToIntVec(string s) {
int len = s.length();
// s = s.substr(1,len-2);
vector<string> strVec = split(s, ' ');
vector<int> retVec;
for (int i = 0; i < strVec.size(); i++) {
int el = atoi(strVec[i].c_str());
retVec.push_back(el);
}
return retVec;
}
class RockGame {
public:
string canMove(int n, int a, int b, int c, int d, string s) {
string retS = "No";
bool rocksOKSN = checkRocks(n, a, c, s);
bool rocksOKFN = checkRocks(n, b, d, s);
if (rocksOKSN && rocksOKFN) {
if (c < d) {
retS = "Yes";
} else {
bool canCross = checkCross(n, a, b, c, d, s);
if (canCross)
retS = "Yes";
}
}
return retS;
}
bool checkRocks(int n, int i1, int i2, string s) {
bool retV = true;
for (int i = i1 + 1; i < (i2 - 1); i++) {
if ((s[i - 1] == '#') && (s[i] == '#')) {
retV = false;
break;
}
}
return retV;
}
bool checkCross(int n, int a, int b, int c, int d, string s) {
bool retV = false;
for (int i = b; i < d; i++) {
// i-1 is center in string, 0-indexed
if ((s[i - 2] == '.') && (s[i - 1] == '.') && (s[i] == '.')) {
retV = true;
break;
}
}
return retV;
}
};
int main(int argc, const char *argv[]) {
RockGame rg;
string nabcdLn, sLn;
getline(cin, nabcdLn);
getline(cin, sLn);
vector<int> nVec = strToIntVec(nabcdLn);
string outStr = rg.canMove(nVec[0], nVec[1], nVec[2], nVec[3], nVec[4], sLn);
cout << outStr << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
vector<string> split(string s, char delim) {
int len = s.length();
string currStr = "";
vector<string> retVec;
for (int i = 0; i < len; i++) {
char ch = s[i];
if (ch == delim) {
retVec.push_back(currStr);
currStr = "";
} else {
currStr += ch;
}
}
retVec.push_back(currStr);
return retVec;
}
vector<int> strToIntVec(string s) {
int len = s.length();
// s = s.substr(1,len-2);
vector<string> strVec = split(s, ' ');
vector<int> retVec;
for (int i = 0; i < strVec.size(); i++) {
int el = atoi(strVec[i].c_str());
retVec.push_back(el);
}
return retVec;
}
class RockGame {
public:
string canMove(int n, int a, int b, int c, int d, string s) {
string retS = "No";
bool rocksOKSN = checkRocks(n, a, c, s);
bool rocksOKFN = checkRocks(n, b, d, s);
if (rocksOKSN && rocksOKFN) {
if (c < d) {
retS = "Yes";
} else {
bool canCross = checkCross(n, a, b, c, d, s);
if (canCross)
retS = "Yes";
}
}
return retS;
}
bool checkRocks(int n, int i1, int i2, string s) {
bool retV = true;
for (int i = i1 + 1; i < (i2 - 1); i++) {
if ((s[i - 1] == '#') && (s[i] == '#')) {
retV = false;
break;
}
}
return retV;
}
bool checkCross(int n, int a, int b, int c, int d, string s) {
bool retV = false;
for (int i = b; i <= d; i++) {
// i-1 is center in string, 0-indexed
if ((s[i - 2] == '.') && (s[i - 1] == '.') && (s[i] == '.')) {
retV = true;
break;
}
}
return retV;
}
};
int main(int argc, const char *argv[]) {
RockGame rg;
string nabcdLn, sLn;
getline(cin, nabcdLn);
getline(cin, sLn);
vector<int> nVec = strToIntVec(nabcdLn);
string outStr = rg.canMove(nVec[0], nVec[1], nVec[2], nVec[3], nVec[4], sLn);
cout << outStr << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,459 | 831,460 | u989996503 | cpp |
p03017 | // Example program
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
// WA #3 -- Jump over B, while B stays at the beginning position
// 9 1 4 9 7
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
for (int i = max(0, b - 2); i <= d - 3; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| // Notes -- Should have done these:
// 1. Pad "#" to beginning and end of the given string -> No need to think hard
// about off-by-1 indices
// 2. Also no need to handle boundary condition (e.g., when B stays at its
// beginning position, and A jumps over B, no need max(0, b - 2))
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
// WA #3 -- Jump over B, while B stays at the beginning position
// 9 1 4 9 7
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
for (int i = max(0, b - 2); i <= d - 2; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,467 | 831,469 | u477824229 | cpp |
p03017 | // Example program
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
for (int i = b - 1; i <= d - 2; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| // Notes -- Should have done these:
// 1. Pad "#" to beginning and end of the given string -> No need to think hard
// about off-by-1 indices
// 2. Also no need to handle boundary condition (e.g., when B stays at its
// beginning position, and A jumps over B, no need max(0, b - 2))
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
// WA #3 -- Jump over B, while B stays at the beginning position
// 9 1 4 9 7
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
for (int i = max(0, b - 2); i <= d - 2; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"call.add",
"literal.number.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.arguments.change"
] | 831,470 | 831,469 | u477824229 | cpp |
p03017 | // Example program
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
// WA #3 -- Jump over B, while B stays at the beginning position
// 9 1 4 9 7
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
for (int i = max(0, b - 2); i <= d - 3; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| // Example program
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
// WA #3 -- Jump over B, while B stays at the beginning position
// 9 1 4 9 7
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
for (int i = max(0, b - 2); i <= d - 2; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,467 | 831,471 | u477824229 | cpp |
p03017 | // Example program
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
for (int i = b - 1; i <= d - 2; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| // Example program
#include <iostream>
#include <string>
using namespace std;
int n, a, b, c, d;
string s;
bool solve_simple(string &s, int x, int y) {
for (int i = x; i < y - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool can_skip(string &s, int a, int b, int c, int d) {
if (d > c) {
return true;
}
// WA #1
// for (int i = b - 1; i < d - 3; i++) {
// WA #2
// 9 1 3 9 6
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
// WA #3 -- Jump over B, while B stays at the beginning position
// 9 1 4 9 7
// .#.#...#.
// for (int i = b - 1; i <= d - 3; i++) {
for (int i = max(0, b - 2); i <= d - 2; i++) {
if (s.substr(i, 3) == "...") {
return true;
}
}
return false;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
bool ans =
solve_simple(s, a, c) && solve_simple(s, b, d) && can_skip(s, a, b, c, d);
cout << (ans ? "Yes" : "No") << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"call.add",
"literal.number.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.arguments.change"
] | 831,470 | 831,471 | u477824229 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long x = 0, ff = 1;
while (ch < '0' || ch > '9') {
if (ch == '-')
ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = x * 10 + ch - '0', ch = getchar();
return x * ff;
}
void write(long long aa) {
if (aa < 0)
putchar('-'), aa = -aa;
if (aa > 9)
write(aa / 10);
putchar('0' + aa % 10);
return;
}
int n, A, B, C, D;
char s[200005];
int main() {
n = read(), A = read(), B = read(), C = read(), D = read();
scanf("%s", s + 1);
for (int i = B + 1; i <= D; ++i)
if (s[i] == '#' && s[i - 1] == '#') {
puts("No");
return 0;
}
for (int i = A + 1; i <= C; ++i)
if (s[i] == '#' && s[i - 1] == '#') {
puts("No");
return 0;
}
if (C < D) {
puts("Yes");
return 0;
}
for (int i = B - 1; i <= D - 2; ++i)
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
puts("Yes");
return 0;
}
puts("No");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long x = 0, ff = 1;
while (ch < '0' || ch > '9') {
if (ch == '-')
ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = x * 10 + ch - '0', ch = getchar();
return x * ff;
}
void write(long long aa) {
if (aa < 0)
putchar('-'), aa = -aa;
if (aa > 9)
write(aa / 10);
putchar('0' + aa % 10);
return;
}
int n, A, B, C, D;
char s[200005];
int main() {
n = read(), A = read(), B = read(), C = read(), D = read();
scanf("%s", s + 1);
for (int i = B + 1; i <= D; ++i)
if (s[i] == '#' && s[i - 1] == '#') {
puts("No");
return 0;
}
for (int i = A + 1; i <= C; ++i)
if (s[i] == '#' && s[i - 1] == '#') {
puts("No");
return 0;
}
if (C < D) {
puts("Yes");
return 0;
}
for (int i = B - 1; i <= D - 1; ++i)
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
puts("Yes");
return 0;
}
puts("No");
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,475 | 831,477 | u098142718 | 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;
for (int i = A; i < max(C, D); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
if ((A < i && i < C) || (B < i && i < D)) {
cout << "No" << endl;
return 0;
}
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
bool flag = false;
for (int i = B; i < D; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i - 2] == '.') {
flag = true;
}
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
} | #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;
for (int i = A; i < max(C, D); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
if ((A < i && i < C) || (B < i && i < D)) {
cout << "No" << endl;
return 0;
}
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
bool flag = false;
for (int i = B; i <= D; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i - 2] == '.') {
flag = true;
}
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,478 | 831,479 | u840810569 | 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;
for (int i = A; i < max(C, D); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
if ((A < i && i < C) || (B < i && i < D)) {
cout << "No" << endl;
return 0;
}
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
bool flag = false;
for (int i = B - 1; i < D; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i - 2] == '.') {
flag = true;
}
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
} | #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;
for (int i = A; i < max(C, D); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
if ((A < i && i < C) || (B < i && i < D)) {
cout << "No" << endl;
return 0;
}
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
bool flag = false;
for (int i = B; i <= D; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i - 2] == '.') {
flag = true;
}
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
} | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,480 | 831,479 | u840810569 | cpp |
p03017 | /*
AUTHOR:shivam51
IIESTS
*/
#include <bits/stdc++.h>
using namespace std;
//
#define add accumulate
#define ll long long int
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define vll vector<ll>
#define lb lower_bound
#define ub upper_bound
#define pll pair<ll, ll>
#define vpll vector<pll>
#define all(v) v.begin(), v.end()
#define rep(i, k, n) for (int i = k; i < n; i++)
#define hs \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
const int md = 1e8;
const ll MAX = 1e5 + 5;
//
//
int main() {
ll n, a, b, x, y;
cin >> n >> a >> b >> x >> y;
string str;
cin >> str;
str = '.' + str;
rep(i, a + 1, x + 1) if (str[i] == '#' && str[i - 1] == '#') {
cout << "No";
return 0;
}
rep(i, b + 1, y + 1) if (str[i] == '#' && str[i - 1] == '#') {
cout << "No";
return 0;
}
if (x < y) {
cout << "Yes";
} else {
rep(i, b + 1,
y + 1) if (str[i] == '.' && str[i + 1] == '.' && str[i - 1] == '.') {
cout << "Yes";
return 0;
}
cout << "No";
}
return 0;
}
| /*
AUTHOR:shivam51
IIESTS
*/
#include <bits/stdc++.h>
using namespace std;
//
#define add accumulate
#define ll long long int
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define vll vector<ll>
#define lb lower_bound
#define ub upper_bound
#define pll pair<ll, ll>
#define vpll vector<pll>
#define all(v) v.begin(), v.end()
#define rep(i, k, n) for (int i = k; i < n; i++)
#define hs \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
const int md = 1e8;
const ll MAX = 1e5 + 5;
//
//
int main() {
ll n, a, b, x, y;
cin >> n >> a >> b >> x >> y;
string str;
cin >> str;
str = ',' + str;
rep(i, a + 1, x + 1) if (str[i] == '#' && str[i - 1] == '#') {
cout << "No";
return 0;
}
rep(i, b + 1, y + 1) if (str[i] == '#' && str[i - 1] == '#') {
cout << "No";
return 0;
}
if (x < y) {
cout << "Yes";
} else {
rep(i, b,
y + 1) if (str[i] == '.' && str[i + 1] == '.' && str[i - 1] == '.') {
cout << "Yes";
return 0;
}
cout << "No";
}
return 0;
}
| [
"misc.typo",
"literal.string.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,493 | 831,494 | u216557283 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define Mod 1000000007
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = a; i < c - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
int mx = 1;
if (c > d) {
for (int i = max(a, b); i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i - 1] == '.') {
mx = 0;
}
}
// cout<<mx<<" ";
if (mx) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define Mod 1000000007
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
for (int i = a; i < c - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
for (int i = b; i < d - 1; i++) {
if (s[i] == s[i - 1] && s[i] == '#') {
cout << "No";
return 0;
}
}
int mx = 1;
if (c > d) {
for (int i = max(a, b) - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i - 1] == '.') {
mx = 0;
}
}
// cout<<mx<<" ";
if (mx) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 831,513 | 831,514 | u158165654 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = 0; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がCまでにあるならOK
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 main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がDまでにあるならOK
for (int i = B - 1; i < D; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,518 | 831,516 | u265249432 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = 0; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がCまでにあるならOK
for (int i = B - 1; 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 main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がDまでにあるならOK
for (int i = B - 1; i < D; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,519 | 831,516 | u265249432 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = 0; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がDまでにあるならOK
for (int i = B - 1; 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 main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がDまでにあるならOK
for (int i = B - 1; i < D; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,520 | 831,516 | u265249432 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = 0; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所があるならOK
for (int i = B - 1; i < N - 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 main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がDまでにあるならOK
for (int i = B - 1; i < D; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,521 | 831,516 | u265249432 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = 0; i < min(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所があるならOK
for (int i = B - 1; i < N - 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 main(void) {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
string S;
cin >> S;
// 2連続の岩がゴールより手前にあったらアウト
for (int i = A; i < max(C, D) - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
// C < D ならそのままOK
if (C < D) {
cout << "Yes" << endl;
return 0;
}
// C > D
// ...
// AB.
// .BA
// B-1より先で追い越せる場所がDまでにあるならOK
for (int i = B - 1; i < D; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.... | 831,522 | 831,516 | u265249432 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B, C, D;
string str;
bool check2 = 0, check3 = 0;
cin >> N >> A >> B >> C >> D;
cin >> str;
int i;
for (i = A - 1; i < C - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
for (i = B - 1; i < D - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
if (C > D) {
for (i = B - 1; i < C; i++) {
if ((str[i - 1] == '.') && (str[i] == '.') && (str[i + 1] == '.')) {
check3 = 1;
break;
}
}
}
if (check2) {
cout << "No";
} else if (C < D) {
cout << "Yes";
} else if (check3) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B, C, D;
string str;
bool check2 = 0, check3 = 0;
cin >> N >> A >> B >> C >> D;
cin >> str;
int i;
for (i = A - 1; i < C - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
for (i = B - 1; i < D - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
if (C > D) {
for (i = B - 1; i < D; i++) {
if ((str[i - 1] == '.') && (str[i] == '.') && (str[i + 1] == '.')) {
check3 = 1;
break;
}
}
}
if (check2) {
cout << "No";
} else if (C < D) {
cout << "Yes";
} else if (check3) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 831,536 | 831,538 | u453235374 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B, C, D;
string str;
bool check2 = 0, check3 = 0;
cin >> N >> A >> B >> C >> D;
cin >> str;
int i;
for (i = A - 1; i < C - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
for (i = B - 1; i < D - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
if (C > D) {
for (i = B - 1; i < C - 1; i++) {
if ((str[i - 1] == '.') && (str[i] == '.') && (str[i + 1] == '.')) {
check3 = 1;
break;
}
}
}
if (check2) {
cout << "No";
} else if (C < D) {
cout << "Yes";
} else if (check3) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, A, B, C, D;
string str;
bool check2 = 0, check3 = 0;
cin >> N >> A >> B >> C >> D;
cin >> str;
int i;
for (i = A - 1; i < C - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
for (i = B - 1; i < D - 1; i++) {
if ((str[i] == '#') && (str[i + 1] == '#')) {
check2 = 1;
break;
}
}
if (C > D) {
for (i = B - 1; i < D; i++) {
if ((str[i - 1] == '.') && (str[i] == '.') && (str[i + 1] == '.')) {
check3 = 1;
break;
}
}
}
if (check2) {
cout << "No";
} else if (C < D) {
cout << "Yes";
} else if (check3) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,540 | 831,538 | u453235374 | cpp |
p03017 | #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ans = false;
break;
}
}
if (d < c) {
bool check = false;
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
check = true;
break;
}
}
ans = ans && check;
}
cout << (ans ? "Yes" : "No") << "\n";
} | #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ans = false;
break;
}
}
if (d < c) {
bool check = false;
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
check = true;
break;
}
}
ans = ans && check;
}
cout << (ans ? "Yes" : "No") << "\n";
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,542 | 831,543 | u346193734 | cpp |
p03017 | #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ans = false;
break;
}
}
if (d < c) {
bool check = false;
for (int i = b + 1; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
check = true;
break;
}
}
ans = ans && check;
}
cout << (ans ? "Yes" : "No") << "\n";
}
| #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ans = false;
break;
}
}
if (d < c) {
bool check = false;
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
check = true;
break;
}
}
ans = ans && check;
}
cout << (ans ? "Yes" : "No") << "\n";
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,546 | 831,543 | u346193734 | cpp |
p03017 | #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ans = false;
break;
}
}
if (d < c) {
bool check = false;
for (int i = b + 1; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
check = true;
break;
}
}
ans = check;
}
cout << (ans ? "Yes" : "No") << "\n";
} | #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ans = true;
for (int i = a + 1; i < max(c, d); i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ans = false;
break;
}
}
if (d < c) {
bool check = false;
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
check = true;
break;
}
}
ans = ans && check;
}
cout << (ans ? "Yes" : "No") << "\n";
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"assignment.change"
] | 831,547 | 831,543 | u346193734 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define INF 1000000007
#define LINF 1000000000000000007
#define MOD 1000000007
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define repb(i, n) for (int i = n - 1; i >= 0; i--)
#define MODE 1
#ifdef MODE
#define DEB(X) cout << #X << ": " << X << " ";
#define ARDEB(i, X) cout << #X << "[" << i << "]: " << X[i] << " ";
#define END cout << endl;
#else
#define DEB(X) \
{}
#define ARDEB(i, X) \
{}
#define END \
{}
#endif
typedef pair<int, int> P;
struct edge {
int to, cost;
};
typedef long long ll;
int ans;
signed main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
int f = 1, f2 = 0;
int co = 0;
if (c < d) {
for (int i = a - 1; i < d; i++) {
if (i == n - 1) {
continue;
}
if (s[i] == '#' && s[i + 1] == '#') {
f = 0;
break;
}
}
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} else {
for (int i = a - 1; i < d; i++) {
if (i == n - 1) {
continue;
}
if (s[i] == '#' && s[i + 1] == '#') {
f = 0;
break;
}
}
for (int i = b - 1; i < c; i++) {
if (i == n - 1) {
continue;
}
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
f2 = 1;
}
}
if (f && f2)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define INF 1000000007
#define LINF 1000000000000000007
#define MOD 1000000007
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define repb(i, n) for (int i = n - 1; i >= 0; i--)
#define MODE 1
#ifdef MODE
#define DEB(X) cout << #X << ": " << X << " ";
#define ARDEB(i, X) cout << #X << "[" << i << "]: " << X[i] << " ";
#define END cout << endl;
#else
#define DEB(X) \
{}
#define ARDEB(i, X) \
{}
#define END \
{}
#endif
typedef pair<int, int> P;
struct edge {
int to, cost;
};
typedef long long ll;
int ans;
signed main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
int f = 1, f2 = 0;
int co = 0;
if (c < d) {
for (int i = a - 1; i < d; i++) {
if (i == n - 1) {
continue;
}
if (s[i] == '#' && s[i + 1] == '#') {
f = 0;
break;
}
}
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} else {
for (int i = a - 1; i < d; i++) {
if (i == n - 1) {
continue;
}
if (s[i] == '#' && s[i + 1] == '#') {
f = 0;
break;
}
}
for (int i = b - 1; i < d; i++) {
if (i == n - 1) {
continue;
}
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
f2 = 1;
}
}
if (f && f2)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 831,548 | 831,549 | u901561754 | 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;
int mn = min(c, d) - 1;
int mx = max(c, d) - 1;
//? ~~ A ~ C,D ~ C,D ~~ ?
// 0 ~~ a-1 ~ mn ~ mx ~~ length()-1
//連続した##のとき除外
for (int i = a; i <= mx - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (c < d) {
cout << "Yes" << endl;
return 0;
} else { //(c>d)
//連続した...ならok
for (int i = b - 2; i <= mn - 2; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
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;
int mn = min(c, d) - 1;
int mx = max(c, d) - 1;
//? ~~ A ? ~ B ? ~ C,D ~ C,D ~~ ?
// 0 ~~ a-1 a ~ b-1 b ~ mn ~ mx ~~ length()-1
//連続した##のとき除外
for (int i = a; i < mx; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (c < d) {
cout << "Yes" << endl;
return 0;
} else { //(c>d)
//連続した...ならok
for (int i = b - 2; i < mn; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
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"
] | 831,551 | 831,553 | u948459352 | 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;
int mn = min(c, d) - 1;
int mx = max(c, d) - 1;
//? ~~ A ~ C,D ~ C,D ~~ ?
// 0 ~~ a-1 ~ mn ~ mx ~~ length()-1
//連続した##のとき除外
for (int i = a; i <= mx - 1; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (c < d) {
cout << "Yes" << endl;
return 0;
} else { //(c>d)
//連続した...ならok
for (int i = b - 2; i <= mn - 2; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
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;
int mn = min(c, d) - 1;
int mx = max(c, d) - 1;
//? ~~ A ? ~ B ? ~ C,D ~ C,D ~~ ?
// 0 ~~ a-1 a ~ b-1 b ~ mn ~ mx ~~ length()-1
//連続した##のとき除外
for (int i = a; i < mx; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (c < d) {
cout << "Yes" << endl;
return 0;
} else { //(c>d)
//連続した...ならok
for (int i = b - 2; i <= mn - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 831,551 | 831,554 | u948459352 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A, --B, --C, --D;
string S;
cin >> S;
auto checkRoute = [&S](int from, int to) {
for (int i = from; i < to; ++i) {
if (S[i] == '#' && S[i + 1] == '#')
return false;
}
return true;
};
if (!checkRoute(A, C)) {
cout << "No" << endl;
return 0;
}
if (!checkRoute(B, D)) {
cout << "No" << endl;
return 0;
}
bool enable = true;
if (D < C) {
enable = false;
for (int i = B; i < D; ++i) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
enable = true;
break;
}
}
}
if (enable) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A, --B, --C, --D;
string S;
cin >> S;
auto checkRoute = [&S](int from, int to) {
for (int i = from; i < to; ++i) {
if (S[i] == '#' && S[i + 1] == '#')
return false;
}
return true;
};
if (!checkRoute(A, C)) {
cout << "No" << endl;
return 0;
}
if (!checkRoute(B, D)) {
cout << "No" << endl;
return 0;
}
bool enable = true;
if (D < C) {
enable = false;
for (int i = B; i <= D; ++i) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
enable = true;
break;
}
}
}
if (enable) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,558 | 831,559 | u762603420 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
// #define ll long long int
#define int long long int
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string path;
cin >> path;
int f = 1;
int k = max(c, d);
for (int i = a - 1; i < n - 1 && i < k - 2; ++i) {
if (path[i] == '#' && path[i + 1] == '#')
f = 0;
}
int l = 1;
if (f) {
if (c > d) {
l = 0;
for (int i = a - 1; i < d; ++i) {
if (path[i] == '.' && path[i - 1] == '.' && path[i + 1] == '.') {
l = 1;
break;
}
}
if (l == 0)
f = 0;
}
}
if (f)
cout << "Yes";
else
cout << "No";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// #define ll long long int
#define int long long int
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string path;
cin >> path;
int f = 1;
int k = max(c, d);
for (int i = a - 1; i < n - 1 && i < k - 2; ++i) {
if (path[i] == '#' && path[i + 1] == '#')
f = 0;
}
int l = 1;
if (f) {
if (c > d) {
l = 0;
for (int i = b - 1; i < d; ++i) {
if (path[i] == '.' && path[i - 1] == '.' && path[i + 1] == '.') {
l = 1;
break;
}
}
if (l == 0)
f = 0;
}
}
if (f)
cout << "Yes";
else
cout << "No";
return 0;
} | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 831,560 | 831,561 | u060049558 | cpp |
p03017 | // finish date: 2019/06/03
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 998244353;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool isreachedA = true;
bool isreachedB = true;
FOR(i, A, C - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedA = false;
FOR(i, B, D - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedB = false;
bool caseCD = false;
if (C > D) {
FOR(i, B - 1, D - 1) {
if ((S[i - 1] == S[i]) && (S[i] == S[i + 1]) && (S[i + 1] == '.'))
caseCD = true;
}
} else {
caseCD = true;
}
if (isreachedA && isreachedB && caseCD) {
cout << "Yes" << endl;
} else {
cout << "Yes" << endl;
}
return 0;
}
| // finish date: 2019/06/03
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 998244353;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool isreachedA = true;
bool isreachedB = true;
FOR(i, A, C - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedA = false;
FOR(i, B, D - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedB = false;
bool caseCD = false;
if (C > D) {
FOR(i, B - 1, D) {
if ((S[i - 1] == S[i]) && (S[i] == S[i + 1]) && (S[i + 1] == '.'))
caseCD = true;
}
} else {
caseCD = true;
}
if (isreachedA && isreachedB && caseCD) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"literal.string.change",
"io.output.change"
] | 831,582 | 831,583 | u285660186 | cpp |
p03017 | // finish date: 2019/06/03
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 998244353;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool isreachedA = true;
bool isreachedB = true;
FOR(i, A, C - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedA = false;
FOR(i, B, D - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedB = false;
bool caseCD = false;
if (C > D) {
FOR(i, B - 2, D - 1) {
if ((S[i - 1] == S[i]) && (S[i] == S[i + 1]) && (S[i + 1] == '.'))
caseCD = true;
}
} else {
caseCD = true;
}
if (isreachedA && isreachedB && caseCD) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| // finish date: 2019/06/03
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 998244353;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool isreachedA = true;
bool isreachedB = true;
FOR(i, A, C - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedA = false;
FOR(i, B, D - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedB = false;
bool caseCD = false;
if (C > D) {
FOR(i, B - 1, D) {
if ((S[i - 1] == S[i]) && (S[i] == S[i + 1]) && (S[i + 1] == '.'))
caseCD = true;
}
} else {
caseCD = true;
}
if (isreachedA && isreachedB && caseCD) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,584 | 831,583 | u285660186 | cpp |
p03017 | // finish date: 2019/06/03
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 998244353;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool isreachedA = true;
bool isreachedB = true;
FOR(i, A, C - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedA = false;
FOR(i, B, D - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedB = false;
bool caseCD = false;
if (C > D) {
FOR(i, B - 1, D - 1) {
if ((S[i - 1] == S[i]) && (S[i] == S[i + 1]) && (S[i + 1] == '.'))
caseCD = true;
}
} else {
caseCD = true;
}
if (isreachedA && isreachedB && caseCD) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| // finish date: 2019/06/03
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int(i) = a; (i) < (b); (i)++)
#define rep(i, n) FOR(i, 0, n)
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<vector<vector<double>>> vvvd;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<vector<char>> vvc;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, pair<int, int>> plii;
const int bigmod = 998244353;
const int INF = 1050000000;
const long long INFll = 100000000000000000;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
bool isreachedA = true;
bool isreachedB = true;
FOR(i, A, C - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedA = false;
FOR(i, B, D - 1)
if ((S[i] == S[i + 1]) && (S[i + 1] == '#')) isreachedB = false;
bool caseCD = false;
if (C > D) {
FOR(i, B - 1, D) {
if ((S[i - 1] == S[i]) && (S[i] == S[i + 1]) && (S[i + 1] == '.'))
caseCD = true;
}
} else {
caseCD = true;
}
if (isreachedA && isreachedB && caseCD) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 831,585 | 831,583 | u285660186 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define INF 2147483647
#define INFF 9223372036854775807
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, m, n) for (int i = m; i < n; i++)
#define ALL(N) (N.begin(), N.end())
#define de cout << "debug" << endl;
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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
A--;
B--;
if (C < D) {
REPP(i, min(A, B), max(C, D) - 1) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else if (C > D) {
REPP(i, min(A, B), max(C, D) - 1) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
REPP(i, B - 1, D - 2) {
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;
#define INF 2147483647
#define INFF 9223372036854775807
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, m, n) for (int i = m; i < n; i++)
#define ALL(N) (N.begin(), N.end())
#define de cout << "debug" << endl;
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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
A--;
B--;
if (C < D) {
REPP(i, min(A, B), max(C, D) - 1) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else if (C > D) {
REPP(i, min(A, B), max(C, D) - 1) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
REPP(i, B - 1, D - 1) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,598 | 831,599 | u901397311 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for (int i = 0; i < n; i++)
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;
}
const ll MOD = 1e9 + 7;
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) {
bool ac = true;
for (int i = A + 1; i < C; i++) {
char c1 = S[i];
char c2 = S[i + 1];
if (c1 == '#' && c2 == '#') {
ac = false;
}
}
bool cd = true;
for (int i = B + 1; i < D; i++) {
char c1 = S[i];
char c2 = S[i + 1];
if (c1 == '#' && c2 == '#') {
cd = false;
}
}
if (cd && ac) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
bool ac = true;
for (int i = A + 1; i < C; i++) {
char c1 = S[i];
char c2 = S[i + 1];
if (c1 == '#' && c2 == '#') {
ac = false;
}
}
bool cd = false;
for (int i = B - 1; i < D - 1; i++) {
char c1 = S[i];
char c2 = S[i + 1];
char c3 = S[i + 2];
if (c1 == '.' && c2 == '.' && c3 == '.') {
cd = true;
}
}
if (cd && ac) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define REP(i, n) for (int i = 0; i < n; i++)
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;
}
const ll MOD = 1e9 + 7;
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) {
bool ac = true;
for (int i = A + 1; i < C; i++) {
char c1 = S[i];
char c2 = S[i + 1];
if (c1 == '#' && c2 == '#') {
ac = false;
}
}
bool cd = true;
for (int i = B + 1; i < D; i++) {
char c1 = S[i];
char c2 = S[i + 1];
if (c1 == '#' && c2 == '#') {
cd = false;
}
}
if (cd && ac) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
bool ac = true;
for (int i = A + 1; i < C; i++) {
char c1 = S[i];
char c2 = S[i + 1];
if (c1 == '#' && c2 == '#') {
ac = false;
}
}
bool cd = false;
for (int i = B - 1; i < D; i++) {
char c1 = S[i];
char c2 = S[i + 1];
char c3 = S[i + 2];
if (c1 == '.' && c2 == '.' && c3 == '.') {
cd = true;
}
}
if (cd && ac) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,603 | 831,604 | u666394517 | cpp |
p03017 | #include "bits/stdc++.h"
typedef long long int lli;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
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;
}
}
if (C < D) {
cout << "Yes" << 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;
}
} | #include "bits/stdc++.h"
typedef long long int lli;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
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;
}
}
if (C < D) {
cout << "Yes" << endl;
return 0;
}
if (C > D) {
for (int i = B; i <= D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
} | [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,608 | 831,609 | u294738119 | cpp |
p03017 | #include "bits/stdc++.h"
typedef long long int lli;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
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;
}
}
if (C < D) {
cout << "Yes" << endl;
return 0;
}
if (C > D) {
for (int i = B; i < D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
} | #include "bits/stdc++.h"
typedef long long int lli;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
S = "#" + S + "#";
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;
}
}
if (C < D) {
cout << "Yes" << endl;
return 0;
}
if (C > D) {
for (int i = B; i <= D; i++) {
if (S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,611 | 831,609 | u294738119 | cpp |
p03017 | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
return z < p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa3 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
return z > p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
if (z != p.z)
return z < p.z;
return w < p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa4 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
if (z != p.z)
return z > p.z;
return w > p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b)
return gcd(b, v);
if (v == b)
return b;
if (b % v == 0)
return v;
return gcd(v, b % v);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pa operator+(const pa &l, const pa &r) {
return {l.first + r.first, l.second + r.second};
}
pa operator-(const pa &l, const pa &r) {
return {l.first - r.first, l.second - r.second};
}
int pr[1200010];
int inv[1200010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0)
return 1 % warukazu;
if (rr == 1)
return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((ll)beki(wa, rr - 1, warukazu) * (ll)wa) % warukazu;
ll zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int comb(int nn, int rr) {
if (rr < 0 || rr > nn || nn < 0)
return 0;
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (int i = ert - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
// cin.tie(0);
// ios::sync_with_stdio(false);
// priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
// sort(ve.begin(),ve.end(),greater<int>());
// mt19937(clock_per_sec);
// mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
//----------------kokomade tenpure------------
string s;
bool ch(int a, int b) {
for (int i = a; i < b; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return 0;
}
}
return 1;
}
bool ok(int a, int b) {
for (int i = a; i <= b; i++)
if (s[i] == '.') {
if (s[i - 1] == '.' && s[i + 1] == '.') {
return 1;
}
}
return 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
s = "s" + s;
if (c < d) {
if (ch(a, c) & ch(b, d))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
if (!ch(b, d)) {
cout << "No" << endl;
return 0;
}
if (!ch(a, c)) {
cout << "No" << endl;
return 0;
}
if (ok(a, c)) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
return z < p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa3 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
return z > p.z;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x)
return x < p.x;
if (y != p.y)
return y < p.y;
if (z != p.z)
return z < p.z;
return w < p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator>(const pa4 &p) const {
if (x != p.x)
return x > p.x;
if (y != p.y)
return y > p.y;
if (z != p.z)
return z > p.z;
return w > p.w;
// return x != p.x ? x<p.x: y<p.y;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b)
return gcd(b, v);
if (v == b)
return b;
if (b % v == 0)
return v;
return gcd(v, b % v);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pa operator+(const pa &l, const pa &r) {
return {l.first + r.first, l.second + r.second};
}
pa operator-(const pa &l, const pa &r) {
return {l.first - r.first, l.second - r.second};
}
int pr[1200010];
int inv[1200010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0)
return 1 % warukazu;
if (rr == 1)
return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((ll)beki(wa, rr - 1, warukazu) * (ll)wa) % warukazu;
ll zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
int comb(int nn, int rr) {
if (rr < 0 || rr > nn || nn < 0)
return 0;
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (int i = ert - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
// cin.tie(0);
// ios::sync_with_stdio(false);
// priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
// sort(ve.begin(),ve.end(),greater<int>());
// mt19937(clock_per_sec);
// mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
//----------------kokomade tenpure------------
string s;
bool ch(int a, int b) {
for (int i = a; i < b; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return 0;
}
}
return 1;
}
bool ok(int a, int b) {
for (int i = a; i <= b; i++)
if (s[i] == '.') {
if (s[i - 1] == '.' && s[i + 1] == '.') {
return 1;
}
}
return 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
s = "s" + s;
if (c < d) {
if (ch(a, c) & ch(b, d))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
if (!ch(b, d)) {
cout << "No" << endl;
return 0;
}
if (!ch(a, c)) {
cout << "No" << endl;
return 0;
}
if (ok(b, d)) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 831,618 | 831,619 | u834777932 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool has_target(string s, int from, int to, string target) {
auto x = s.find(target, from);
// printf("has_target %d, %d\n", x, string::npos);
if (x == string::npos) {
return false;
} else if (x < to) {
return true;
}
return false;
}
int main() {
string s;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
if (c > d) {
bool overtakes = has_target(s, b - 1, c - 1, "...");
if (!overtakes) {
cout << "No" << endl;
return 0;
}
}
bool ok1 = !has_target(s, a, c, "##");
bool ok2 = !has_target(s, b, d, "##");
cout << (ok1 && ok2 ? "Yes" : "No") << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool has_target(string s, int from, int to, string target) {
auto x = s.find(target, from);
// printf("has_target %d, %d, %s\n", x, to, target.c_str());
if (x == string::npos) {
return false;
} else if (x < to) {
return true;
}
return false;
}
int main() {
string s;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
if (c > d) {
bool overtakes = has_target(s, b - 1, d, "...");
if (!overtakes) {
cout << "No" << endl;
return 0;
}
}
bool ok1 = !has_target(s, a, c, "##");
bool ok2 = !has_target(s, b, d, "##");
cout << (ok1 && ok2 ? "Yes" : "No") << endl;
return 0;
}
| [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,625 | 831,626 | u590241855 | cpp |
p03017 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool has_target(string s, int from, int to, string target) {
auto x = s.find(target, from);
// printf("has_target %d, %d\n", x, string::npos);
if (x == string::npos) {
return false;
} else if (x < to) {
return true;
}
return false;
}
int main() {
string s;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
if (c > d) {
bool overtakes = has_target(s, b, c - 1, "...");
if (!overtakes) {
cout << "No" << endl;
return 0;
}
}
bool ok1 = !has_target(s, a, c, "##");
bool ok2 = !has_target(s, b, d, "##");
cout << (ok1 && ok2 ? "Yes" : "No") << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool has_target(string s, int from, int to, string target) {
auto x = s.find(target, from);
// printf("has_target %d, %d, %s\n", x, to, target.c_str());
if (x == string::npos) {
return false;
} else if (x < to) {
return true;
}
return false;
}
int main() {
string s;
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
cin >> s;
a--;
b--;
c--;
d--;
if (c > d) {
bool overtakes = has_target(s, b - 1, d, "...");
if (!overtakes) {
cout << "No" << endl;
return 0;
}
}
bool ok1 = !has_target(s, a, c, "##");
bool ok2 = !has_target(s, b, d, "##");
cout << (ok1 && ok2 ? "Yes" : "No") << endl;
return 0;
}
| [
"call.arguments.change",
"call.arguments.add"
] | 831,627 | 831,626 | u590241855 | cpp |
p03017 | #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s = "#" + s + "#";
auto can_jump = [&](int start, int goal) {
for (int i = start; i + 1 <= goal; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
return true;
}
};
if (!can_jump(a, c) || !can_jump(b, d)) {
cout << "No" << endl;
return 0;
}
if (c > d) {
bool sunuke = false;
for (int i = b; i <= d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
sunuke = true;
}
}
if (!sunuke) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s = "#" + s + "#";
auto can_jump = [&](int start, int goal) {
for (int i = start; i + 1 <= goal; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
};
if (!can_jump(a, c) || !can_jump(b, d)) {
cout << "No" << endl;
return 0;
}
if (c > d) {
bool sunuke = false;
for (int i = b; i <= d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
sunuke = true;
}
}
if (!sunuke) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| [] | 831,628 | 831,629 | u993967581 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = {0, -1, 1, 0};
const ll dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
void mul(ll a, ll b) { a = a * b % INF; }
///////////////////////////////////////
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) {
int cnt = 0;
for (int i = A; i <= D; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} else {
int cnt = 0;
for (int i = A; i <= C; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
int c = 0;
for (int i = B; i <= D; ++i) {
if (S[i] == '.') {
c++;
} else {
c = 0;
}
if (c >= 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = {0, -1, 1, 0};
const ll dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
void mul(ll a, ll b) { a = a * b % INF; }
///////////////////////////////////////
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) {
int cnt = 0;
for (int i = A; i <= D; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} else {
int cnt = 0;
for (int i = A; i <= C; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
int c = 0;
for (int i = B - 1; i <= D + 1; ++i) {
if (S[i] == '.') {
c++;
} else {
c = 0;
}
if (c >= 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,639 | 831,640 | u406158207 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = {0, -1, 1, 0};
const ll dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
void mul(ll a, ll b) { a = a * b % INF; }
///////////////////////////////////////
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) {
int cnt = 0;
for (int i = A; i <= D; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} else {
int cnt = 0;
for (int i = A; i <= D; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
int c = 0;
for (int i = B; i <= D; ++i) {
if (S[i] == '.') {
c++;
} else {
c = 0;
}
if (c >= 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = {0, -1, 1, 0};
const ll dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
void mul(ll a, ll b) { a = a * b % INF; }
///////////////////////////////////////
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) {
int cnt = 0;
for (int i = A; i <= D; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} else {
int cnt = 0;
for (int i = A; i <= C; ++i) {
if (S[i] == '#') {
cnt++;
} else {
cnt = 0;
}
if (cnt >= 2) {
cout << "No" << endl;
return 0;
}
}
int c = 0;
for (int i = B - 1; i <= D + 1; ++i) {
if (S[i] == '.') {
c++;
} else {
c = 0;
}
if (c >= 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,641 | 831,640 | u406158207 | cpp |
p03017 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(), (a).end()
#define INF (1 << 29)
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;
}
int N, A, B, C, D;
string S;
bool flag = true;
int main() {
// ifstream in("input.txt");
// cin.rdbuf(in.rdbuf());
cin >> N >> A >> B >> C >> D >> S;
A--;
B--;
C--;
D--;
if (C > D) { //追い越し
bool oiko = false;
repi(i, B - 1, C + 1) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
oiko = true;
}
if (!oiko)
flag = false;
}
repi(i, A + 1, C) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
repi(i, B + 1, D) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
if (flag)
out("Yes");
else
out("No");
}
| #include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(), (a).end()
#define INF (1 << 29)
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;
}
int N, A, B, C, D;
string S;
bool flag = true;
int main() {
// ifstream in("input.txt");
// cin.rdbuf(in.rdbuf());
cin >> N >> A >> B >> C >> D >> S;
A--;
B--;
C--;
D--;
if (C > D) { //追い越し
bool oiko = false;
repi(i, B - 1, D) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
oiko = true;
}
if (!oiko)
flag = false;
}
repi(i, A + 1, C) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
repi(i, B + 1, D) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
if (flag)
out("Yes");
else
out("No");
}
| [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 831,645 | 831,646 | u190907730 | cpp |
p03017 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(), (a).end()
#define INF (1 << 29)
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;
}
int N, A, B, C, D;
string S;
bool flag = true;
int main() {
// ifstream in("input.txt");
// cin.rdbuf(in.rdbuf());
cin >> N >> A >> B >> C >> D >> S;
A--;
B--;
C--;
D--;
if (C > D) { //追い越し
bool oiko = false;
repi(i, B - 1, C) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
oiko = true;
}
if (!oiko)
flag = false;
}
repi(i, A + 1, C) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
repi(i, B + 1, D) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
if (flag)
out("Yes");
else
out("No");
}
| #include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(), (a).end()
#define INF (1 << 29)
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;
}
int N, A, B, C, D;
string S;
bool flag = true;
int main() {
// ifstream in("input.txt");
// cin.rdbuf(in.rdbuf());
cin >> N >> A >> B >> C >> D >> S;
A--;
B--;
C--;
D--;
if (C > D) { //追い越し
bool oiko = false;
repi(i, B - 1, D) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
oiko = true;
}
if (!oiko)
flag = false;
}
repi(i, A + 1, C) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
repi(i, B + 1, D) {
if (S[i] == '#' && S[i + 1] == '#') {
flag = false;
break;
}
}
if (flag)
out("Yes");
else
out("No");
}
| [
"identifier.change",
"call.arguments.change"
] | 831,647 | 831,646 | u190907730 | cpp |
p03017 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define lol long long
int N, A, B, C, D;
string S;
bool pos(int a, int b) {
if (b - 2 <= a) {
return true;
} else if (S[a + 1] == '.') {
return pos(a + 2, b);
} else if (S[a] == '.') {
return pos(a + 1, b);
} else {
return false;
}
}
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
S = S + "l";
bool can = false;
if (C < D) {
if (pos(A, C) && pos(B, D)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
for (int i = B - 1; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
can = true;
}
}
if (can && pos(A, C) && pos(B, D)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define lol long long
int N, A, B, C, D;
string S;
bool pos(int a, int b) {
if (b - 2 <= a) {
return true;
} else if (S[a + 1] == '.') {
return pos(a + 2, b);
} else if (S[a] == '.') {
return pos(a + 1, b);
} else {
return false;
}
}
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
S = S + "l";
bool can = false;
if (C < D) {
if (pos(A, C) && pos(B, D)) {
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] == '.') {
can = true;
}
}
if (can && pos(A, C) && pos(B, D)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,652 | 831,653 | u086366728 | cpp |
p03017 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
bool solve(string s, ll start, ll stop) {
// cout << "solve" << endl;
bool flag = false;
for (int i = start + 1; i <= stop; i++) {
if (s[i] == '#') {
// cout << "#" << endl;
if (flag)
return false;
flag = true;
} else {
// cout << "." << endl;
flag = false;
}
}
return true;
}
bool can_throw(string S, ll start, ll stop) {
// return true;
for (int i = start; i <= stop; i++) {
if (S[i - 1] == '.' and S[i] == '.' and S[i + 1] == '.') {
return true;
}
}
return false;
}
// Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long A;
scanf("%lld", &A);
long long B;
scanf("%lld", &B);
long long C;
scanf("%lld", &C);
long long D;
scanf("%lld", &D);
// 0indexs
A--;
B--;
C--;
D--;
std::string S;
std::cin >> S;
if ((C < D) or (C < B)) {
if (solve(S, A, C) and solve(S, B, D)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
if (solve(S, A, C) and solve(S, B, D)) {
if (can_throw(S, max({A, B}), max({C, D}))) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
cout << "No" << endl;
}
}
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
bool solve(string s, ll start, ll stop) {
// cout << "solve" << endl;
bool flag = false;
for (int i = start + 1; i <= stop; i++) {
if (s[i] == '#') {
// cout << "#" << endl;
if (flag)
return false;
flag = true;
} else {
// cout << "." << endl;
flag = false;
}
}
return true;
}
bool can_throw(string S, ll start, ll stop) {
// return true;
for (int i = start; i <= stop; i++) {
if (S[i - 1] == '.' and S[i] == '.' and S[i + 1] == '.') {
return true;
}
}
return false;
}
// Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long A;
scanf("%lld", &A);
long long B;
scanf("%lld", &B);
long long C;
scanf("%lld", &C);
long long D;
scanf("%lld", &D);
// 0indexs
A--;
B--;
C--;
D--;
std::string S;
std::cin >> S;
if ((C < D) or (C < B)) {
if (solve(S, A, C) and solve(S, B, D)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
if (solve(S, A, C) and solve(S, B, D)) {
if (can_throw(S, max({A, B}), min({C, D}))) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
cout << "No" << endl;
}
}
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 831,656 | 831,657 | u706730549 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
char S[200010] = {};
bool flag = true;
bool flag2 = false;
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A; i < C - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
for (int i = B; i < D - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
if (D <= C && flag) {
for (int i = B - 1; i < C - 1; i++) {
if (S[i] == '.' && S[i - 1] == '.' && S[i + 1] != '#')
flag2 = true;
}
if (!flag2)
flag = false;
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <climits>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
char S[200010] = {};
bool flag = true;
bool flag2 = false;
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A; i < C - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
for (int i = B; i < D - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
if (D < C && flag) {
for (int i = B - 1; i <= D - 1; i++) {
if (S[i] == '.' && S[i - 1] == '.' && S[i + 1] == '.')
flag2 = true;
}
if (!flag2)
flag = false;
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.opposites",
"literal.string.change"
] | 831,658 | 831,659 | u364497081 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
char S[200010] = {};
bool flag = true;
bool flag2 = false;
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A; i < C - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
for (int i = B; i < D - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
if (D <= C && flag) {
for (int i = B - 1; i < C - 1; i++) {
if (S[i] == '.' && S[i - 1] == '.' && S[i + 1] == '.')
flag2 = true;
}
if (!flag2)
flag = false;
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <climits>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll N, A, B, C, D;
char S[200010] = {};
bool flag = true;
bool flag2 = false;
int main() {
cin >> N >> A >> B >> C >> D;
cin >> S;
for (int i = A; i < C - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
for (int i = B; i < D - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
if (D < C && flag) {
for (int i = B - 1; i <= D - 1; i++) {
if (S[i] == '.' && S[i - 1] == '.' && S[i + 1] == '.')
flag2 = true;
}
if (!flag2)
flag = false;
}
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 831,660 | 831,659 | u364497081 | cpp |
p03017 | #include "bits/stdc++.h"
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
#define ll long long
#define clock (clock() * 1000.0 / CLOCKS_PER_SEC)
#define rc(s) return cout << s, 0
#define rcg(s) \
cout << s; \
exit(0)
#define _ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cerr.tie(0); \
cout.tie(0);
#define db(x) cerr << #x << " = " << x << '\n'
#define pb push_back
#define mp make_pair
#define all(s) s.begin(), s.end()
#define sz(x) (int)((x).size())
//# define int ll
using namespace std;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#define LOCAL
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define show(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
int gcd(int a, int b) {
if (b)
return gcd(b, a % b);
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
int n, a, b, c, d;
int32_t main() {
_
// freopen("input","r",stdin);
cin >>
n >> a >> b >> c >> d;
string s;
cin >> s;
a--;
b--;
c--;
d--;
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#')
rc("No");
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#')
rc("No");
}
if (c < d)
rc("Yes");
for (int i = max(0, b - 1); i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
rc("Yes");
}
rc("No");
return 0;
}
| #include "bits/stdc++.h"
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
#define ll long long
#define clock (clock() * 1000.0 / CLOCKS_PER_SEC)
#define rc(s) return cout << s, 0
#define rcg(s) \
cout << s; \
exit(0)
#define _ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cerr.tie(0); \
cout.tie(0);
#define db(x) cerr << #x << " = " << x << '\n'
#define pb push_back
#define mp make_pair
#define all(s) s.begin(), s.end()
#define sz(x) (int)((x).size())
//# define int ll
using namespace std;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#define LOCAL
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define show(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
int gcd(int a, int b) {
if (b)
return gcd(b, a % b);
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
int n, a, b, c, d;
int32_t main() {
_
// freopen("input","r",stdin);
cin >>
n >> a >> b >> c >> d;
string s;
cin >> s;
a--;
b--;
c--;
d--;
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#')
rc("No");
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#')
rc("No");
}
if (c < d)
rc("Yes");
for (int i = max(0, b - 1); i <= d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
rc("Yes");
}
rc("No");
return 0;
}
| [
"expression.operator.compare.change"
] | 831,667 | 831,668 | u288444854 | cpp |
p03017 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("No"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MX = 200005;
bool can(string s, int a, int b) {
srep(i, a, b) {
if (s[i] == '#' && s[i + 1] == '#')
return false;
}
return true;
}
bool swcan(string s, int a, int b) {
srep(i, a, b - 1) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
return true;
}
return false;
}
int main() {
int n, a, b, c, d;
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
string s;
cin >> s;
s = "#" + s;
// if (a > b) swap(a,b), swap(c,d);
if (!can(s, a, c))
dame;
if (!can(s, b, d))
dame;
if (c > d) {
if (!swcan(s, b - 1, c + 1))
dame;
}
puts("Yes");
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("No"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MX = 200005;
bool can(string s, int a, int b) {
srep(i, a, b) {
if (s[i] == '#' && s[i + 1] == '#')
return false;
}
return true;
}
bool swcan(string s, int a, int b) {
srep(i, a, b - 1) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
return true;
}
return false;
}
int main() {
int n, a, b, c, d;
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
string s;
cin >> s;
s = "#" + s;
// if (a > b) swap(a,b), swap(c,d);
if (!can(s, a, c))
dame;
if (!can(s, b, d))
dame;
if (c > d) {
if (!swcan(s, b - 1, d + 1))
dame;
}
puts("Yes");
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 831,692 | 831,693 | u457283867 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ll long long
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a = a - 1;
b = b - 1;
c = c - 1;
d = d - 1;
char k;
int michi[n];
int i, j;
for (i = 0; i < n; i++) {
cin >> k;
if (k == '#') {
michi[i] = 1;
} else {
michi[i] = 0;
}
}
int renzoku = 0;
if (c < d) {
for (i = a + 1; i < d; i++) {
if (michi[i] == 1) {
renzoku++;
} else {
renzoku = 0;
}
if (renzoku == 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
else {
for (i = a + 1; i < c; i++) {
if (michi[i] == 1) {
renzoku++;
} else {
renzoku = 0;
}
if (renzoku == 2) {
cout << "No" << endl;
return 0;
}
}
renzoku = 0;
for (i = b - 1; i < d + 1; i++) {
if (michi[i] == 0) {
renzoku++;
} else {
renzoku = 0;
}
if (renzoku == 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ll long long
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a = a - 1;
b = b - 1;
c = c - 1;
d = d - 1;
char k;
int michi[n];
int i, j;
for (i = 0; i < n; i++) {
cin >> k;
if (k == '#') {
michi[i] = 1;
} else {
michi[i] = 0;
}
}
int renzoku = 0;
if (c < d) {
for (i = a + 1; i < d; i++) {
if (michi[i] == 1) {
renzoku++;
} else {
renzoku = 0;
}
if (renzoku == 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
else {
for (i = a + 1; i < c; i++) {
if (michi[i] == 1) {
renzoku++;
} else {
renzoku = 0;
}
if (renzoku == 2) {
cout << "No" << endl;
return 0;
}
}
renzoku = 0;
for (i = b - 1; i <= d + 1; i++) {
if (michi[i] == 0) {
renzoku++;
} else {
renzoku = 0;
}
if (renzoku == 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,696 | 831,697 | u127768253 | cpp |
p03017 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int n, a, b, c, d;
string s;
int ch(int i, int j) {
for (int x = i; x < j; x++)
if (s[x] == '#' && s[x + 1] == '#')
return 0;
return 1;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
// cout<<s;
a--;
b--;
c--;
d--;
int g = ch(a, c) * ch(b, d);
if (c > d) {
int fl = 0;
for (int i = b; i < d; i++)
if (s[i] == s[i + 1] && s[i + 1] == '.' && s[i] == s[i + 2])
fl = 1;
if (fl && g) {
cout << "Yes";
return 0;
} else
cout << "No";
return 0;
}
// cout<<g;
if (g) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int n, a, b, c, d;
string s;
int ch(int i, int j) {
for (int x = i; x < j; x++)
if (s[x] == '#' && s[x + 1] == '#')
return 0;
return 1;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
// cout<<s;
a--;
b--;
c--;
d--;
int g = ch(a, c) * ch(b, d);
if (c > d) {
int fl = 0;
for (int i = b - 1; i < d; i++)
if (s[i] == s[i + 1] && s[i + 1] == '.' && s[i] == s[i + 2])
fl = 1;
if (fl && g) {
cout << "Yes";
return 0;
} else
cout << "No";
return 0;
}
// cout<<g;
if (g) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 831,705 | 831,706 | u095884941 | cpp |
p03017 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int n, a, b, c, d;
string s;
int ch(int i, int j) {
for (int x = i; x < j; x++)
if (s[x] == '#' && s[x + 1] == '#')
return 0;
return 1;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
// cout<<s;
a--;
b--;
c--;
d--;
int g = ch(a, c) * ch(b, d);
if (c > d) {
int fl = 0;
for (int i = b; i < d - 1; i++)
if (s[i] == s[i + 1] && s[i + 1] == '.' && s[i] == s[i + 2])
fl = 1;
if (fl && g) {
cout << "Yes";
return 0;
} else
cout << "No";
return 0;
}
// cout<<g;
if (g) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
using namespace std;
int n, a, b, c, d;
string s;
int ch(int i, int j) {
for (int x = i; x < j; x++)
if (s[x] == '#' && s[x + 1] == '#')
return 0;
return 1;
}
int main() {
cin >> n >> a >> b >> c >> d >> s;
// cout<<s;
a--;
b--;
c--;
d--;
int g = ch(a, c) * ch(b, d);
if (c > d) {
int fl = 0;
for (int i = b - 1; i < d; i++)
if (s[i] == s[i + 1] && s[i + 1] == '.' && s[i] == s[i + 2])
fl = 1;
if (fl && g) {
cout << "Yes";
return 0;
} else
cout << "No";
return 0;
}
// cout<<g;
if (g) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,707 | 831,706 | u095884941 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define BIG 1000000010
#define EPS 1e-9
#define fst first
#define scd second
#define debug(x) cout << x << endl;
#define repi(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) repi(i, 0, n)
#define repn(i, n) for (int i = n; i >= 0; i--)
#define int long long
signed main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
int now = 0, mx = 0;
cin >> s;
if (c < d) {
repi(i, a - 1, c) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
repi(i, b - 1, d) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
} else {
repi(i, b - 1, d + 1) {
if (s[i] == '.')
now++;
else {
mx = max(mx, now);
now = 0;
}
}
mx = max(mx, now);
if (mx < 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define BIG 1000000010
#define EPS 1e-9
#define fst first
#define scd second
#define debug(x) cout << x << endl;
#define repi(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) repi(i, 0, n)
#define repn(i, n) for (int i = n; i >= 0; i--)
#define int long long
signed main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
int now = 0, mx = 0;
cin >> s;
if (c < d) {
repi(i, a - 1, c) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
repi(i, b - 1, d) {
if (s[i] == '#' && s[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
} else {
// cout<<b-1<<" "<<d<<endl;
repi(i, b - 2, d + 1) {
if (s[i] == '.')
now++;
else {
mx = max(mx, now);
now = 0;
}
}
mx = max(mx, now);
if (mx < 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,714 | 831,715 | u386769326 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
cin >> S;
bool sn_ok = true;
bool fn_ok = true;
for (int i = A; i < C; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
sn_ok = false;
}
}
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
fn_ok = false;
}
}
string yes = "Yes";
string no = "No";
if (C < D) {
if (sn_ok && fn_ok) {
cout << yes << endl;
} else {
cout << no << endl;
}
} else {
if (sn_ok && fn_ok) {
bool ok = false;
// B + 1からはじめて、D+1までの
for (int i = B; i < D - 1; i++) {
if ((S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')) {
ok = true;
}
}
if (ok) {
cout << yes << endl;
} else {
// cout << "ok"<<endl;
cout << no << endl;
}
} else {
cout << no << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N, A, B, C, D;
string S;
int main() {
cin >> N >> A >> B >> C >> D;
A--;
B--;
C--;
D--;
cin >> S;
bool sn_ok = true;
bool fn_ok = true;
for (int i = A; i < C; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
sn_ok = false;
}
}
for (int i = B; i < D; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
fn_ok = false;
}
}
string yes = "Yes";
string no = "No";
if (C < D) {
if (sn_ok && fn_ok) {
cout << yes << endl;
} else {
cout << no << endl;
}
} else {
if (sn_ok && fn_ok) {
bool ok = false;
// B + 1からはじめて、D+1までの
for (int i = B - 1; i < D; i++) {
if ((S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')) {
ok = true;
}
}
if (ok) {
cout << yes << endl;
} else {
// cout << "ok"<<endl;
cout << no << endl;
}
} else {
cout << no << endl;
}
}
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,725 | 831,724 | u489053642 | cpp |
p03017 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 200000 + 5;
char aa[maxn];
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
getchar();
cin >> aa[1];
char ss = aa[1];
int te = 0;
int la = max(c, d);
for (int i = 2; i <= n; i++) {
cin >> aa[i];
if (aa[i] == '#' && ss == '#' && i > a && i < la) {
te = 1;
break;
}
ss = aa[i];
}
la = min(c, d);
if (c == d)
te = 1;
if (c > d) {
te = 1;
for (int i = b; i < la - 1; i++) {
if (aa[i] == '.' && aa[i + 1] == '.' && aa[i + 2] == '.') {
te = 0;
break;
}
}
}
if (te)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 200000 + 5;
char aa[maxn];
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
getchar();
cin >> aa[1];
char ss = aa[1];
int te = 0;
int la = max(c, d);
for (int i = 2; i <= n; i++) {
cin >> aa[i];
if (aa[i] == '#' && ss == '#' && i > a && i < la) {
te = 1;
break;
}
ss = aa[i];
}
la = min(c, d);
if (c == d)
te = 1;
if (c > d) {
te = 1;
for (int i = b - 1; i <= la - 1; i++) {
if (aa[i] == '.' && aa[i + 1] == '.' && aa[i + 2] == '.') {
te = 0;
break;
}
}
}
if (te)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,728 | 831,729 | u249468506 | cpp |
p03017 | #include <bits/stdc++.h>
#define FOR0(i, n) for (i = 0; i < n; i++)
#define FOR(i, j, n) for (i = j; i < n; i++)
#define FORD(i, j, k) for (i = j; i >= k; i--)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define inf 1000000000
#define ninf -1000000000
#define endl '\n'
#define she_told_me_dont_worry \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// Use cout.flush() for interactive problems.
// Use this for increased stack size: g++ -o a.exe -Wl,--stack=256000000 -O2
// source.cpp
inline long long MAX2(long long a, long long int b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;
int main() {
she_told_me_dont_worry int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
int i;
cin >> s;
bool is = false;
int lim = MAX2(c, d);
FOR(i, a, lim) {
if (s[i] == '#' && s[i + 1] == '#')
is = true;
}
if (is) {
cout << "No";
return 0;
}
if (d < c) {
is = true;
FOR(i, b - 1, d - 1) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
is = false;
}
if (is) {
cout << "No";
return 0;
}
}
cout << "Yes";
cerr << endl
<< "Time elapsed : " << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
} | #include <bits/stdc++.h>
#define FOR0(i, n) for (i = 0; i < n; i++)
#define FOR(i, j, n) for (i = j; i < n; i++)
#define FORD(i, j, k) for (i = j; i >= k; i--)
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define inf 1000000000
#define ninf -1000000000
#define endl '\n'
#define she_told_me_dont_worry \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// Use cout.flush() for interactive problems.
// Use this for increased stack size: g++ -o a.exe -Wl,--stack=256000000 -O2
// source.cpp
inline long long MAX2(long long a, long long int b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;
int main() {
she_told_me_dont_worry int n;
cin >> n;
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
int i;
cin >> s;
bool is = false;
int lim = MAX2(c, d);
FOR(i, a, lim) {
if (s[i] == '#' && s[i + 1] == '#')
is = true;
}
if (is) {
cout << "No";
return 0;
}
if (d < c) {
is = true;
FOR(i, b - 1, d) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
is = false;
}
if (is) {
cout << "No";
return 0;
}
}
cout << "Yes";
cerr << endl
<< "Time elapsed : " << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
} | [
"expression.operation.binary.remove"
] | 831,733 | 831,734 | u453412459 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, val) mi = min(mi, val)
#define chmax(ma, val) ma = max(ma, val)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
char dirchar[4] = {'<', '^', '>', 'v'};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// 多次元vector生成
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T sum(vector<T> a) { return accumulate(all(a), (T)0); }
// mapでカウントとかする
template <typename T> void add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// デフォルト値つきのmapのget
template <typename T, typename U> U get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> bool contains(set<T> t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U> bool contains(map<T, U> t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
bool operator<(Edge e) { return cost < e.cost; }
};
template <class T> using Graph = vec<vec<Edge<T>>>;
template <class T> ostream &operator<<(ostream &os, Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
//======================================================
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
A--, B--, C--, D--;
repr(i, A, C) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
repr(i, B, D) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
repr(i, B, D) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, val) mi = min(mi, val)
#define chmax(ma, val) ma = max(ma, val)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
char dirchar[4] = {'<', '^', '>', 'v'};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// 多次元vector生成
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T sum(vector<T> a) { return accumulate(all(a), (T)0); }
// mapでカウントとかする
template <typename T> void add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// デフォルト値つきのmapのget
template <typename T, typename U> U get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> bool contains(set<T> t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U> bool contains(map<T, U> t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
bool operator<(Edge e) { return cost < e.cost; }
};
template <class T> using Graph = vec<vec<Edge<T>>>;
template <class T> ostream &operator<<(ostream &os, Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
//======================================================
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
A--, B--, C--, D--;
repr(i, A, C) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
repr(i, B, D) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
repr(i, B - 1, D) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 831,735 | 831,736 | u366676780 | cpp |
p03017 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, val) mi = min(mi, val)
#define chmax(ma, val) ma = max(ma, val)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
char dirchar[4] = {'<', '^', '>', 'v'};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// 多次元vector生成
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T sum(vector<T> a) { return accumulate(all(a), (T)0); }
// mapでカウントとかする
template <typename T> void add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// デフォルト値つきのmapのget
template <typename T, typename U> U get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> bool contains(set<T> t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U> bool contains(map<T, U> t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
bool operator<(Edge e) { return cost < e.cost; }
};
template <class T> using Graph = vec<vec<Edge<T>>>;
template <class T> ostream &operator<<(ostream &os, Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
//======================================================
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
A--, B--, C--, D--;
repr(i, A, C) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
repr(i, B, D) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
repr(i, B, D - 2) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, val) mi = min(mi, val)
#define chmax(ma, val) ma = max(ma, val)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
char dirchar[4] = {'<', '^', '>', 'v'};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// 多次元vector生成
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T sum(vector<T> a) { return accumulate(all(a), (T)0); }
// mapでカウントとかする
template <typename T> void add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// デフォルト値つきのmapのget
template <typename T, typename U> U get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> bool contains(set<T> t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U> bool contains(map<T, U> t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
bool operator<(Edge e) { return cost < e.cost; }
};
template <class T> using Graph = vec<vec<Edge<T>>>;
template <class T> ostream &operator<<(ostream &os, Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
//======================================================
int main(void) {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
A--, B--, C--, D--;
repr(i, A, C) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
repr(i, B, D) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
repr(i, B - 1, D) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 831,737 | 831,736 | u366676780 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, s, n) for (int i = (s); (n) > i; i++)
#define REP(i, n) rep(i, 0, n)
#define RANGE(x, a, b) (min(a, b) <= (x) && (x) <= max(a, b)) // hei
#define DUPLE(a, b, c, d) \
(RANGE(a, c, d) || RANGE(b, c, d) || RANGE(c, a, b) || RANGE(d, a, b))
#define INCLU(a, b, c, d) (RANGE(a, c, d) && (b, c, d))
#define PW(x) ((x) * (x))
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MODU 998244353LL
#define bitcheck(a, b) ((a >> b) & 1)
#define bitset(a, b) (a |= (1 << b))
#define bitunset(a, b) (a &= ~(1 << b))
#define MP(a, b) make_pair((a), (b))
#define Manh(a, b) (abs((a).first-(b).first) + abs((a).second - ((b).second))
#define pritnf printf
#define scnaf scanf
#define itn int
#define PI 3.141592653589
#define izryt bool
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
pll Dir[4] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
//[a, b)
#define Getsum(ar, a, b) (ar[b] - ar[a])
#define INF 10000000000000000LL
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
struct Edge {
int from, to;
ll w;
bool operator<(const Edge &rhs) const {
return MP(w, MP(from, to)) < MP(rhs.w, MP(rhs.from, rhs.to));
}
};
ll mod_pow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
typedef vector<set<Edge>> Graph;
// BEGIN CUT HERE
struct RUP {
int n;
vector<int> dat, laz;
const int def = INT_MAX;
RUP() {}
RUP(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, def);
laz.clear();
laz.resize(2 * n - 1, -1);
}
inline void eval(int len, int k) {
if (laz[k] < 0)
return;
if (k * 2 + 1 < n * 2 - 1) {
laz[k * 2 + 1] = laz[k];
laz[k * 2 + 2] = laz[k];
}
dat[k] = laz[k];
laz[k] = -1;
}
int update(int a, int b, int x, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return dat[k];
if (a <= l && r <= b)
return laz[k] = x;
eval(r - l, k);
dat[k] = min(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
return dat[k];
}
int query(int a, int b, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return dat[k];
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
void update(int a, int b, int x) { update(a, b, x, 0, 0, n); }
int query(int a, int b) { return query(a, b, 0, 0, n); }
};
// END CUT HERE
signed main(void) {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s += "##";
a--, b--, c--, d--;
bool si = false;
rep(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#') {
si = true;
}
}
if (d < c) {
bool suki = false;
rep(i, max(a, b), min(c, d) - 1) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
suki = true;
}
}
if (suki == false)
si = true;
}
if (si) {
printf("No\n");
} else
printf("Yes\n");
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, s, n) for (int i = (s); (n) > i; i++)
#define REP(i, n) rep(i, 0, n)
#define RANGE(x, a, b) (min(a, b) <= (x) && (x) <= max(a, b)) // hei
#define DUPLE(a, b, c, d) \
(RANGE(a, c, d) || RANGE(b, c, d) || RANGE(c, a, b) || RANGE(d, a, b))
#define INCLU(a, b, c, d) (RANGE(a, c, d) && (b, c, d))
#define PW(x) ((x) * (x))
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MODU 998244353LL
#define bitcheck(a, b) ((a >> b) & 1)
#define bitset(a, b) (a |= (1 << b))
#define bitunset(a, b) (a &= ~(1 << b))
#define MP(a, b) make_pair((a), (b))
#define Manh(a, b) (abs((a).first-(b).first) + abs((a).second - ((b).second))
#define pritnf printf
#define scnaf scanf
#define itn int
#define PI 3.141592653589
#define izryt bool
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
pll Dir[4] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
//[a, b)
#define Getsum(ar, a, b) (ar[b] - ar[a])
#define INF 10000000000000000LL
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
struct Edge {
int from, to;
ll w;
bool operator<(const Edge &rhs) const {
return MP(w, MP(from, to)) < MP(rhs.w, MP(rhs.from, rhs.to));
}
};
ll mod_pow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
typedef vector<set<Edge>> Graph;
// BEGIN CUT HERE
struct RUP {
int n;
vector<int> dat, laz;
const int def = INT_MAX;
RUP() {}
RUP(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, def);
laz.clear();
laz.resize(2 * n - 1, -1);
}
inline void eval(int len, int k) {
if (laz[k] < 0)
return;
if (k * 2 + 1 < n * 2 - 1) {
laz[k * 2 + 1] = laz[k];
laz[k * 2 + 2] = laz[k];
}
dat[k] = laz[k];
laz[k] = -1;
}
int update(int a, int b, int x, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return dat[k];
if (a <= l && r <= b)
return laz[k] = x;
eval(r - l, k);
dat[k] = min(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
return dat[k];
}
int query(int a, int b, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return dat[k];
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
void update(int a, int b, int x) { update(a, b, x, 0, 0, n); }
int query(int a, int b) { return query(a, b, 0, 0, n); }
};
// END CUT HERE
signed main(void) {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s += "##";
a--, b--, c--, d--;
bool si = false;
rep(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#') {
si = true;
}
}
if (d < c) {
bool suki = false;
rep(i, max(a, b) - 1, min(c, d)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
suki = true;
}
}
if (suki == false)
si = true;
}
if (si) {
printf("No\n");
} else
printf("Yes\n");
return 0;
}
| [
"expression.operation.binary.remove"
] | 831,738 | 831,739 | u152129372 | cpp |
p03017 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, s, n) for (int i = (s); (n) > i; i++)
#define REP(i, n) rep(i, 0, n)
#define RANGE(x, a, b) (min(a, b) <= (x) && (x) <= max(a, b)) // hei
#define DUPLE(a, b, c, d) \
(RANGE(a, c, d) || RANGE(b, c, d) || RANGE(c, a, b) || RANGE(d, a, b))
#define INCLU(a, b, c, d) (RANGE(a, c, d) && (b, c, d))
#define PW(x) ((x) * (x))
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MODU 998244353LL
#define bitcheck(a, b) ((a >> b) & 1)
#define bitset(a, b) (a |= (1 << b))
#define bitunset(a, b) (a &= ~(1 << b))
#define MP(a, b) make_pair((a), (b))
#define Manh(a, b) (abs((a).first-(b).first) + abs((a).second - ((b).second))
#define pritnf printf
#define scnaf scanf
#define itn int
#define PI 3.141592653589
#define izryt bool
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
pll Dir[4] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
//[a, b)
#define Getsum(ar, a, b) (ar[b] - ar[a])
#define INF 10000000000000000LL
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
struct Edge {
int from, to;
ll w;
bool operator<(const Edge &rhs) const {
return MP(w, MP(from, to)) < MP(rhs.w, MP(rhs.from, rhs.to));
}
};
ll mod_pow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
typedef vector<set<Edge>> Graph;
// BEGIN CUT HERE
struct RUP {
int n;
vector<int> dat, laz;
const int def = INT_MAX;
RUP() {}
RUP(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, def);
laz.clear();
laz.resize(2 * n - 1, -1);
}
inline void eval(int len, int k) {
if (laz[k] < 0)
return;
if (k * 2 + 1 < n * 2 - 1) {
laz[k * 2 + 1] = laz[k];
laz[k * 2 + 2] = laz[k];
}
dat[k] = laz[k];
laz[k] = -1;
}
int update(int a, int b, int x, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return dat[k];
if (a <= l && r <= b)
return laz[k] = x;
eval(r - l, k);
dat[k] = min(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
return dat[k];
}
int query(int a, int b, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return dat[k];
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
void update(int a, int b, int x) { update(a, b, x, 0, 0, n); }
int query(int a, int b) { return query(a, b, 0, 0, n); }
};
// END CUT HERE
signed main(void) {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s += "##";
a--, b--, c--, d--;
bool si = false;
rep(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#') {
si = true;
}
}
if (d < c) {
bool suki = false;
rep(i, max(a, b), min(c, d)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
suki = true;
}
}
if (suki == false)
si = true;
}
if (si) {
printf("No\n");
} else
printf("Yes\n");
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, s, n) for (int i = (s); (n) > i; i++)
#define REP(i, n) rep(i, 0, n)
#define RANGE(x, a, b) (min(a, b) <= (x) && (x) <= max(a, b)) // hei
#define DUPLE(a, b, c, d) \
(RANGE(a, c, d) || RANGE(b, c, d) || RANGE(c, a, b) || RANGE(d, a, b))
#define INCLU(a, b, c, d) (RANGE(a, c, d) && (b, c, d))
#define PW(x) ((x) * (x))
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MODU 998244353LL
#define bitcheck(a, b) ((a >> b) & 1)
#define bitset(a, b) (a |= (1 << b))
#define bitunset(a, b) (a &= ~(1 << b))
#define MP(a, b) make_pair((a), (b))
#define Manh(a, b) (abs((a).first-(b).first) + abs((a).second - ((b).second))
#define pritnf printf
#define scnaf scanf
#define itn int
#define PI 3.141592653589
#define izryt bool
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
pll Dir[4] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
//[a, b)
#define Getsum(ar, a, b) (ar[b] - ar[a])
#define INF 10000000000000000LL
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
struct Edge {
int from, to;
ll w;
bool operator<(const Edge &rhs) const {
return MP(w, MP(from, to)) < MP(rhs.w, MP(rhs.from, rhs.to));
}
};
ll mod_pow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
typedef vector<set<Edge>> Graph;
// BEGIN CUT HERE
struct RUP {
int n;
vector<int> dat, laz;
const int def = INT_MAX;
RUP() {}
RUP(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, def);
laz.clear();
laz.resize(2 * n - 1, -1);
}
inline void eval(int len, int k) {
if (laz[k] < 0)
return;
if (k * 2 + 1 < n * 2 - 1) {
laz[k * 2 + 1] = laz[k];
laz[k * 2 + 2] = laz[k];
}
dat[k] = laz[k];
laz[k] = -1;
}
int update(int a, int b, int x, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return dat[k];
if (a <= l && r <= b)
return laz[k] = x;
eval(r - l, k);
dat[k] = min(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
return dat[k];
}
int query(int a, int b, int k, int l, int r) {
eval(r - l, k);
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return dat[k];
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
void update(int a, int b, int x) { update(a, b, x, 0, 0, n); }
int query(int a, int b) { return query(a, b, 0, 0, n); }
};
// END CUT HERE
signed main(void) {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
s += "##";
a--, b--, c--, d--;
bool si = false;
rep(i, min(a, b), max(c, d)) {
if (s[i] == '#' && s[i + 1] == '#') {
si = true;
}
}
if (d < c) {
bool suki = false;
rep(i, max(a, b) - 1, min(c, d)) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
suki = true;
}
}
if (suki == false)
si = true;
}
if (si) {
printf("No\n");
} else
printf("Yes\n");
return 0;
}
| [
"expression.operation.binary.add"
] | 831,740 | 831,739 | u152129372 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
char s[N];
int main() {
int n, a, b, c, d;
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
scanf("%s", s + 1);
for (int i = a + 1; i <= max(c, d); i++) {
if (s[i] == '#' && s[i - 1] == '#') {
printf("NO\n");
return 0;
}
}
if (c < d) {
printf("YES\n");
return 0;
}
for (int i = b; i <= d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
char s[N];
int main() {
int n, a, b, c, d;
scanf("%d %d %d %d %d", &n, &a, &b, &c, &d);
scanf("%s", s + 1);
for (int i = a + 1; i <= max(c, d); i++) {
if (s[i] == '#' && s[i - 1] == '#') {
printf("No\n");
return 0;
}
}
if (c < d) {
printf("Yes\n");
return 0;
}
for (int i = b; i <= d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
printf("Yes\n");
return 0;
}
}
printf("No\n");
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 831,750 | 831,751 | u593031180 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = A; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} 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 <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = A; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,754 | 831,755 | u134519179 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = A; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = A - 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 <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = A; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
} | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one"
] | 831,756 | 831,755 | u134519179 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = 0; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = A - 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 <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = A; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"identifier.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one"
] | 831,757 | 831,755 | u134519179 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = 0; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = 0; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
for (int i = A; i < max(C, D) - 2; i++) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No" << endl;
return 0;
}
}
if (C < D) {
cout << "Yes" << endl;
} else {
for (int i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 831,758 | 831,755 | u134519179 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string S;
cin >> S;
for (int i = A; i < C; ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No\n";
return 0;
}
}
for (int i = B; i < D; ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No\n";
return 0;
}
}
if (C < D) {
cout << "Yes\n";
return 0;
}
for (int i = B - 1; i + 1 < min(D, N); ++i) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
--A;
--B;
--C;
--D;
string S;
cin >> S;
for (int i = A; i < C; ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No\n";
return 0;
}
}
for (int i = B; i < D; ++i) {
if (S[i] == '#' && S[i + 1] == '#') {
cout << "No\n";
return 0;
}
}
if (C < D) {
cout << "Yes\n";
return 0;
}
for (int i = B - 1; i < min(D, N - 1); ++i) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"misc.off_by_one"
] | 831,767 | 831,768 | u003080851 | cpp |
p03017 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
void err() {
cout << "No" << endl;
exit(0);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// a
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
for (int i = a; i + 1 <= c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
err();
}
}
for (int i = b; i + 1 <= d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
err();
}
}
if (c < d) {
cout << "Yes" << endl;
return 0;
}
int cnt = 0;
for (int i = a; i <= d + 1; i++) {
if (s[i] == '.')
cnt++;
if (s[i] == '#')
cnt = 0;
if (cnt == 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
void err() {
cout << "No" << endl;
exit(0);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// a
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
for (int i = a; i + 1 <= c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
err();
}
}
for (int i = b; i + 1 <= d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
err();
}
}
if (c < d) {
cout << "Yes" << endl;
return 0;
}
int cnt = 0;
for (int i = b - 1; i <= d + 1; i++) {
if (s[i] == '.')
cnt++;
if (s[i] == '#')
cnt = 0;
if (cnt == 3) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change"
] | 831,769 | 831,770 | u817760251 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define REP(n) FOR(i, 1, (n))
#define pb push_back
#define f first
#define s second
#define INF 100000000000000000
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<piii> viii;
int main() {
FAST_IO;
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
bool ok = true;
FOR(i, a, c - 1) {
if (s[i] == '#' && s[i - 1] == '#')
ok = false;
}
FOR(i, b, d - 1) {
if (s[i] == '#' && s[i - 1] == '#')
ok = false;
}
if (d < c) {
bool ok2 = false;
FOR(i, b, d - 2) {
if (s[i - 1] != '#' && s[i] != '#' && s[i + 1] != '#')
ok2 = true;
}
ok &= ok2;
}
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FAST_IO \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define REP(n) FOR(i, 1, (n))
#define pb push_back
#define f first
#define s second
#define INF 100000000000000000
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<piii> viii;
int main() {
FAST_IO;
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d >> s;
bool ok = true;
FOR(i, a, c - 1) {
if (s[i] == '#' && s[i - 1] == '#')
ok = false;
}
FOR(i, b, d - 1) {
if (s[i] == '#' && s[i - 1] == '#')
ok = false;
}
if (d < c) {
bool ok2 = false;
FOR(i, b - 1, d - 1) {
if (s[i - 1] != '#' && s[i] != '#' && s[i + 1] != '#')
ok2 = true;
}
ok &= ok2;
}
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,775 | 831,776 | u157886944 | cpp |
p03017 | //#include "bits/stdc++.h"
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, l, r) REPEAT(i, l, r, true) // [l, r)
#define rep(i, n) REP(i, 0, n) // [0, n)
#define REPEAT(i, l, r, condition) \
for (int i = (condition) ? l : r - 1; (condition) ? i < r : i >= l; \
(condition) ? ++i : --i) // false<-[l, r)->true
#define all(e) e.begin(), e.end()
#define rall(e) e.rbegin(), e.rend()
#define pb push_back
#define fs first
#define sc second
#ifdef LOCAL
#define show(...) \
cerr << #__VA_ARGS__ << " = "; \
_DEBUG(__VA_ARGS__)
#define showlr(n, l, r) \
cerr << #n << " = "; \
for (int i = l; i < r; i++) { \
cerr << n[i] << ", "; \
} \
cerr << endl // [l, r)
#else
#define show(...)
#define showlr(n, l, r)
#endif
#define YN(condition) puts((condition) ? "YES" : "NO")
#define Yn(condition) puts((condition) ? "Yes" : "No")
#define yn(condition) puts((condition) ? "yes" : "no")
#define YES puts("YES")
#define Yes puts("Yes")
#define yes puts("yes")
#define NO puts("NO")
#define No puts("No")
#define no puts("no")
#define case (i) printf("Case #%lld: ", i)
using namespace std;
using vi = vector<int>;
using pint = pair<int, int>;
struct io {
io() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.tie(0);
cout << fixed << setprecision(20);
}
} io;
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (T &e : v)
is >> e;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> v) {
os << "{";
for (T &e : v)
os << e << (v.size() - (int)(&e - &v[0]) > 1 ? ", " : "");
os << "}";
return os;
}
void _DEBUG() {}
template <typename H, typename... T> void _DEBUG(H a, T... b) {
cerr << a << (sizeof...(b) ? "," : "\n");
_DEBUG(b...);
}
inline void in() {}
template <typename H, typename... T> void in(H &a, T &...b) {
cin >> a;
in(b...);
}
inline void out() {}
template <typename H, typename... T> void out(H a, T... b) {
cout << a << (sizeof...(b) ? " " : "\n");
out(b...);
}
template <class T> void resz(int n, T &v) { v.resize(n); }
template <class H, class... T> void resz(int n, H &a, T &...b) {
a.resize(n);
resz(n, b...);
}
template <typename V, typename H> void resize(vector<V> &v, const H a) {
v.resize(a);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &v, const H &a, const T... b) {
v.resize(a);
for (auto &v : v)
resize(v, b...);
}
const int INF = 1LL << 55;
const int MOD = 1000000007;
const double EPS = 1e-8;
/*------------end of definitions------------*/
int N, A, B, C, D;
string S;
signed main() {
in(N, A, B, C, D);
A--;
B--;
C--;
D--;
in(S);
auto ACrocks = S.find("##", A);
if (ACrocks != string::npos) {
if (ACrocks < C) {
No;
return 0;
}
}
auto BDrocks = S.find("##", B);
if (BDrocks != string::npos) {
if (BDrocks < D) {
No;
return 0;
}
}
if (C > D) { //飛び越える
auto space = S.find("...", B);
if (space == string::npos) {
No;
return 0;
}
show(space, D);
if (space <= D) {
Yes;
return 0;
} else {
No;
return 0;
}
}
Yes;
return 0;
}
| //#include "bits/stdc++.h"
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, l, r) REPEAT(i, l, r, true) // [l, r)
#define rep(i, n) REP(i, 0, n) // [0, n)
#define REPEAT(i, l, r, condition) \
for (int i = (condition) ? l : r - 1; (condition) ? i < r : i >= l; \
(condition) ? ++i : --i) // false<-[l, r)->true
#define all(e) e.begin(), e.end()
#define rall(e) e.rbegin(), e.rend()
#define pb push_back
#define fs first
#define sc second
#ifdef LOCAL
#define show(...) \
cerr << #__VA_ARGS__ << " = "; \
_DEBUG(__VA_ARGS__)
#define showlr(n, l, r) \
cerr << #n << " = "; \
for (int i = l; i < r; i++) { \
cerr << n[i] << ", "; \
} \
cerr << endl // [l, r)
#else
#define show(...)
#define showlr(n, l, r)
#endif
#define YN(condition) puts((condition) ? "YES" : "NO")
#define Yn(condition) puts((condition) ? "Yes" : "No")
#define yn(condition) puts((condition) ? "yes" : "no")
#define YES puts("YES")
#define Yes puts("Yes")
#define yes puts("yes")
#define NO puts("NO")
#define No puts("No")
#define no puts("no")
#define case (i) printf("Case #%lld: ", i)
using namespace std;
using vi = vector<int>;
using pint = pair<int, int>;
struct io {
io() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.tie(0);
cout << fixed << setprecision(20);
}
} io;
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (T &e : v)
is >> e;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> v) {
os << "{";
for (T &e : v)
os << e << (v.size() - (int)(&e - &v[0]) > 1 ? ", " : "");
os << "}";
return os;
}
void _DEBUG() {}
template <typename H, typename... T> void _DEBUG(H a, T... b) {
cerr << a << (sizeof...(b) ? "," : "\n");
_DEBUG(b...);
}
inline void in() {}
template <typename H, typename... T> void in(H &a, T &...b) {
cin >> a;
in(b...);
}
inline void out() {}
template <typename H, typename... T> void out(H a, T... b) {
cout << a << (sizeof...(b) ? " " : "\n");
out(b...);
}
template <class T> void resz(int n, T &v) { v.resize(n); }
template <class H, class... T> void resz(int n, H &a, T &...b) {
a.resize(n);
resz(n, b...);
}
template <typename V, typename H> void resize(vector<V> &v, const H a) {
v.resize(a);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &v, const H &a, const T... b) {
v.resize(a);
for (auto &v : v)
resize(v, b...);
}
const int INF = 1LL << 55;
const int MOD = 1000000007;
const double EPS = 1e-8;
/*------------end of definitions------------*/
int N, A, B, C, D;
string S;
signed main() {
in(N, A, B, C, D);
A--;
B--;
C--;
D--;
in(S);
auto ACrocks = S.find("##", A);
if (ACrocks != string::npos) {
if (ACrocks < C) {
No;
return 0;
}
}
auto BDrocks = S.find("##", B);
if (BDrocks != string::npos) {
if (BDrocks < D) {
No;
return 0;
}
}
if (C > D) { //飛び越える
auto space = S.find("...", B - 1);
if (space == string::npos) {
No;
return 0;
}
show(space, D);
if (space < D) {
Yes;
return 0;
} else {
No;
return 0;
}
}
Yes;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 831,780 | 831,781 | u810724221 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
bool solve() {
int i, j;
string str;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> str;
if (c > d) {
int f = 0;
for (i = b - 1, j = 0; i <= d; i++) {
if (str[i] == '.')
j++;
else
j = 0;
if (j == 3) {
f = 1;
break;
}
}
if (f == 0)
return false;
}
for (i = a + 1; i < max(c, d) - 1; i++) {
if (str[i] == '#' && str[i + 1] == '#')
return false;
}
return true;
}
int main() {
if (solve())
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
bool solve() {
int i, j;
string str;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> str;
if (c > d) {
int f = 0;
for (i = b - 1, j = 0; i <= d + 1; i++) {
if (str[i] == '.')
j++;
else
j = 0;
if (j == 3) {
f = 1;
break;
}
}
if (f == 0)
return false;
}
for (i = a + 1; i < max(c, d) - 1; i++) {
if (str[i] == '#' && str[i + 1] == '#')
return false;
}
return true;
}
int main() {
if (solve())
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 831,797 | 831,798 | u309112964 | cpp |
p03017 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
static const double EPS = 1e-9;
template <class T> bool INRANGE(T x, T a, T b) { return a <= x && x <= b; }
template <class T> void amin(T &a, T v) {
if (a > v)
a = v;
}
template <class T> void amax(T &a, T v) {
if (a < v)
a = v;
}
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
#define PI (acos(-1))
#define ARRAY_NUM(a) (sizeof(a) / sizeof(a[0]))
#define NG (-1)
#define BIG ((int)1e9 + 10)
#define BIGLL ((ll)4e18)
#define SZ(a) ((int)(a).size())
#define SQ(a) ((a) * (a))
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ok = true;
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ok = false;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ok = false;
}
}
if (c > d && ok) {
ok = false;
for (int i = b + 1; i <= d - 1; i++) {
if (s[i - 1] == '.' && s[i + 1] == '.' && s[i] == '.') {
ok = true;
}
}
}
if (ok) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
static const double EPS = 1e-9;
template <class T> bool INRANGE(T x, T a, T b) { return a <= x && x <= b; }
template <class T> void amin(T &a, T v) {
if (a > v)
a = v;
}
template <class T> void amax(T &a, T v) {
if (a < v)
a = v;
}
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
#define PI (acos(-1))
#define ARRAY_NUM(a) (sizeof(a) / sizeof(a[0]))
#define NG (-1)
#define BIG ((int)1e9 + 10)
#define BIGLL ((ll)4e18)
#define SZ(a) ((int)(a).size())
#define SQ(a) ((a) * (a))
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
string s;
cin >> s;
bool ok = true;
for (int i = a; i < c; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ok = false;
}
}
for (int i = b; i < d; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
ok = false;
}
}
if (c > d && ok) {
ok = false;
for (int i = b; i <= d; i++) {
if (s[i - 1] == '.' && s[i + 1] == '.' && s[i] == '.') {
ok = true;
}
}
}
if (ok) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change"
] | 831,799 | 831,800 | u922299738 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimization("Ofast")
#pragma GCC optimization("unroll-loops")
#pragma GCC target("avx2,avx,fma")
#define ll long long int
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define make_pair
#define rep(i, l, r) for (i = l; i < r; i++)
#define ld long double
#define ff first
#define ss second
#define pii pair<int, int>
#define pi 3.1415926535897932384626433832
int main() {
io;
int i, n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
a -= 1;
b -= 1;
c -= 1;
d -= 1;
int r = 0;
rep(i, a, c + 1) {
if (s[i] == '#')
r++;
else
r = 0;
if (r > 1)
break;
}
if (r > 1) {
cout << "No";
return 0;
}
r = 0;
rep(i, b, d + 1) {
if (s[i] == '#')
r++;
else
r = 0;
if (r > 1)
break;
}
if (r > 1) {
cout << "No";
return 0;
}
if (b > a && d > c) {
cout << "Yes";
return 0;
}
r = 0;
rep(i, b - 1, d + 1) {
if (s[i] == '.')
r++;
else
r = 0;
if (r >= 3)
break;
}
if (r > 2) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimization("Ofast")
#pragma GCC optimization("unroll-loops")
#pragma GCC target("avx2,avx,fma")
#define ll long long int
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define make_pair
#define rep(i, l, r) for (i = l; i < r; i++)
#define ld long double
#define ff first
#define ss second
#define pii pair<int, int>
#define pi 3.1415926535897932384626433832
int main() {
io;
int i, n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin >> s;
a -= 1;
b -= 1;
c -= 1;
d -= 1;
int r = 0;
rep(i, a, c + 1) {
if (s[i] == '#')
r++;
else
r = 0;
if (r > 1)
break;
}
if (r > 1) {
cout << "No";
return 0;
}
r = 0;
rep(i, b, d + 1) {
if (s[i] == '#')
r++;
else
r = 0;
if (r > 1)
break;
}
if (r > 1) {
cout << "No";
return 0;
}
if (d > c) {
cout << "Yes";
return 0;
}
r = 0;
rep(i, b - 1, d + 2) {
if (s[i] == '.')
r++;
else
r = 0;
if (r >= 3)
break;
}
if (r > 2) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
| [
"expression.operation.binary.remove",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 831,809 | 831,810 | u445107674 | cpp |
p03017 | #include <algorithm>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define ll long long
#define eps LDBL_EPSILON
#define moder 1000000007
#define double long double
#define INF LLONG_MAX / 10000
#define P pair<int, int>
#define prique priority_queue
using namespace std;
string s;
int n, a, b, c, d;
signed main() {
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
bool f = false;
int cnt = a;
while (cnt < c) {
int memo = cnt;
if (s[cnt + 1] != '#')
cnt++;
else if (cnt + 2 < s.size() && s[cnt + 2] != '#')
cnt += 2;
if (memo == cnt) {
puts("No");
return 0;
}
}
cnt = b;
while (cnt < d) {
int memo = cnt;
if (s[cnt + 1] != '#')
cnt++;
else if (cnt + 2 < s.size() && s[cnt + 2] != '#')
cnt += 2;
if (memo == cnt) {
puts("No");
return 0;
}
}
if (d < c) {
for (int i = b - 1; i < d - 1; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
f = true;
}
if (!f) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
} | #include <algorithm>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
#define ll long long
#define eps LDBL_EPSILON
#define moder 1000000007
#define double long double
#define INF LLONG_MAX / 10000
#define P pair<int, int>
#define prique priority_queue
using namespace std;
string s;
int n, a, b, c, d;
signed main() {
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
bool f = false;
int cnt = a;
while (cnt < c) {
int memo = cnt;
if (s[cnt + 1] != '#')
cnt++;
else if (cnt + 2 < s.size() && s[cnt + 2] != '#')
cnt += 2;
if (memo == cnt) {
puts("No");
return 0;
}
}
cnt = b;
while (cnt < d) {
int memo = cnt;
if (s[cnt + 1] != '#')
cnt++;
else if (cnt + 2 < s.size() && s[cnt + 2] != '#')
cnt += 2;
if (memo == cnt) {
puts("No");
return 0;
}
}
if (d < c) {
for (int i = b - 1; i < d; i++) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.')
f = true;
}
if (!f) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 831,811 | 831,812 | u379822620 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int mod = 99991;
const int maxn = 200007;
char vis[maxn];
int main() {
int n, a, b, c, d, flag = 0;
cin >> n >> a >> b >> c >> d;
cin >> vis + 1;
for (int i = max(a, b); i <= min(c, d) - 2; i++) {
if (vis[i] == '.' && vis[i + 1] == '.' && vis[i + 2] == '.') {
flag = 1;
break;
}
}
if (a < b && c > d && flag == 0)
cout << "No";
else {
for (int i = min(a, b); i <= max(c, d) - 1; i++) {
if (vis[i] == '#' && vis[i + 1] == '#') {
cout << "No";
return 0;
}
}
cout << "Yes";
}
return 0;
}
/*
2 11 4 4+3+4
3 22 6 11+5+6
*/
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int mod = 99991;
const int maxn = 200007;
char vis[maxn];
int main() {
int n, a, b, c, d, flag = 0;
cin >> n >> a >> b >> c >> d;
cin >> vis + 1;
for (int i = max(a, b) - 1; i <= min(c, d) - 1; i++) {
// cout<<vis[i]<<endl;
if (vis[i] == '.' && vis[i + 1] == '.' && vis[i + 2] == '.') {
flag = 1;
break;
}
}
if (a < b && c > d && flag == 0)
cout << "No";
else {
for (int i = min(a, b); i <= max(c, d) - 1; i++) {
if (vis[i] == '#' && vis[i + 1] == '#') {
cout << "No";
return 0;
}
}
cout << "Yes";
}
return 0;
}
/*
2 11 4 4+3+4
3 22 6 11+5+6
*/
| [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,815 | 831,816 | u130934466 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
string S;
bool can_jump(int l, int r) {
bool rock = false;
FOR(i, l + 1, r) {
if (S[i] == '#') {
if (rock)
return false;
rock = true;
} else {
rock = false;
}
}
return true;
}
bool can_advanced_jump(int l, int r) {
FOR(i, l, r - 1) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
return true;
}
return false;
}
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D >> S;
if (A < B && D < C) {
if (can_jump(A - 1, C - 1) && can_jump(B - 1, D - 1) &&
can_advanced_jump(B - 2, D - 1))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (B < A && C < D) {
if (can_jump(A - 1, C - 1) && can_jump(B - 1, D - 1) &&
can_advanced_jump(A - 2, C - 1))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
if (can_jump(A - 1, C - 1) && can_jump(B - 1, D - 1))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
string S;
bool can_jump(int l, int r) {
bool rock = false;
FOR(i, l + 1, r) {
if (S[i] == '#') {
if (rock)
return false;
rock = true;
} else {
rock = false;
}
}
return true;
}
bool can_advanced_jump(int l, int r) {
FOR(i, l, r - 1) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
return true;
}
return false;
}
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D >> S;
if (A < B && D < C) {
if (can_jump(A - 1, C - 1) && can_jump(B - 1, D - 1) &&
can_advanced_jump(B - 2, D))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (B < A && C < D) {
if (can_jump(A - 1, C - 1) && can_jump(B - 1, D - 1) &&
can_advanced_jump(A - 2, C))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
if (can_jump(A - 1, C - 1) && can_jump(B - 1, D - 1))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
} | [
"expression.operation.binary.remove"
] | 831,817 | 831,818 | u472675932 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#ifdef _DEBUG
#define DMP(x) cerr << #x << ": " << x << "\n"
#else
#define DMP(x) ((void)0)
#endif
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
typedef long long lint;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
if (C < D) {
bool flag = true;
for (int i = A; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
for (int i = B; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
if (flag)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
} else {
bool flag = false;
for (int i = B - 2; i < C - 2; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
flag = true;
}
if (flag)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
#ifdef _DEBUG
#define DMP(x) cerr << #x << ": " << x << "\n"
#else
#define DMP(x) ((void)0)
#endif
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
typedef long long lint;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
if (C < D) {
bool flag = true;
for (int i = A; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
for (int i = B; i < D - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
flag = false;
}
if (flag)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
} else {
bool flag = false;
for (int i = B - 2; i < D - 1; i++) {
if (S[i] == '.' && S[i + 1] == '.' && S[i + 2] == '.')
flag = true;
}
if (flag)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 831,823 | 831,824 | u532573979 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
int i, j;
int goal = max(c, d);
for (i = a + 1; i <= goal; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
bool check = false;
goal = min(c, d) + 1;
if (c > d) {
for (i = b + 2; i <= goal; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i - 2] == '.') {
check = true;
break;
}
}
if (check == false) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
cin >> n >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
cin >> s;
int i, j;
int goal = max(c, d);
for (i = a + 1; i <= goal; i++) {
if (s[i] == '#' && s[i - 1] == '#') {
cout << "No" << endl;
return 0;
}
}
bool check = false;
goal = min(c, d) + 1;
if (c > d) {
for (i = b + 1; i <= goal; i++) {
if (s[i] == '.' && s[i - 1] == '.' && s[i - 2] == '.') {
check = true;
break;
}
}
if (check == false) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 831,825 | 831,826 | u216374186 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define cinv(n, vec) \
VL(vec)(n); \
for (auto &v : vec) \
cin >> v;
#define int long long
#define itn int
#define pb push_back
#define m_p make_pair
#define m_t make_tuple
#define eb emplace_back
#define p_p(a, b) pb(m_p(a, b))
#define all(a) a.begin(), a.end()
#define SORT(a) sort(all(a))
#define RSORT(a) sort(all(a), greater<>())
#define UNIQUE(a) a.erase(unique(all(a)), a.end())
#define SZ(a) (ll)(a.size())
#define ENDL cout << endl
#define debg(a) cout << #a << " " << a << endl;
#define debgp(a) cout << #a << " " << a.fi << " : " << a.se << endl
#define call(a) \
for (auto i : a) \
cout << i << " "; \
cout << endl
#define show(a) \
for (cont & y : a) { \
for (cont & x : y) { \
cout << x << " "; \
} \
cout << endl; \
}
#define out(a) cout << (a) << endl
#define cont const auto
#define fi first
#define se second
#define V vector
#define P pair
#define T tuple
#define VV(type, name, y, x, a) \
vector<vector<type>> name = vector<vector<type>>(y, vector<type>(x, a))
#define PQ priority_queue
typedef long long ll;
typedef double D;
typedef long double LD;
typedef string str;
typedef vector<ll> VL;
typedef pair<ll, ll> PL;
typedef vector<pair<ll, ll>> VP;
typedef tuple<ll, ll, ll> T3;
typedef tuple<ll, ll, ll, ll> T4;
const long long INF = 1LL << 60;
const long long MOD = 1e9 + 7;
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YN(bool b) { cout << (b ? "Yes" : "No") << endl; }
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return (gcd(b, a % b));
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
str s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
int e = min(a, b);
int f = max(c, d);
for (int i = e; i <= f - 1; ++i) {
if (s[i] == '#' && s[i + 1] == '#') {
out("No");
return 0;
}
}
if (c < d) {
Yes();
return 0;
}
for (int i = e; i < f - 1; ++i) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
if (b < i + 2) {
Yes();
return 0;
}
}
}
No();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define cinv(n, vec) \
VL(vec)(n); \
for (auto &v : vec) \
cin >> v;
#define int long long
#define itn int
#define pb push_back
#define m_p make_pair
#define m_t make_tuple
#define eb emplace_back
#define p_p(a, b) pb(m_p(a, b))
#define all(a) a.begin(), a.end()
#define SORT(a) sort(all(a))
#define RSORT(a) sort(all(a), greater<>())
#define UNIQUE(a) a.erase(unique(all(a)), a.end())
#define SZ(a) (ll)(a.size())
#define ENDL cout << endl
#define debg(a) cout << #a << " " << a << endl;
#define debgp(a) cout << #a << " " << a.fi << " : " << a.se << endl
#define call(a) \
for (auto i : a) \
cout << i << " "; \
cout << endl
#define show(a) \
for (cont & y : a) { \
for (cont & x : y) { \
cout << x << " "; \
} \
cout << endl; \
}
#define out(a) cout << (a) << endl
#define cont const auto
#define fi first
#define se second
#define V vector
#define P pair
#define T tuple
#define VV(type, name, y, x, a) \
vector<vector<type>> name = vector<vector<type>>(y, vector<type>(x, a))
#define PQ priority_queue
typedef long long ll;
typedef double D;
typedef long double LD;
typedef string str;
typedef vector<ll> VL;
typedef pair<ll, ll> PL;
typedef vector<pair<ll, ll>> VP;
typedef tuple<ll, ll, ll> T3;
typedef tuple<ll, ll, ll, ll> T4;
const long long INF = 1LL << 60;
const long long MOD = 1e9 + 7;
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YN(bool b) { cout << (b ? "Yes" : "No") << endl; }
template <class T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return (gcd(b, a % b));
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, b, c, d;
str s;
cin >> n >> a >> b >> c >> d >> s;
a--;
b--;
c--;
d--;
int e = min(a, b);
int f = max(c, d);
for (int i = e; i < f - 1; ++i) {
if (s[i] == '#' && s[i + 1] == '#') {
out("No");
return 0;
}
}
if (c < d) {
Yes();
return 0;
}
for (int i = e; i < f - 1; ++i) {
if (s[i] == '.' && s[i + 1] == '.' && s[i + 2] == '.') {
if (b < i + 2 && i < d) {
Yes();
return 0;
}
}
}
No();
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"
] | 831,827 | 831,828 | u423624748 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.