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 |
|---|---|---|---|---|---|---|---|
p02953 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<ll> H(N);
REP... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<ll> H(N);
REP... | [
"control_flow.branch.if.condition.change"
] | 756,225 | 756,226 | u135626132 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "Yes";
return 0;
}
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = n - 1; i > 0; i--) {
if (v[i] < v[i - 1])
v[i]--;
}
for (int i = 0; i < n - 1; i++) ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "Yes";
return 0;
}
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = n - 1; i > 0; i--) {
if (v[i] < v[i - 1])
v[i - 1]--;
}
for (int i = 0; i < n - 1; i... | [
"expression.operation.binary.add"
] | 756,241 | 756,242 | u515923980 | cpp |
p02953 | //#define _GLIBCXX_DEBUG
#include <algorithm>
#include <bitset>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
signed main() {
ios_ba... | //#define _GLIBCXX_DEBUG
#include <algorithm>
#include <bitset>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
signed main() {
ios_ba... | [
"call.arguments.change"
] | 756,245 | 756,246 | u879223592 | cpp |
p02953 | //#define _GLIBCXX_DEBUG
#include <algorithm>
#include <bitset>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
signed main() {
ios_ba... | //#define _GLIBCXX_DEBUG
#include <algorithm>
#include <bitset>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
signed main() {
ios_ba... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 756,247 | 756,246 | u879223592 | cpp |
p02953 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<ll> H(n);
rep(i, n) { cin >> H[i]; }
for (int i = n - 2; i > 0; i--) {
if (H[i - 1]... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<ll> H(n);
rep(i, n) { cin >> H[i]; }
for (int i = n - 1; i >= 1; i--) {
if (H[i - 1... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change"
] | 756,253 | 756,254 | u745267317 | cpp |
p02953 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main(void) {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h.at(i);
ll low = h.at(0);
for (int i = 1; i < n; i++) {
low = max(low, h.at(i) - 1);
i... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main(void) {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h.at(i);
ll low = h.at(0);
for (int i = 1; i < n; i++) {
low = max(low, h.at(i) - 1);
i... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 756,257 | 756,258 | u062198110 | cpp |
p02953 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main(void) {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h.at(i);
ll low = h.at(0);
for (int i = 1; i < n; i++) {
low = max(low, h.at(i) + 1);
i... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main(void) {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h.at(i);
ll low = h.at(0);
for (int i = 1; i < n; i++) {
low = max(low, h.at(i) - 1);
i... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 756,259 | 756,258 | u062198110 | cpp |
p02953 | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <uno... | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <uno... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 756,271 | 756,272 | u840713046 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
///////////////////////
bool ans = true;
int M;
rep(i, n) {
M = max(h[i], M);
if (M - h[i] >= 2) {
// cout<<i<<endl;
ans... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
///////////////////////
bool ans = true;
int M = 0;
rep(i, n) {
M = max(h[i], M);
if (M - h[i] >= 2) {
// cout<<i<<endl;
... | [
"variable_declaration.value.change"
] | 756,273 | 756,274 | u531461815 | cpp |
p02953 | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
void solve(void) {
ll N;
cin >> N;
vector<ll> H(N);
for (ll ni = 0; ni < N; ++ni)
cin >> H[ni];
for (ll ni = N - 2; ni - 1 >= 0; --ni) {
if (H[ni - 1] > H[ni])
H[ni]--;
if (H[ni - 1] > H[ni]) {
cout << ... | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
void solve(void) {
ll N;
cin >> N;
vector<ll> H(N);
for (ll ni = 0; ni < N; ++ni)
cin >> H[ni];
for (ll ni = N - 1; ni - 1 >= 0; --ni) {
if (H[ni - 1] > H[ni])
H[ni - 1]--;
if (H[ni - 1] > H[ni]) {
cout... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 756,277 | 756,278 | u108377418 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | [] | 756,283 | 756,284 | u489823438 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 756,285 | 756,284 | u489823438 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | [
"expression.operation.binary.add"
] | 756,286 | 756,284 | u489823438 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,287 | 756,284 | u489823438 | cpp |
p02953 | // abc136_c.cc
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> h(n);
for (auto &x : h)
cin >> x;
for (int i = n - 1; i >= 0; i--) {
if (h[i] > h[i + 1])
h[i]--;
}
bool ok = true;
... | // abc136_c.cc
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> h(n);
for (auto &x : h)
cin >> x;
for (int i = n - 2; i >= 0; i--) {
if (h[i] > h[i + 1])
h[i]--;
}
bool ok = true;
... | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 756,288 | 756,289 | u349225213 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
int pre = -999;
for (int i = 0; i < n; ++i) {
if (pre <= h[i] - 1) {
pre = h[i] - 1;
} else if (pre <= h[i]) {
pre = h[i];
} else
puts("N... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
int pre = -999;
for (int i = 0; i < n; ++i) {
if (pre <= h[i] - 1) {
pre = h[i] - 1;
} else if (pre <= h[i]) {
pre = h[i];
} else {
puts(... | [] | 756,298 | 756,299 | u348398921 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> pi;
typedef pair<int, int> vi;
#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i = a; i < b; i++)
bool sort_by(vi c, vi d) { return c.S < d.S; }
int main() {
int N;
c... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> pi;
typedef pair<int, int> vi;
#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i = a; i < b; i++)
bool sort_by(vi c, vi d) { return c.S < d.S; }
int main() {
int N;
c... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,300 | 756,301 | u712837698 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> pi;
typedef pair<int, int> vi;
#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i = a; i < b; i++)
bool sort_by(vi c, vi d) { return c.S < d.S; }
int main() {
int N;
c... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> pi;
typedef pair<int, int> vi;
#define F first
#define S second
#define PB push_back
#define MK make_pair
#define REP(i, a, b) for (int i = a; i < b; i++)
bool sort_by(vi c, vi d) { return c.S < d.S; }
int main() {
int N;
c... | [
"control_flow.branch.if.add"
] | 756,302 | 756,301 | u712837698 | cpp |
p02953 | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define REPV(iter, v) \
for (auto(iter) = (v).begin(); (iter) != (v).end(); ++(iter))
#define ALL(v) (v).begin(), (v).end()
#define MOD 1000000007
using namespace std;
typedef lon... | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define REPV(iter, v) \
for (auto(iter) = (v).begin(); (iter) != (v).end(); ++(iter))
#define ALL(v) (v).begin(), (v).end()
#define MOD 1000000007
using namespace std;
typedef lon... | [
"literal.string.change"
] | 756,318 | 756,319 | u188706971 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
vector<ll> h(n);
rep(i, n) { cin >> h[i]; }
bool ans = 1;
for (ll i = n - 1; i > 0; i++) {
if (h[i] == h[i - 1] - 1)
h[i - 1]--;
else if (h[i] < h[i ... | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
vector<ll> h(n);
rep(i, n) { cin >> h[i]; }
bool ans = 1;
for (ll i = n - 1; i > 0; i--) {
if (h[i] == h[i - 1] - 1)
h[i - 1]--;
else if (h[i] < h[i ... | [] | 756,324 | 756,325 | u816145694 | cpp |
p02953 | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define ll long long
using namespace std;
long long MOD = 1000000007;
int main() {
int N;
cin >> N;
int tmp = 0;... | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define ll long long
using namespace std;
long long MOD = 1000000007;
int main() {
int N;
cin >> N;
int tmp = 0;... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,336 | 756,337 | u658993896 | cpp |
p02953 | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define ll long long
using namespace std;
long long MOD = 1000000007;
int main() {
int N;
cin >> N;
int tmp = MO... | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define ll long long
using namespace std;
long long MOD = 1000000007;
int main() {
int N;
cin >> N;
int tmp = 0;... | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,338 | 756,337 | u658993896 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100005];
string ans;
cin >> n;
bool flag = true;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i > 0; i--) {
if (a[i - 1] >= a[i] + 2) {
flag = false;
break;
} else if (a[i - 1] = a[i] + 1) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100005];
string ans;
cin >> n;
bool flag = true;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i > 0; i--) {
if (a[i - 1] >= a[i] + 2) {
flag = false;
break;
} else if (a[i - 1] == a[i] + 1) {
... | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 756,351 | 756,352 | u732421371 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#d... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#d... | [
"expression.operation.binary.remove"
] | 756,357 | 756,358 | u465760322 | cpp |
p02953 |
#include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
// << fixed << setprecision(0) <<
// sort(ALL(),greater<int>())... |
#include <bits/stdc++.h>
#include <math.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1001001001;
const int mINF = -1001001001;
// << fixed << setprecision(0) <<
// sort(ALL(),greater<int>())... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 756,363 | 756,364 | u281876921 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
if (i > 0) {
if (i == 1 && data.at(i) < data.at(i - 1)) {
data.at(i - 1)--;
}
if (data.at(i) >= data.at(i - 1)) {
if ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
if (i > 0) {
if (i == 1 && data.at(i) < data.at(i - 1)) {
data.at(i - 1)--;
}
if (data.at(i) >= data.at(i - 1)) {
if ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,367 | 756,368 | u634967948 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define REPS(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define RREP(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define RREPS(i, n) for (int i = ((int)(n)); i > 0; i--)
#define IREP(i, m, n) for (int i = ... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define REPS(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define RREP(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define RREPS(i, n) for (int i = ((int)(n)); i > 0; i--)
#define IREP(i, m, n) for (int i = ... | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.variable.change"
] | 756,369 | 756,370 | u530107518 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define REPS(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define RREP(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define RREPS(i, n) for (int i = ((int)(n)); i > 0; i--)
#define IREP(i, m, n) for (int i = ... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define REPS(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define RREP(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define RREPS(i, n) for (int i = ((int)(n)); i > 0; i--)
#define IREP(i, m, n) for (int i = ... | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.variable.change"
] | 756,371 | 756,370 | u530107518 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++)
cin >> H.at(i);
int maxv = -1;
for (int i = 0; i < N - 1; i++) {
if (H.at(i) < H.at(i + 1))
H.at(i + 1)--;
if (H.at(i) - H.at(i + 1) >= 2)
cout << "No" << endl... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++)
cin >> H.at(i);
int maxv = -1;
for (int i = 0; i < N - 1; i++) {
if (H.at(i) < H.at(i + 1))
H.at(i + 1)--;
if (H.at(i) - H.at(i + 1) >= 1) {
cout << "No" << en... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 756,382 | 756,383 | u533566373 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
}
bool ret = false;
int max = 0;
for (int i = 0; i < n; i++) {
if (max - 1 > data.at(i + 1)) {
ret = true;
}
if (max < data.at(i)) {... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
}
bool ret = false;
int max = 0;
for (int i = 0; i < n; i++) {
if (max - 1 > data.at(i)) {
ret = true;
}
if (max < data.at(i)) {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 756,386 | 756,387 | u164352406 | cpp |
p02953 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, H1;
cin >> N;
vector<int> H(N);
cin >> H1;
H[0] = H1 - 1;
bool flag = true;
for (int i = 1; i < N; i++) {
int Hi;
cin >> Hi;
if (Hi > H[i - 1]) {
H[i] = Hi - 1;
} else if (Hi == H[i - 1]) {
... | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, H1;
cin >> N;
vector<int> H(N);
cin >> H1;
H[0] = H1 - 1;
bool flag = true;
for (int i = 1; i < N; i++) {
int Hi;
cin >> Hi;
if (Hi > H[i - 1]) {
H[i] = Hi - 1;
} else if (Hi == H[i - 1]) {
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,390 | 756,391 | u346629192 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool ans = true;
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) {
a[i + 1]--;
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool ans = true;
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) {
a[i + 1]--;
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,394 | 756,395 | u214137532 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool ans = true;
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) {
a[i + 1]--;
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool ans = true;
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) {
a[i + 1]--;
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,396 | 756,395 | u214137532 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<ll> H(N);
for (int i = 0; i < N; i++)
cin >> H[i];
string ans = "Yes";
for (int i = N - 1; i >= 0; i--) {
if (H[i - 1] - H[i] >= 2)
ans = "No";
if (H[i - 1] - H[i] == 1)
H[i - 1]-... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<ll> H(N);
for (int i = 0; i < N; i++)
cin >> H[i];
string ans = "Yes";
for (int i = N - 1; i >= 1; i--) {
if (H[i - 1] - H[i] >= 2)
ans = "No";
if (H[i - 1] - H[i] == 1)
H[i - 1]-... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 756,397 | 756,398 | u398610336 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
using namespace std;
signed main(void) {
int n;
cin >> n;
int h[n];
int maxi;
cin >> h[0];
rep(i, 1, n - 1) {
cin >> h[i];
if (h[i - 1] <= h[i] - 1)
h[i]--;
}
rep(i, 1, n) {
if (!(h[i - 1] <= h[i])) {
... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
using namespace std;
signed main(void) {
int n;
cin >> n;
int h[n];
cin >> h[0];
rep(i, 1, n) {
cin >> h[i];
if (h[i - 1] <= h[i] - 1)
h[i]--;
}
rep(i, 1, n) {
if (!(h[i - 1] <= h[i])) {
cout << "No" <<... | [
"variable_declaration.remove",
"expression.operation.binary.remove"
] | 756,399 | 756,400 | u890331732 | cpp |
p02953 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,401 | 756,402 | u719699113 | cpp |
p02953 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,403 | 756,402 | u719699113 | cpp |
p02953 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,401 | 756,404 | u719699113 | cpp |
p02953 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordere... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,403 | 756,404 | u719699113 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define yes(n) cout << ((n) ? "yes" : "no") << en... | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define yes(n) cout << ((n) ? "yes" : "no") << en... | [
"control_flow.branch.if.condition.change"
] | 756,407 | 756,408 | u964763428 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define yes(n) cout << ((n) ? "yes" : "no") << en... | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define yes(n) cout << ((n) ? "yes" : "no") << en... | [
"control_flow.branch.if.condition.change"
] | 756,409 | 756,408 | u964763428 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h[i];
int pre = -999;
rep(i, n) {
if (pre < h[i]) {
pre = h[i] - 1;
} else if (pre = h[i]) {
pre = h[i];
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h[i];
int pre = -999;
rep(i, n) {
if (pre < h[i]) {
pre = h[i] - 1;
} else if (pre == h[i]) {
pre = h[i];
... | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 756,415 | 756,416 | u147556624 | cpp |
p02953 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
int n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
int pre = -10;
for (int i = 0; i < n; i++) {
if (pre < h[i]) {
pre = h[i] - 1;
} else if (pre == h[i]) {
pre = h[i];
} else {
pu... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
int pre = -10;
for (int i = 0; i < n; i++) {
if (pre < h[i]) {
pre = h[i] - 1;
} else if (pre == h[i]) {
pre = h[i];
} els... | [] | 756,417 | 756,418 | u147556624 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "Yes";
return 0;
}
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
if (h[n - 1] < h[n - 2]) {
h[n - 1]--;
if (h[n - 1] < h[n - 2]) {
cout << "No";
return 0;
}
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "Yes";
return 0;
}
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
if (h[n - 1] < h[n - 2]) {
h[n - 2]--;
if (h[n - 1] < h[n - 2]) {
cout << "No";
return 0;
}
... | [
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 756,423 | 756,424 | u294547216 | cpp |
p02953 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
auto h = vector<int>(n);
for (auto &h_i : h)
cin >> h_i;
auto h_last = 2'000'000'000;
for (int i = n - 1; i >= 0; i++) {
if (h[i] <= h_last) {
h_last = h[i];
continue;
}
if (h[i] - 1 <= h_... | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
auto h = vector<int>(n);
for (auto &h_i : h)
cin >> h_i;
auto h_last = 2'000'000'000;
for (int i = n - 1; i >= 0; i--) {
if (h[i] <= h_last) {
h_last = h[i];
continue;
}
if (h[i] - 1 <= h_... | [] | 756,425 | 756,426 | u723394740 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i < (n + 1); ++i)
using namespace std;
using ll = long long;
const int INF = -100100100;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h[i];
int cnt = 0;
v... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i < (n + 1); ++i)
using namespace std;
using ll = long long;
const int INF = -100100100;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h[i];
int cnt = 0;
v... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,429 | 756,430 | u412659798 | cpp |
p02953 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <st... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <st... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,431 | 756,432 | u310790595 | cpp |
p02953 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#incl... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#incl... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,433 | 756,434 | u809967037 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 0
#define mn 1e9
#define v(dt) vector<dt>
#define pr(x, y) pair<x, y>
#define loop(x, s, n) for (int x = s; x < n; ++x)
#define in_arr(n) \
loop(i, 0, n) { cin >> a[i]; }
#defin... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 0
#define mn 1e9
#define v(dt) vector<dt>
#define pr(x, y) pair<x, y>
#define loop(x, s, n) for (int x = s; x < n; ++x)
#define in_arr(n) \
loop(i, 0, n) { cin >> a[i]; }
#defin... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,441 | 756,442 | u341811631 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
typedef pair<ll, ll> P;
#define bit(n) (1LL << (n))
//#define int long l... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
typedef pair<ll, ll> P;
#define bit(n) (1LL << (n))
//#define int long l... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,447 | 756,448 | u324825702 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
rep... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
rep... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,449 | 756,450 | u561143568 | cpp |
p02953 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namesp... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namesp... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,462 | 756,463 | u644778646 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define FOR(i, s, n) for (int i = s; i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(n) (... | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define FOR(i, s, n) for (int i = s; i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(n) (... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,466 | 756,467 | u330661451 | cpp |
p02953 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#incl... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#incl... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 756,493 | 756,494 | u293523151 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int H[N];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int maxH = 1;
for (int i = 0; i < N - 1; i++) {
maxH = max(maxH, H[i]);
if (maxH < H[i] + 1) {
cout << "No" << endl;
return 0;
}
}
cout << "Y... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int H[N];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int maxH = 1;
for (int i = 0; i < N; i++) {
maxH = max(maxH, H[i]);
if (maxH > H[i] + 1) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,503 | 756,504 | u469315559 | cpp |
p02953 | #include <bits/stdc++.h>
#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 LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 ... | #include <bits/stdc++.h>
#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 LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 ... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,505 | 756,506 | u057611820 | cpp |
p02953 | #include <bits/stdc++.h>
#define int long long
#define mod 1000000007
#define trace(x) cerr << #x << ": " << x << " " << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | ... | #include <bits/stdc++.h>
#define int long long
#define mod 1000000007
#define trace(x) cerr << #x << ": " << x << " " << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 756,517 | 756,518 | u125467827 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(void) {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h.at(i); }
int left = 0;
string flag = "Yes";
rep(i, n - 1) {
if (left < h.at(i)) {
left = h.at(i);
}
if (abs(left ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(void) {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h.at(i); }
int left = 0;
string flag = "Yes";
rep(i, n - 1) {
if (left < h.at(i)) {
left = h.at(i);
}
if (left - h.... | [
"control_flow.branch.if.condition.change"
] | 756,521 | 756,522 | u690475097 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define fi first
#define so second
#define ps push_back
#define ld long double
#define mod 1000000007
signed main() {
int n, i, ct = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++)
cin >> a[i];
for (i = n - 2; i >= 0; i--) {
if (... | #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define fi first
#define so second
#define ps push_back
#define ld long double
#define mod 1000000007
signed main() {
int n, i, ct = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++)
cin >> a[i];
for (i = n - 2; i >= 0; i--) {
if (... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,532 | 756,533 | u842462845 | cpp |
p02953 | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
stack<long> h;
for (int i = 0; i < n; i++) {
long n;
cin >> n;
h.push(n);
}
l... | #include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
stack<long> h;
for (int i = 0; i < n; i++) {
long n;
cin >> n;
h.push(n);
}
l... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 756,542 | 756,543 | u649220991 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,544 | 756,545 | u341447450 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
if (N == 1) {
cout << "Yes" << endl;
return 0;
}
vector<ll> H(N);
for (ll i = 0; i < N; i++) {
cin >> H.at(i);
}
H[0]--;
for (ll i = 1; i < N - 1; i++) {
if (H[i] > H[i - 1]) {
H... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
if (N == 1) {
cout << "Yes" << endl;
return 0;
}
vector<ll> H(N);
for (ll i = 0; i < N; i++) {
cin >> H.at(i);
}
H[0]--;
for (ll i = 1; i < N; i++) {
if (H[i] > H[i - 1]) {
H[i]-... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 756,546 | 756,547 | u868205915 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long llong;
int main(void) {
int N;
cin >> N;
int H[N];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
bool flag = true;
for (int i = N - 1; i > 0; i--) {
if (H[i - 1] <= H[i])
;
else if (H[i - 1] + 1 == H[i])
H[i - 1] -=... | #include <bits/stdc++.h>
using namespace std;
typedef long long llong;
int main(void) {
int N;
cin >> N;
int H[N];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
bool flag = true;
for (int i = N - 1; i > 0; i--) {
if (H[i - 1] <= H[i])
;
else if (H[i - 1] - 1 == H[i])
H[i - 1] -=... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,548 | 756,549 | u616090453 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long llong;
int main(void) {
int N;
cin >> N;
int H[N];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
bool flag = true;
for (int i = N - 1; i > 0; i--) {
if (H[i - 1] <= H[i])
;
else if (H[i - 1] + 1 == H[i])
H[i - 1] +=... | #include <bits/stdc++.h>
using namespace std;
typedef long long llong;
int main(void) {
int N;
cin >> N;
int H[N];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
bool flag = true;
for (int i = N - 1; i > 0; i--) {
if (H[i - 1] <= H[i])
;
else if (H[i - 1] - 1 == H[i])
H[i - 1] -=... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"expression.operator.change"
] | 756,550 | 756,549 | u616090453 | cpp |
p02953 | // Author: getharshkumar
#include <bits/stdc++.h>
using namespace std;
#define ll int64_t
const ll N = 1e6 + 6, M = 1e9 + 7;
ll a[N];
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
ll n;
cin >> n >> a[0];
a[0]--;
for (ll i = 1; i < n; i++) {
cin >> a[i];
if (a[i] > a[i - 1])
a[i]--... | // Author: getharshkumar
#include <bits/stdc++.h>
using namespace std;
#define ll int64_t
const ll N = 1e6 + 6, M = 1e9 + 7;
ll a[N];
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
ll n;
cin >> n >> a[0];
a[0]--;
for (ll i = 1; i < n; i++) {
cin >> a[i];
if (a[i] > a[i - 1])
a[i]--... | [
"control_flow.branch.if.condition.change"
] | 756,565 | 756,566 | u319625425 | cpp |
p02953 | #include "bits/stdc++.h"
#define MY_ABS(N) ((N > 0) ? N : (-1 * N))
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
... | #include "bits/stdc++.h"
#define MY_ABS(N) ((N > 0) ? N : (-1 * N))
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,589 | 756,590 | u585586208 | cpp |
p02953 | #include <iostream>
using namespace std;
int n, x, Max;
int main() {
cin >> n;
Max = 0;
bool flag = true;
for (int i = 0; i < n; i++) {
cin >> x;
if (Max - 1 > x) {
flag = false;
} else {
Max = max(Max, x);
}
}
if (flag == true)
cout << "YES" << endl;
else
cout << "NO"... | #include <iostream>
using namespace std;
int n, x, Max;
int main() {
cin >> n;
Max = 0;
bool flag = true;
for (int i = 0; i < n; i++) {
cin >> x;
if (Max - 1 > x) {
flag = false;
} else {
Max = max(Max, x);
}
}
if (flag == true)
cout << "Yes" << endl;
else
cout << "No"... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,607 | 756,608 | u587292349 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
for (int i = N - 2; i >= N; i--) {
if (H[i] - 1 > H[i + 1]) {
cout << "No" << endl;
return 0;
}
if (H[i] > H[i + 1]) {
H[i]--;
}
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
for (int i = N - 2; i >= 0; i--) {
if (H[i] - 1 > H[i + 1]) {
cout << "No" << endl;
return 0;
}
if (H[i] > H[i + 1]) {
H[i]--;
}
... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 756,619 | 756,620 | u584139221 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
int max = 0;
bool flag = true;
for (int i = 1; i < n; i++) {
if (max < h.at(i - 1)) {
max = h.at(i - 1);
}
if (1 < h.at(i) - max) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
int max = 0;
bool flag = true;
for (int i = 1; i < n; i++) {
if (max < h.at(i - 1)) {
max = h.at(i - 1);
}
if (1 < max - h.at(i)) {
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 756,632 | 756,633 | u999989620 | cpp |
p02953 | #include "bits/stdc++.h"
typedef long long ll;
using namespace std;
static const int MAX = 100000;
int main() {
int n, H[MAX];
cin >> n;
for (int i = 0; i < n; ++i)
cin >> H[i];
bool can = true;
H[0]--;
for (int i = 1; i < n; ++i) {
if (H[i - 1] + 1 == H[i])
H[i]--;
if (H[i - 1] > H[i])... | #include "bits/stdc++.h"
typedef long long ll;
using namespace std;
static const int MAX = 100000;
int main() {
int n, H[MAX];
cin >> n;
for (int i = 0; i < n; ++i)
cin >> H[i];
bool can = true;
H[0]--;
for (int i = 1; i < n; ++i) {
if (H[i - 1] + 1 <= H[i])
H[i]--;
if (H[i - 1] > H[i])... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,634 | 756,635 | u616461826 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
int num = 0;
if (N == 1) {
cout << "Yes" << endl;
} else {
for (int i = 0; i < N - 2; ++i) {
if (H[i] >= H[i + 1] + 2) {
cout << "No" ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
int num = 0;
if (N == 1) {
cout << "Yes" << endl;
} else {
for (int i = 0; i < N - 1; ++i) {
if (H[i] >= H[i + 1] + 2) {
cout << "No" ... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 756,638 | 756,637 | u091026689 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
typedef long long ll;
#define endl '\n'
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int MOD = 1000000007;
//////////////////////////////////////////
int n;
void Input() { cin >> n; }
void Solve()... | #include <bits/stdc++.h>
using namespace std;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
typedef long long ll;
#define endl '\n'
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int MOD = 1000000007;
//////////////////////////////////////////
int n;
void Input() { cin >> n; }
void Solve()... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,639 | 756,640 | u423831742 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define rep0(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define rrep0(i, n) for (ll(i) = (n)-1; (i) >= 0; --(i))
#define rep1(i, n) for (ll(i) = 1; (i) <= (n); ++(i))
#define rrep1(i, n) for (ll(i) = (n); (i) >= 1; --(i))
#define nfor(i, a, b) for (ll(i) = (a); (i) < (b); ++(i... | #include <bits/stdc++.h>
using namespace std;
#define rep0(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define rrep0(i, n) for (ll(i) = (n)-1; (i) >= 0; --(i))
#define rep1(i, n) for (ll(i) = 1; (i) <= (n); ++(i))
#define rrep1(i, n) for (ll(i) = (n); (i) >= 1; --(i))
#define nfor(i, a, b) for (ll(i) = (a); (i) < (b); ++(i... | [
"identifier.change"
] | 756,643 | 756,644 | u801513186 | cpp |
p02953 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
for (int i = 0; i < n; i++)
cin >> h[i];
int flag = 0;
for (int i = n - 1; i > 0; i--) {
if (h[i - 1] < h[i])
continue;
else if (h[i - 1] == h[i] + 1)
h[i - 1] = max(h[i - 1] - 1, 1);
else {
... | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
for (int i = 0; i < n; i++)
cin >> h[i];
int flag = 0;
for (int i = n - 1; i > 0; i--) {
if (h[i - 1] <= h[i])
continue;
else if (h[i - 1] == h[i] + 1)
h[i - 1] = max(h[i - 1] - 1, 1);
else {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,656 | 756,657 | u098923136 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int n, a[123456], c;
int main() {
cin >> n >> a[0];
int m = a[0];
for (int i = 1; i < n; i++) {
cin >> a[i];
a[i] -= m;
if (a[i] < 0)
a[i] += 1;
m += a[i];
}
for (int i = 0; i < (n - 1); i++) {
if (a[i] < 0) { //ここ
if (c == 0)
... | #include <bits/stdc++.h>
using namespace std;
int n, a[123456], c;
int main() {
cin >> n >> a[0];
int m = a[0];
for (int i = 1; i < n; i++) {
cin >> a[i];
a[i] -= m;
if (a[i] < 0)
a[i] += 1;
m += a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] < 0) { // why?
if (c == 0)
... | [
"control_flow.loop.for.condition.change"
] | 756,660 | 756,661 | u477516105 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100001];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ok = 0;
for (int i = n; i >= 1; i--) {
if (a[i - 1] > a[i]) {
if (a[i - 1] - a[i] > 1) {
ok = 1;
break;
} else
a[i - 1]--;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100001];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ok = 0;
for (int i = n; i >= 1; i--) {
if (a[i - 1] > a[i]) {
if (a[i - 1] - a[i] > 1) {
ok = 1;
break;
} else
a[i - 1]--;
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,675 | 756,676 | u638965820 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 100100100100100;
const ll mod = 1000000007;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a.at(i);
for (int i = 0; i < n - 1; i++) {
if (a.at(i) <= a.at(i + 1))
a.at(i)--;
}
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 100100100100100;
const ll mod = 1000000007;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a.at(i);
for (int i = 0; i < n - 1; i++) {
if (a.at(i) < a.at(i + 1))
a.at(i + 1)--;
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,686 | 756,687 | u822169805 | cpp |
p02953 | #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() {
int n;
cin >> n;
int h[100005];
rep(i, n) cin >> h[i];
bool flag = false;
for (int i = n - 1; i >= 1; i++) {
if (h[i - 1] - h[i] > 1) {
puts("... | #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() {
int n;
cin >> n;
int h[100005];
rep(i, n) cin >> h[i];
bool flag = false;
for (int i = n - 1; i >= 1; i--) {
if (h[i - 1] - h[i] > 1) {
puts("... | [] | 756,699 | 756,700 | u620735210 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int a;
cin >> a;
long long int b[100010], c;
for (int i = 0; i < a; i++)
cin >> b[i];
c = 0;
for (int i = 0; i < a - 1; i++) {
if (b[i] > b[i + 1] + 1 || b[i] < c) {
cout << "No" << endl;
return 0;
}
else ... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int a;
cin >> a;
long long int b[100010], c;
for (int i = 0; i < a; i++)
cin >> b[i];
c = 0;
for (int i = 0; i < a - 1; i++) {
if (b[i] > b[i + 1] + 1 || b[i + 1] < c) {
cout << "No" << endl;
return 0;
}
e... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 756,705 | 756,706 | u530329977 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 756,711 | 756,712 | u917282863 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 1)
cout << "Yes";
else {
for (int i = n; i > 0; i--) {
int x = a[i - 1] - a[i];
if (x <= 0)
continue;
else {
if (x > 1) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 1)
cout << "Yes";
else {
for (int i = n - 1; i > 0; i--) {
int x = a[i - 1] - a[i];
if (x <= 0)
continue;
else {
if (x > 1) ... | [
"control_flow.loop.for.initializer.change"
] | 756,715 | 756,716 | u166896158 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 1)
cout << "Yes";
else {
for (int i = n; i > 0; i++) {
int x = a[i - 1] - a[i];
if (x <= 0)
continue;
else {
if (x > 1) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 1)
cout << "Yes";
else {
for (int i = n - 1; i > 0; i--) {
int x = a[i - 1] - a[i];
if (x <= 0)
continue;
else {
if (x > 1) ... | [
"control_flow.loop.for.initializer.change"
] | 756,717 | 756,716 | u166896158 | cpp |
p02953 | #include <bits/stdc++.h>
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (i... | #include <bits/stdc++.h>
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (i... | [
"call.arguments.change",
"call.arguments.add"
] | 756,732 | 756,733 | u837233010 | cpp |
p02953 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define endl "\n"
const long long INF = (long long)1e18;
const long long MOD = 1'000'000'007;
string yn(bool f) { return f ? "Yes" : "No"; }
string YN(bool f) {... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define endl "\n"
const long long INF = (long long)1e18;
const long long MOD = 1'000'000'007;
string yn(bool f) { return f ? "Yes" : "No"; }
string YN(bool f) {... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 756,750 | 756,751 | u233393801 | cpp |
p02953 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
h[0]--;
int flag = 1;
rep(i, n - 1) {
if (h[i] < h[i + 1])
h[i + 1]--;
if (h[i... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
h[0]--;
int flag = 1;
rep(i, n - 1) {
if (h[i] < h[i + 1])
h[i + 1]--;
if (h[i... | [
"literal.string.change",
"io.output.change"
] | 756,752 | 756,753 | u405620865 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int in() {
int x;
scanf("%d", &x);
return x;
}
static const int MAX = 100000;
int main() {
int N = in(), h[MAX], x = 0;
rep(i, N) h[i] = in();
rep(i... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int in() {
int x;
scanf("%d", &x);
return x;
}
static const int MAX = 100000;
int main() {
int N = in(), h[MAX], x = 0;
rep(i, N) h[i] = in();
rep(i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,754 | 756,755 | u378125390 | cpp |
p02953 | #include <algorithm>
#include <assert.h>
#include <iostream>
#include <vector>
//#include <functional>
int main() {
int32_t N;
std::cin >> N;
int32_t cur = 0;
int32_t peak = 0;
for (int32_t i = 0; i < N; i++) {
std::cin >> cur;
if (peak - cur >= 2) {
std::cout << "No";
return 0;
}
... | #include <algorithm>
#include <assert.h>
#include <iostream>
#include <vector>
//#include <functional>
int main() {
int32_t N;
std::cin >> N;
int32_t cur = 0;
int32_t peak = 0;
for (int32_t i = 0; i < N; i++) {
std::cin >> cur;
if (peak - cur >= 2) {
std::cout << "No";
return 0;
}
... | [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 756,756 | 756,757 | u775900747 | cpp |
p02953 | #include <algorithm>
#include <functional>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
int main() {
int N;
int n[100040];
int time = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> n[i];
}
if (N == 1) {
cout << "Yes";
} else {
for (int i = N - 1; i > 0; ... | #include <algorithm>
#include <functional>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
int main() {
int N;
int n[100040];
int time = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> n[i];
}
if (N == 1) {
cout << "Yes";
} else {
for (int i = N - 1; i > 0; ... | [
"control_flow.break.add"
] | 756,760 | 756,761 | u473116917 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
for (int i = 0; i < n; i++) {
if (h.at(i) < h.at(i + 1)) {
h.at(i + 1) = h.at(i + 1) - 1;
}
}
for (int i = 0; i < n; i++) {
if (h.at(i)... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
for (int i = 0; i < n - 1; i++) {
if (h.at(i) < h.at(i + 1)) {
h.at(i + 1) = h.at(i + 1) - 1;
}
}
for (int i = 0; i < n - 1; i++) {
if ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 756,772 | 756,773 | u707853565 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N == 1) {
cout << "Yes" << endl;
return 0;
}
vector<long long> H(N);
for (int i = 0; i < N; i++)
cin >> H.at(i);
bool jdg = true;
for (int i = N - 1; i > 0; i++) {
if (H[i] < H[i - 1]) {
H[i - 1]--;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N == 1) {
cout << "Yes" << endl;
return 0;
}
vector<long long> H(N);
for (int i = 0; i < N; i++)
cin >> H.at(i);
bool jdg = true;
for (int i = N - 1; i > 0; i--) {
if (H[i] < H[i - 1]) {
H[i - 1]--;
... | [] | 756,786 | 756,787 | u615258936 | cpp |
p02953 | #include <algorithm>
#include <bits/stdc++.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#in... | #include <algorithm>
#include <bits/stdc++.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#in... | [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change"
] | 756,792 | 756,793 | u431929942 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string flag;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
for (int i = n - 1; i >= 1; i--) {
cout << i;
if (vec.at(i) <= vec.at(i - 1) - 2) {
flag = "No";
break;
}
if (vec.a... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string flag;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
for (int i = n - 1; i >= 1; i--) {
if (vec.at(i) <= vec.at(i - 1) - 2) {
flag = "No";
break;
}
if (vec.at(i) == vec.at(... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,804 | 756,805 | u694859623 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vct vector<ll>
#define umap map<ll, ll>
int main() {
ll n;
cin >> n;
ll ar[n];
for (ll i = 0; i < n; i++)
cin >> ar[i];
ll flg = 1;
ll mx = ar[n - 1];
for (ll i = n - 2; i >= 0; i--) {
ll cur = ar[i];
if (cur > mx) {
... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vct vector<ll>
#define umap map<ll, ll>
int main() {
ll n;
cin >> n;
ll ar[n];
for (ll i = 0; i < n; i++)
cin >> ar[i];
ll flg = 1;
ll mx = ar[n - 1];
for (ll i = n - 2; i >= 0; i--) {
ll cur = ar[i];
if (cur > mx) {
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 756,816 | 756,817 | u176464463 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cur, nxt;
cin >> cur;
cur--;
int ar[n - 1];
for (int i = 0; i < n - 1; i++) {
cin >> ar[i];
}
for (int i = 0; i < n - 1; i++) {
nxt = ar[i];
if (cur > nxt) {
nxt--;
}
if (cur < nxt) {
cout... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cur, nxt;
cin >> cur;
cur--;
int ar[n - 1];
for (int i = 0; i < n - 1; i++) {
cin >> ar[i];
}
for (int i = 0; i < n - 1; i++) {
nxt = ar[i];
if (nxt > cur) {
nxt--;
}
if (cur > nxt) {
cout... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.compare.change"
] | 756,818 | 756,819 | u176464463 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> H(n);
for (int i = 0; i < n; i++) {
cin >> H.at(i);
}
if (n == 1) {
cout << "Yes" << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (H.at(i - 1) + 1 == H.at(i)) {
H.at(i - 1)--;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> H(n);
for (int i = 0; i < n; i++) {
cin >> H.at(i);
}
if (n == 1) {
cout << "Yes" << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (H.at(i - 1) - 1 == H.at(i)) {
H.at(i - 1)--;
... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 756,823 | 756,824 | u596200441 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> H(n);
for (int i = 0; i < n; i++) {
cin >> H.at(i);
}
if (n == 1) {
cout << "Yes" << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (H.at(i - 1) + 1 == H.at(i)) {
H.at(i - 1)--;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> H(n);
for (int i = 0; i < n; i++) {
cin >> H.at(i);
}
if (n == 1) {
cout << "Yes" << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (H.at(i - 1) - 1 == H.at(i)) {
H.at(i - 1)--;
... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,825 | 756,824 | u596200441 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> H(n);
for (int i = 0; i < n; i++) {
cin >> H.at(i);
}
if (n == 1) {
cout << "Yes" << endl;
return 0;
}
for (int i = n; i > 0; i--) {
if (H.at(i - 1) + 1 == H.at(i)) {
H.at(i - 1)--;
} el... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int64_t> H(n);
for (int i = 0; i < n; i++) {
cin >> H.at(i);
}
if (n == 1) {
cout << "Yes" << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (H.at(i - 1) - 1 == H.at(i)) {
H.at(i - 1)--;
... | [
"control_flow.loop.for.initializer.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,826 | 756,824 | u596200441 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
for (int i = n - 1; i > 0; i--) {
if (h.at(i - 1) == h.at(i) - 1) {
h.at(i - 1) -= 1;
} else if (h.at(i - 1) > h.at(i)) {
cout << "No" << end... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
for (int i = n - 1; i > 0; i--) {
if (h.at(i - 1) == h.at(i) + 1) {
h.at(i - 1) -= 1;
} else if (h.at(i - 1) > h.at(i)) {
cout << "No" << end... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 756,827 | 756,828 | u770009793 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> H(N);
for (long long i = 0; i < N; i++) {
cin >> H[i];
}
string ans = "Yes";
for (long long i = 1; i < N; i++) {
if (H[i - 1] <= H[i]) {
H[i] -= 1;
}
}
for (long long i = 0; i < N -... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> H(N);
for (long long i = 0; i < N; i++) {
cin >> H[i];
}
string ans = "Yes";
for (long long i = 1; i < N; i++) {
if (H[i - 1] < H[i]) {
H[i] -= 1;
}
}
for (long long i = 0; i < N - ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 756,853 | 756,854 | u654055742 | cpp |
p02953 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e5)
#define PI (acos(-1))
#define print(x) cout << x << endl
ll gcd(ll a, ll b) { return b ? ... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1e5)
#define PI (acos(-1))
#define print(x) cout << x << endl
ll gcd(ll a, ll b) { return b ? ... | [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add"
] | 756,855 | 756,856 | u802905102 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.