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 |
|---|---|---|---|---|---|---|---|
p03072 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repf(i, a, b) for (int i = (a); i < (b); i++)
#define repi(i, a, b) for (int i = (a); i <= (b); i++)
#define repr(i, a, b) for (int i = (a); i >= (b); i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(all(x));
#define RSORT(x) sort(rall(x));
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vd = vector<double>;
using vb = vector<bool>;
using pii = pair<int, int>;
using vc = vector<char>;
using vvc = vector<vc>;
using vs = vector<string>;
using tiii = tuple<int, int, int>;
const ll inf = 1ll << 29;
const ll mod = 1000000007;
const double eps = 1e-9;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int N;
cin >> N;
vi H(N);
rep(i, N) cin >> H.at(i);
int ans = 0;
int max_H = 0;
rep(i, N) {
if (max_H <= H.at(i))
ans++;
max_H = H.at(i - 1);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repf(i, a, b) for (int i = (a); i < (b); i++)
#define repi(i, a, b) for (int i = (a); i <= (b); i++)
#define repr(i, a, b) for (int i = (a); i >= (b); i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(all(x));
#define RSORT(x) sort(rall(x));
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vd = vector<double>;
using vb = vector<bool>;
using pii = pair<int, int>;
using vc = vector<char>;
using vvc = vector<vc>;
using vs = vector<string>;
using tiii = tuple<int, int, int>;
const ll inf = 1ll << 29;
const ll mod = 1000000007;
const double eps = 1e-9;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int N;
cin >> N;
vi H(N);
rep(i, N) cin >> H.at(i);
int ans = 0;
int max_H = 0;
rep(i, N) {
if (max_H <= H.at(i)) {
ans++;
max_H = H.at(i);
}
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 882,415 | 882,414 | u850516963 | cpp |
p03072 | #include <bits/stdc++.h>
#define INF 1000000000
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int N, maxtmp = 0, cnt = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
if (maxtmp >= A[i])
cnt++;
if (maxtmp < A[i])
maxtmp = A[i];
}
cout << cnt << endl;
}
| #include <bits/stdc++.h>
#define INF 1000000000
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int N, maxtmp = 0, cnt = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
if (maxtmp <= A[i])
cnt++;
if (maxtmp < A[i])
maxtmp = A[i];
}
cout << cnt << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,416 | 882,417 | u207948013 | cpp |
p03072 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// cout << << endl;
typedef long long int ll;
typedef long double ld;
const ll INF = 1LL << 60;
#define MOD 1000000007
#define MAX_V 100010
#define MAX_N 100010
bool pairCompare(const pair<double, ll> &firstElof,
const pair<double, ll> &secondElof) {
return firstElof.second < secondElof.second;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll junnretu(ll n) {
ll ans = 1;
for (ll i = 1; i <= n; i++) {
ans *= i;
}
return ans;
}
int main() {
ll n, max = 0, ans = 0;
cin >> n;
for (ll i = 0; i < n; i++) {
ll x;
cin >> x;
if (x > max) {
ans++;
max = x;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// cout << << endl;
typedef long long int ll;
typedef long double ld;
const ll INF = 1LL << 60;
#define MOD 1000000007
#define MAX_V 100010
#define MAX_N 100010
bool pairCompare(const pair<double, ll> &firstElof,
const pair<double, ll> &secondElof) {
return firstElof.second < secondElof.second;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll junnretu(ll n) {
ll ans = 1;
for (ll i = 1; i <= n; i++) {
ans *= i;
}
return ans;
}
int main() {
ll n, max = 0, ans = 0;
cin >> n;
for (ll i = 0; i < n; i++) {
ll x;
cin >> x;
if (x >= max) {
ans++;
max = x;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,418 | 882,419 | u273928723 | cpp |
p03072 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
// const ll INF = 1LL<<60;
const long long INF = 1LL << 60; // 仮想的な無限大の値
int main() {
ll N;
cin >> N;
vector<ll> H(N);
rep(i, N) cin >> H[i];
vector<ll> S(N, 0);
rep(i, N) S[i + 1] = max(S[i], H[i]);
ll ans = 0;
rep(i, N) if (H[i] >= S[i + 1]) ans++;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
// const ll INF = 1LL<<60;
const long long INF = 1LL << 60; // 仮想的な無限大の値
int main() {
ll N;
cin >> N;
vector<ll> H(N);
rep(i, N) cin >> H[i];
vector<ll> S(N + 1, 0);
rep(i, N) S[i + 1] = max(S[i], H[i]);
ll ans = 0;
rep(i, N) if (H[i] >= S[i + 1]) ans++;
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 882,362 | 882,363 | u409417260 | cpp |
p03072 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
bool temp = true;
for (int j = 0; j < i; j++) {
if (h[j] < h[i]) {
temp = false;
break;
}
}
if (temp) {
ans++;
}
}
cout << ans;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
bool temp = true;
for (int j = 0; j < i; j++) {
if (h[j] > h[i]) {
temp = false;
break;
}
}
if (temp) {
ans++;
}
}
cout << ans;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,431 | 882,432 | u205280593 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int max = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
int h;
cin >> h;
if (h > max) {
max = h;
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int max = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
int h;
cin >> h;
if (h >= max) {
max = h;
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,445 | 882,446 | u538808095 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
int niceView = 1; //西端は常に見られる
int maxHeight = h.at(0);
for (int i = 1; i < n; i++) {
if (maxHeight <= h.at(i)) {
maxHeight = h.at(0);
niceView++;
}
}
cout << niceView << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
int niceView = 1; //西端は常に見られる
int maxHeight = h.at(0);
for (int i = 1; i < n; i++) {
if (maxHeight <= h.at(i)) {
maxHeight = h.at(i);
niceView++;
}
}
cout << niceView << endl;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 882,447 | 882,448 | u815628714 | cpp |
p03072 | #include <iostream>
#include <vector>
int main() {
using namespace std;
int n;
cin >> n;
vector<int> h(n);
for (int hi : h)
cin >> hi;
int h_max = 0;
int ans = 0;
for (const int &hi : h) {
if (h_max <= hi) {
h_max = hi;
++ans;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <vector>
int main() {
using namespace std;
int n;
cin >> n;
vector<int> h(n);
for (int &hi : h)
cin >> hi;
int h_max = 0;
int ans = 0;
for (const int &hi : h) {
if (h_max <= hi) {
h_max = hi;
++ans;
}
}
cout << ans << endl;
return 0;
} | [] | 882,449 | 882,450 | u356069145 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
int high = 0;
int count = 0;
for (int i = 0; i < N; i++) {
cin >> H.at(i);
int high = max(high, H.at(i));
if (H.at(i) >= high)
count++;
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
int high = 0;
int count = 0;
for (int i = 0; i < N; i++) {
cin >> H.at(i);
high = max(high, H.at(i));
if (H.at(i) >= high)
count++;
}
cout << count << endl;
}
| [] | 882,451 | 882,452 | u021657949 | cpp |
p03072 | #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 w = h[0], aw = 1;
for (int i = 1; i < n; i++) {
w = max(w, h[i]);
if (w = h[i]) {
aw++;
}
}
cout << aw << 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[i];
}
int w = h[0], aw = 1;
for (int i = 1; i < n; i++) {
w = max(w, h[i]);
if (w == h[i]) {
aw++;
}
}
cout << aw << endl;
}
| [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 882,453 | 882,454 | u834753207 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 1;
int max_h = h[0];
for (int i = 1; i < n; i++) {
if ((h[i] > h[i - 1]) && (max_h <= h[i]))
ans++;
max_h = max(max_h, h[i]);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 1;
int max_h = h[0];
for (int i = 1; i < n; i++) {
if ((h[i] >= h[i - 1]) && (max_h <= h[i]))
ans++;
max_h = max(max_h, h[i]);
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,458 | 882,459 | u748757847 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int h;
int m = -1;
int res = 0;
for (int i = 0; i < n; i++) {
cin >> h;
if (m <= h) {
res++;
}
m = max(m, h);
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int h;
cin >> n;
int m = -1;
int res = 0;
for (int i = 0; i < n; i++) {
cin >> h;
if (m <= h) {
res++;
}
m = max(m, h);
}
cout << res << endl;
}
| [] | 882,464 | 882,465 | u231354686 | cpp |
p03072 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9 + 7;
constexpr ll MOD = 1e9 + 7;
typedef tuple<int, int, int> tpl;
typedef tuple<ll, ll, ll> tpL;
int dx4[4] = {1, 0, 0, -1};
int dy4[4] = {0, 1, -1, 0};
int dx2[2] = {1, 0};
int dy2[2] = {0, 1};
/***********************************************************************************/
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
//ユークリッド互除法
template <typename T> T gcd(T x, T y) {
if (y == 0) {
return x;
} else {
return gcd(y, x % y);
}
}
/*最小公倍数*/
template <typename T> T lcm(T x, T y) {
T tmp = gcd(x, y);
return x / tmp * y;
}
/*素因数分解*/
template <typename T> map<T, T> prime_factorization(T m) {
map<T, T> tmp;
for (T i = 2; i * i <= m; i++) {
while (m % i == 0) {
tmp[i]++;
m /= i;
}
}
if (m != 1) {
tmp[m] = 1;
}
return tmp;
}
//約数の列挙
template <typename T> vector<T> divisor(T n) {
vector<T> res;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) {
res.push_back(n / i);
}
}
}
return res;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/******************************************************************************************/
template <typename T>
bool next_combination(const T first, const T last, int k) {
const T subset = first + k;
// empty container | k = 0 | k == n
if (first == last || first == subset || last == subset) {
return false;
}
T src = subset;
while (first != src) {
src--;
if (*src < *(last - 1)) {
T dest = subset;
while (*src >= *dest) {
dest++;
}
iter_swap(src, dest);
rotate(src + 1, dest + 1, last);
rotate(subset, subset + (last - dest) - 1, last);
return true;
}
}
// restore
rotate(first, subset, last);
return false;
}
//エラトステネスの篩
/*nまでの素数を列挙して配列に保持*/
vector<ll> Eratosthenes(ll n) {
vector<ll> arr(n + 1);
for (ll i = 0; i <= n; i++) {
arr[i] = 1;
}
arr[0] = arr[1] = 0;
for (ll i = 2; i < sqrt(n); i++) {
if (arr[i]) {
for (ll j = 0; i * (j + 2) < n; j++) {
arr[i * (j + 2)] = 0;
}
}
}
return arr;
}
struct Combination {
vector<ll> fact, rfact;
Combination(ll sz) : fact(sz + 1), rfact(sz + 1) {
fact[0] = 1;
for (ll i = 1; i < fact.size(); i++) {
fact[i] = fact[i - 1] % MOD * i % MOD;
}
//逆元
rfact[sz] = inv(fact[sz]);
for (ll i = sz - 1; i >= 0; i--) {
rfact[i] = rfact[i + 1] % MOD * (i + 1) % MOD;
}
}
ll inv(ll x) { return pow(x, MOD - 2); }
ll pow(ll x, ll n) {
ll ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= MOD;
(x *= x) %= MOD;
n >>= 1;
}
return (ret);
}
ll P(ll n, ll r) {
if (r < 0 || n < r)
return (0);
return (fact[n] * rfact[n - r] % MOD);
}
ll C(ll p, ll q) {
if (q < 0 || p < q)
return (0LL);
return (fact[p] % MOD * rfact[q] % MOD * rfact[p - q] % MOD);
}
ll H(ll n, ll r) {
if (n < 0 || r < 0)
return (0);
return (r == 0 ? 1 : C(n + r - 1, r));
}
};
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T> using Matrix = vector<vector<T>>;
template <typename T> void warshall_floyd(Matrix<T> &g, T INF) {
for (int k = 0; k < g.size(); k++) {
for (int i = 0; i < g.size(); i++) {
for (int j = 0; j < g.size(); j++) {
if (g[i][k] == INF || g[k][j] == INF)
continue;
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
}
//繋げる方向を一方向にする
typedef struct union_find {
vector<ll> pa; //親
vector<ll> ra; //木の深さ
vector<ll> siz;
// n要素で初期化
void init(ll n) {
pa.resize(n);
ra.resize(n);
siz.resize(n);
for (ll i = 0; i < n; i++) {
pa[i] = i; /*各ノードに番号を振る,この時par[x]=xとなる時は木の根となる*/
ra[i] = 0LL; /*各ノード自体の高さは0*/
siz[i] = 1LL;
}
}
//木の根を求める
ll find(ll x) {
if (pa[x] == x) {
return x; /*根ならそのノードの番号を返す*/
} else {
return pa[x] = find(pa[x]); /*根でないならさらにノードの根を探す*/
}
}
// xとyの属する集合を併合する
void unite(ll x, ll y) {
x = find(x); // xの根の番号を探す
y = find(y); // yの根の番号を探す
if (x == y) { //一致すればつながっている
return;
}
pa[y] = x;
siz[x] += siz[y];
}
// xとyが同じ集合に属するか判定
bool same(ll x, ll y) {
return find(x) == find(y); //同じ集合なら1、違うなら0が返る
}
} UF;
template <typename T> vector<T> dijkstra(WeightedGraph<T> &g, int s) {
const auto INF = numeric_limits<T>::max();
vector<T> dist(g.size(), INF);
using Pi = pair<T, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
dist[s] = 0;
que.emplace(dist[s], s);
while (!que.empty()) {
T cost;
int idx;
tie(cost, idx) = que.top();
que.pop();
if (dist[idx] < cost)
continue;
for (auto &e : g[idx]) {
auto next_cost = cost + e.cost;
if (dist[e.to] <= next_cost)
continue;
dist[e.to] = next_cost;
que.emplace(dist[e.to], e.to);
}
}
return dist;
}
// RMQ
//セグ木
template <typename T> struct SegmentTree {
private:
T N;
vector<T> node; // 0-index
public:
SegmentTree(T siz) {
N = 1;
while (N < siz) {
N *= 2;
}
node.resize(2 * N - 1, 1e15);
}
void build(vector<T> &dat) {
for (int i = 0; i < dat.size(); i++) {
node[i + N - 1] = dat[i];
}
for (int i = N - 2; i >= 0; i--) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(T k, T x) {
k += N - 1;
node[k] = x;
while (k > 0) {
k = (k - 1) / 2; //親
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)
T getMin(T a, T b) { return getMin(a, b, 0, 0, N); }
T getMin(T a, T b, T k, T l, T r) {
if (r <= a || b <= l) {
return INF;
}
if (a <= l && r <= b) {
return node[k];
}
T vl = getMin(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = getMin(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
T find(T a, T b, T x) { return (find(a, b, x, 0, 0, N)); }
//頂点k(区間[l,r)の)の部分木について区間[a,b)内でx以下の値を持つ要素の最右位置を返す
T find(T a, T b, T x, T k, T l, T r) {
if (node[k] > x || r <= a || b <= l) {
//自分の頂点がxより大きいか範囲外の場合、この区間にないため-1を返す
return -1;
}
if (k >= N - 1) {
//自分の頂点が葉なら見つかったことになるので、その位置を返す
return (k - (N - 1));
}
//右の区間の部分木を見る
T rv = find(a, b, x, 2 * k + 2, (l + r) >> 1, r);
if (rv != -1) {
//戻り値が-1以外なら見つかったのでその位置を返す
return rv;
}
//右の部分偽になかったので左の部分木を調べる
return (find(a, b, x, 2 * k + 1, l, (l + r) >> 1));
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
cin >> n;
int before = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (before <= c) {
cnt++;
}
before = c;
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9 + 7;
constexpr ll MOD = 1e9 + 7;
typedef tuple<int, int, int> tpl;
typedef tuple<ll, ll, ll> tpL;
int dx4[4] = {1, 0, 0, -1};
int dy4[4] = {0, 1, -1, 0};
int dx2[2] = {1, 0};
int dy2[2] = {0, 1};
/***********************************************************************************/
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
//ユークリッド互除法
template <typename T> T gcd(T x, T y) {
if (y == 0) {
return x;
} else {
return gcd(y, x % y);
}
}
/*最小公倍数*/
template <typename T> T lcm(T x, T y) {
T tmp = gcd(x, y);
return x / tmp * y;
}
/*素因数分解*/
template <typename T> map<T, T> prime_factorization(T m) {
map<T, T> tmp;
for (T i = 2; i * i <= m; i++) {
while (m % i == 0) {
tmp[i]++;
m /= i;
}
}
if (m != 1) {
tmp[m] = 1;
}
return tmp;
}
//約数の列挙
template <typename T> vector<T> divisor(T n) {
vector<T> res;
for (T i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) {
res.push_back(n / i);
}
}
}
return res;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/******************************************************************************************/
template <typename T>
bool next_combination(const T first, const T last, int k) {
const T subset = first + k;
// empty container | k = 0 | k == n
if (first == last || first == subset || last == subset) {
return false;
}
T src = subset;
while (first != src) {
src--;
if (*src < *(last - 1)) {
T dest = subset;
while (*src >= *dest) {
dest++;
}
iter_swap(src, dest);
rotate(src + 1, dest + 1, last);
rotate(subset, subset + (last - dest) - 1, last);
return true;
}
}
// restore
rotate(first, subset, last);
return false;
}
//エラトステネスの篩
/*nまでの素数を列挙して配列に保持*/
vector<ll> Eratosthenes(ll n) {
vector<ll> arr(n + 1);
for (ll i = 0; i <= n; i++) {
arr[i] = 1;
}
arr[0] = arr[1] = 0;
for (ll i = 2; i < sqrt(n); i++) {
if (arr[i]) {
for (ll j = 0; i * (j + 2) < n; j++) {
arr[i * (j + 2)] = 0;
}
}
}
return arr;
}
struct Combination {
vector<ll> fact, rfact;
Combination(ll sz) : fact(sz + 1), rfact(sz + 1) {
fact[0] = 1;
for (ll i = 1; i < fact.size(); i++) {
fact[i] = fact[i - 1] % MOD * i % MOD;
}
//逆元
rfact[sz] = inv(fact[sz]);
for (ll i = sz - 1; i >= 0; i--) {
rfact[i] = rfact[i + 1] % MOD * (i + 1) % MOD;
}
}
ll inv(ll x) { return pow(x, MOD - 2); }
ll pow(ll x, ll n) {
ll ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= MOD;
(x *= x) %= MOD;
n >>= 1;
}
return (ret);
}
ll P(ll n, ll r) {
if (r < 0 || n < r)
return (0);
return (fact[n] * rfact[n - r] % MOD);
}
ll C(ll p, ll q) {
if (q < 0 || p < q)
return (0LL);
return (fact[p] % MOD * rfact[q] % MOD * rfact[p - q] % MOD);
}
ll H(ll n, ll r) {
if (n < 0 || r < 0)
return (0);
return (r == 0 ? 1 : C(n + r - 1, r));
}
};
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T> using Matrix = vector<vector<T>>;
template <typename T> void warshall_floyd(Matrix<T> &g, T INF) {
for (int k = 0; k < g.size(); k++) {
for (int i = 0; i < g.size(); i++) {
for (int j = 0; j < g.size(); j++) {
if (g[i][k] == INF || g[k][j] == INF)
continue;
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
}
//繋げる方向を一方向にする
typedef struct union_find {
vector<ll> pa; //親
vector<ll> ra; //木の深さ
vector<ll> siz;
// n要素で初期化
void init(ll n) {
pa.resize(n);
ra.resize(n);
siz.resize(n);
for (ll i = 0; i < n; i++) {
pa[i] = i; /*各ノードに番号を振る,この時par[x]=xとなる時は木の根となる*/
ra[i] = 0LL; /*各ノード自体の高さは0*/
siz[i] = 1LL;
}
}
//木の根を求める
ll find(ll x) {
if (pa[x] == x) {
return x; /*根ならそのノードの番号を返す*/
} else {
return pa[x] = find(pa[x]); /*根でないならさらにノードの根を探す*/
}
}
// xとyの属する集合を併合する
void unite(ll x, ll y) {
x = find(x); // xの根の番号を探す
y = find(y); // yの根の番号を探す
if (x == y) { //一致すればつながっている
return;
}
pa[y] = x;
siz[x] += siz[y];
}
// xとyが同じ集合に属するか判定
bool same(ll x, ll y) {
return find(x) == find(y); //同じ集合なら1、違うなら0が返る
}
} UF;
template <typename T> vector<T> dijkstra(WeightedGraph<T> &g, int s) {
const auto INF = numeric_limits<T>::max();
vector<T> dist(g.size(), INF);
using Pi = pair<T, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
dist[s] = 0;
que.emplace(dist[s], s);
while (!que.empty()) {
T cost;
int idx;
tie(cost, idx) = que.top();
que.pop();
if (dist[idx] < cost)
continue;
for (auto &e : g[idx]) {
auto next_cost = cost + e.cost;
if (dist[e.to] <= next_cost)
continue;
dist[e.to] = next_cost;
que.emplace(dist[e.to], e.to);
}
}
return dist;
}
// RMQ
//セグ木
template <typename T> struct SegmentTree {
private:
T N;
vector<T> node; // 0-index
public:
SegmentTree(T siz) {
N = 1;
while (N < siz) {
N *= 2;
}
node.resize(2 * N - 1, 1e15);
}
void build(vector<T> &dat) {
for (int i = 0; i < dat.size(); i++) {
node[i + N - 1] = dat[i];
}
for (int i = N - 2; i >= 0; i--) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(T k, T x) {
k += N - 1;
node[k] = x;
while (k > 0) {
k = (k - 1) / 2; //親
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)
T getMin(T a, T b) { return getMin(a, b, 0, 0, N); }
T getMin(T a, T b, T k, T l, T r) {
if (r <= a || b <= l) {
return INF;
}
if (a <= l && r <= b) {
return node[k];
}
T vl = getMin(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = getMin(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
T find(T a, T b, T x) { return (find(a, b, x, 0, 0, N)); }
//頂点k(区間[l,r)の)の部分木について区間[a,b)内でx以下の値を持つ要素の最右位置を返す
T find(T a, T b, T x, T k, T l, T r) {
if (node[k] > x || r <= a || b <= l) {
//自分の頂点がxより大きいか範囲外の場合、この区間にないため-1を返す
return -1;
}
if (k >= N - 1) {
//自分の頂点が葉なら見つかったことになるので、その位置を返す
return (k - (N - 1));
}
//右の区間の部分木を見る
T rv = find(a, b, x, 2 * k + 2, (l + r) >> 1, r);
if (rv != -1) {
//戻り値が-1以外なら見つかったのでその位置を返す
return rv;
}
//右の部分偽になかったので左の部分木を調べる
return (find(a, b, x, 2 * k + 1, l, (l + r) >> 1));
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
cin >> n;
int maxi = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (maxi <= c) {
cnt++;
maxi = c;
}
}
cout << cnt << endl;
return 0;
}
| [
"variable_declaration.name.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.variable.change"
] | 882,477 | 882,478 | u504142483 | cpp |
p03072 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int max = a[0], ans;
for (int i = 1; i < n; i++) {
if (max <= a[i])
ans++;
if (max < a[i])
max = a[i];
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int max = a[0], ans = 1;
for (int i = 1; i < n; i++) {
if (max <= a[i])
ans++;
if (max < a[i])
max = a[i];
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.value.change"
] | 882,479 | 882,480 | u056912761 | cpp |
p03072 | #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++)
#define _GLIBCXX_DEBUG
static const int MAX = 20;
int main() {
int N;
cin >> N;
int H[MAX];
int count = 1;
int Hmax;
rep(i, N) cin >> H[i];
Hmax = H[0];
rep2(i, 1, N - 1) {
if (Hmax <= H[i + 1])
count++;
Hmax = max(H[i + 1], Hmax);
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define _GLIBCXX_DEBUG
static const int MAX = 20;
int main() {
int N;
cin >> N;
int H[MAX];
int count = 1;
int Hmax;
rep(i, N) cin >> H[i];
Hmax = H[0];
rep2(i, 1, N) {
if (Hmax <= H[i])
count++;
Hmax = max(H[i], Hmax);
}
cout << count << endl;
} | [
"expression.operation.binary.remove"
] | 882,488 | 882,489 | u378125390 | cpp |
p03072 | #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++)
#define _GLIBCXX_DEBUG
static const int MAX = 20;
int main() {
int N;
cin >> N;
int H[MAX];
int count = 1;
int Hmax;
rep(i, N) cin >> H[i];
Hmax = H[0];
rep2(i, 1, N - 1) {
if (Hmax <= H[i + 1])
count++;
Hmax = max(H[i], Hmax);
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define _GLIBCXX_DEBUG
static const int MAX = 20;
int main() {
int N;
cin >> N;
int H[MAX];
int count = 1;
int Hmax;
rep(i, N) cin >> H[i];
Hmax = H[0];
rep2(i, 1, N) {
if (Hmax <= H[i])
count++;
Hmax = max(H[i], Hmax);
}
cout << count << endl;
} | [
"expression.operation.binary.remove"
] | 882,490 | 882,489 | u378125390 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int N, H[20];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int ans = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j < i; j++) {
if (H[i] < H[j])
break;
if (j = i - 1)
ans++;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, H[20];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int ans = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j < i; j++) {
if (H[i] < H[j])
break;
if (j == i - 1)
ans++;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 882,493 | 882,494 | u204523044 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, h, hmax, i, ans = 1;
cin >> n >> hmax;
for (i = 1; i < n; i++) {
cin >> h;
if (h > hmax) {
ans++;
hmax = h;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, h, hmax, i, ans = 1;
cin >> n >> hmax;
for (i = 1; i < n; i++) {
cin >> h;
if (h >= hmax) {
ans++;
hmax = h;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,497 | 882,498 | u088895504 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, h, hmax, i, ans = 0;
cin >> n >> hmax;
for (i = 1; i < n; i++) {
cin >> h;
if (h > hmax) {
ans++;
hmax = h;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, h, hmax, i, ans = 1;
cin >> n >> hmax;
for (i = 1; i < n; i++) {
cin >> h;
if (h >= hmax) {
ans++;
hmax = h;
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,499 | 882,498 | u088895504 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n;
int mxh = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> h;
if (mxh < h) {
mxh = h;
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n;
int mxh = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> h;
if (mxh <= h) {
mxh = h;
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,505 | 882,506 | u332946309 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int N;
cin >> N;
int max = 0;
int ans = 0;
vector<int> A(N);
rep(i, N) cin >> A.at(i);
rep(i, N) {
if (max <= A.at(i)) {
ans++;
max = A.at(i);
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int N;
cin >> N;
int max = 0;
int ans = 0;
vector<int> A(N);
rep(i, N) cin >> A.at(i);
rep(i, N) {
if (max <= A.at(i)) {
ans++;
max = A.at(i);
}
}
cout << ans << endl;
}
| [] | 882,511 | 882,512 | u854161810 | cpp |
p03072 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define for_p(i, a, b) for (int i = a; i < b; i++)
#define for_m(i, a, b) for (int i = a - 1; i >= b; i--)
// a = s1.size();
// vector<string> s1;
// string s2 = accumulate( s1.begin(), s1.end(), string() );
using namespace std;
int main() {
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
int i = 0, j = 0;
double d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0;
int a1[256], a2[512], a3[1024];
char s1[200000], s2[200000], s3[200000];
cin >> a;
for (i = 0; i < a; i++) {
cin >> a1[i];
}
b++;
for (i = 1; i < a; i++) {
for (j = 0; j < i; j++) {
if (a1[j] < a1[i]) {
c++;
}
}
if (c == 0) {
b++;
}
c = 0;
}
cout << b << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define for_p(i, a, b) for (int i = a; i < b; i++)
#define for_m(i, a, b) for (int i = a - 1; i >= b; i--)
// a = s1.size();
// vector<string> s1;
// string s2 = accumulate( s1.begin(), s1.end(), string() );
using namespace std;
int main() {
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
int i = 0, j = 0;
double d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0;
int a1[256], a2[512], a3[1024];
char s1[200000], s2[200000], s3[200000];
cin >> a;
for (i = 0; i < a; i++) {
cin >> a1[i];
}
b++;
for (i = 1; i < a; i++) {
for (j = 0; j < i; j++) {
if (a1[j] > a1[i]) {
c++;
}
}
if (c == 0) {
b++;
}
c = 0;
}
cout << b << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,513 | 882,514 | u479202791 | cpp |
p03072 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define for_p(i, a, b) for (int i = a; i < b; i++)
#define for_m(i, a, b) for (int i = a - 1; i >= b; i--)
// a = s1.size();
// vector<string> s1;
// string s2 = accumulate( s1.begin(), s1.end(), string() );
using namespace std;
int main() {
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
int i = 0, j = 0;
double d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0;
int a1[256], a2[512], a3[1024];
char s1[200000], s2[200000], s3[200000];
cin >> a;
for (i = 0; i < a; i++) {
cin >> a1[i];
}
b++;
for (i = 1; i < a; i++) {
for (j = 0; j < i; j++) {
if (a1[j] < a1[i]) {
c++;
}
}
if (c == 0) {
b++;
}
c = 0;
}
cout << c << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define for_p(i, a, b) for (int i = a; i < b; i++)
#define for_m(i, a, b) for (int i = a - 1; i >= b; i--)
// a = s1.size();
// vector<string> s1;
// string s2 = accumulate( s1.begin(), s1.end(), string() );
using namespace std;
int main() {
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
int i = 0, j = 0;
double d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0;
int a1[256], a2[512], a3[1024];
char s1[200000], s2[200000], s3[200000];
cin >> a;
for (i = 0; i < a; i++) {
cin >> a1[i];
}
b++;
for (i = 1; i < a; i++) {
for (j = 0; j < i; j++) {
if (a1[j] > a1[i]) {
c++;
}
}
if (c == 0) {
b++;
}
c = 0;
}
cout << b << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"io.output.change"
] | 882,515 | 882,514 | u479202791 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int n, *H;
cin >> n;
H = new int[n];
for (int i; i < n; i++)
cin >> H[i];
int ans = 1;
int i = 0;
for (i = 1; i < n; i++) {
bool can = true;
for (int j = 0; j < i; j++) {
if (H[j] > H[i])
can = false;
}
if (can)
ans++;
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, *H;
cin >> n;
H = new int[n];
for (int i = 0; i < n; i++)
cin >> H[i];
int ans = 1;
int i = 0;
for (i = 1; i < n; i++) {
bool can = true;
for (int j = 0; j < i; j++) {
if (H[j] > H[i])
can = false;
}
if (can)
ans++;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"variable_declaration.value.change"
] | 882,524 | 882,525 | u110383054 | cpp |
p03072 | #include <array>
#include <iostream>
#include <string>
using namespace std;
int main() {
int num;
cin >> num;
int mou;
int old = 0;
int see = 0;
int f = 0;
int loop = 0;
while (num--) {
cin >> mou;
if (mou > old && mou >= f) {
see++;
}
if (loop == 0) {
f = mou;
}
if (mou >= old) {
old = mou;
}
loop++;
}
cout << see << endl;
} | #include <array>
#include <iostream>
#include <string>
using namespace std;
int main() {
int num;
cin >> num;
int mou;
int old = 0;
int see = 0;
int f = 0;
int loop = 0;
while (num--) {
cin >> mou;
if (mou >= old && mou >= f) {
see++;
}
if (loop == 0) {
f = mou;
}
if (mou >= old) {
old = mou;
}
loop++;
}
cout << see << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,526 | 882,527 | u840731541 | cpp |
p03072 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mod 1000000007
string divide[4] = {"dream", "dreamer", "erase", "eraser"};
int main() {
int N; //山の数
cin >> N;
vector<int> H(N); //山の高さ
for (int i = 0; i < N; i++) {
cin >> H[i]; //高さを順番に入力
}
// 1番目の山の高さと同じかそれより高い山を数える
int count = 0;
int max = 0; //一番高い山の高さを入れる変数
for (int i = 0; i < N; i++) {
if (max < H[i]) {
max += H[i];
}
if (max <= H[i]) {
count++;
}
}
cout << count << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mod 1000000007
string divide[4] = {"dream", "dreamer", "erase", "eraser"};
int main() {
int N; //山の数
cin >> N;
vector<int> H(N); //山の高さ
for (int i = 0; i < N; i++) {
cin >> H[i]; //高さを順番に入力
}
// 1番目の山の高さと同じかそれより高い山を数える
int count = 0;
int max = 0; //一番高い山の高さを入れる変数
for (int i = 0; i < N; i++) {
if (max < H[i]) {
max = H[i];
}
if (max <= H[i]) {
count++;
}
}
cout << count << endl;
} | [
"assignment.value.change"
] | 882,530 | 882,531 | u539675863 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N; // yama no kazu
cin >> N;
int H[100];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int count = 0; // mieru ryokan no kazu
int max = 0; // saidai yama takasa
for (int i = 0; i < N; i++) {
if (H[i] < max) {
max = H[i];
}
if (max <= H[i]) {
count++;
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int H[100];
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int count = 0;
int max = 0;
for (int i = 0; i < N; i++) {
if (H[i] > max) {
max = H[i];
}
if (max <= H[i]) {
count++;
}
}
cout << count << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,532 | 882,533 | u539675863 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> height(N);
for (int i = 0; i < N; i++) {
cin >> height.at(i);
}
int count = 0;
for (int i = 0; i < N; i++) {
bool flag = true;
for (int j = 0; j < i; j++) {
if (height.at(j) > height.at(i)) {
flag = false;
}
if (flag) {
count++;
}
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> height(N);
for (int i = 0; i < N; i++) {
cin >> height.at(i);
}
int count = 0;
for (int i = 0; i < N; i++) {
bool flag = true;
for (int j = 0; j < i; j++) {
if (height.at(j) > height.at(i)) {
flag = false;
}
}
if (flag) {
count++;
}
}
cout << count << endl;
} | [] | 882,534 | 882,535 | u477343425 | cpp |
p03072 | #include <algorithm> //sort(all(変数),greater<型名>()) で降順に
#include <cmath> //切り上げceil(値)
#include <deque>
#include <iomanip> //setprecision(数字)
#include <iostream>
#include <list>
#include <map>
#include <numeric> //xとyの最大公約数は__gcd(x,y),xとyの最小公倍数は(x*y)/__gcd
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <bits/stdc++.h>
#include <cstdio>
#include <cstdlib>
#include <tuple>
#include <utility>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define vll vector<ll>
#define vi vector<int>
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define mod 1000000007
using ll = long long;
using namespace std;
int main() {
int n;
cin >> n;
vi h(n);
rep(i, n) { cin >> h[i]; }
int ans = 0;
rep(i, n) {
bool flag = true;
rep(j, i) {
if (h[i] > h[j]) {
flag = false;
break;
}
}
if (flag) {
ans++;
}
}
cout << ans;
return 0;
}
| #include <algorithm> //sort(all(変数),greater<型名>()) で降順に
#include <cmath> //切り上げceil(値)
#include <deque>
#include <iomanip> //setprecision(数字)
#include <iostream>
#include <list>
#include <map>
#include <numeric> //xとyの最大公約数は__gcd(x,y),xとyの最小公倍数は(x*y)/__gcd
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <bits/stdc++.h>
#include <cstdio>
#include <cstdlib>
#include <tuple>
#include <utility>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define vll vector<ll>
#define vi vector<int>
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define mod 1000000007
using ll = long long;
using namespace std;
int main() {
int n;
cin >> n;
vi h(n);
rep(i, n) { cin >> h[i]; }
int ans = 0;
rep(i, n) {
bool flag = true;
rep(j, i) {
if (h[i] < h[j]) {
flag = false;
break;
}
}
if (flag) {
ans++;
}
}
cout << ans;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,538 | 882,539 | u667375816 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> h[i];
int max = h[0];
int cnt = 1;
for (int i = 1, i_len = (int)n; i < i_len; ++i) {
if (h[i] > max) {
cnt++;
}
amax(max, h[i]);
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> h[i];
int max = h[0];
int cnt = 1;
for (int i = 1, i_len = (int)n; i < i_len; ++i) {
if (h[i] >= max) {
cnt++;
}
amax(max, h[i]);
}
cout << cnt << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,540 | 882,541 | u509680664 | cpp |
p03072 | // template
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<long long, long long> LP;
#define INF 999999999
#define MOD 1000000007
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; i++)
#define REP_AB(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define UNIQUE(v) \
sort(ALL(v)); \
v.erase(unique(ALL(v)), v.end());
#define SIZE(x) ((ll)(x).size())
#define REVERSE(v) reverse(ALL(v))
// true / false
#define BIN_SEARCH(v, a) binary_search(ALL(v), a)
// index
#define BIN_LEFT(v, a) (lower_bound(ALL(v), a) - v.begin())
#define BIN_RIGHT(v, a) (upper_bound(ALL(v), a) - v.begin())
#define BIN_INSERT(v, a) (v.insert(v.begin() + BIN_LEFT(v, a), a))
#define DEL(v, i) v.erase(v.begin() + i)
#define INSERT(v, i, a) v.insert(v.begin() + i, a)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
#define out cout
#define in cin
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
// template end
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, c = 0, max = -1;
in >> N;
vector<ll> H(N);
REP(i, N) { in >> H[i]; }
REP(i, N) {
if (max < H[i]) {
c++;
max = H[i];
}
}
out << c << endl;
} | // template
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<long long, long long> LP;
#define INF 999999999
#define MOD 1000000007
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; i++)
#define REP_AB(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define UNIQUE(v) \
sort(ALL(v)); \
v.erase(unique(ALL(v)), v.end());
#define SIZE(x) ((ll)(x).size())
#define REVERSE(v) reverse(ALL(v))
// true / false
#define BIN_SEARCH(v, a) binary_search(ALL(v), a)
// index
#define BIN_LEFT(v, a) (lower_bound(ALL(v), a) - v.begin())
#define BIN_RIGHT(v, a) (upper_bound(ALL(v), a) - v.begin())
#define BIN_INSERT(v, a) (v.insert(v.begin() + BIN_LEFT(v, a), a))
#define DEL(v, i) v.erase(v.begin() + i)
#define INSERT(v, i, a) v.insert(v.begin() + i, a)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
#define out cout
#define in cin
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
// template end
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, c = 0, max = -1;
in >> N;
vector<ll> H(N);
REP(i, N) { in >> H[i]; }
REP(i, N) {
if (max <= H[i]) {
c++;
max = H[i];
}
}
out << c << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,548 | 882,549 | u703877026 | cpp |
p03072 | // templates
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define sort_key(struct_name, key_name) \
[](const struct_name &x, const struct_name &y) { \
return x.key_name < y.key_name; \
}
#define pb(x) push_back(x)
typedef long long ll;
using namespace std;
// main
int main() {
int N;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
int ans = 1;
for (int i = 1; i < N; i++) {
if (H[i] >= *max_element(H.begin(), H.begin() + i - 1))
ans += 1;
}
cout << ans << endl;
} | // templates
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define sort_key(struct_name, key_name) \
[](const struct_name &x, const struct_name &y) { \
return x.key_name < y.key_name; \
}
#define pb(x) push_back(x)
typedef long long ll;
using namespace std;
// main
int main() {
int N;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
int ans = 1;
for (int i = 1; i < N; i++) {
if (H[i] >= *max_element(H.begin(), H.begin() + i))
ans += 1;
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 882,552 | 882,553 | u970738863 | cpp |
p03072 | #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> vec(n);
rep(i, n) { cin >> vec.at(i); }
int max = 0;
int num = 0;
rep(i, n) {
if (i == 0) {
max = vec.at(i);
continue;
}
if (vec.at(i) >= max) {
max = vec.at(i);
num++;
}
}
cout << num << endl;
} | #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> vec(n);
rep(i, n) { cin >> vec.at(i); }
int max = 0;
int num = 1;
rep(i, n) {
if (i == 0) {
max = vec.at(i);
continue;
}
if (vec.at(i) >= max) {
max = vec.at(i);
num++;
}
}
cout << num << endl;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 882,558 | 882,559 | u741134767 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int N, H[21], max_h, cnt = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> H[i];
if (H[i] >= max_h) {
cnt++;
}
max_h = max(max_h, H[i]);
}
cout << cnt << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, H[21], max_h = -1, cnt = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> H[i];
if (H[i] >= max_h) {
cnt++;
}
max_h = max(max_h, H[i]);
}
cout << cnt << endl;
return 0;
}
| [
"variable_declaration.value.change"
] | 882,566 | 882,567 | u134181243 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int max;
cin >> max;
int ret = 1;
for (int i = 1; i < n; ++i) {
int h;
cin >> h;
if (max < h) {
++ret;
max = h;
}
}
cout << ret << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int max;
cin >> max;
int ret = 1;
for (int i = 1; i < n; ++i) {
int h;
cin >> h;
if (max <= h) {
++ret;
max = h;
}
}
cout << ret << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,574 | 882,575 | u611571299 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for (int i = m; i < (int)(n); i++)
#define MOD 1000000007
int arrayMax(vector<int> p, int idx) {
int max_Val = p.at(0);
rep(i, idx) { max_Val = max(max_Val, p.at(i)); }
return max_Val;
}
int main() {
int N;
cin >> N;
vector<int> Hi;
rep(i, N) {
int tmpHi;
cin >> tmpHi;
Hi.push_back(tmpHi);
}
int ans = 1;
rep(i, N) {
if (i == 0)
continue;
int Himax = arrayMax(Hi, i - 1);
if (Hi.at(i) >= Himax)
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for (int i = m; i < (int)(n); i++)
#define MOD 1000000007
int arrayMax(vector<int> p, int idx) {
int max_Val = p.at(0);
rep(i, idx) { max_Val = max(max_Val, p.at(i)); }
return max_Val;
}
int main() {
int N;
cin >> N;
vector<int> Hi;
rep(i, N) {
int tmpHi;
cin >> tmpHi;
Hi.push_back(tmpHi);
}
int ans = 1;
rep(i, N) {
if (i == 0)
continue;
int Himax = arrayMax(Hi, i);
if (Hi.at(i) >= Himax)
ans++;
}
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 882,576 | 882,577 | u503640463 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
int maxH = 0;
int res = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= maxH) {
res += 1;
maxH = a[i];
}
}
cout << maxH << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
int maxH = 0;
int res = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= maxH) {
res += 1;
maxH = a[i];
}
}
cout << res << '\n';
return 0;
} | [
"identifier.change",
"io.output.change"
] | 882,578 | 882,579 | u217173261 | cpp |
p03072 | #include <bits/stdc++.h>
#include <cctype>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
std::string line;
typedef long long ll;
int main() {
int n, h[110];
cin >> n;
rep(i, n) cin >> h[i];
int ans = 1;
for (int i = 1; i <= n; i++) {
bool flg = 1;
for (int j = 0; j < i; j++) {
if (h[j] > h[i]) {
flg = 0;
break;
}
}
if (flg)
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#include <cctype>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
std::string line;
typedef long long ll;
int main() {
int n, h[110];
cin >> n;
rep(i, n) cin >> h[i];
int ans = 1;
for (int i = 1; i < n; i++) {
bool flg = 1;
for (int j = 0; j < i; j++) {
if (h[j] > h[i]) {
flg = 0;
break;
}
}
if (flg)
ans++;
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 882,583 | 882,584 | u796819311 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, ans = 0, tall;
cin >> N >> X;
tall = X;
for (int i = 1; i < N; i++) {
cin >> X;
if (X >= tall)
ans++;
tall = max(tall, X);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, ans = 0, tall;
cin >> N >> X;
tall = X;
for (int i = 1; i < N; i++) {
cin >> X;
if (X >= tall)
ans++;
tall = max(tall, X);
}
cout << ans + 1;
} | [] | 882,585 | 882,586 | u347057617 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, ans = 0, tall;
cin >> N >> X;
tall = X;
for (int i = 1; i < N; i++) {
cin >> X;
if (X >= tall)
ans++;
tall = max(tall, X);
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, ans = 0, tall;
cin >> N >> X;
tall = X;
for (int i = 1; i < N; i++) {
cin >> X;
if (X >= tall)
ans++;
tall = max(tall, X);
}
cout << ans + 1;
} | [
"expression.operation.binary.add"
] | 882,587 | 882,586 | u347057617 | cpp |
p03072 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int count = 0;
int flag = 0;
int N;
cin >> N;
vector<int> X(N);
rep(i, N) { cin >> X[i]; }
rep(i, N) {
rep(j, i) {
if (X[j] <= X[i]) {
flag++;
}
}
if (flag > 0) {
count++;
}
flag = 0;
}
cout << count;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int count = 0;
int flag = 0;
int N;
cin >> N;
vector<int> X(N);
rep(i, N) { cin >> X[i]; }
rep(i, N) {
rep(j, i) {
if (X[j] > X[i]) {
flag++;
}
}
if (flag == 0) {
count++;
}
flag = 0;
}
cout << count;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,588 | 882,589 | u573537453 | cpp |
p03072 | // 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// --------------------<optimizations>--------------------
#pragma GCC optimize("O3")
//(UNCOMMENT WHEN HAVING LOTS OF RECURSIONS)\
#pragma comment(linker, "/stack:200000000")
//(UNCOMMENT WHEN TRYING TO BRUTEFORCE WITH A LOT OF LOOPS)\
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define F first
#define S second
#define ld long double
#define built __builtin_popcountll
#define mst(a, i) memset(a, i, sizeof(a))
#define all(x) x.begin(), x.end()
#define itit(it, a) for (auto it = (a).begin(); it != (a).end(); it++)
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define reprr(i, a, b) for (ll i = a; i >= b; i--)
#define pi 3.14159265358979323846264338327950288419716939937510582097494459230
ll max3(ll x, ll y, ll z) { return max(max(x, y), z); }
ll min3(ll x, ll y, ll z) { return min(min(x, y), z); }
const ll N = 1e5 + 10, M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7,
inf = 1e17 + 10;
const int INF = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
int X[] = {0, 1, 0, -1};
int Y[] = {-1, 0, 1, 0};
ll power(ll x, ll n) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return result;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
ll h[n];
ll maxi = 0;
ll ans = 0;
rep(i, 0, n) {
cin >> h[i];
if (h[i] >= maxi) {
maxi = max(maxi, h[i]);
ans++;
}
}
return 0;
}
/* The judge is never wrong! Your code is buggy
Look for:
* * Read the problem carefully.
* * Don't forget to sort(), mod, ll!!!!
* * Initial value = +/- infinity instead of zero!!!
* * an easier and alternate approach
* * read the problem statement carefully
* * if concept is correct and still WA, try with a different implementation
* * special cases (n=1?)
* * if you have no idea just guess the appropriate well-known algorithm instead
of doing nothing :/
*/ | // 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// 🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤🖤
// //
// --------------------<optimizations>--------------------
#pragma GCC optimize("O3")
//(UNCOMMENT WHEN HAVING LOTS OF RECURSIONS)\
#pragma comment(linker, "/stack:200000000")
//(UNCOMMENT WHEN TRYING TO BRUTEFORCE WITH A LOT OF LOOPS)\
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define F first
#define S second
#define ld long double
#define built __builtin_popcountll
#define mst(a, i) memset(a, i, sizeof(a))
#define all(x) x.begin(), x.end()
#define itit(it, a) for (auto it = (a).begin(); it != (a).end(); it++)
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repr(i, a, b) for (ll i = a; i > b; i--)
#define reprr(i, a, b) for (ll i = a; i >= b; i--)
#define pi 3.14159265358979323846264338327950288419716939937510582097494459230
ll max3(ll x, ll y, ll z) { return max(max(x, y), z); }
ll min3(ll x, ll y, ll z) { return min(min(x, y), z); }
const ll N = 1e5 + 10, M = 2e5 + 10, M2 = 1e6 + 10, mod = 1e9 + 7,
inf = 1e17 + 10;
const int INF = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
int X[] = {0, 1, 0, -1};
int Y[] = {-1, 0, 1, 0};
ll power(ll x, ll n) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return result;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
ll h[n];
ll maxi = 0;
ll ans = 0;
rep(i, 0, n) {
cin >> h[i];
if (h[i] >= maxi) {
maxi = max(maxi, h[i]);
ans++;
}
}
cout << ans;
return 0;
}
/* The judge is never wrong! Your code is buggy
Look for:
* * Read the problem carefully.
* * Don't forget to sort(), mod, ll!!!!
* * Initial value = +/- infinity instead of zero!!!
* * an easier and alternate approach
* * read the problem statement carefully
* * if concept is correct and still WA, try with a different implementation
* * special cases (n=1?)
* * if you have no idea just guess the appropriate well-known algorithm instead
of doing nothing :/
*/
| [] | 882,590 | 882,591 | u652633828 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 1;
bool a;
cin >> n;
vector<int> h(n);
cin >> h.at(0);
for (int i = 1; i < n; i++) {
a = true;
cin >> h.at(i);
for (int l = 0; l < i; l++) {
if (h.at(i) > h.at(l)) {
a = false;
break;
}
}
if (a) {
sum++;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 1;
bool a;
cin >> n;
vector<int> h(n);
cin >> h.at(0);
for (int i = 1; i < n; i++) {
a = true;
cin >> h.at(i);
for (int l = 0; l < i; l++) {
if (h.at(i) < h.at(l)) {
a = false;
break;
}
}
if (a) {
sum++;
}
}
cout << sum << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,594 | 882,595 | u442754977 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int h_max = 0;
int answer = 0;
for (int i = 0; i < N; i++) {
int H;
cin >> H;
if (H > h_max) {
answer++;
h_max = H;
}
}
cout << answer;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int h_max = 0;
int answer = 0;
for (int i = 0; i < N; i++) {
int H;
cin >> H;
if (H >= h_max) {
answer++;
h_max = H;
}
}
cout << answer;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,602 | 882,603 | u599568485 | cpp |
p03072 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
int ans = 0;
int max = 0;
for (int j = 0; j < n; j++) {
if (j == 0) {
ans++;
max = h[j];
} else if (h[j] > h[j - 1] && h[j] > max) {
ans++;
max = h[j];
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
int ans = 0;
int max = 0;
for (int j = 0; j < n; j++) {
if (j == 0) {
ans++;
max = h[j];
} else if (h[j] >= h[j - 1] && h[j] >= max) {
ans++;
max = h[j];
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,604 | 882,605 | u726187349 | cpp |
p03072 | #include <bits/stdc++.h>
#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<int> h(n);
rep(i, n) cin >> h[i + 1];
int res = 1;
int max_hight = h[1];
for (int i = 2; i < (n); ++i) {
max_hight = max(max_hight, h[i]);
if (max_hight <= h[i])
res++;
else
continue;
}
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
#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<int> h(n);
rep(i, n) cin >> h[i + 1];
int res = 1;
int max_hight = h[1];
for (int i = 2; i < (n + 1); ++i) {
max_hight = max(max_hight, h[i]);
if (max_hight <= h[i])
res++;
else
continue;
}
cout << res << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 882,610 | 882,611 | u139255323 | cpp |
p03072 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, ans(0), M;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >> h[i];
if (h[i] >= M) {
M = h[i];
ans++;
}
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, ans(0), M(0);
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; i++) {
cin >> h[i];
if (h[i] >= M) {
M = h[i];
ans++;
}
}
cout << ans << endl;
} | [
"call.arguments.add"
] | 882,636 | 882,637 | u456658814 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int n, h, dp[20], cnt = 1;
cin >> n;
cin >> dp[0];
for (int i = 1; i < n; i++) {
cin >> h;
if (h > dp[i - 1]) {
cnt++;
dp[i] = h;
} else {
dp[i] = dp[i - 1];
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, h, dp[20], cnt = 1;
cin >> n;
cin >> dp[0];
for (int i = 1; i < n; i++) {
cin >> h;
if (h >= dp[i - 1]) {
cnt++;
dp[i] = h;
} else {
dp[i] = dp[i - 1];
}
}
cout << cnt << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,638 | 882,639 | u522506260 | cpp |
p03072 | #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 cnt = 1;
int nax = 0;
for (int i = 1; i < N; i++) {
if (H[i] >= nax) {
cnt++;
nax = H[i];
}
}
cout << cnt;
return 0;
}
| #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 cnt = 1;
int nax = H[0];
for (int i = 1; i < N; i++) {
if (H[i] >= nax) {
cnt++;
nax = H[i];
}
}
cout << cnt;
return 0;
}
| [] | 882,648 | 882,649 | u101513772 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[110];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int count = 0;
for (int i = 1; i < n; i++) {
bool isOk = true;
for (int j = 0; j < i - 1; j++) {
if (h[j] > h[i]) {
isOk = false;
}
}
if (isOk) {
count++;
}
}
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[110];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int count = 1;
for (int i = 1; i < n; i++) {
bool isOk = true;
for (int j = 0; j < i; j++) {
if (h[j] > h[i]) {
isOk = false;
}
}
if (isOk) {
count++;
}
}
cout << count << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 882,653 | 882,654 | u692131329 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 1;
cin >> n;
vector<int> v(n);
cin >> v.at(0);
for (int i = 1; i < n; i++) {
cin >> v.at(i);
bool a = 1;
for (int j = 0; j < i; j++) {
if (v.at(i) < v.at(j))
a = 0;
}
if (a = 1)
s++;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 1;
cin >> n;
vector<int> v(n);
cin >> v.at(0);
for (int i = 1; i < n; i++) {
cin >> v.at(i);
bool a = 1;
for (int j = 0; j < i; j++) {
if (v.at(i) < v.at(j))
a = 0;
}
if (a)
s++;
}
cout << s << endl;
} | [
"control_flow.loop.for.condition.change",
"assignment.change"
] | 882,655 | 882,656 | u757584836 | cpp |
p03072 | #include <algorithm>
#include <functional>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define All(x) (x).begin(), (x).end()
using namespace std;
using pii = pair<int, int>;
typedef long long ll;
#define MOD 1000000007
#define EPS 10e-8
int main() {
int a, b[100000009], ma, c;
ma = c = 0;
cin >> a;
rep(i, a) {
cin >> b[i];
if (b[i] >= ma) {
ma = b[i];
c++;
}
}
cout << c << endl;
}
| #include <algorithm>
#include <functional>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define All(x) (x).begin(), (x).end()
using namespace std;
using pii = pair<int, int>;
typedef long long ll;
#define MOD 1000000007
#define EPS 10e-8
int main() {
int a, b[1009], ma, c;
ma = c = 0;
cin >> a;
rep(i, a) {
cin >> b[i];
if (b[i] >= ma) {
ma = b[i];
c++;
}
}
cout << c << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 882,657 | 882,658 | u008229752 | cpp |
p03072 | #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// INT_MAX 2,147,483,647 = 2*1.0e9
int main() {
int N;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
int ans = 1;
int prevMax = H[0];
for (int i = 1; i < N; i++) {
if (H[i] >= prevMax) {
prevMax = H[1];
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// INT_MAX 2,147,483,647 = 2*1.0e9
int main() {
int N;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
int ans = 1;
int prevMax = H[0];
for (int i = 1; i < N; i++) {
if (H[i] >= prevMax) {
prevMax = H[i];
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 882,663 | 882,664 | u561443723 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#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 fs first
#define sc second
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
int cnt = 1;
bool ans = true;
rep1(i, N) {
ans = true;
rep(j, N) if (H[j] > H[i]) ans = false;
if (ans == true)
cnt++;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#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 fs first
#define sc second
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
int cnt = 1;
bool ans = true;
rep1(i, N) {
ans = true;
rep(j, i + 1) if (H[j] > H[i]) ans = false;
if (ans == true)
cnt++;
}
cout << cnt << endl;
} | [
"call.arguments.change"
] | 882,672 | 882,673 | u263715385 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int N, A;
int max = 0;
int some_count = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A;
if (A >= max) {
some_count++;
A = max;
}
}
cout << some_count << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, A;
int max = 0;
int some_count = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A;
if (A >= max) {
some_count++;
max = A;
}
}
cout << some_count << endl;
return 0;
}
| [
"assignment.change"
] | 882,674 | 882,675 | u399527001 | cpp |
p03072 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) vector<vector<int>> vec(n, vector<int>(m, l));
#define vvll(vec, n, m, l) vector<vector<ll>> vec(n, vector<ll>(m, l));
#define vint vector<int>;
#define pint pair<int, int>;
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(x) (x).begin(), (x).end()
#define debug system("pause")
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> h(n);
int ans = 0;
rep(i, n) {
cin >> h[i];
rep(j, i) {
if (h[i] < h[j]) {
break;
}
if (j + 1 == i) {
ans++;
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e8;
using namespace std;
#define vvint(vec, n, m, l) vector<vector<int>> vec(n, vector<int>(m, l));
#define vvll(vec, n, m, l) vector<vector<ll>> vec(n, vector<ll>(m, l));
#define vint vector<int>;
#define pint pair<int, int>;
#define rep(i, a) for (int i = 0; i < (a); i++)
#define all(x) (x).begin(), (x).end()
#define debug system("pause")
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> h(n);
int ans = 0;
rep(i, n) {
cin >> h[i];
rep(j, i) {
if (h[i] < h[j]) {
break;
}
if (j + 1 == i) {
ans++;
}
}
}
cout << ans + 1 << endl;
debug;
} | [
"expression.operation.binary.add"
] | 882,682 | 882,683 | u776194115 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 1;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (h[j] <= h[i]) {
if (j = i - 1)
m++;
} else {
break;
}
}
}
cout << m << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 1;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (h[j] <= h[i]) {
if (j == i - 1)
m++;
} else {
break;
}
}
}
cout << m << endl;
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 882,684 | 882,685 | u930561195 | cpp |
p03072 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
//#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a), i##formax = (b); i < i##formax; i++)
typedef long long ll;
int main() {
int n, ct = 0, mx = 101;
cin >> n;
int h[n];
FOR(i, 0, n) {
cin >> h[i];
if (h[i] >= mx) {
ct += 1;
}
mx = max(mx, h[i]);
}
cout << ct << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
//#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a), i##formax = (b); i < i##formax; i++)
typedef long long ll;
int main() {
int n, ct = 0, mx = 0;
cin >> n;
int h[n];
FOR(i, 0, n) {
cin >> h[i];
if (h[i] >= mx) {
ct += 1;
}
mx = max(mx, h[i]);
}
cout << ct << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 882,688 | 882,689 | u287367500 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int temp, N, max, count = 1;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> temp;
if (i == 0) {
max = temp;
} else if (max < temp) {
count++;
max = temp;
}
}
cout << count << endl;
} | #include <iostream>
using namespace std;
int main() {
int temp, N, max, count = 1;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> temp;
if (i == 0) {
max = temp;
} else if (max <= temp) {
count++;
max = temp;
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,694 | 882,695 | u710135612 | cpp |
p03072 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define Rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define int long long
using namespace std;
signed main() {
int x, y, z, w, i, j = 0;
cin >> x;
std::vector<int> v(x);
rep(i, x) { cin >> v[i]; }
z = v[0];
Rep(i, x) {
if (v[i] >= z) {
j++;
} else {
z = v[i];
}
}
cout << j << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define Rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define int long long
using namespace std;
signed main() {
int x, y, z, w, i, j = 1;
cin >> x;
std::vector<int> v(x);
rep(i, x) { cin >> v[i]; }
z = v[0];
repone(i, x) {
if (v[i] >= z) {
j++;
z = v[i];
}
}
cout << j << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change"
] | 882,696 | 882,697 | u893330446 | cpp |
p03072 | #include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
int N, ans = 1;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
for (int i = 1; i < N; ++i) {
int cnt = 0;
rep(j, i + 1) {
if (H[i] <= H[j]) {
cnt++;
}
}
if (cnt == i + 1) {
ans++;
}
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
int main() {
int N, ans = 1;
cin >> N;
vector<int> H(N);
rep(i, N) cin >> H[i];
for (int i = 1; i < N; ++i) {
int cnt = 0;
rep(j, i + 1) {
if (H[j] <= H[i]) {
cnt++;
}
}
if (cnt == i + 1) {
ans++;
}
}
cout << ans << endl;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 882,698 | 882,699 | u887207211 | cpp |
p03072 | #include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> P;
constexpr ll mod = 1000000007;
int main() {
int n;
cin >> n;
vll h(n);
ll ma = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (ma >= h[i])
ans++;
ma = max(ma, h[i]);
}
cout << ans;
} | #include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> P;
constexpr ll mod = 1000000007;
int main() {
int n;
cin >> n;
vll h(n);
ll ma = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (ma <= h[i])
ans++;
ma = max(ma, h[i]);
}
cout << ans;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,700 | 882,701 | u408650734 | cpp |
p03072 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 1;
for (int i = 1; i < n; i++) {
int judge = 0;
for (int j = 0; j < i; j++) {
if (h[j] < h[i]) {
judge += 1;
}
if (judge == i) {
ans += 1;
}
}
}
cout << ans;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 1;
for (int i = 1; i < n; i++) {
int judge = 0;
for (int j = 0; j < i; j++) {
if (h[j] <= h[i]) {
judge += 1;
}
if (judge == i) {
ans += 1;
}
}
}
cout << ans;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,702 | 882,703 | u725133562 | cpp |
p03072 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define all(x) (x).begin(), (x).end()
#define fst first
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define sw swap
#define FOR(i, m, n) for (int i = m; i < n; i++)
using LL = long long;
using ULL = unsigned long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, x1, c = 1;
cin >> N >> x1;
rep(i, N - 1) {
int x2;
cin >> x2;
if (x1 <= x2) {
x1 = x2;
c++;
cout << x1;
}
}
cout << c;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define all(x) (x).begin(), (x).end()
#define fst first
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define sw swap
#define FOR(i, m, n) for (int i = m; i < n; i++)
using LL = long long;
using ULL = unsigned long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, x1, c = 1;
cin >> N >> x1;
rep(i, N - 1) {
int x2;
cin >> x2;
if (x1 <= x2) {
x1 = x2;
c++;
}
}
cout << c;
} | [] | 882,704 | 882,705 | u379928983 | cpp |
p03072 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define all(x) (x).begin(), (x).end()
#define fst first
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define sw swap
#define FOR(i, m, n) for (int i = m; i < n; i++)
using LL = long long;
using ULL = unsigned long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, x1, c;
cin >> N >> x1;
rep(i, N) {
int x2;
cin >> x2;
if (x1 <= x2) {
x1 = x2;
c++;
}
}
cout << c;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define all(x) (x).begin(), (x).end()
#define fst first
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define sw swap
#define FOR(i, m, n) for (int i = m; i < n; i++)
using LL = long long;
using ULL = unsigned long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, x1, c = 1;
cin >> N >> x1;
rep(i, N - 1) {
int x2;
cin >> x2;
if (x1 <= x2) {
x1 = x2;
c++;
}
}
cout << c;
} | [
"variable_declaration.value.change"
] | 882,706 | 882,705 | u379928983 | cpp |
p03072 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
int count = 1;
int max_high = H[0];
for (int i = 1; i < N; ++i) {
if (H[i] >= max_high) {
count++;
}
max_high = max(H[i], H[i - 1]);
}
cout << count << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
int count = 1;
int max_high = H[0];
for (int i = 1; i < N; ++i) {
if (H[i] >= max_high) {
count++;
}
max_high = max(H[i], max_high);
}
cout << count << endl;
return 0;
} | [
"assignment.value.change",
"call.arguments.change"
] | 882,707 | 882,708 | u318150500 | cpp |
p03072 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
int ans = 0;
int max = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (max < h[i]) {
max = h[i];
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
int ans = 0;
int max = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (max <= h[i]) {
max = h[i];
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,711 | 882,712 | u195054737 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, count = 0;
cin >> N;
vector<int> height, core;
height.resize(N);
core.resize(N);
for (int i = 0; i < N; i++)
cin >> height[i];
for (int t = 0; t < N; t++) {
for (int j = 0; j < t + 1; j++)
if (height[t + 1] >= height[j])
core[t]++;
if (core[t] == t + 1)
count++;
}
cout << count;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, count = 0;
cin >> N;
vector<int> height, core;
height.resize(N);
core.resize(N);
for (int i = 0; i < N; i++)
cin >> height[i];
for (int t = 0; t < N; t++) {
for (int j = 0; j < t + 1; j++)
if (height[t + 1] >= height[j])
core[t]++;
if (core[t] == t + 1)
count++;
}
cout << count + 1;
return 0;
}
| [
"expression.operation.binary.add"
] | 882,714 | 882,715 | u174509352 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int n, flag;
int ans = 1;
cin >> n;
int h[110];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
flag = 0;
for (int j = 0; j < i; j++) {
if (h[i] <= h[j]) {
flag = 1;
}
}
if (flag == 0) {
ans += 1;
}
}
cout << ans;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, flag;
int ans = 1;
cin >> n;
int h[110];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 1; i < n; i++) {
flag = 0;
for (int j = 0; j < i; j++) {
if (h[i] < h[j]) {
flag = 1;
}
}
if (flag == 0) {
ans += 1;
}
}
cout << ans;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,718 | 882,719 | u817783285 | cpp |
p03072 | #include <stdio.h>
int main() {
int N, k;
scanf("%d", &N);
int H[N];
for (k = 0; k < N; k++) {
scanf("%d", &H[k]);
}
int max = 0;
int c = 0;
for (k = 0; k < N; k++) {
if (H[k] > max) {
max = H[k];
c++;
}
}
printf("%d", c);
return 0;
} | #include <stdio.h>
int main() {
int N, k;
scanf("%d", &N);
int H[N];
for (k = 0; k < N; k++) {
scanf("%d", &H[k]);
}
int max = 0;
int c = 0;
for (k = 0; k < N; k++) {
if (H[k] >= max) {
max = H[k];
c++;
}
}
printf("%d", c);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,720 | 882,721 | u374372942 | cpp |
p03072 |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
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();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define EXISTch(s, c) \
((((s).find_first_of(c)) != std::string::npos) ? 1 : 0) // cがあれば1 if(1)
#define SORT(c) sort((c).begin(), (c).end())
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = (int)1000000007;
const LL MOD = (LL)1000000007; // 10^9+7
const LL INF2 = (LL)100000000000000000; // 10^18
int main() {
int n;
cin >> n;
int ans = 0;
int mx = -1;
int now;
for (int i = 0; i < n; i++) {
cin >> now;
if (now > mx)
ans++;
mx = max(mx, now);
}
cout << ans << endl;
} |
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
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();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define EXISTch(s, c) \
((((s).find_first_of(c)) != std::string::npos) ? 1 : 0) // cがあれば1 if(1)
#define SORT(c) sort((c).begin(), (c).end())
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = (int)1000000007;
const LL MOD = (LL)1000000007; // 10^9+7
const LL INF2 = (LL)100000000000000000; // 10^18
int main() {
int n;
cin >> n;
int ans = 0;
int mx = -1;
int now;
for (int i = 0; i < n; i++) {
cin >> now;
if (now >= mx)
ans++;
mx = max(mx, now);
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,732 | 882,733 | u874996917 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, t;
cin >> t;
int h[t];
int temp = 0, tot = 0, highest = 0;
for (i = 0; i < t; i++) {
cin >> h[i];
if (h[i] > highest)
highest = h[i];
if (h[i] > temp && h[i] >= highest)
temp = h[i];
else {
tot++;
temp = h[i];
}
}
cout << t - tot << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int i, t;
cin >> t;
int h[t];
int temp = 0, tot = 0, highest = 0;
for (i = 0; i < t; i++) {
cin >> h[i];
if (h[i] > highest)
highest = h[i];
if (h[i] >= temp && h[i] >= highest)
temp = h[i];
else {
tot++;
temp = h[i];
}
}
cout << t - tot << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,743 | 882,744 | u415778984 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
int maxh = 0;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
maxh = max(maxh, h.at(i));
if (h.at(i) > maxh) {
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
int maxh = 0;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
maxh = max(maxh, h.at(i));
if (h.at(i) >= maxh) {
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,745 | 882,746 | u370447425 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int unit[N];
for (int i = 0; i < N; i++) {
cin >> unit[i];
}
int ans = 0, min = 0;
for (int i = 0; i < N; i++) {
min = 0;
for (int j = 0; j < i; j++) {
if (unit[j] > unit[i])
min = 1;
break;
}
if (min == 0)
ans++;
}
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int unit[N];
for (int i = 0; i < N; i++) {
cin >> unit[i];
}
int ans = 0, min = 0;
for (int i = 0; i < N; i++) {
min = 0;
for (int j = 0; j < i; j++) {
if (unit[j] > unit[i])
min = 1;
}
if (min == 0)
ans++;
}
cout << ans << endl;
return 0;
}
| [] | 882,747 | 882,748 | u747087681 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<string> vs;
typedef vector<vll> vvll;
typedef pair<ll, ll> pii;
typedef pair<string, ll> psi;
typedef pair<ll, string> pis;
typedef pair<ll, vll> plv;
#define REP(i, a, b) for (ll i = ll(a); i <= ll(b); ++i)
#define REPR(i, a, b) for (ll i = ll(a); i >= ll(b); --i)
#define pb push_back
#define mp make_pair
#define all(v) (v).begin(), (v).end()
template <typename T> T absolute(T a, T b) { return a >= 0 ? a : -a; }
template <typename T> T sqr(T a) { return a * a; }
ll read() {
ll res, f = 1;
register char ch;
while ((ch = getchar()) > '9' || ch < '0')
(ch == '-') && (f = -1);
for (res = ch - '0'; (ch = getchar()) >= '0' && ch <= '9';
res = res * 10 + ch - '0')
;
return res * f;
}
int main() {
ll n, cnt = 0;
scanf("%lld", &n);
ll a[n];
ll maxi = 0;
REP(i, 0, n) {
scanf("%lld", &a[i]);
if (a[i] >= maxi)
cnt++;
maxi = max(maxi, a[i]);
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<string> vs;
typedef vector<vll> vvll;
typedef pair<ll, ll> pii;
typedef pair<string, ll> psi;
typedef pair<ll, string> pis;
typedef pair<ll, vll> plv;
#define REP(i, a, b) for (ll i = ll(a); i <= ll(b); ++i)
#define REPR(i, a, b) for (ll i = ll(a); i >= ll(b); --i)
#define pb push_back
#define mp make_pair
#define all(v) (v).begin(), (v).end()
template <typename T> T absolute(T a, T b) { return a >= 0 ? a : -a; }
template <typename T> T sqr(T a) { return a * a; }
ll read() {
ll res, f = 1;
register char ch;
while ((ch = getchar()) > '9' || ch < '0')
(ch == '-') && (f = -1);
for (res = ch - '0'; (ch = getchar()) >= '0' && ch <= '9';
res = res * 10 + ch - '0')
;
return res * f;
}
int main() {
ll n, cnt = 0;
scanf("%lld", &n);
ll a[n];
ll maxi = 0;
REP(i, 0, n - 1) {
scanf("%lld", &a[i]);
if (a[i] >= maxi)
cnt++;
maxi = max(maxi, a[i]);
}
cout << cnt << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 882,758 | 882,759 | u423832505 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define sz(v) ll(v.size)
int main() {
ll N;
cin >> N;
vector<ll> H(N);
rep(i, N) { cin >> H[i]; }
ll highest = 0;
ll counter = 0;
rep(i, N) {
if (highest < H[i]) {
counter++;
highest = H[i];
}
}
cout << counter << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define sz(v) ll(v.size)
int main() {
ll N;
cin >> N;
vector<ll> H(N);
rep(i, N) { cin >> H[i]; }
ll highest = 0;
ll counter = 0;
rep(i, N) {
if (highest <= H[i]) {
counter++;
highest = H[i];
}
}
cout << counter << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,774 | 882,775 | u333190709 | cpp |
p03072 | #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 S = 1;
for (int j = 0; j < N; j++) {
int s = 1;
for (int i = 0; i < j; i++) {
if (H.at(j) > H.at(i)) {
s *= 1;
} else {
s *= 0;
}
}
if (s == 1) {
S += 1;
} else {
S = S;
}
}
cout << S << 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 S = 1;
for (int j = 1; j < N; j++) {
int s = 1;
for (int i = 0; i < j; i++) {
if (H.at(j) >= H.at(i)) {
s *= 1;
} else {
s *= 0;
}
}
if (s == 1) {
S += 1;
} else {
S = S;
}
}
cout << S << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,776 | 882,777 | u991310813 | cpp |
p03072 | #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 S = 0;
for (int j = 0; j < N; j++) {
int s = 1;
for (int i = 0; i < j; i++) {
if (H.at(j) > H.at(i)) {
s *= 1;
} else {
s *= 0;
}
}
if (s == 1) {
S += 1;
} else {
S = S;
}
}
cout << S << 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 S = 1;
for (int j = 1; j < N; j++) {
int s = 1;
for (int i = 0; i < j; i++) {
if (H.at(j) >= H.at(i)) {
s *= 1;
} else {
s *= 0;
}
}
if (s == 1) {
S += 1;
} else {
S = S;
}
}
cout << S << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,778 | 882,777 | u991310813 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
int j = 1;
int k = vec.at(0);
int count = 0;
while (N > j) {
if (k <= vec.at(j)) {
count++;
k = vec.at(j);
}
j++;
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
int j = 1;
int k = vec.at(0);
int count = 1;
while (N > j) {
if (k <= vec.at(j)) {
count++;
k = vec.at(j);
}
j++;
}
cout << count << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 882,791 | 882,792 | u346059918 | cpp |
p03072 |
#include <algorithm>
#include <bits/stdc++.h>
#include <numeric>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], highest[n];
int count = 1;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (i == 0) {
highest[0] = h[0];
} else {
if (h[i] > highest[i - 1]) {
highest[i] = h[i];
} else {
highest[i] = highest[i - 1];
}
}
}
for (int i = 1; i < n; i++) {
if (h[i] > highest[i - 1]) {
count++;
}
}
cout << count << endl;
} |
#include <algorithm>
#include <bits/stdc++.h>
#include <numeric>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], highest[n];
int count = 1;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (i == 0) {
highest[0] = h[0];
} else {
if (h[i] > highest[i - 1]) {
highest[i] = h[i];
} else {
highest[i] = highest[i - 1];
}
}
}
for (int i = 1; i < n; i++) {
if (h[i] >= highest[i - 1]) {
count++;
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,793 | 882,794 | u827974318 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
typedef long long int lli;
#define pb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define INF 1000000000
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
int n;
int h[30];
int main() {
fastio;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
int sum = 0;
for (int i = 2; i <= n; i++) {
int cnt = 0;
for (int j = i - 1; j >= 1; j--) {
if (h[i] >= h[j])
cnt++;
}
if (cnt == i - 1)
sum++;
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
typedef long long int lli;
#define pb emplace_back
#define mp make_pair
#define pii pair<int, int>
#define INF 1000000000
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
int n;
int h[30];
int main() {
fastio;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
int sum = 1;
for (int i = 2; i <= n; i++) {
int cnt = 0;
for (int j = i - 1; j >= 1; j--) {
if (h[i] >= h[j])
cnt++;
}
if (cnt == i - 1)
sum++;
}
cout << sum << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 882,799 | 882,800 | u059313618 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> H;
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
int count = 0;
for (int i = 1; i < N; i++) {
bool flg = true;
for (int j = 0; j < i; j++) {
if (H.at(i) < H.at(j)) {
flg = false;
}
}
if (flg)
count++;
}
cout << count + 1 << 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 count = 0;
for (int i = 1; i < N; i++) {
bool flg = true;
for (int j = 0; j < i; j++) {
if (H.at(i) < H.at(j)) {
flg = false;
}
}
if (flg)
count++;
}
cout << count + 1 << endl;
} | [] | 882,813 | 882,814 | u489117389 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, a, max, C;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
max = H.at(0);
for (int i = 0; i < N; i++) {
a = H.at(i) - max;
if (a >= 0) {
C += 1;
max = H.at(i);
}
}
cout << C << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, a, max, C;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
C = 0;
max = H.at(0);
for (int i = 0; i < N; i++) {
a = H.at(i) - max;
if (a >= 0) {
C++;
max = H.at(i);
}
}
cout << C << endl;
} | [
"assignment.add"
] | 882,818 | 882,819 | u025771681 | cpp |
p03072 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const ll LINF = 1e18;
const int MOD = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
int maxN = h[0], ans = 0;
for (int i = 1; i < n; i++) {
if (maxN <= h[i])
ans++;
maxN = max(maxN, h[i]);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const ll LINF = 1e18;
const int MOD = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
int maxN = h[0], ans = 1;
for (int i = 1; i < n; i++) {
if (maxN <= h[i])
ans++;
maxN = max(maxN, h[i]);
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 882,820 | 882,821 | u654240084 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int N, ans = 0, last;
int main() {
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
for (int i = 0; i < N; i++) {
int ok = 1;
for (int j = 0; j < i; j++) {
if (H[j] > H[i])
ok = 0;
break;
}
if (ok)
ans++;
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int N, ans = 0, last;
int main() {
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
for (int i = 0; i < N; i++) {
int ok = 1;
for (int j = 0; j < i; j++) {
if (H[j] > H[i]) {
ok = 0;
}
}
if (ok) {
ans++;
}
}
cout << ans;
}
| [] | 882,827 | 882,828 | u904951912 | cpp |
p03072 | #include <bits/stdc++.h>
#include <iostream>
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 count = 1;
int maxH = H.at(1);
for (int i = 1; i < N; i++) {
if (maxH <= H.at(i)) {
count++;
maxH = H.at(i);
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
#include <iostream>
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 count = 1;
int maxH = H.at(0);
for (int i = 1; i < N; i++) {
if (maxH <= H.at(i)) {
count++;
maxH = H.at(i);
}
}
cout << count << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 882,831 | 882,832 | u707059295 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int H[n];
for (int i = 0; i < n; i++) {
cin >> H[i];
}
int minHeight = H[0];
int cnt;
for (int i = 0; i < n; i++) {
if (minHeight <= H[i]) {
minHeight = H[i];
cnt++;
}
}
cout << cnt << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int H[n];
for (int i = 0; i < n; i++) {
cin >> H[i];
}
int minHeight = H[0];
int cnt = 0;
for (int i = 0; i < n; i++) {
if (minHeight <= H[i]) {
minHeight = H[i];
cnt++;
}
}
cout << cnt << endl;
}
| [
"variable_declaration.value.change"
] | 882,833 | 882,834 | u929024786 | cpp |
p03072 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int maxHeight(vector<int>::iterator begin, vector<int>::iterator end) {
int ret = 0;
while (begin++ != end) {
ret = max(ret, *begin);
}
return ret;
}
int main() {
int n;
cin >> n;
vector<int> heights(n);
for (auto &height : heights) {
cin >> height;
}
int count = 0;
for (int i = 0; i < heights.size(); i++) {
if (maxHeight(heights.begin(), heights.begin() + i + 1) == heights[i]) {
count++;
}
}
cout << count << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int maxHeight(vector<int>::iterator begin, vector<int>::iterator end) {
int ret = 0;
while (begin != end) {
ret = max(ret, *begin);
begin++;
}
return ret;
}
int main() {
int n;
cin >> n;
vector<int> heights(n);
for (auto &height : heights) {
cin >> height;
}
int count = 0;
for (int i = 0; i < heights.size(); i++) {
if (maxHeight(heights.begin(), heights.begin() + i + 1) == heights[i]) {
count++;
}
}
cout << count << endl;
return 0;
} | [
"control_flow.loop.condition.change",
"expression.unary.arithmetic.add"
] | 882,840 | 882,841 | u498695849 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
int main() {
int n;
cin >> n;
std::vector<int> H(109);
rep(i, n) cin >> H[i];
int ans = 0;
for (int i = 0; i < n; ++i) {
bool is_candidate = true;
for (int j = 0; j < i; ++j) {
if (H[j] < H[i])
is_candidate = false;
}
if (is_candidate)
++ans;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, v.size()) {
if (i)
os << " ";
os << v[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
REP(i, v.size()) {
if (i)
os << endl;
os << v[i];
}
return os;
}
int main() {
int n;
cin >> n;
std::vector<int> H(109);
rep(i, n) cin >> H[i];
int ans = 0;
for (int i = 0; i < n; ++i) {
bool is_candidate = true;
for (int j = 0; j < i; ++j) {
if (H[j] > H[i])
is_candidate = false;
}
if (is_candidate)
++ans;
}
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,842 | 882,843 | u430974466 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int i;
int n = 0;
cin >> N;
vector<int> H(N);
int max = 0;
for (i = 0; i < N; i++) {
cin >> H.at(i);
}
for (i = 0; i < N; i++) {
if (max < H.at(i)) {
n++;
max = H.at(i);
}
}
cout << n << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int i;
int n = 0;
cin >> N;
vector<int> H(N);
int max = 0;
for (i = 0; i < N; i++) {
cin >> H.at(i);
}
for (i = 0; i < N; i++) {
if (H.at(i) >= max) {
n++;
max = H.at(i);
}
}
cout << n << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 882,846 | 882,847 | u548596361 | cpp |
p03072 | #include <bits/stdc++.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
void solve() {
int n;
vector<int> h;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
h.push_back(k);
}
int count = 0;
for (int i = 0; i < n; i++) {
bool b = true;
for (int j = 0; j < i; j++) {
if (h[j] > h[i]) {
b = false;
}
}
if (b) {
count++;
}
}
cout << count << endl;
}
int main() {
solve();
return 0;
}
| #include <bits/stdc++.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
void solve() {
int n;
cin >> n;
vector<int> h;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
h.push_back(k);
}
int count = 0;
for (int i = 0; i < n; i++) {
bool b = true;
for (int j = 0; j < i; j++) {
if (h[j] > h[i]) {
b = false;
}
}
if (b) {
count++;
}
}
cout << count << endl;
}
int main() {
solve();
return 0;
}
| [] | 882,850 | 882,851 | u272496669 | cpp |
p03072 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> mt(n);
vector<int> maxmt(n);
for (int i = 0; i < n; i++) {
cin >> mt[i];
}
maxmt[0] = mt[0];
for (int i = 1; i < n; i++) {
maxmt[i] = max(mt[i - 1], mt[i]);
}
int c;
for (int i = 0; i < n; i++) {
if (mt[i] == maxmt[i]) {
c++;
}
}
cout << c;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> mt(n);
vector<int> maxmt(n);
for (int i = 0; i < n; i++) {
cin >> mt[i];
}
maxmt[0] = mt[0];
for (int i = 1; i < n; i++) {
maxmt[i] = max(maxmt[i - 1], mt[i]);
}
int c = 0;
for (int i = 0; i < n; i++) {
if (mt[i] == maxmt[i]) {
c++;
}
}
cout << c;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"variable_declaration.value.change"
] | 882,852 | 882,853 | u544165468 | cpp |
p03072 | #include <bits/stdc++.h>
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
int main() {
speed;
int n;
int h[20];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 1;
for (int i = 1; i < n; i++) {
int count = 0;
for (int j = i - 1; j >= 0; j--) {
if (h[i] - h[j] >= 0)
count++;
else {
count = 0;
break;
}
}
if (count > 0)
ans++;
}
cout << ans << "/n";
return 0;
}
| #include <bits/stdc++.h>
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
int main() {
speed;
int n;
int h[20];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int ans = 1;
for (int i = 1; i < n; i++) {
int count = 0;
for (int j = i - 1; j >= 0; j--) {
if (h[i] - h[j] >= 0)
count++;
else {
count = 0;
break;
}
}
if (count > 0)
ans++;
}
cout << ans << endl;
return 0;
}
| [
"io.output.change"
] | 882,856 | 882,857 | u662918817 | cpp |
p03072 | #define debug_interval ','
#define dump_interval ' '
#define debug_toggle 1
//{
#include <bits/stdc++.h>
using namespace std;
#define hi cerr << "hi" << endl;
#define int long long
#define INT_MAX LLONG_MAX
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define fi first
#define se second
#define mp make_pair
#define rev reverse
#define dans dump(ans)
#define MOD 1000000007
#define amp(v, n) (v).count(n) ? v[n]++ : v[n] = 1
#define sysp system("pause")
#define PI acos(-1)
#define pf push_front
#define ins insert
//{
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();
}
template <class... A> inline void dump() { cout << endl; }
template <class... A> inline void dump_rest() { cout << endl; }
template <class T, class... A>
inline void dump_rest(const T &first, const A &...rest) {
cout << dump_interval << first;
dump_rest(rest...);
}
template <class T, class... A>
inline void dump(const T &first, const A &...rest) {
cout << first;
dump_rest(rest...);
}
template <class... A> inline void debug() { cerr << endl; }
template <class... A> inline void debug_rest() { cerr << endl; }
template <class T, class... A>
inline void debug_rest(const T &first, const A &...rest) {
cerr << debug_interval << first;
debug_rest(rest...);
}
template <class T, class... A>
inline void debug(const T &first, const A &...rest) {
if (debug_toggle)
cerr << first, debug_rest(rest...);
}
unsigned XorShift(void) {
static unsigned x = 123456789;
static unsigned y = 362436069;
static unsigned z = 521288629;
static unsigned w = 88675123;
unsigned t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
//}
typedef vector<int> vint;
typedef pair<int, int> pint;
typedef vector<pint> vpint;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
template <int m> class mint {
private:
int i;
public:
mint() : i(0) {}
mint(int i) : i((i % m + m) % m) {}
mint operator+(const mint &o) { return o.i + i; }
mint operator*(const mint &o) { return o.i * i; }
mint operator-() { return -i; }
operator int() { return i; }
};
//}
main() {
int n, ans = 0;
int h[n];
rep(i, n) cin >> h[i];
int dp = h[0];
rep(i, n) {
if (dp <= h[i]) {
ans++;
dp = h[i];
}
}
dans;
}
| #define debug_interval ','
#define dump_interval ' '
#define debug_toggle 1
//{
#include <bits/stdc++.h>
using namespace std;
#define hi cerr << "hi" << endl;
#define int long long
#define INT_MAX LLONG_MAX
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define fi first
#define se second
#define mp make_pair
#define rev reverse
#define dans dump(ans)
#define MOD 1000000007
#define amp(v, n) (v).count(n) ? v[n]++ : v[n] = 1
#define sysp system("pause")
#define PI acos(-1)
#define pf push_front
#define ins insert
//{
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();
}
template <class... A> inline void dump() { cout << endl; }
template <class... A> inline void dump_rest() { cout << endl; }
template <class T, class... A>
inline void dump_rest(const T &first, const A &...rest) {
cout << dump_interval << first;
dump_rest(rest...);
}
template <class T, class... A>
inline void dump(const T &first, const A &...rest) {
cout << first;
dump_rest(rest...);
}
template <class... A> inline void debug() { cerr << endl; }
template <class... A> inline void debug_rest() { cerr << endl; }
template <class T, class... A>
inline void debug_rest(const T &first, const A &...rest) {
cerr << debug_interval << first;
debug_rest(rest...);
}
template <class T, class... A>
inline void debug(const T &first, const A &...rest) {
if (debug_toggle)
cerr << first, debug_rest(rest...);
}
unsigned XorShift(void) {
static unsigned x = 123456789;
static unsigned y = 362436069;
static unsigned z = 521288629;
static unsigned w = 88675123;
unsigned t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
//}
typedef vector<int> vint;
typedef pair<int, int> pint;
typedef vector<pint> vpint;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
template <int m> class mint {
private:
int i;
public:
mint() : i(0) {}
mint(int i) : i((i % m + m) % m) {}
mint operator+(const mint &o) { return o.i + i; }
mint operator*(const mint &o) { return o.i * i; }
mint operator-() { return -i; }
operator int() { return i; }
};
//}
main() {
int n, ans = 0;
cin >> n;
int h[n];
rep(i, n) cin >> h[i];
int dp = h[0];
rep(i, n) {
if (dp <= h[i]) {
ans++;
dp = h[i];
}
}
dans;
}
| [] | 882,871 | 882,872 | u130196064 | cpp |
p03072 | #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 Answer = 0;
int flag = 0;
for (int i = 1; i < N; i++) {
flag = 0;
for (int j = 0; j < i; j++) {
if (H.at(i) < H.at(j)) {
flag = 1;
break;
}
}
if (flag == 0)
Answer++;
}
cout << Answer << endl;
return 0;
}
| #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 Answer = 1;
int flag = 0;
for (int i = 1; i < N; i++) {
flag = 0;
for (int j = 0; j < i; j++) {
if (H.at(i) < H.at(j)) {
flag = 1;
break;
}
}
if (flag == 0)
Answer++;
}
cout << Answer << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 882,875 | 882,876 | u031274276 | cpp |
p03072 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int maximum = 0;
int total = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > maximum) {
total++;
maximum = arr[i];
}
}
cout << total;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int maximum = 0;
int total = 0;
for (int i = 0; i < n; i++) {
if (arr[i] >= maximum) {
total++;
maximum = arr[i];
}
}
cout << total;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,897 | 882,898 | u553927381 | cpp |
p03072 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int maxv = 0;
int s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > maxv) {
maxv = a[i];
s++;
}
}
cout << s;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int maxv = 0;
int s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] >= maxv) {
maxv = a[i];
s++;
}
}
cout << s;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,901 | 882,902 | u950909548 | cpp |
p03072 | #include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
int ans = 0;
int prev = 0;
int tmp = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tmp;
if (tmp >= prev)
ans++;
prev = tmp;
}
cout << ans << endl;
}
| #include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
int ans = 0;
int prev = 0;
int tmp = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tmp;
if (tmp >= prev) {
ans++;
prev = tmp;
}
}
cout << ans << endl;
}
| [] | 882,919 | 882,920 | u785521224 | cpp |
p03072 | #include <iostream>
int n;
int a = 0, b;
int c = 0;
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> b;
if (a < b) {
a = b;
c++;
}
}
std::cout << c;
} | #include <iostream>
int n;
int a = 0, b;
int c = 0;
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> b;
if (a <= b) {
a = b;
c++;
}
}
std::cout << c;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,938 | 882,939 | u261026404 | cpp |
p03072 | #include <iostream>
int n;
// int a[30];
int a = 0, b;
int c = 1;
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> b;
if (a < b)
a = b, c++;
}
std::cout << c;
} | #include <iostream>
int n;
int a = 0, b;
int c = 0;
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> b;
if (a <= b) {
a = b;
c++;
}
}
std::cout << c;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 882,940 | 882,939 | u261026404 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.