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;
using ll = long long;
using P = pair<ll, ll>;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int fstoneA = 0, fstoneB = 0;
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
fstoneA = 1;
}
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
int N, A, B, C, D;
cin >> N >> A >> B >> C >> D;
string S;
cin >> S;
int fstoneA = 0, fstoneB = 0;
for (int i = A - 1; i < C - 1; i++) {
if (S[i] == '#' && S[i + 1] == '#')
fstoneA = 1;
}
... | [
"control_flow.loop.for.condition.change"
] | 832,756 | 832,755 | u129667379 | cpp |
p03017 | #if 1
#include <bits/stdc++.h>
using namespace std;
int n, s1, s2, e1, e2;
char a[200005];
int b[2];
int main() {
scanf("%d %d %d %d %d", &n, &s1, &s2, &e1, &e2);
// if(s1 > e1) swap(s1,e1);
// if(s2 > e2) swap(s2,e2);
if (s1 > e1 || s2 > e2) {
printf("No");
return 0;
}
scanf("%s", a + 1);
int c... | #if 1
#include <bits/stdc++.h>
using namespace std;
int n, s1, s2, e1, e2;
char a[200005];
int b[2];
int main() {
scanf("%d %d %d %d %d", &n, &s1, &s2, &e1, &e2);
// if(s1 > e1) swap(s1,e1);
// if(s2 > e2) swap(s2,e2);
if (s1 > e1 || s2 > e2) {
printf("No");
return 0;
}
scanf("%s", a + 1);
int c... | [
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,761 | 832,762 | u998677610 | cpp |
p03017 | #if 1
#include <bits/stdc++.h>
using namespace std;
int n, s1, s2, e1, e2;
char a[200005];
int b[2];
int main() {
scanf("%d %d %d %d %d", &n, &s1, &s2, &e1, &e2);
// if(s1 > e1) swap(s1,e1);
// if(s2 > e2) swap(s2,e2);
if (s1 > e1 || s2 > e2) {
printf("No");
return 0;
}
scanf("%s", a + 1);
int c... | #if 1
#include <bits/stdc++.h>
using namespace std;
int n, s1, s2, e1, e2;
char a[200005];
int b[2];
int main() {
scanf("%d %d %d %d %d", &n, &s1, &s2, &e1, &e2);
// if(s1 > e1) swap(s1,e1);
// if(s2 > e2) swap(s2,e2);
if (s1 > e1 || s2 > e2) {
printf("No");
return 0;
}
scanf("%s", a + 1);
int c... | [
"control_flow.loop.for.initializer.change"
] | 832,763 | 832,762 | u998677610 | cpp |
p03017 | #pragma region include
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i... | #pragma region include
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define REP(i... | [
"control_flow.loop.for.initializer.change"
] | 832,772 | 832,773 | u435935167 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rept(i, a, b)... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rept(i, a, b)... | [
"expression.operation.binary.add"
] | 832,774 | 832,775 | u569041543 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define REP(i, x) for (int(i) = 0; (i) < (x); (i)++)
#define pi 3.1415926535
const int MOD = 1000000007;
using nam... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define REP(i, x) for (int(i) = 0; (i) < (x); (i)++)
#define pi 3.1415926535
const int MOD = 1000000007;
using nam... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,776 | 832,777 | u342129174 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define REP(i, x) for (int(i) = 0; (i) < (x); (i)++)
#define pi 3.1415926535
const int MOD = 1000000007;
using nam... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define REP(i, x) for (int(i) = 0; (i) < (x); (i)++)
#define pi 3.1415926535
const int MOD = 1000000007;
using nam... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change"
] | 832,778 | 832,777 | u342129174 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
ll A;
cin >> A;
ll B;
cin >> B;
ll C;
cin >> C;
ll D;
cin >> D;
string S;
cin >> S;
bool jumpable = false;
ll cnt = 0;
for (ll j = B - 2; j < min(C, D); ++j) {
if (S[j] == '.') {
cn... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
ll A;
cin >> A;
ll B;
cin >> B;
ll C;
cin >> C;
ll D;
cin >> D;
string S;
cin >> S;
bool jumpable = false;
ll cnt = 0;
for (ll j = B - 2; j < D + 1; ++j) {
if (S[j] == '.') {
cnt +=... | [
"control_flow.loop.for.condition.change",
"call.remove",
"call.arguments.change",
"expression.operation.binary.change"
] | 832,781 | 832,782 | u275710783 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
ll A;
cin >> A;
ll B;
cin >> B;
ll C;
cin >> C;
ll D;
cin >> D;
string S;
cin >> S;
bool jumpable = false;
ll cnt = 0;
for (ll j = B - 2; j < C; ++j) {
if (S[j] == '.') {
cnt += 1;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
ll A;
cin >> A;
ll B;
cin >> B;
ll C;
cin >> C;
ll D;
cin >> D;
string S;
cin >> S;
bool jumpable = false;
ll cnt = 0;
for (ll j = B - 2; j < D + 1; ++j) {
if (S[j] == '.') {
cnt +=... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one"
] | 832,783 | 832,782 | u275710783 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
char S[200005];
cin >> N >> A >> B >> C >> D;
cin >> S;
if (B < C) {
// A < B < C < D の配置 (Bは Aの移動の邪魔にならない)
if (C < D) {
int frag_ad = 1;
for (int i = A - 1; i < D - 2; i++) {
if (S[i] == '#' && S[i + ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
char S[200005];
cin >> N >> A >> B >> C >> D;
cin >> S;
if (B < C) {
// A < B < C < D の配置 (Bは Aの移動の邪魔にならない)
if (C < D) {
int frag_ad = 1;
for (int i = A - 1; i < D - 2; i++) {
if (S[i] == '#' && S[i + ... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,790 | 832,791 | u399232305 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
char S[200005];
cin >> N >> A >> B >> C >> D;
cin >> S;
if (B < C) {
// A < B < C < D の配置 (BはAの移動の邪魔にならない)
if (C < D) {
int frag_ad = 1;
for (int i = A - 1; i < D - 2; i++) {
if (S[i] == '#' && S[i + 1... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B, C, D;
char S[200005];
cin >> N >> A >> B >> C >> D;
cin >> S;
if (B < C) {
// A < B < C < D の配置 (Bは Aの移動の邪魔にならない)
if (C < D) {
int frag_ad = 1;
for (int i = A - 1; i < D - 2; i++) {
if (S[i] == '#' && S[i + ... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 832,792 | 832,791 | u399232305 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
// #include<boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#define BEGIN \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); ... | #include <bits/stdc++.h>
using namespace std;
// #include<boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#define BEGIN \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); ... | [
"expression.operation.binary.remove"
] | 832,810 | 832,811 | u743561048 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B, C,... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B, C,... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,812 | 832,813 | u864171425 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B, C,... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B, C,... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 832,814 | 832,813 | u864171425 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B, C,... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF LONG_MAX
#define MOD 1000000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, A, B, C,... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 832,815 | 832,813 | u864171425 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); +... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); +... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 832,816 | 832,817 | u721367699 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 100000000... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 100000000... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,818 | 832,819 | u866733412 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 100000000... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 100000000... | [
"assignment.variable.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,820 | 832,819 | u866733412 | cpp |
p03017 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 100000000... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr long long MOD = 100000000... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.variable.change",
"expression.operation.binary.remove"
] | 832,821 | 832,819 | u866733412 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main(void) {
string s;
int i, j, n, a, b, c, d;
bool r1 = 0, b1 = 0, b2 = 0, b3 = 0;
cin >> n >> a >> b >> c >> d;... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main(void) {
string s;
int i, n, a, b, c, d;
bool r1 = 0, b1 = 0, b2 = 0, b3 = 0;
cin >> n >> a >> b >> c >> d;
... | [
"variable_declaration.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 832,829 | 832,830 | u516922881 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ini(arr, val) memset(arr, (val), sizeof(arr))
#define loop(i, n) for (ll i = 0; i < n; i++)
#define all(a) (a).begin(), (a).end()
#define exist(s, e) (s.find(e) != s.end())
#define dbg(x) cerr << #x << " is " << x << endl;
#define pt(x) cout ... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ini(arr, val) memset(arr, (val), sizeof(arr))
#define loop(i, n) for (ll i = 0; i < n; i++)
#define all(a) (a).begin(), (a).end()
#define exist(s, e) (s.find(e) != s.end())
#define dbg(x) cerr << #x << " is " << x << endl;
#define pt(x) cout ... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,834 | 832,835 | u105645742 | cpp |
p03017 | #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef long long ll;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin... | #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef long long ll;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin... | [
"control_flow.loop.for.initializer.change"
] | 832,842 | 832,843 | u678503521 | cpp |
p03017 | #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef long long ll;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin... | #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef long long ll;
int main() {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
string s;
cin... | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,844 | 832,843 | u678503521 | cpp |
p03017 | // template version 1.11
using namespace std;
#include <bits/stdc++.h>
#include <iostream>
// varibable settings {{{
#define infile "../test/sample-1.in"
#define int long long
const int INF = 1e18;
const int MOD = 1e9 + 7;
// }}}
// define basic macro {{{
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i,... | // template version 1.11
using namespace std;
#include <bits/stdc++.h>
#include <iostream>
// varibable settings {{{
#define infile "../test/sample-1.in"
#define int long long
const int INF = 1e18;
const int MOD = 1e9 + 7;
// }}}
// define basic macro {{{
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i,... | [
"expression.operation.binary.remove"
] | 832,866 | 832,867 | u314057689 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, k, s, a, b, c, d;
char st[200005];
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", st + 1);
for (i = a; i < max(c, d); ++i)
if (st[i] == '#' && st[i + 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
... | #include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, k, s, a, b, c, d;
char st[200005];
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", st + 1);
for (i = a; i < max(c, d); ++i)
if (st[i] == '#' && st[i + 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"call.arguments.change",
"expression.operation.binary.change"
] | 832,871 | 832,872 | u886728471 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, k, s, a, b, c, d;
char st[200005];
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", st + 1);
for (i = a; i < max(c, d); ++i)
if (st[i] == '#' && st[i + 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
... | #include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, k, s, a, b, c, d;
char st[200005];
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", st + 1);
for (i = a; i < max(c, d); ++i)
if (st[i] == '#' && st[i + 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
... | [
"assignment.value.change",
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"call.arguments.change"
] | 832,873 | 832,872 | u886728471 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, k, s, a, b, c, d;
char st[200005];
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", st + 1);
for (i = a; i < max(c, d); ++i)
if (st[i] == '#' && st[i + 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
... | #include <bits/stdc++.h>
using namespace std;
int n, m, i, j, t, k, s, a, b, c, d;
char st[200005];
int main() {
scanf("%d%d%d%d%d", &n, &a, &b, &c, &d);
scanf("%s", st + 1);
for (i = a; i < max(c, d); ++i)
if (st[i] == '#' && st[i + 1] == '#') {
printf("No\n");
return 0;
}
if (c < d) {
... | [
"assignment.value.change",
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change",
"literal.number.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"misc.off_by_one"
] | 832,874 | 832,872 | u886728471 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll div_ceil(ll, ll);
int dx[4] = {0, 0, -1, 1};... | #include <bits/stdc++.h>
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll div_ceil(ll, ll);
int dx[4] = {0, 0, -1, 1};... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 832,878 | 832,879 | u408053343 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll div_ceil(ll, ll);
int dx[4] = {0, 0, -1, 1};... | #include <bits/stdc++.h>
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll div_ceil(ll, ll);
int dx[4] = {0, 0, -1, 1};... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 832,880 | 832,879 | u408053343 | cpp |
p03017 | #include <bits/stdc++.h>
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll div_ceil(ll, ll);
int dx[4] = {0, 0, -1, 1};... | #include <bits/stdc++.h>
#define REP(i, N) for (int i = 0; i < (N); ++i)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define PB push_back
#define MP make_pair
using namespace std;
typedef long long ll;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll div_ceil(ll, ll);
int dx[4] = {0, 0, -1, 1};... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,881 | 832,879 | u408053343 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
bool f(int x, int y, string s) {
for (int i = x; i < y - 2; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool g(int x, int y, string s) { //すぬけ君がふぬけ君を抜けるか判定
for (int i = x - 1; i < y; i++) {
if (s[i - 1] == '.' && ... | #include <bits/stdc++.h>
using namespace std;
bool f(int x, int y, string s) {
for (int i = x; i < y - 2; i++) {
if (s[i] == '#' && s[i + 1] == '#') {
return false;
}
}
return true;
}
bool g(int x, int y, string s) { //すぬけ君がふぬけ君を抜けるか判定
for (int i = x - 1; i < y; i++) {
if (s[i - 1] == '.' && ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 832,891 | 832,892 | u528388170 | cpp |
p03017 | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) ... | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) ... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 832,893 | 832,894 | u337054478 | cpp |
p03017 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S[A] = 'A';
S[B] = 'B'... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, A, B, C, D;
string S;
cin >> N >> A >> B >> C >> D >> S;
A = A - 1;
B = B - 1;
C = C - 1;
D = D - 1;
S[A] = 'A';
S[B] = 'B'... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 832,899 | 832,900 | u490552503 | 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); i >= 0; i--)
#define ALL(x) (x).begin(), (x).end()
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
typedef long long ll;
type... | #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); i >= 0; i--)
#define ALL(x) (x).begin(), (x).end()
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
typedef long long ll;
type... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 832,910 | 832,911 | u875541682 | cpp |
p03017 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
using namespace std;
#defi... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
using namespace std;
#defi... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,915 | 832,916 | u415518175 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool ans_sub = false;
cin >> n >> a >> b >> c >> d;
cin >> s;
if (d < c) { //交差する必要あり
//三連'.'検索
for (int i = b - 1; i < d - 1; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
... | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool ans_sub = false;
cin >> n >> a >> b >> c >> d;
cin >> s;
if (d < c) { //交差する必要あり
//三連'.'検索
for (int i = b - 1; i < d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"literal.number.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 832,920 | 832,921 | u048128931 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool ans_sub = false;
cin >> n >> a >> b >> c >> d;
cin >> s;
if (d < c) { //交差する必要あり
//三連'.'検索
for (int i = b - 1; i < d - 1; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
... | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool ans_sub = false;
cin >> n >> a >> b >> c >> d;
cin >> s;
if (d < c) { //交差する必要あり
//三連'.'検索
for (int i = b - 1; i < d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 832,922 | 832,921 | u048128931 | cpp |
p03017 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool ans_sub = false;
cin >> n >> a >> b >> c >> d;
cin >> s;
if (d < c) { //交差する必要あり
//三連'.'検索
for (int i = b - 1; i < d - 1; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
... | #include <iostream>
#include <string>
using namespace std;
int main() {
int n, a, b, c, d;
string s;
bool ans_sub = false;
cin >> n >> a >> b >> c >> d;
cin >> s;
if (d < c) { //交差する必要あり
//三連'.'検索
for (int i = b - 1; i < d; i++) {
if (s[i - 1] == '.' && s[i] == '.' && s[i + 1] == '.') {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.loop.for.initializer.change"
] | 832,923 | 832,921 | u048128931 | cpp |
p03017 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using db = double;
using ldb = long db;
using str = string;
using vll = V<ll>;
using vvll = V... | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using db = double;
using ldb = long db;
using str = string;
using vll = V<ll>;
using vvll = V... | [
"expression.operation.binary.remove"
] | 832,954 | 832,955 | u177143886 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; --i)
using... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; --i)
using... | [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 832,958 | 832,959 | u698883164 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; --i)
using... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; --i)
using... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 832,962 | 832,959 | u698883164 | cpp |
p03017 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; --i)
using... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repp(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; --i)
using... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 832,963 | 832,959 | u698883164 | cpp |
p03003 | #include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v... | #include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v... | [
"expression.operation.binary.add"
] | 832,970 | 832,971 | u918357423 | cpp |
p03004 | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | [
"literal.string.change",
"call.arguments.change"
] | 832,980 | 832,981 | u224756887 | cpp |
p03004 | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"call.arguments.change"
] | 832,982 | 832,981 | u224756887 | cpp |
p03004 | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | #include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stac... | [
"assignment.add"
] | 832,983 | 832,984 | u224756887 | cpp |
p03004 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { ... | [] | 832,987 | 832,988 | u600402037 | cpp |
p03004 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { ... | [] | 832,989 | 832,990 | u600402037 | cpp |
p03004 | //#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("fma,avx,avx2")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ld long double
#define sz(a) (int)(a).size()
#define all(a) (a).begin(), (a).end()
#define x first
#define y second
mt19937 rnd(chro... | //#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("fma,avx,avx2")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ld long double
#define sz(a) (int)(a).size()
#define all(a) (a).begin(), (a).end()
#define x first
#define y second
mt19937 rnd(chro... | [
"literal.number.change",
"variable_declaration.value.change"
] | 833,003 | 833,004 | u304537903 | cpp |
p03004 | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using P = pair<int, int>;
using PL = pair<lint, lint>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) ... | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using P = pair<int, int>;
using PL = pair<lint, lint>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) ... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 833,005 | 833,006 | u914173586 | cpp |
p03004 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
#define sim template <class c
#defi... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
#define sim template <class c
#defi... | [
"misc.opposites",
"expression.operator.compare.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 833,024 | 833,025 | u306697932 | cpp |
p03004 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
#define sim template <class c
#defi... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
#define sim template <class c
#defi... | [
"misc.opposites",
"expression.operator.compare.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change"
] | 833,026 | 833,025 | u306697932 | cpp |
p03004 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <... | [
"expression.operation.binary.add"
] | 833,041 | 833,042 | u017271745 | cpp |
p03004 | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef... | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef... | [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 833,047 | 833,048 | u934272719 | cpp |
p03004 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <... | [
"variable_declaration.type.primitive.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operator.a... | 833,072 | 833,073 | u221285045 | cpp |
p03004 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; ++i)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (ll i = a; i >= b; i--)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#de... | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; ++i)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (ll i = a; i >= b; i--)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#de... | [
"literal.number.change",
"variable_declaration.value.change"
] | 833,082 | 833,083 | u495699318 | cpp |
p03004 | #include <bits/stdc++.h>
using namespace std;
#define all(V) V.begin(), V.end()
#define ll long long
#define MOD 998244353
const double SMALL = pow(10, -12);
vector<pair<double, double>> P[4];
double M[4][4], L[4][4];
void chmin(double &x, double y) { x = min(x, y); }
void chmax(double &x, double y) { x = max(x, y);... | #include <bits/stdc++.h>
using namespace std;
#define all(V) V.begin(), V.end()
#define ll long long
#define MOD 998244353
const double SMALL = pow(10, -12);
vector<pair<double, double>> P[4];
double M[4][4], L[4][4];
void chmin(double &x, double y) { x = min(x, y); }
void chmax(double &x, double y) { x = max(x, y);... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 833,098 | 833,099 | u045811375 | cpp |
p03004 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
using vint = vector<int>;
usi... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
using vint = vector<int>;
usi... | [
"assignment.change"
] | 833,113 | 833,112 | u685892567 | cpp |
p03004 | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#defin... | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#defin... | [
"call.arguments.change"
] | 833,120 | 833,121 | u284124505 | cpp |
p03004 | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
const ll INF = LLONG_MAX / 2;
int n;
vector<ll> x, y;
vector<int> dx, dy;
ll solve(ll t) {
ll xmin = INF;
ll ymin = INF;
ll xmax = -INF;
ll ym... | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
const ll INF = LLONG_MAX / 2;
int n;
vector<ll> x, y;
vector<int> dx, dy;
ll solve(ll t) {
ll xmin = INF;
ll ymin = INF;
ll xmax = -INF;
ll ym... | [
"literal.number.change",
"variable_declaration.value.change"
] | 833,139 | 833,140 | u468811760 | cpp |
p03004 | #include <bits/stdc++.h>
using namespace std;
int main() {
cout.precision(17);
cout.setf(ios_base::fixed, ios_base::floatfield);
int N;
cin >> N;
vector<pair<int64_t, int64_t>> info[4];
map<char, int> idx;
idx['R'] = 0;
idx['L'] = 1;
idx['U'] = 2;
idx['D'] = 3;
int64_t x, y;
char d;
vector... | #include <bits/stdc++.h>
using namespace std;
int main() {
cout.precision(17);
cout.setf(ios_base::fixed, ios_base::floatfield);
int N;
cin >> N;
vector<pair<int64_t, int64_t>> info[4];
map<char, int> idx;
idx['R'] = 0;
idx['L'] = 1;
idx['U'] = 2;
idx['D'] = 3;
int64_t x, y;
char d;
vector... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 833,175 | 833,176 | u726604439 | cpp |
p03004 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <v... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <v... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 833,191 | 833,192 | u090994275 | cpp |
p03004 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define mins(x, y) x = min(x, y)
#define maxs(x, y) x = max(x, y)
using namespace std;
const double inf = 1e10;
struct D {
vector<double> l, r;
D() : l(3, inf), r(3, -inf) {}
void add(double x, int v) {
++v;
mins(l[v], x);
maxs... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define mins(x, y) x = min(x, y)
#define maxs(x, y) x = max(x, y)
using namespace std;
const double inf = 1e10;
struct D {
vector<double> l, r;
D() : l(3, inf), r(3, -inf) {}
void add(double x, int v) {
++v;
mins(l[v], x);
maxs... | [] | 833,193 | 833,194 | u639032323 | cpp |
p03004 | #include <bits/stdc++.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = (i... | #include <bits/stdc++.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = (i... | [
"call.arguments.change"
] | 833,211 | 833,212 | u704625420 | cpp |
p03004 | #pragma GCC optimize("O3")
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using QWORD = uint64... | #pragma GCC optimize("O3")
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using QWORD = uint64... | [
"preprocessor.define.value.change",
"literal.float.change"
] | 833,223 | 833,224 | u487476769 | cpp |
p03004 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include ... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include ... | [
"expression.operation.unary.add"
] | 833,228 | 833,229 | u862095327 | cpp |
p03018 | #include <bits/stdc++.h>
#define ll long long
#define str string
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define vc vector<char>
#define vvc vector<vc>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vvvll vector<vvll... | #include <bits/stdc++.h>
#define ll long long
#define str string
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define vc vector<char>
#define vvc vector<vc>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vvvll vector<vvll... | [
"assignment.variable.change",
"identifier.change"
] | 833,251 | 833,252 | u938335949 | cpp |
p03018 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
int n = s.size();
int acnt = 0, ans = 0;
rep(i, n - 1) {
// cout << s[i] << " ";
if (s[i] == 'A') {
acnt++;
} else ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
int n = s.size();
int acnt = 0;
ll ans = 0;
rep(i, n - 1) {
// cout << s[i] << " ";
if (s[i] == 'A') {
acnt++;
} ... | [] | 833,274 | 833,273 | u489302942 | cpp |
p03018 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
int n = s.size();
int acnt = 0, ans = 0;
rep(i, n - 1) {
// cout << s[i] << " ";
if (s[i] == 'A') {
acnt++;
} else ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
int n = s.size();
int acnt = 0;
ll ans = 0;
rep(i, n - 1) {
// cout << s[i] << " ";
if (s[i] == 'A') {
acnt++;
} ... | [] | 833,275 | 833,273 | u489302942 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int64_t MOD = 1000000007;
const long long INF = 1LL << 60;
int main() {
int64_t ans = 0, temp = 0;
string S;
cin >> S;
rep(i, S.size() - 1) {
if (S.at(i) == 'A')
temp++;
else if (S.at(i) == 'B' && S... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int64_t MOD = 1000000007;
const long long INF = 1LL << 60;
int main() {
int64_t ans = 0, temp = 0;
string S;
cin >> S;
rep(i, S.size() - 1) {
if (S.at(i) == 'A')
temp++;
else if (S.at(i) == 'B' && S... | [] | 833,278 | 833,279 | u153686508 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
ll ans = 0;
int l = 0; // Aが連続した回数
REP(i, s.size() - 2) {
if (s[i] == 'A')
l++;
else
l = 0;
if (s[i] != 'A... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
ll ans = 0;
int l = 0; // Aが連続した回数
REP(i, s.size() - 2) {
if (s[i] == 'A')
l++;
else
l = 0;
if (s[i] != 'A... | [
"assignment.add"
] | 833,286 | 833,287 | u893239355 | cpp |
p03018 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n - 1); i >= 0; i--)
#define ALL(v) v.begin(), v.end()
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
string s;
cin >> s;
int n = s.size();
int a_count = 0;
int ans = 0... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n - 1); i >= 0; i--)
#define ALL(v) v.begin(), v.end()
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
string s;
cin >> s;
int n = s.size();
int a_count = 0;
ll ans = 0;... | [
"variable_declaration.type.change"
] | 833,297 | 833,298 | u233586402 | cpp |
p03018 | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b)... | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b)... | [
"variable_declaration.type.change"
] | 833,316 | 833,315 | u688789047 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e16 + 7;
int mod = 1e9 + 7;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
signed main() {
string S;
cin >> S;
S += "Z";
int cnt = 0;
int ans = 0;
for (int i = 0; i < S.size() - 1; i++) {
if (... | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e16 + 7;
int mod = 1e9 + 7;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
signed main() {
string S;
cin >> S;
S += "Z";
int cnt = 0;
int ans = 0;
for (int i = 0; i < S.size() - 1; i++) {
if (... | [] | 833,323 | 833,324 | u237390401 | cpp |
p03018 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
int main() {
string s;
cin >> s;
int l = s.length();
s += "ZZZZZZZZ";
int abc, a, bc, ans;
abc = 0;
a = 0;
b... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
using namespace std;
int main() {
string s;
cin >> s;
int l = s.length();
s += "ZZZZZZZZ";
ll abc, a, bc, ans;
abc = 0;
a = 0;
bc... | [
"variable_declaration.type.change"
] | 833,333 | 833,334 | u841856382 | cpp |
p03018 | #include <bits/stdc++.h>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define irrep(i, n) for (int i = (int)(n - 1); i > -1; i--)
#define irrep2(i, n, a) for (int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using ll = ... | #include <bits/stdc++.h>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define irrep(i, n) for (int i = (int)(n - 1); i > -1; i--)
#define irrep2(i, n, a) for (int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using ll = ... | [] | 833,349 | 833,350 | u829260400 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
//最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
//出力系
#define print(x) cout << x << endl
#... | #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
//最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
//出力系
#define print(x) cout << x << endl
#... | [] | 833,356 | 833,357 | u832995587 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
//最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
//出力系
#define print(x) cout << x << endl
#... | #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
//最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
//出力系
#define print(x) cout << x << endl
#... | [
"variable_declaration.type.change"
] | 833,359 | 833,357 | u832995587 | cpp |
p03018 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define ll long long
#define INF 21474836... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define ll long long
#define INF 21474836... | [
"expression.unary.arithmetic.add"
] | 833,407 | 833,408 | u170301438 | cpp |
p03018 | // includes
#include <bits/stdc++.h>
// macros
#define ll long long int
#define pb emplace_back
#define mk make_pair
#define pq priority_queue
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define irep(itr, st) for (auto i... | // includes
#include <bits/stdc++.h>
// macros
#define ll long long int
#define pb emplace_back
#define mk make_pair
#define pq priority_queue
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define irep(itr, st) for (auto i... | [
"assignment.value.change"
] | 833,451 | 833,452 | u424110125 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
#define MAXNUM 222222
typedef long long ll;
char s[MAXNUM];
int main() {
scanf("%s", s);
int ssize = strlen(s);
int bef = 0;
ll res = 0;
for (int i = ssize - 1; i >= 0; i--) {
if (bef && s[i] == 'C' && s[i + 1] == 'B')
bef++;
else if (s[i] == 'B' && ... | #include <bits/stdc++.h>
using namespace std;
#define MAXNUM 222222
typedef long long ll;
char s[MAXNUM];
int main() {
scanf("%s", s);
int ssize = strlen(s);
int bef = 0;
ll res = 0;
for (int i = ssize - 1; i >= 0; i--) {
if (bef && s[i] == 'C' && s[i + 1] == 'B')
bef++;
else if (s[i] == 'B' && ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 833,489 | 833,490 | u930038564 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rreps(i, e, n) for (int i = (n)-1; i >= (e); i--)
#d... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rreps(i, e, n) for (int i = (n)-1; i >= (e); i--)
#d... | [
"variable_declaration.type.change"
] | 833,525 | 833,524 | u225581241 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
long long ans = 0;
int w = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'A') {
w++;
} else if (s.substr(i, 2) == "BC") {
ans += w;
} else {
w = 0;
}
}
printf("%lld\n", ans)... | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
long long ans = 0;
int w = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'A') {
w++;
} else if (s.substr(i, 2) == "BC") {
ans += w;
i++;
} else {
w = 0;
}
}
printf("%l... | [
"expression.unary.arithmetic.add"
] | 833,532 | 833,533 | u123756661 | cpp |
p03018 | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
string s;
ll N;
int main() {
cin >> s;
N = s.size();
ll count = 0;
ll p = 0;
ll ans = 0;
while (p < N - 2) {
if (s[p] == 'A' && s[p + 1] == 'B' && s[p + 2] == 'C') {
ans += count + 1;
count = 0;
s[p + ... | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
string s;
ll N;
int main() {
cin >> s;
N = s.size();
ll count = 0;
ll p = 0;
ll ans = 0;
while (p < N - 2) {
if (s[p] == 'A' && s[p + 1] == 'B' && s[p + 2] == 'C') {
ans += count + 1;
s[p + 2] = 'A';
p... | [] | 833,537 | 833,538 | u705230587 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
int cnt = 0;
long long ans = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'B' && s[i + 1] == 'C') {
cnt++;
i++;
} else if (s[i] == 'A') {
ans += cnt;
} else {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
int cnt = 0;
long long ans = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'C' && s[i + 1] == 'B') {
cnt++;
i++;
} else if (s[i] == 'A') {
ans += cnt;
} else {
... | [
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 833,549 | 833,550 | u660341491 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rep2(i, a, b) for (ll i = a; i < b; ++i)
const ll MOD = 1000000007;
string alp = "abcdefghijklmnopqrstuvwxyz";
int main() {
string S;
cin >>... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rep2(i, a, b) for (ll i = a; i < b; ++i)
const ll MOD = 1000000007;
string alp = "abcdefghijklmnopqrstuvwxyz";
int main() {
string S;
cin >>... | [] | 833,563 | 833,564 | u275786410 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
int move_cnt[200005];
int main(void) {
string S;
cin >> S;
S.push_back('A');
int N = S.length();
int BC_cnt = 0;
long long ans = 0;
for (int i = N - 1; 0 <= i; i--) {
if (0 < i && S[i - 1] == 'B' && S[i] == 'C') {
BC_cnt++;
i--;
} else i... | #include <bits/stdc++.h>
using namespace std;
int move_cnt[200005];
int main(void) {
string S;
cin >> S;
S.push_back('A');
int N = S.length();
int BC_cnt = 0;
long long ans = 0;
for (int i = N - 1; 0 <= i; i--) {
if (0 < i && S[i - 1] == 'B' && S[i] == 'C') {
BC_cnt++;
i--;
} else i... | [
"assignment.add"
] | 833,617 | 833,618 | u543284218 | cpp |
p03018 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF 1 << 30
#define LINF (ll)1 << 62
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF 1 << 30
#define LINF (ll)1 << 62
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (... | [] | 833,633 | 833,634 | u242679311 | cpp |
p03018 | #include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9 + 7)
#define inf (int)(3e18 + 7)
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i < n; i++)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(v) v.begin(), v.end()
#define mkp make_pair
#define... | #include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9 + 7)
#define inf (int)(3e18 + 7)
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i < n; i++)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(v) v.begin(), v.end()
#define mkp make_pair
#define... | [] | 833,639 | 833,640 | u147049801 | cpp |
p03018 | // From Naruto to Hokage
//#include <RJ>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define eb emplace_back
#define endl '\n'
#define mii map<ll, ll>
#define pii pair<ll, ll>
#define vi vector<ll>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#defin... | // From Naruto to Hokage
//#include <RJ>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define eb emplace_back
#define endl '\n'
#define mii map<ll, ll>
#define pii pair<ll, ll>
#define vi vector<ll>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#defin... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 833,647 | 833,648 | u592186586 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long ans;
int n;
char s[N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1), cnt = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'A')
cnt++;
if (s[i] == 'C')
cnt = 0;
if (s[i] == 'B') {
if (s[i + 1] == 'C... | #include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long ans;
int n;
char s[N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1), cnt = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'A')
cnt++;
if (s[i] == 'C')
cnt = 0;
if (s[i] == 'B') {
if (s[i + 1] == 'C... | [
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 833,658 | 833,659 | u768967683 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1000000007;
typedef long long ll;
char s[N];
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
ll tmp = 0, ans = 0;
for (int i = len; i > 0; i--) {
if (s[i - 1] == 'B' && s[i] == 'C') {
tmp++;
i--;
... | #include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1000000007;
typedef long long ll;
char s[N];
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
ll tmp = 0, ans = 0;
for (int i = len; i > 0; i--) {
if (s[i - 1] == 'B' && s[i] == 'C') {
tmp++;
i--;
... | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 833,664 | 833,665 | u222613738 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
const int N = 2e5 + 10;
int n;
char s[N];
int main() {
while (~scanf("%s", s)) {
n = strlen(s);
if (n <= 2) {
puts("0");
continue;
}
LL ans = 0;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
const int N = 2e5 + 10;
int n;
char s[N];
int main() {
while (~scanf("%s", s)) {
n = strlen(s);
if (n <= 2) {
puts("0");
continue;
}
LL ans = 0;
... | [
"literal.number.change",
"assignment.value.change"
] | 833,702 | 833,703 | u454658584 | cpp |
p03018 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; ... | [
"expression.unary.arithmetic.add"
] | 833,704 | 833,705 | u228214259 | cpp |
p03018 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 7;
string s;
int main() {
cin >> s;
int len = s.length();
int cnt = 0;
ll ans = 0;
... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 7;
string s;
int main() {
cin >> s;
int len = s.length();
int cnt = 0;
ll ans = 0;
... | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 833,708 | 833,709 | u291016794 | cpp |
p03018 | #include <iostream>
#include <string>
using namespace std;
int main(void) {
string str;
cin >> str;
long long count = 0;
long long sum = 0;
long long length = str.length();
for (long long i = 0; i < length - 1; i++) {
if (str[i] == 'A') {
count++;
} else if (str[i] == 'B') {
if (count ==... | #include <iostream>
#include <string>
using namespace std;
int main(void) {
string str;
cin >> str;
long long count = 0;
long long sum = 0;
long long length = str.length();
for (long long i = 0; i < length - 1; i++) {
if (str[i] == 'A') {
count++;
} else if (str[i] == 'B') {
if (count ==... | [] | 833,725 | 833,726 | u276796245 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll h[200010], n, tt;
char s[200010];
bool bo[200010];
inline int rd() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = x * 10 + ch - '0';
return x;
}
... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll h[200010], n, tt;
char s[200010];
bool bo[200010];
inline int rd() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = x * 10 + ch - '0';
return x;
}
... | [
"control_flow.loop.for.condition.change"
] | 833,731 | 833,732 | u138339515 | cpp |
p03018 | #include <bits/stdc++.h>
using namespace std;
char s[200005];
int main() {
int num1 = 0;
int num2 = 0;
scanf("%s", s + 1);
int n = strlen(s + 1);
long long ans = 0;
for (int i = 1; i < n; i++) {
if (num1 != 0 && s[i] == 'B' && s[i + 1] == 'C' && i < n) {
i++;
ans += num1;
num1 = 1;
... | #include <bits/stdc++.h>
using namespace std;
char s[200005];
int main() {
int num1 = 0;
int num2 = 0;
scanf("%s", s + 1);
int n = strlen(s + 1);
long long ans = 0;
for (int i = 1; i < n; i++) {
if (num1 != 0 && s[i] == 'B' && s[i + 1] == 'C' && i < n) {
i++;
ans += num1;
} else if (s[i]... | [] | 833,750 | 833,751 | u818518063 | cpp |
p03018 | #include <iostream>
using namespace std;
int main() {
int a, ans = 0;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A')
s[i] = '1';
if (i < s.size() - 1 && s[i] == 'B' && s[i + 1] == 'C')
s.replace(s.begin() + i, s.begin() + i + 2, "2");
}
for (int i = 0; i < s.si... | #include <iostream>
using namespace std;
int main() {
long a = 0, ans = 0;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A')
s[i] = '1';
if (i < s.size() - 1 && s[i] == 'B' && s[i + 1] == 'C')
s.replace(s.begin() + i, s.begin() + i + 2, "2");
}
for (int i = 0; i <... | [
"variable_declaration.type.primitive.change",
"variable_declaration.value.change"
] | 833,754 | 833,753 | u612175324 | cpp |
p03018 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
using namespace std;
#defi... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
using namespace std;
#defi... | [
"control_flow.loop.for.condition.change"
] | 833,765 | 833,766 | u415518175 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.