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 |
|---|---|---|---|---|---|---|---|
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
vector<int> D(N + 1);
D[0] = 0;
int count = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
for (int i = 0; i < N; i++) {
if (D[i] <= X) {
count++;
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
vector<int> D(N + 1);
D[0] = 0;
int count = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
for (int i = 0; i <= N; i++) {
if (D[i] <= X) {
count++;
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 811,881 | 811,882 | u016183710 | cpp |
p03000 | // include
// ------------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <vector>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
// code
// ------------------------------------------------
int main() {
int n, x;
cin >> n >> x;
vi l(n);
rep(i, n) cin >> l[i];
int cnt = 0;
int d = 0;
for (int i = 1; i <= n; i++) {
d = d + l[i - 1];
// cout << d << endl;
if (d <= x)
cnt++;
}
cout << cnt;
return 0;
}
// funcの実体
// ------------------------------------------------
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
| // include
// ------------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <vector>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
// code
// ------------------------------------------------
int main() {
int n, x;
cin >> n >> x;
vi l(n);
rep(i, n) cin >> l[i];
int cnt = 0;
int d = 0;
for (int i = 1; i <= n; i++) {
d = d + l[i - 1];
// cout << d << endl;
if (d <= x)
cnt++;
}
cout << cnt + 1;
return 0;
}
// funcの実体
// ------------------------------------------------
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
| [
"expression.operation.binary.add"
] | 811,883 | 811,884 | u610897920 | cpp |
p03000 | // include
// ------------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <vector>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
// code
// ------------------------------------------------
int main() {
int n, x;
cin >> n >> x;
vi l(n);
rep(i, n) cin >> l[i];
int cnt;
int d = 0;
for (int i = 1; i <= n; i++) {
d = d + l[i - 1];
if (d <= x)
cnt++;
}
cout << cnt;
return 0;
}
// funcの実体
// ------------------------------------------------
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
| // include
// ------------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <vector>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
// code
// ------------------------------------------------
int main() {
int n, x;
cin >> n >> x;
vi l(n);
rep(i, n) cin >> l[i];
int cnt = 0;
int d = 0;
for (int i = 1; i <= n; i++) {
d = d + l[i - 1];
// cout << d << endl;
if (d <= x)
cnt++;
}
cout << cnt + 1;
return 0;
}
// funcの実体
// ------------------------------------------------
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
| [
"variable_declaration.value.change"
] | 811,885 | 811,884 | u610897920 | cpp |
p03000 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define _GLIBCXX_DEBAC
/*map<Keyの型, Valueの型> 変数名;
queue<型> 変数名;
priority_queue<型> 変数名;
priority_queue<型, vector<型>, greater<型>> 変数名;*/
// copy(v1.begin(), v1.end(), back_inserter(v2));
using namespace std;
ll gcd(ll a, ll b) {
ll c;
if (a < b) {
c = a;
a = b;
b = c;
}
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
ll lcm(ll a, ll b) {
ll c;
c = a * b / gcd(a, b);
return c;
}
int sort_greater(int m, int n) {
vector<int> a(m);
for (int i = 0; i < m; i++) {
cin >> a[i];
}
sort(a.begin(), a.end(), greater<int>());
for (int i = 0; i < n; i++) {
cout << a[i];
}
return 0;
}
int bubblesort(int a[], int n) {
int sw = 0;
bool flag = 1;
for (int i = 0; flag; i++) {
flag = 0;
for (int j = n - 1; j >= i + 1; j--) {
if (a[j] < a[j - 1]) {
swap(a[j], a[j - 1]);
flag = 1;
sw += 1;
}
}
}
return sw;
}
int a_z() {
for (int i = 0; i <= ('Z' - 'A'); i++) {
cout << (char)('A' + i);
}
return 0;
}
int selecttionsort(int a[], int n) {
int t, sw = 0, minj;
for (int i = 0; i < n - 1; i++) {
minj = i;
for (int j = 0; j < n - 1; j++) {
if (a[j] < a[minj]) {
minj = j;
}
}
t = a[i];
a[i] = a[minj];
a[minj] = t;
if (i != minj)
sw += 1;
}
return sw;
}
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
map<string, int> memo;
using P = pair<int, int>;
struct Clock {
int hour, minute, second;
void set(int h, int m, int s) {
hour = h;
minute = m;
second = s;
}
string to_str() {
string h, m, s;
h = to_string(hour);
m = to_string(minute);
s = to_string(second);
if (h.size() < 2)
h = "0" + h;
if (m.size() < 2)
m = "0" + m;
if (s.size() < 2)
s = "0" + s;
return h + ":" + m + ":" + s;
}
void shift(int diff_second) {
int h, m;
h = diff_second / 3600;
m = diff_second / 60;
diff_second %= 60;
second += diff_second;
}
};
/*void dfs(int v, int p = -1) {
for (int u : to[v]) {
if (u == p) continue;
ans[u] += ans[v];
dfs(u, v);
}
}*/
int main() {
// sort(a.begin(),a.end());
int n, x;
cin >> n >> x;
vector<int> a(n + 1);
a[0] = 0;
rep(i, n) {
int x;
cin >> x;
a[i + 1] = a[i] + x;
}
int ans = 0;
rep(i, n) {
if (a[i] <= x)
ans++;
}
cout << ans;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define _GLIBCXX_DEBAC
/*map<Keyの型, Valueの型> 変数名;
queue<型> 変数名;
priority_queue<型> 変数名;
priority_queue<型, vector<型>, greater<型>> 変数名;*/
// copy(v1.begin(), v1.end(), back_inserter(v2));
using namespace std;
ll gcd(ll a, ll b) {
ll c;
if (a < b) {
c = a;
a = b;
b = c;
}
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
ll lcm(ll a, ll b) {
ll c;
c = a * b / gcd(a, b);
return c;
}
int sort_greater(int m, int n) {
vector<int> a(m);
for (int i = 0; i < m; i++) {
cin >> a[i];
}
sort(a.begin(), a.end(), greater<int>());
for (int i = 0; i < n; i++) {
cout << a[i];
}
return 0;
}
int bubblesort(int a[], int n) {
int sw = 0;
bool flag = 1;
for (int i = 0; flag; i++) {
flag = 0;
for (int j = n - 1; j >= i + 1; j--) {
if (a[j] < a[j - 1]) {
swap(a[j], a[j - 1]);
flag = 1;
sw += 1;
}
}
}
return sw;
}
int a_z() {
for (int i = 0; i <= ('Z' - 'A'); i++) {
cout << (char)('A' + i);
}
return 0;
}
int selecttionsort(int a[], int n) {
int t, sw = 0, minj;
for (int i = 0; i < n - 1; i++) {
minj = i;
for (int j = 0; j < n - 1; j++) {
if (a[j] < a[minj]) {
minj = j;
}
}
t = a[i];
a[i] = a[minj];
a[minj] = t;
if (i != minj)
sw += 1;
}
return sw;
}
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
};
map<string, int> memo;
using P = pair<int, int>;
struct Clock {
int hour, minute, second;
void set(int h, int m, int s) {
hour = h;
minute = m;
second = s;
}
string to_str() {
string h, m, s;
h = to_string(hour);
m = to_string(minute);
s = to_string(second);
if (h.size() < 2)
h = "0" + h;
if (m.size() < 2)
m = "0" + m;
if (s.size() < 2)
s = "0" + s;
return h + ":" + m + ":" + s;
}
void shift(int diff_second) {
int h, m;
h = diff_second / 3600;
m = diff_second / 60;
diff_second %= 60;
second += diff_second;
}
};
/*void dfs(int v, int p = -1) {
for (int u : to[v]) {
if (u == p) continue;
ans[u] += ans[v];
dfs(u, v);
}
}*/
int main() {
// sort(a.begin(),a.end());
int n, x;
cin >> n >> x;
vector<int> a(n + 1);
a[0] = 0;
rep(i, n) {
int x;
cin >> x;
a[i + 1] = a[i] + x;
}
int ans = 0;
rep(i, n + 1) {
if (a[i] <= x)
ans++;
}
cout << ans;
return 0;
}
| [
"expression.operation.binary.add"
] | 811,887 | 811,888 | u545938555 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
int dist = 0;
int leap;
for (int i = 0; i < n; i++) {
cin >> leap;
dist += leap;
ans++;
if (dist > x) {
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
int dist = 0;
int leap;
for (int i = 0; i < n + 1; i++) {
cin >> leap;
dist += leap;
ans++;
if (dist > x) {
break;
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,891 | 811,892 | u176218583 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
int dist = 0;
int leap;
for (int i = 0; i < n; i++) {
cin >> leap;
dist += leap;
ans++;
if (dist >= x) {
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
int dist = 0;
int leap;
for (int i = 0; i < n + 1; i++) {
cin >> leap;
dist += leap;
ans++;
if (dist > x) {
break;
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 811,893 | 811,892 | u176218583 | cpp |
p03000 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, X, ans;
cin >> N >> X;
vector<int> L(N), D(N);
D[0] = 0;
ans = 0;
rep(i, N) cin >> L[i];
for (int i = 1; i < N; i++)
D[i] = D[i - 1] + L[i - 1];
rep(i, N)(D[i] <= X) && ans++;
cout << ans << endl;
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, X, ans;
cin >> N >> X;
vector<int> L(N), D(N + 1);
D[0] = 0;
ans = 0;
rep(i, N) cin >> L[i];
for (int i = 1; i < N + 1; i++)
D[i] = D[i - 1] + L[i - 1];
rep(i, N + 1)(D[i] <= X) && ans++;
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,894 | 811,895 | u879294842 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
using namespace std;
typedef long long ll;
int N, X;
int L[101];
int main() {
cin >> N >> X;
repn(i, N) cin >> L[i];
int ans = 0;
int dis = 0;
for (int i = 1; i <= N; i++) {
dis += L[i - 1];
if (dis <= X) {
ans++;
} else {
break;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
using namespace std;
typedef long long ll;
int N, X;
int L[105];
int main() {
cin >> N >> X;
repn(i, N) cin >> L[i];
int ans = 0;
int dis = 0;
for (int i = 1; i <= N + 1; i++) {
dis += L[i - 1];
if (dis <= X) {
ans++;
} else {
break;
}
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,901 | 811,902 | u731886385 | cpp |
p03000 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip>
#include <iostream> // cout, endl, cin
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define ll long long
using vt = ll; //ここで数値の型を変えられる
#define rep(i, n) for (vt i = 0; i < (vt)(n); i++)
#define reps(i, s, n) for (vt i = (vt)(s); i < (vt)(n); i++)
#define all(v) v.begin(), v.end()
#define P pair<int, int>
const ll MOD = 1000000007;
int main() {
ll n, x;
cin >> n >> x;
vector<ll> l(n);
rep(i, n) cin >> l.at(i);
ll d = 0, ans = 0;
rep(i, n) {
d += l.at(i);
if (d <= x) {
ans++;
}
}
cout << ans;
return 0;
} | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip>
#include <iostream> // cout, endl, cin
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define ll long long
using vt = ll; //ここで数値の型を変えられる
#define rep(i, n) for (vt i = 0; i < (vt)(n); i++)
#define reps(i, s, n) for (vt i = (vt)(s); i < (vt)(n); i++)
#define all(v) v.begin(), v.end()
#define P pair<int, int>
const ll MOD = 1000000007;
int main() {
ll n, x;
cin >> n >> x;
vector<ll> l(n);
rep(i, n) cin >> l.at(i);
ll d = 0, ans = 1;
rep(i, n) {
d += l.at(i);
if (d <= x) {
ans++;
} else
break;
}
cout << ans;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 811,911 | 811,912 | u822725754 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, n) for (int i = 1; i <= (n); i++)
int main() {
int n, x, ans = 1, d = 0;
cin >> n;
vector<int> l(n);
rep(i, n) cin >> l[i];
rep(i, n) {
d += l[i];
if (d <= x)
ans++;
}
cout << ans;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, n) for (int i = 1; i <= (n); i++)
int main() {
int n, x, ans = 1, d = 0;
cin >> n >> x;
vector<int> l(n);
rep(i, n) cin >> l[i];
rep(i, n) {
d += l[i];
if (d <= x)
ans++;
}
cout << ans;
return 0;
} | [
"expression.operation.binary.add"
] | 811,921 | 811,922 | u088751997 | cpp |
p03000 | #include <iostream>
using namespace std;
void _130() {
int n, x;
int l[100];
cin >> n >> x;
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
int d = 0;
for (int i = 0; i < n; ++i) {
d = d + l[i];
// cout << d << endl;
if (d > x) {
cout << i + 1 << endl;
return;
}
}
cout << n << endl;
}
int main() {
_130();
return 0;
}
| #include <iostream>
using namespace std;
void _130() {
int n, x;
int l[100];
cin >> n >> x;
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
int d = 0;
for (int i = 0; i < n; ++i) {
d = d + l[i];
// cout << d << endl;
if (d > x) {
cout << i + 1 << endl;
return;
}
}
cout << n + 1 << endl;
}
int main() {
_130();
return 0;
}
| [
"expression.operation.binary.add"
] | 811,933 | 811,934 | u243740419 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int Y = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
if (Y > X) {
break;
}
int L;
cin >> L;
ans++;
Y += L;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int Y = 0;
int ans = 0;
for (int i = 0; i <= N; i++) {
if (Y > X) {
break;
}
int L;
cin >> L;
ans++;
Y += L;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 811,935 | 811,936 | u280120599 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> D(110, 0), L(110, 0);
for (int i = 0; i < n; i++) {
cin >> L[i];
D[i + 1] = D[i] + L[i];
}
int ans = 0;
for (int i = 0; i < n && D[i] <= x; i++) {
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> D(110, 0), L(110, 0);
for (int i = 0; i < n; i++) {
cin >> L[i];
D[i + 1] = D[i] + L[i];
}
int ans = 0;
for (int i = 0; i < n + 1 && D[i] <= x; i++) {
ans++;
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,942 | 811,943 | u756208532 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[n];
for (int i = 0; i < n; i++) {
cin >> l[i];
}
int d = l[0];
int c = 1;
while (d <= x) {
d += l[c];
c++;
}
cout << c << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[n];
for (int i = 0; i < n; i++) {
cin >> l[i];
}
int d = l[0];
int c = 1;
while (d <= x && c < n + 1) {
d += l[c];
c++;
}
cout << c << endl;
} | [
"control_flow.loop.condition.change"
] | 811,946 | 811,947 | u765815947 | cpp |
p03000 | #include <bits/stdc++.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define rep(I, N) for (int I = 1; I <= (N); ++I)
#define repp(I, N) for (int I = 0; I < (N); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORR(I, A, B) for (int I = (A); I >= (B); I--)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-7;
const int mod = 1e9 + 7;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
LL a[N], d[N];
int main() {
LL n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++)
cin >> a[i];
d[1] = 0;
for (int i = 2; i <= n; i++)
d[i] = a[i - 1] + d[i - 1];
int ans = 0;
for (int i = 1; i <= n; i++) {
if (d[i] <= x)
ans++;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define rep(I, N) for (int I = 1; I <= (N); ++I)
#define repp(I, N) for (int I = 0; I < (N); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORR(I, A, B) for (int I = (A); I >= (B); I--)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-7;
const int mod = 1e9 + 7;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
LL a[N], d[N];
int main() {
LL n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++)
cin >> a[i];
d[1] = 0;
for (int i = 2; i <= n + 1; i++)
d[i] = a[i - 1] + d[i - 1];
int ans = 0;
for (int i = 1; i <= n + 1; i++) {
if (d[i] <= x)
ans++;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,952 | 811,953 | u842262709 | cpp |
p03000 | #include <bits/stdc++.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define rep(I, N) for (int I = 1; I <= (N); ++I)
#define repp(I, N) for (int I = 0; I < (N); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORR(I, A, B) for (int I = (A); I >= (B); I--)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-7;
const int mod = 1e9 + 7;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
int a[N], d[N];
int main() {
int n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++)
cin >> a[i];
d[1] = 0;
for (int i = 2; i <= n; i++)
d[i] = a[i - 1] + d[i - 1];
int ans = 0;
for (int i = 1; i <= n; i++) {
if (d[i] <= x)
ans++;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define rep(I, N) for (int I = 1; I <= (N); ++I)
#define repp(I, N) for (int I = 0; I < (N); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORR(I, A, B) for (int I = (A); I >= (B); I--)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-7;
const int mod = 1e9 + 7;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
LL a[N], d[N];
int main() {
LL n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++)
cin >> a[i];
d[1] = 0;
for (int i = 2; i <= n + 1; i++)
d[i] = a[i - 1] + d[i - 1];
int ans = 0;
for (int i = 1; i <= n + 1; i++) {
if (d[i] <= x)
ans++;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,954 | 811,953 | u842262709 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n, x;
cin >> n >> x;
vector<int> ls(n);
for (int i = 0; i < n; i++) {
cin >> ls[i];
}
int d = 0, cnt = 1;
for (int i = 0; i < n + 1; i++) {
d = d + ls[cnt - 1];
if (d > x) {
break;
}
cnt++;
}
cout << cnt << "\n";
} | #include <iostream>
#include <vector>
using namespace std;
int main(int argc, const char *argv[]) {
int n, x;
cin >> n >> x;
vector<int> ls(n);
for (int i = 0; i < n; i++) {
cin >> ls[i];
}
int d = 0, cnt = 1;
for (int i = 0; i < n; i++) {
d = d + ls[i];
if (d > x) {
break;
}
cnt++;
}
cout << cnt << "\n";
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 811,959 | 811,960 | u289545075 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef pair<ll, ll> pair_t;
using Graph = vector<vector<ll>>;
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
/***** define constant start *******/
const ll MOD = 1000000007;
const double PI = 3.1415926535897932;
const ll INF = 1 << 29;
/****** define constant end ********/
/****** define variable start ******/
ll n, x;
vl l;
/******* define variable end *******/
ll solve() {
cin >> n >> x;
l.resize(n);
REP(i, n) { cin >> l[i]; }
vl sum(n + 1);
sum[0] = 0;
REP(i, n) { sum[i + 1] = sum[i] + l[i]; }
ll ans = 0;
REP(i, n) {
if (sum[i] > x) {
cout << ans << endl;
return 0;
}
ans++;
}
cout << ans << endl;
return 0;
}
int main() {
// clock_t start = clock();
cout << std::fixed << std::setprecision(10);
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll end_solve = solve();
/*
clock_t end = clock();
const double time = static_cast<double>(end - start) / CLOCKS_PER_SEC *
1000.0; printf("time %lf[ms]\n", time);
*/
return (int)end_solve;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef pair<ll, ll> pair_t;
using Graph = vector<vector<ll>>;
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
/***** define constant start *******/
const ll MOD = 1000000007;
const double PI = 3.1415926535897932;
const ll INF = 1 << 29;
/****** define constant end ********/
/****** define variable start ******/
ll n, x;
vl l;
/******* define variable end *******/
ll solve() {
cin >> n >> x;
l.resize(n);
REP(i, n) { cin >> l[i]; }
vl sum(n + 1);
sum[0] = 0;
REP(i, n) { sum[i + 1] = sum[i] + l[i]; }
ll ans = 0;
REP(i, n + 1) {
if (sum[i] > x) {
cout << ans << endl;
return 0;
}
ans++;
}
cout << ans << endl;
return 0;
}
int main() {
// clock_t start = clock();
cout << std::fixed << std::setprecision(10);
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll end_solve = solve();
/*
clock_t end = clock();
const double time = static_cast<double>(end - start) / CLOCKS_PER_SEC *
1000.0; printf("time %lf[ms]\n", time);
*/
return (int)end_solve;
}
| [
"expression.operation.binary.add"
] | 811,961 | 811,962 | u313994303 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[n];
rep(i, n) {
cin >> l[i];
x -= l[i];
if (x < 0) {
cout << i + 1;
return 0;
}
}
cout << n;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[n];
rep(i, n) {
cin >> l[i];
x -= l[i];
if (x < 0) {
cout << i + 1;
return 0;
}
}
cout << n + 1;
} | [
"expression.operation.binary.add"
] | 811,966 | 811,967 | u018372223 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int L[N];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
int d[N + 1];
int count = 0;
for (int i = 1; i <= N; i++) {
d[i] = d[i - 1] + L[i - 1];
if (d[i] > X) {
break;
} else
count++;
}
cout << count;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int L[N];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
int d[N + 1] = {0};
int count = 1;
for (int i = 1; i <= N; i++) {
d[i] = d[i - 1] + L[i - 1];
if (d[i] > X) {
break;
} else
count++;
}
cout << count;
}
| [
"variable_declaration.value.change",
"literal.number.change"
] | 811,972 | 811,971 | u109191542 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <iomanip> //doubleの桁数指定
#include <iostream>
#include <list> //前後に数値を入れれる配列
#include <map> //map
#include <string> //文字列
#include <vector> //vecror
#define REP(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++) // forの短縮
#define rep(i, n) REP(i, 0, n) // REPが0の時
#define ll long long int
using namespace std;
double PI = 3.141592653589793; //円周率
//常設関数↓
//最大公約数
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//最小公倍数
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
// degree → radian
ll chg_DegRad(int deg) { return deg * PI / 180.0; }
// radian → degree
ll chg_RadDeg(int rad) { return rad * 180.0 / PI; }
//距離
double dis(double xa, double ya, double xb, double yb) {
return pow(pow(xa - xb, 2.0) + pow(ya - yb, 2.0), 0.5);
}
//提出コード↓
int n, x, L[110], D, c;
int main() {
cin >> n >> x;
rep(i, n) cin >> L[i];
rep(i, n) {
if (D > x)
break;
D += L[i];
c++;
}
cout << c << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip> //doubleの桁数指定
#include <iostream>
#include <list> //前後に数値を入れれる配列
#include <map> //map
#include <string> //文字列
#include <vector> //vecror
#define REP(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++) // forの短縮
#define rep(i, n) REP(i, 0, n) // REPが0の時
#define ll long long int
using namespace std;
double PI = 3.141592653589793; //円周率
//常設関数↓
//最大公約数
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//最小公倍数
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
// degree → radian
ll chg_DegRad(int deg) { return deg * PI / 180.0; }
// radian → degree
ll chg_RadDeg(int rad) { return rad * 180.0 / PI; }
//距離
double dis(double xa, double ya, double xb, double yb) {
return pow(pow(xa - xb, 2.0) + pow(ya - yb, 2.0), 0.5);
}
//提出コード↓
int n, x, L[110], D, c;
int main() {
cin >> n >> x;
rep(i, n) cin >> L[i];
rep(i, n + 1) {
if (D > x)
break;
D += L[i];
c++;
}
cout << c << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 811,975 | 811,976 | u751428191 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
int ans = 0, sum = 0;
for (int i = 0; i < n && sum <= x; ++i) {
int y;
cin >> y;
sum += y;
++ans;
}
cout << ans;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
int ans = 0, sum = 0;
for (int i = 0; i <= n && sum <= x; ++i) {
int y;
cin >> y;
sum += y;
++ans;
}
cout << ans;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 811,977 | 811,978 | u505466816 | cpp |
p03000 | #include <iostream>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, x, ans = 0, sum = 0;
cin >> n >> x;
REP(i, n) {
int y;
cin >> y;
sum += y;
ans += sum <= x;
}
cout << ans;
}
| #include <iostream>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, x, ans = 0, sum = 0;
cin >> n >> x;
REP(i, n) {
int y;
cin >> y;
sum += y;
ans += (sum <= x);
}
cout << ans + 1;
}
| [
"expression.operation.binary.add"
] | 811,979 | 811,980 | u505466816 | cpp |
p03000 |
#include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
int main(void) {
int N, X;
cin >> N >> X;
vector<int> L(N + 1, 0);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
vector<int> D(N + 1, 0);
for (int i = 1; i < N + 1; i++) {
D.at(i) = D.at(i - 1) + L.at(i - 1);
// cout << D.at(i) << endl;
}
int counter = 0;
for (int i = 0; i < N; i++) {
if (D.at(i) <= X)
counter++;
}
cout << counter << endl;
return (0);
} | #include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
int main(void) {
int N, X;
cin >> N >> X;
vector<int> L(N + 1, 0);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
vector<int> D(N + 1, 0);
for (int i = 1; i < N + 1; i++) {
D.at(i) = D.at(i - 1) + L.at(i - 1);
// cout << D.at(i) << endl;
}
int counter = 0;
for (int i = 0; i < N + 1; i++) {
if (D.at(i) <= X)
counter++;
}
cout << counter << endl;
return (0);
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 811,992 | 811,993 | u027946359 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, D = 0, count = 1;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++)
cin >> L.at(i);
for (int i = 1; i < N; i++) {
D += L.at(i);
if (D <= X)
count++;
else
break;
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, D = 0, count = 1;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++)
cin >> L.at(i);
for (int i = 0; i < N; i++) {
D += L.at(i);
if (D <= X)
count++;
else
break;
}
cout << count << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 811,998 | 811,999 | u485673106 | cpp |
p03000 | #include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int count = 0, D = 0;
for (int i = 0; i < N; ++i) {
int L;
cin >> L;
D += L;
if (D < X)
++count;
else
break;
}
cout << count << endl;
} | #include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int count = 1, D = 0;
for (int i = 0; i < N; ++i) {
int L;
cin >> L;
D += L;
if (D <= X)
++count;
else
break;
}
cout << count << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,000 | 812,001 | u323542775 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
int count = 0;
int bounce = 0;
while (count <= N - 1 && bounce <= X) {
bounce += L.at(count);
count++;
}
if (count == N - 1) {
cout << count + 1 << endl;
}
else {
cout << count << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
int count = 0;
int bounce = 0;
while (count <= N - 1 && bounce <= X) {
bounce += L.at(count);
count++;
}
if (bounce <= X) {
cout << count + 1 << endl;
}
else {
cout << count << endl;
}
}
| [
"expression.operation.binary.remove"
] | 812,002 | 812,003 | u629548179 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
int count = 0;
int bounce = 0;
while (count <= N - 1 && bounce <= X) {
bounce += L.at(count);
count++;
}
if (count == N - 1) {
cout << N + 1 << endl;
} else {
cout << count << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
int count = 0;
int bounce = 0;
while (count <= N - 1 && bounce <= X) {
bounce += L.at(count);
count++;
}
if (bounce <= X) {
cout << count + 1 << endl;
}
else {
cout << count << endl;
}
}
| [
"expression.operation.binary.remove",
"identifier.change",
"io.output.change"
] | 812,004 | 812,003 | u629548179 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int N, X, L[100];
cin >> N >> X;
rep(i, N) cin >> L[i];
int diff = 0, norm = 1;
rep(i, N + 1) {
diff += L[i];
if (diff > X)
break;
// diff += L[i];
norm++;
}
cout << norm << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int N, X, L[100];
cin >> N >> X;
rep(i, N) cin >> L[i];
int diff = 0, norm = 1;
rep(i, N) {
diff += L[i];
if (diff > X)
break;
// diff += L[i];
norm++;
}
cout << norm << endl;
}
| [
"expression.operation.binary.remove"
] | 812,007 | 812,008 | u258108378 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[100];
int sum = 0;
int cnt = 1;
rep(i, n) {
cin >> l[i];
if (sum <= x) {
sum += l[i];
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[100];
int sum = 0;
int cnt = 0;
rep(i, n + 1) {
cin >> l[i];
if (sum <= x) {
sum += l[i];
cnt++;
}
}
cout << cnt << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,011 | 812,012 | u745267317 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[100];
int sum = 0;
int cnt = 0;
rep(i, n) {
cin >> l[i];
if (sum <= x) {
sum += l[i];
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[100];
int sum = 0;
int cnt = 0;
rep(i, n + 1) {
cin >> l[i];
if (sum <= x) {
sum += l[i];
cnt++;
}
}
cout << cnt << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,013 | 812,012 | u745267317 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int pos = 0;
int ans = 1;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
pos += L;
if (L <= X)
ans++;
}
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int pos = 0;
int ans = 1;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
pos += L;
if (pos <= X)
ans++;
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 812,015 | 812,016 | u016119075 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
int sum = 0;
for (int i = 0; i < n; ++i) {
int l;
cin >> l;
if (sum <= x) {
++ans;
}
sum += l;
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
int sum = 0;
for (int i = 0; i < n; ++i) {
int l;
cin >> l;
if (sum + l <= x) {
++ans;
}
sum += l;
}
cout << ans + 1 << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 812,019 | 812,020 | u497552697 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int main() {
int N, X;
cin >> N >> X;
int D = 0;
int count = 0;
vector<int> l(N);
for (int i = 0; i < N; i++) {
cin >> l.at(i);
}
for (int i = 0; i < N; i++) {
if (i == 0) {
count++;
} else {
D = D + l.at(i - 1);
if (D <= X) {
count++;
} else {
break;
}
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int main() {
int N, X;
cin >> N >> X;
int D = 0;
int count = 0;
vector<int> l(N);
for (int i = 0; i < N; i++) {
cin >> l.at(i);
}
for (int i = 0; i < N + 1; i++) {
if (i == 0) {
count++;
} else {
D = D + l.at(i - 1);
if (D <= X) {
count++;
} else {
break;
}
}
}
cout << count << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,021 | 812,022 | u537507471 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, x, l, count = 0;
cin >> n >> x;
int point = 0;
for (int i = 1; i <= n; i++) {
if (i != 1) {
cin >> l;
point += l;
}
if (point <= x) {
count++;
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, x, l, count = 0;
cin >> n >> x;
int point = 0;
for (int i = 1; i <= n + 1; i++) {
if (i != 1) {
cin >> l;
point += l;
}
if (point <= x) {
count++;
}
}
cout << count << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,025 | 812,026 | u485821416 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, x;
cin >> n >> x;
vector<int> l(n + 2);
vector<int> d(n + 2);
for (int i = 1; i <= n; ++i)
cin >> l[i];
l[1] = 0;
d[1] = 0;
for (int i = 2; i <= n + 1; ++i) {
d[i] = d[i - 1] + l[i - 1];
}
int counter = 0;
for (int i = 2; i <= n + 1; ++i) {
if (d[i] <= x)
++counter;
}
cout << counter << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, x;
cin >> n >> x;
vector<int> l(n + 2);
vector<int> d(n + 2);
for (int i = 1; i <= n + 1; ++i)
cin >> l[i];
l[0] = 0;
d[0] = 0;
for (int i = 1; i <= n + 1; ++i) {
d[i] = d[i - 1] + l[i - 1];
}
int counter = 0;
for (int i = 1; i <= n + 1; ++i) {
if (d[i] <= x)
++counter;
}
cout << counter << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,027 | 812,028 | u699111690 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, L;
cin >> N >> X;
int D = 0;
int ans = 1;
for (int i = 0; i <= N; i++) {
cin >> L;
D += L;
if (D >= X)
break;
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, L;
cin >> N >> X;
int D = 0;
int ans = 1;
for (int i = 0; i < N; i++) {
cin >> L;
D += L;
if (D > X)
break;
ans++;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 812,031 | 812,032 | u455876837 | cpp |
p03000 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define rep(i, a, b) for (long long i = (a); (i) < (b); (i)++)
#define all(i) i.begin(), i.end()
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail> void debug_out(Head h, Tail... t) {
std::cerr << " " << h;
debug_out(t...);
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &os, std::pair<T1, T2> pa) {
return os << pa.first << " " << pa.second;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, std::vector<T> vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
long long pow_mod(long long a, long long b, long long mod = -1) {
if (b == 0)
return 1;
if ((a == 0) || (mod != -1 && (a + mod) % mod == 0))
return 0;
long long x = 1;
while (b > 0) {
if (b & 1)
x = (mod != -1) ? (x * a) % mod : x * a;
a = (mod != -1) ? (a * a) % mod : a * a;
b >>= 1;
}
return x;
}
// const long long MOD = 998244353;
const long long MOD = 1e9 + 7;
using ll = long long;
using P = std::pair<long long, long long>;
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
ll n, x;
std::cin >> n >> x;
std::vector<ll> l(n);
rep(i, 0, n) std::cin >> l[i];
ll sum = 0, cnt = 0;
while (sum <= x) {
cnt++;
if (cnt <= n)
sum += l[cnt];
else
break;
}
std::cout << cnt << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#define rep(i, a, b) for (long long i = (a); (i) < (b); (i)++)
#define all(i) i.begin(), i.end()
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail> void debug_out(Head h, Tail... t) {
std::cerr << " " << h;
debug_out(t...);
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &os, std::pair<T1, T2> pa) {
return os << pa.first << " " << pa.second;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, std::vector<T> vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
long long pow_mod(long long a, long long b, long long mod = -1) {
if (b == 0)
return 1;
if ((a == 0) || (mod != -1 && (a + mod) % mod == 0))
return 0;
long long x = 1;
while (b > 0) {
if (b & 1)
x = (mod != -1) ? (x * a) % mod : x * a;
a = (mod != -1) ? (a * a) % mod : a * a;
b >>= 1;
}
return x;
}
// const long long MOD = 998244353;
const long long MOD = 1e9 + 7;
using ll = long long;
using P = std::pair<long long, long long>;
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
ll n, x;
std::cin >> n >> x;
std::vector<ll> l(n);
rep(i, 0, n) std::cin >> l[i];
ll sum = 0, cnt = 0;
while (sum <= x) {
cnt++;
if (cnt <= n)
sum += l[cnt - 1];
else
break;
}
std::cout << cnt << "\n";
return 0;
}
| [
"assignment.change"
] | 812,040 | 812,041 | u080318287 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int boundCount = 1;
int prevD = 0;
for (int i = 0; i < n; ++i) {
int input;
cin >> input;
int boundD = prevD + input;
if (boundD <= x) {
++boundCount;
prevD = boundD;
}
}
cout << boundCount << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int boundCount = 1;
int prevD = 0;
for (int i = 0; i < n; ++i) {
int input;
cin >> input;
int boundD = prevD + input;
if (boundD <= x) {
++boundCount;
}
prevD = boundD;
}
cout << boundCount << endl;
} | [] | 812,042 | 812,043 | u584797714 | cpp |
p03000 | #include <bits/stdc++.h>
#define ford(i, a, b) for (int i = (a); i >= b; i--)
#define rep(i, a, b) for (int i = (a); (i) <= (b); (i)++)
#define ll long long
#define re return
#define mp map<int, int>
using namespace std;
int ans = 0, cnt = 0, n, x;
int main() {
cin >> n >> x;
rep(i, 1, n) {
int a;
cin >> a;
cnt += a;
if (cnt > x)
break;
ans++;
}
cout << ans;
re 0;
}
| #include <bits/stdc++.h>
#define ford(i, a, b) for (int i = (a); i >= b; i--)
#define rep(i, a, b) for (int i = (a); (i) <= (b); (i)++)
#define ll long long
#define re return
#define mp map<int, int>
using namespace std;
int ans = 1, cnt = 0, n, x;
int main() {
cin >> n >> x;
rep(i, 1, n) {
int a;
cin >> a;
cnt += a;
if (cnt > x)
break;
ans++;
}
cout << ans;
re 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,056 | 812,057 | u796123030 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> vec(n);
int sum = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
sum += vec.at(i);
if (sum <= x) {
ans++;
} else
break;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> vec(n);
int sum = 0;
int ans = 1;
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
sum += vec.at(i);
if (sum <= x) {
ans++;
} else
break;
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,060 | 812,061 | u873762144 | cpp |
p03000 | //{{{
#include <bits/stdc++.h>
using namespace std;
#define repX(a, b, c, x, ...) x
#define repN(a) repX a
#define rep(...) repN((__VA_ARGS__, rep3, rep2, loop))(__VA_ARGS__)
#define rrep(...) repN((__VA_ARGS__, rrep3, rrep2))(__VA_ARGS__)
#define loop(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, begin, end) \
for (int i = (int)(begin), i##_end = (int)(end); i < i##_end; ++i)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, begin, end) \
for (int i = (int)(end - 1), i##_end = (int)(begin); i >= i##_end; --i)
#define foreach(x, a) for (auto &x : a)
#define each(x, a) for (auto &x : a)
template <class T> void Sort(T &a) { sort(a.begin(), a.end()); }
template <class T, class Compare> void Sort(T &a, Compare comp) {
sort(a.begin(), a.end(), comp);
}
template <class T> void Reverse(T &a) { reverse(a.begin(), a.end()); }
using ll = long long;
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &j) {
o << "{" << j.first << ", " << j.second << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &j) {
o << "{";
for (auto t = j.begin(); t != j.end(); ++t)
o << (t != j.begin() ? ", " : "") << *t;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &j) {
o << "{";
for (auto t = j.begin(); t != j.end(); ++t)
o << (t != j.begin() ? ", " : "") << *t;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const multiset<T> &j) {
o << "{";
for (auto t = j.begin(); t != j.end(); ++t)
o << (t != j.begin() ? ", " : "") << *t;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &j) {
o << "{";
for (int i = 0; i < (int)j.size(); ++i)
o << (i > 0 ? ", " : "") << j[i];
o << "}";
return o;
}
#ifdef LOCAL
inline void dump(void) { cerr << endl; }
template <class Head, class... Tail>
inline void dump(Head &&head, Tail &&...tail) {
cerr << head << " ";
dump(tail...);
}
#define debug(...) \
do { \
cerr << "[L." << __LINE__ << "]\t" << #__VA_ARGS__ << "="; \
dump(__VA_ARGS__); \
} while (0)
#else
#define dump(...)
#define debug(...)
#endif
template <class T, class U> inline bool chmax(T &a, U b) {
return (b > a) ? (a = b, true) : false;
}
template <class T, class U> inline bool chmin(T &a, U b) {
return (b < a) ? (a = b, true) : false;
}
struct IoSetup {
IoSetup() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
};
} ioSetup;
class in {
int n;
public:
in() {}
in(int n_) : n(n_){};
template <class T> operator T() {
T ret;
cin >> ret;
return ret;
}
template <class T> operator vector<T>() {
vector<T> ret(n);
for (int i = 0; i < n; i++)
cin >> ret[i];
return ret;
}
};
template <class T> void print(const T &a) { cout << a; }
void out() { cout << '\n'; }
template <class T> void out(const T &t) {
print(t);
cout << '\n';
}
template <class Head, class... Tail>
void out(const Head &head, const Tail &...tail) {
print(head);
cout << " ";
out(tail...);
}
template <std::uint_fast64_t Mod> class Modular {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr Modular(const u64 x = 0) noexcept : a(x % Mod) {}
constexpr u64 val() const noexcept { return a; }
constexpr Modular operator+(const Modular rhs) const noexcept {
return Modular(*this) += rhs;
}
constexpr Modular operator-(const Modular rhs) const noexcept {
return Modular(*this) -= rhs;
}
constexpr Modular operator*(const Modular rhs) const noexcept {
return Modular(*this) *= rhs;
}
constexpr Modular operator/(const Modular rhs) const noexcept {
return Modular(*this) /= rhs;
}
constexpr bool operator==(const Modular rhs) const noexcept {
return Modular(*this).val() == rhs.val();
}
Modular &operator+=(const Modular rhs) noexcept {
a += rhs.a;
if (a >= Mod)
a -= Mod;
return *this;
}
Modular &operator-=(const Modular rhs) noexcept {
if (a < rhs.a)
a += Mod;
a -= rhs.a;
return *this;
}
Modular &operator++() noexcept { return *this += 1; }
Modular &operator--() noexcept { return *this -= 1; }
Modular &operator*=(const Modular rhs) noexcept {
a = a * rhs.a % Mod;
return *this;
}
Modular &operator/=(Modular rhs) noexcept {
u64 exp = Mod - 2;
while (exp) {
if (exp % 2)
*this *= rhs;
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
template <std::uint_fast64_t Mod>
ostream &operator<<(ostream &os, const Modular<Mod> &m) {
return os << m.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; }
const double pi = acos(-1);
const double eps = 1e-9;
const ll inf = 1001001001;
const ll mod = (ll)1e9 + 7;
using mint = Modular<mod>;
//}}}
int main() {
int N = in();
int X = in();
vector<int> L = in();
int sum = 0;
int ans = 1;
rep(i, N) {
sum += L[i];
if (sum <= X)
ans++;
}
out(ans);
}
| //{{{
#include <bits/stdc++.h>
using namespace std;
#define repX(a, b, c, x, ...) x
#define repN(a) repX a
#define rep(...) repN((__VA_ARGS__, rep3, rep2, loop))(__VA_ARGS__)
#define rrep(...) repN((__VA_ARGS__, rrep3, rrep2))(__VA_ARGS__)
#define loop(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, begin, end) \
for (int i = (int)(begin), i##_end = (int)(end); i < i##_end; ++i)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, begin, end) \
for (int i = (int)(end - 1), i##_end = (int)(begin); i >= i##_end; --i)
#define foreach(x, a) for (auto &x : a)
#define each(x, a) for (auto &x : a)
template <class T> void Sort(T &a) { sort(a.begin(), a.end()); }
template <class T, class Compare> void Sort(T &a, Compare comp) {
sort(a.begin(), a.end(), comp);
}
template <class T> void Reverse(T &a) { reverse(a.begin(), a.end()); }
using ll = long long;
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &j) {
o << "{" << j.first << ", " << j.second << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &j) {
o << "{";
for (auto t = j.begin(); t != j.end(); ++t)
o << (t != j.begin() ? ", " : "") << *t;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &j) {
o << "{";
for (auto t = j.begin(); t != j.end(); ++t)
o << (t != j.begin() ? ", " : "") << *t;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const multiset<T> &j) {
o << "{";
for (auto t = j.begin(); t != j.end(); ++t)
o << (t != j.begin() ? ", " : "") << *t;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &j) {
o << "{";
for (int i = 0; i < (int)j.size(); ++i)
o << (i > 0 ? ", " : "") << j[i];
o << "}";
return o;
}
#ifdef LOCAL
inline void dump(void) { cerr << endl; }
template <class Head, class... Tail>
inline void dump(Head &&head, Tail &&...tail) {
cerr << head << " ";
dump(tail...);
}
#define debug(...) \
do { \
cerr << "[L." << __LINE__ << "]\t" << #__VA_ARGS__ << "="; \
dump(__VA_ARGS__); \
} while (0)
#else
#define dump(...)
#define debug(...)
#endif
template <class T, class U> inline bool chmax(T &a, U b) {
return (b > a) ? (a = b, true) : false;
}
template <class T, class U> inline bool chmin(T &a, U b) {
return (b < a) ? (a = b, true) : false;
}
struct IoSetup {
IoSetup() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
};
} ioSetup;
class in {
int n;
public:
in() {}
in(int n_) : n(n_){};
template <class T> operator T() {
T ret;
cin >> ret;
return ret;
}
template <class T> operator vector<T>() {
vector<T> ret(n);
for (int i = 0; i < n; i++)
cin >> ret[i];
return ret;
}
};
template <class T> void print(const T &a) { cout << a; }
void out() { cout << '\n'; }
template <class T> void out(const T &t) {
print(t);
cout << '\n';
}
template <class Head, class... Tail>
void out(const Head &head, const Tail &...tail) {
print(head);
cout << " ";
out(tail...);
}
template <std::uint_fast64_t Mod> class Modular {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr Modular(const u64 x = 0) noexcept : a(x % Mod) {}
constexpr u64 val() const noexcept { return a; }
constexpr Modular operator+(const Modular rhs) const noexcept {
return Modular(*this) += rhs;
}
constexpr Modular operator-(const Modular rhs) const noexcept {
return Modular(*this) -= rhs;
}
constexpr Modular operator*(const Modular rhs) const noexcept {
return Modular(*this) *= rhs;
}
constexpr Modular operator/(const Modular rhs) const noexcept {
return Modular(*this) /= rhs;
}
constexpr bool operator==(const Modular rhs) const noexcept {
return Modular(*this).val() == rhs.val();
}
Modular &operator+=(const Modular rhs) noexcept {
a += rhs.a;
if (a >= Mod)
a -= Mod;
return *this;
}
Modular &operator-=(const Modular rhs) noexcept {
if (a < rhs.a)
a += Mod;
a -= rhs.a;
return *this;
}
Modular &operator++() noexcept { return *this += 1; }
Modular &operator--() noexcept { return *this -= 1; }
Modular &operator*=(const Modular rhs) noexcept {
a = a * rhs.a % Mod;
return *this;
}
Modular &operator/=(Modular rhs) noexcept {
u64 exp = Mod - 2;
while (exp) {
if (exp % 2)
*this *= rhs;
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
template <std::uint_fast64_t Mod>
ostream &operator<<(ostream &os, const Modular<Mod> &m) {
return os << m.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; }
const double pi = acos(-1);
const double eps = 1e-9;
const ll inf = 1001001001;
const ll mod = (ll)1e9 + 7;
using mint = Modular<mod>;
//}}}
int main() {
int N = in();
int X = in();
vector<int> L = in(N);
int sum = 0;
int ans = 1;
rep(i, N) {
sum += L[i];
if (sum <= X)
ans++;
}
out(ans);
}
| [
"call.arguments.change"
] | 812,066 | 812,067 | u899220667 | cpp |
p03000 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<string, int>> vpsi;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define STI(s) atoi(s.c_str())
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int P = 1000000007;
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
//////////////////////////////////////////////////////
int n, x;
cin >> n >> x;
int l;
int d = 0;
int ans = 0;
rep(i, n) {
cin >> l;
d += l;
if (d <= x)
ans++;
}
fin(ans);
//////////////////////////////////////////////////////
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<string, int>> vpsi;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define STI(s) atoi(s.c_str())
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int P = 1000000007;
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
//////////////////////////////////////////////////////
int n, x;
cin >> n >> x;
int l;
int d = 0;
int ans = 1;
rep(i, n) {
cin >> l;
d += l;
if (d <= x)
ans++;
}
fin(ans);
//////////////////////////////////////////////////////
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,070 | 812,071 | u228475480 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> x >> n;
vector<int> d(n + 1);
d[0] = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
d[i + 1] = d[i] + x;
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (d[i] <= x) {
ans++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> d(n + 1);
d[0] = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
d[i + 1] = d[i] + x;
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (d[i] <= x) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 812,072 | 812,073 | u227722533 | cpp |
p03000 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define ALL(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800 / 2
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy8[8] = {0, 1, 0, -1, 1, 1, -1, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
bool issame(int x, int y) { return root(x) == root(y); }
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<ll> enum_div(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
// グラフセット
struct Edge {
ll to; // 辺の行き先
ll weight; // 辺の重み
Edge(int t, int w) : to(t), weight(w) {}
};
// using Graph = vector<vector<Edge>>;
using Graph = vector<vector<int>>;
int main() {
ll N, X;
cin >> N >> X;
ll L[N];
ll ans = 0;
ll m = 0;
FOR(i, 0, N - 1) {
cin >> L[i];
m += L[i];
if (m <= X)
ans++;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define ALL(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800 / 2
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy8[8] = {0, 1, 0, -1, 1, 1, -1, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
bool issame(int x, int y) { return root(x) == root(y); }
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to) {
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty()) {
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos) {
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<ll> enum_div(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[]) {
int i, j;
char *temp;
for (i = 0; i < no; i++) {
for (j = i + 1; j < no; j++) {
if (strcmp((month[i]), (month[j])) > 0) {
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
// グラフセット
struct Edge {
ll to; // 辺の行き先
ll weight; // 辺の重み
Edge(int t, int w) : to(t), weight(w) {}
};
// using Graph = vector<vector<Edge>>;
using Graph = vector<vector<int>>;
int main() {
ll N, X;
cin >> N >> X;
ll L[N];
ll ans = 0;
ll m = 0;
FOR(i, 0, N - 1) {
cin >> L[i];
m += L[i];
if (m <= X)
ans++;
}
cout << ans + 1 << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,078 | 812,079 | u043443359 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb emplace_back
#define mp make_pair
#define f(i, a, n) for (int i = a; i < n; i++)
#define F first
#define E endl
#define S second
#define fast ios::sync_with_stdio(false), cin.tie(0);
int main() {
ll n, b;
cin >> n >> b;
ll a[n + 1];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll sum = 0;
ll ans = 1;
for (ll i = 1; i < n; i++) {
sum = sum + a[i];
if (sum <= b)
ans++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb emplace_back
#define mp make_pair
#define f(i, a, n) for (int i = a; i < n; i++)
#define F first
#define E endl
#define S second
#define fast ios::sync_with_stdio(false), cin.tie(0);
int main() {
ll n, b;
cin >> n >> b;
ll a[n + 1];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll sum = 0;
ll ans = 1;
for (ll i = 0; i < n; i++) {
sum = sum + a[i];
if (sum <= b)
ans++;
}
cout << ans;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,080 | 812,081 | u366029725 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
int N, X;
int L[100];
int main() {
cin >> N >> X;
rep(i, N) { cin >> L[i]; }
int sum = 0;
int ans = 0;
rep(i, N) {
sum += L[i];
if (sum > X) {
break;
}
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
int N, X;
int L[1000];
int main() {
cin >> N >> X;
rep(i, N) { cin >> L[i]; }
int sum = 0;
int ans = 1;
rep(i, N) {
sum += L[i];
// printf("i: %d sum: %d\n", i, sum);
if (sum > X) {
break;
}
ans++;
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change"
] | 812,082 | 812,083 | u455366471 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N, -1);
ll sum = 0;
rep(i, N) cin >> L.at(i);
for (int i = 0; i < N; i++) {
sum += L.at(i);
if (X < sum) {
cout << i + 1 << endl;
return 0;
}
}
cout << N - 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N, -1);
ll sum = 0;
rep(i, N) cin >> L.at(i);
for (int i = 0; i < N; i++) {
sum += L.at(i);
if (X < sum) {
cout << i + 1 << endl;
return 0;
}
}
cout << N + 1 << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 812,091 | 812,092 | u343935874 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, x, l[105] = {}, d[105] = {};
int ans = 1;
cin >> n >> x;
for (int i = 0; i < n; i++)
cin >> l[i];
for (int i = 1; i < n; i++) {
d[i] = d[i - 1] + l[i - 1];
if (d[i] <= x)
ans++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, x, l[105] = {}, d[105] = {};
int ans = 1;
cin >> n >> x;
for (int i = 0; i < n; i++)
cin >> l[i];
for (int i = 1; i < n + 1; i++) {
d[i] = d[i - 1] + l[i - 1];
if (d[i] <= x)
ans++;
}
cout << ans;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,093 | 812,094 | u512624048 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1), D(N + 1);
for (int i = 1; i < N + 1; i++)
cin >> L.at(i);
// D1 = 0
// D2 = D1 + L1 = 0 + 3 = 3
// D3 = D2 + L2 = 3 + 4 = 7
int i;
D.at(1) = 0;
for (i = 2; i <= N; i++) {
if (D.at(i - 1) + L.at(i - 1) > X)
break;
D.at(i) = D.at(i - 1) + L.at(i - 1);
}
cout << i - 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1), D(N + 10);
for (int i = 1; i < N + 1; i++)
cin >> L.at(i);
// D1 = 0
// D2 = D1 + L1 = 0 + 3 = 3
// D3 = D2 + L2 = 3 + 4 = 7
// 0,3,7,12
int i;
D.at(1) = 0;
for (i = 2; i < N + 2; i++) {
if (D.at(i - 1) + L.at(i - 1) > X)
break;
D.at(i) = D.at(i - 1) + L.at(i - 1);
}
cout << i - 1 << endl;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one"
] | 812,095 | 812,096 | u440632112 | cpp |
p03000 | #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
const ll MOD = 1e9 + 7;
const int INF = 1e9;
int dx4[4] = {0, -1, 1, 0};
int dy4[4] = {-1, 0, 0, 1};
int dx8[8] = {0, -1, 1, 0, -1, 1, -1, 1};
int dy8[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int main() {
int n, x;
cin >> n >> x;
int ans = 1, d = 0;
vector<int> l(n);
for (int i = 1; i < n; i++) {
cin >> l[i];
d += l[i];
if (d > x)
break;
else {
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
const ll MOD = 1e9 + 7;
const int INF = 1e9;
int dx4[4] = {0, -1, 1, 0};
int dy4[4] = {-1, 0, 0, 1};
int dx8[8] = {0, -1, 1, 0, -1, 1, -1, 1};
int dy8[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int main() {
int n, x;
cin >> n >> x;
int ans = 1, d = 0;
vector<int> l(n);
for (int i = 0; i < n; i++) {
cin >> l[i];
d += l[i];
if (d > x)
break;
else {
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,108 | 812,109 | u736209378 | cpp |
p03000 | /*
[abc130] B - Bounding
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int MAX_N = 100;
int N, X;
int L[MAX_N];
ll solve() {
int d = 0;
int ans = 0;
for (int i = 0; i < N && d <= X; i++) {
ans++;
d += L[i];
}
return ans;
}
int main() {
cin >> N >> X;
for (int i = 0; i < N; i++) {
cin >> L[i];
}
cout << solve() << endl;
return 0;
}
| /*
[abc130] B - Bounding
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int MAX_N = 100;
int N, X;
int L[MAX_N + 1];
ll solve() {
int d = 0;
int ans = 0;
for (int i = 0; i <= N && d <= X; i++) {
ans++;
d += L[i];
}
return ans;
}
int main() {
cin >> N >> X;
for (int i = 0; i < N; i++) {
cin >> L[i];
}
cout << solve() << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,110 | 812,111 | u302149106 | cpp |
p03000 | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v)
out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 200010
int main() {
int N, X, sum = 0, ans = 0;
cin >> N >> X;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
sum += L;
ans += L <= X;
}
cout << ans + 1 << endl;
return 0;
}
| #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v)
out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 200010
int main() {
int N, X, sum = 0, ans = 0;
cin >> N >> X;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
sum += L;
ans += sum <= X;
}
cout << ans + 1 << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 812,112 | 812,113 | u378419207 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
rep(i, N) cin >> L[i];
int ans = 1;
int len = 0;
rep(i, N) {
len += L[i];
if (len >= X)
break;
ans++;
}
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, X;
cin >> N >> X;
vector<int> L(N);
rep(i, N) cin >> L[i];
int ans = 1;
int len = 0;
rep(i, N) {
len += L[i];
if (len > X)
break;
ans++;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,116 | 812,117 | u147556624 | cpp |
p03000 | #include <bits/stdc++.h>
#include <string>
using namespace std;
int main() {
int count = 0;
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
for (int i = 0; i < N; i++) {
if (D[i] <= X) {
count++;
}
}
cout << count;
} | #include <bits/stdc++.h>
#include <string>
using namespace std;
int main() {
int count = 0;
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
for (int i = 0; i <= N; ++i) {
if (D[i] <= X) {
count++;
}
}
cout << count;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,118 | 812,119 | u573537453 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 1;
int total = 0;
rep(i, n) {
int tmp;
cin >> tmp;
total += tmp;
if (total < x)
ans++;
else
break;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 1;
int total = 0;
rep(i, n) {
int tmp;
cin >> tmp;
total += tmp;
if (total <= x)
ans++;
else
break;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,140 | 812,141 | u741134767 | cpp |
p03000 | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) \
sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORL(i, a, b) for (LL i = (a); i < (b); ++i)
#define REPL(i, n) FORL(i, 0, n)
#define SIZE(a) int((a).size())
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_LARGE = 1000000100;
// debug func
template <typename T> void vecprint(vector<T> v) {
for (auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template <typename T> void vecvecprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) { cerr << vv[i][j] << " "; }
cerr << endl;
}
}
template <typename T> void pqprint(priority_queue<T> q) {
while (!q.empty()) {
cerr << q.top() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void qprint(queue<T> q) {
while (!q.empty()) {
cerr << q.front() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void vecqprint(vector<queue<T>> v) {
for (int i = 0; i < v.size(); i++) {
qprint(v[i]);
}
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
/* Credits: Thomas Draper */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
rotate(k, itr2, last);
return true;
}
}
rotate(first, k, last);
return false;
}
inline double get_time_sec(void) {
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count()) /
1000000000;
}
template <typename T> T gcd(T a, T b) {
if (a > b)
swap(a, b);
if (a == 0)
return b;
else
return gcd(b % a, a);
}
template <typename T> map<T, T> prime_list(T n) {
map<T, T> ret;
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret[i] = 0;
while (n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if (n != 1)
ret[n]++;
return ret;
}
int main(void) {
int n, x;
cin >> n >> x;
VI pos(n + 1, 0);
FOR(i, 1, n + 1) {
int tmp;
cin >> tmp;
pos[i] = pos[i - 1] + tmp;
}
vecprint(pos);
int ans = 0;
REP(i, n + 1) {
if (pos[i] > x) {
ans++;
}
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) \
sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORL(i, a, b) for (LL i = (a); i < (b); ++i)
#define REPL(i, n) FORL(i, 0, n)
#define SIZE(a) int((a).size())
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_LARGE = 1000000100;
// debug func
template <typename T> void vecprint(vector<T> v) {
for (auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template <typename T> void vecvecprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) { cerr << vv[i][j] << " "; }
cerr << endl;
}
}
template <typename T> void pqprint(priority_queue<T> q) {
while (!q.empty()) {
cerr << q.top() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void qprint(queue<T> q) {
while (!q.empty()) {
cerr << q.front() << " ";
q.pop();
}
cerr << endl;
}
template <typename T> void vecqprint(vector<queue<T>> v) {
for (int i = 0; i < v.size(); i++) {
qprint(v[i]);
}
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
/* Credits: Thomas Draper */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
rotate(k, itr2, last);
return true;
}
}
rotate(first, k, last);
return false;
}
inline double get_time_sec(void) {
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count()) /
1000000000;
}
template <typename T> T gcd(T a, T b) {
if (a > b)
swap(a, b);
if (a == 0)
return b;
else
return gcd(b % a, a);
}
template <typename T> map<T, T> prime_list(T n) {
map<T, T> ret;
for (T i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret[i] = 0;
while (n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if (n != 1)
ret[n]++;
return ret;
}
int main(void) {
int n, x;
cin >> n >> x;
VI pos(n + 1, 0);
FOR(i, 1, n + 1) {
int tmp;
cin >> tmp;
pos[i] = pos[i - 1] + tmp;
}
vecprint(pos);
int ans = 0;
REP(i, n + 1) {
if (pos[i] <= x) {
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,157 | 812,158 | u637983859 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000000 + 7;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
Int N, X;
cin >> N >> X;
vector<Int> L(N);
for (Int i = 0; i < N; i++) {
cin >> L[i];
}
vector<Int> sum(N + 1);
for (Int i = 0; i < N; i++) {
sum[i + 1] = sum[i] + L[i];
}
Int ans = 0;
for (Int i = 0; i < N; i++) {
if (sum[i] <= X)
ans = i + 1;
else
break;
}
cout << ans << "\n";
}
| #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000000 + 7;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
Int N, X;
cin >> N >> X;
vector<Int> L(N);
for (Int i = 0; i < N; i++) {
cin >> L[i];
}
vector<Int> sum(N + 1);
for (Int i = 0; i < N; i++) {
sum[i + 1] = sum[i] + L[i];
}
Int ans = 0;
for (Int i = 0; i < N + 1; i++) {
if (sum[i] <= X)
ans = i + 1;
else
break;
}
cout << ans << "\n";
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,161 | 812,162 | u612271542 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, coo, count;
cin >> n >> x;
coo = 0;
count = 0;
for (int i = 0; i < n; i++) {
int l;
cin >> l;
coo = l;
if (coo <= x) {
count += 1;
}
}
cout << count << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x, coo, count;
cin >> n >> x;
coo = 0;
count = 1;
for (int i = 0; i < n; i++) {
int l;
cin >> l;
coo += l;
if (coo <= x) {
count += 1;
}
}
cout << count << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 812,166 | 812,167 | u961443099 | cpp |
p03000 | #include <bits/stdc++.h>
#include <iomanip>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef long l;
typedef pair<int, int> P;
const int INF = 10010010;
const double PI = 3.141592653589;
int main() {
int x, n;
cin >> n >> x;
int c = 1;
int sum = 0;
vector<int> l(n);
rep(i, n) { cin >> l[i]; }
for (int i = 1; i < n; i++) {
sum = sum + l[i - 1];
// cout<<sum<<endl;
if (sum <= x)
c++;
}
cout << c << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iomanip>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef long l;
typedef pair<int, int> P;
const int INF = 10010010;
const double PI = 3.141592653589;
int main() {
int x, n;
cin >> n >> x;
int c = 1;
int sum = 0;
vector<int> l(n);
rep(i, n) { cin >> l[i]; }
for (int i = 1; i <= n; i++) {
sum = sum + l[i - 1];
// cout<<sum<<endl;
if (sum <= x)
c++;
}
cout << c << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,171 | 812,172 | u634999820 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
for (int i = 0; i < n; i++)
cin >> l[i];
int ans = 1;
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += l[i];
if (sum <= x)
++ans;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
for (int i = 0; i < n; i++)
cin >> l[i];
int ans = 1;
int sum = 0;
for (int i = 0; i < n; i++) {
sum += l[i];
if (sum <= x)
++ans;
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,175 | 812,176 | u804520294 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
typedef long long ll;
#define endl '\n'
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int MOD = 1000000007;
//////////////////////////////////////////
int n, x;
int L[100];
void Input() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> L[i];
}
}
void Solve() {
int com = 0;
int cnt = 1;
for (int i = 1; i < n; i++) {
com = com + L[i - 1];
if (com > x) {
break;
}
cnt++;
}
cout << cnt << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
Input();
Solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
typedef long long ll;
#define endl '\n'
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const int MOD = 1000000007;
//////////////////////////////////////////
int n, x;
int L[100];
void Input() {
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> L[i];
}
}
void Solve() {
int com = 0;
int cnt = 1;
for (int i = 1; i <= n; i++) {
com = com + L[i - 1];
if (com > x) {
break;
}
cnt++;
}
cout << cnt << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
Input();
Solve();
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,192 | 812,193 | u423831742 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
int main() {
lint n, x;
cin >> n >> x;
vector<lint> l(n);
REP(i, n) { cin >> l[i]; }
lint ans = 0;
lint d = 0;
FOR(i, 1, n) {
d = d + l[i - 1];
if (d > x) {
cout << i << "\n";
return 0;
}
}
cout << n << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
int main() {
lint n, x;
cin >> n >> x;
vector<lint> l(n);
REP(i, n) { cin >> l[i]; }
lint ans = 0;
lint d = 0;
FOR(i, 1, n + 1) {
d = d + l[i - 1];
if (d > x) {
cout << i << "\n";
return 0;
}
}
cout << n + 1 << "\n";
return 0;
} | [
"expression.operation.binary.add"
] | 812,194 | 812,195 | u517411077 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, i, j, s = 0, b = -1;
int a[110];
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
if (s > x && b == -1) {
b = i + 1;
}
}
if (b == -1)
b = n;
cout << b << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x, i, j, s = 0, b = -1;
int a[110];
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
if (s > x && b == -1) {
b = i + 1;
}
}
if (b == -1)
b = n + 1;
cout << b << endl;
return 0;
} | [
"assignment.change"
] | 812,233 | 812,234 | u834488582 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, i, j, s = 0, b = -1;
int a[110];
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
if (s > x && b == -1) {
b = i + 1;
}
}
if (b = -1)
b = n;
cout << b << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x, i, j, s = 0, b = -1;
int a[110];
cin >> n >> x;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
if (s > x && b == -1) {
b = i + 1;
}
}
if (b == -1)
b = n + 1;
cout << b << endl;
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo",
"assignment.change"
] | 812,235 | 812,234 | u834488582 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, l[101], total = 0, cnt = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i < n; i++) {
total += l[i];
if (total <= x)
cnt++;
}
cout << cnt << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, x, l[101], total = 0, cnt = 1;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i < n; i++) {
total += l[i];
if (total <= x)
cnt++;
}
cout << cnt << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,244 | 812,245 | u522506260 | cpp |
p03000 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, X, D = 0, cnt = 0;
cin >> N >> X;
int L[N];
for (int i = 0; i < N; i++)
cin >> L[i];
for (int i = 0;; i++, cnt++) {
D = D + L[i - 1];
if (D > X)
break;
}
cout << cnt << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, X, D = 0, cnt = 1;
cin >> N >> X;
int L[N];
for (int i = 0; i < N; i++)
cin >> L[i];
for (int i = 1;; i++, cnt++) {
D = D + L[i - 1];
if (D > X)
break;
}
cout << cnt << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,248 | 812,249 | u937275419 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define ll long long
int main() {
ll n, x;
cin >> n >> x;
ll a[n];
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
ll d = 0, i = 1, c = 1;
while ((d + a[i - 1]) <= x && i < n) {
d = a[i - 1] + d;
// cout<<"d "<<d<<endl;
i++;
c++;
}
cout << c << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define ll long long
int main() {
ll n, x;
cin >> n >> x;
ll a[n];
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
ll d = 0, i = 0, c = 1;
while ((d + a[i]) <= x && i < n) {
d = a[i] + d;
// cout<<"d "<<d<<endl;
i++;
c++;
}
cout << c << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.remove"
] | 812,250 | 812,251 | u159663513 | cpp |
p03000 | #include <iostream>
#include <math.h>
using namespace std;
int main(void) {
int n, x, l[100];
int i, j, k, sum = 0;
cin >> n >> x;
l[0] = 0;
for (i = 1; i < n; i++) {
cin >> l[i];
sum = sum + l[i];
if (sum > x) {
break;
}
}
cout << i;
return 0;
}
| #include <iostream>
#include <math.h>
using namespace std;
int main(void) {
int n, x, l[100];
int i, j, k, sum = 0;
cin >> n >> x;
l[0] = 0;
for (i = 1; i <= n; i++) {
cin >> l[i];
sum = sum + l[i];
if (sum > x) {
break;
}
}
cout << i;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,266 | 812,267 | u660656075 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int INF = pow(2, 29);
const int MOD = 1000000007;
int main() {
int N, X;
cin >> N >> X;
int result = 1, sum = 0;
rep(i, N) {
int L;
cin >> L;
sum += L;
if (L > X)
break;
result++;
}
cout << result << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int INF = pow(2, 29);
const int MOD = 1000000007;
int main() {
int N, X;
cin >> N >> X;
int result = 1, sum = 0;
rep(i, N) {
int L;
cin >> L;
sum += L;
if (sum > X)
break;
result++;
}
cout << result << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 812,274 | 812,275 | u680707192 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int INF = pow(2, 29);
const int MOD = 1000000007;
int main() {
int N, X;
cin >> N >> X;
int result = 1, sum = 0;
rep(i, N) {
int L;
cin >> L;
sum += L;
if (L > sum)
break;
result++;
}
cout << result << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
using namespace std;
typedef long long ll;
const ll LLINF = 9223372036854775807;
const int INF = pow(2, 29);
const int MOD = 1000000007;
int main() {
int N, X;
cin >> N >> X;
int result = 1, sum = 0;
rep(i, N) {
int L;
cin >> L;
sum += L;
if (sum > X)
break;
result++;
}
cout << result << endl;
return 0;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 812,276 | 812,275 | u680707192 | cpp |
p03000 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr ll INF = 1'000'000'000'000'000'000;
namespace utils {
#define ALL(x) begin(x), end(x)
#define rALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;
template <class T> bool min_update(T &X, const T &A) {
if (X > A) {
X = A;
return true;
}
return false;
}
template <class T> bool max_update(T &X, const T &A) {
if (X < A) {
X = A;
return true;
}
return false;
}
using V_Set = unordered_set<int>;
using E_Set = unordered_map<int, V_Set>;
ll operator"" _64(unsigned long long x) { return ll(x); }
ull operator"" _64u(unsigned long long x) { return ull(x); }
template <typename T> vector<T> make_vector(size_t sz, T t) {
return vector<T>(sz, t);
}
template <typename T, typename... Ts> auto make_vector(size_t sz, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(sz, make_vector<T>(ts...));
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto &&x : v) {
os << x << ' ';
}
return os;
}
} // namespace utils
using namespace utils;
class solver {
public:
void run(istream &is, ostream &os) {
ll N, X;
is >> N >> X;
if (!is)
return;
ll D = 0;
vector<ll> bounce(1000000, 0);
bounce[D]++;
for (int i = 0; i < N; ++i) {
ll L;
is >> L;
D = D + L;
bounce[D]++;
} // end i
ll ans = 0;
for (int i = 1; i <= X; ++i) {
ans += bounce[i];
} // end i
cout << ans << endl;
}
};
int main(int argc, char *argv[]) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(16) << scientific;
#ifdef DEBUG
string test_cases = "test_B.txt";
cerr << "DEBUG MODE" << endl;
cerr << test_cases << " -->" << endl;
auto fs = fstream(test_cases, fstream::in);
int lp = 0;
while (fs) {
lp++;
cout << lp << "#------\n";
solver().run(fs, cout);
}
cout << "------#" << endl;
if (lp <= 1) {
while (cin)
solver().run(cin, cout);
}
#else
solver().run(cin, cout);
#endif
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr ll INF = 1'000'000'000'000'000'000;
namespace utils {
#define ALL(x) begin(x), end(x)
#define rALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;
template <class T> bool min_update(T &X, const T &A) {
if (X > A) {
X = A;
return true;
}
return false;
}
template <class T> bool max_update(T &X, const T &A) {
if (X < A) {
X = A;
return true;
}
return false;
}
using V_Set = unordered_set<int>;
using E_Set = unordered_map<int, V_Set>;
ll operator"" _64(unsigned long long x) { return ll(x); }
ull operator"" _64u(unsigned long long x) { return ull(x); }
template <typename T> vector<T> make_vector(size_t sz, T t) {
return vector<T>(sz, t);
}
template <typename T, typename... Ts> auto make_vector(size_t sz, Ts... ts) {
return vector<decltype(make_vector<T>(ts...))>(sz, make_vector<T>(ts...));
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto &&x : v) {
os << x << ' ';
}
return os;
}
} // namespace utils
using namespace utils;
class solver {
public:
void run(istream &is, ostream &os) {
ll N, X;
is >> N >> X;
if (!is)
return;
ll D = 0;
vector<ll> bounce(1000000, 0);
bounce[D]++;
for (int i = 0; i < N; ++i) {
ll L;
is >> L;
D = D + L;
bounce[D]++;
} // end i
ll ans = 0;
for (int i = 0; i <= X; ++i) {
ans += bounce[i];
} // end i
cout << ans << endl;
}
};
int main(int argc, char *argv[]) {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << setprecision(16) << scientific;
#ifdef DEBUG
string test_cases = "test_B.txt";
cerr << "DEBUG MODE" << endl;
cerr << test_cases << " -->" << endl;
auto fs = fstream(test_cases, fstream::in);
int lp = 0;
while (fs) {
lp++;
cout << lp << "#------\n";
solver().run(fs, cout);
}
cout << "------#" << endl;
if (lp <= 1) {
while (cin)
solver().run(cin, cout);
}
#else
solver().run(cin, cout);
#endif
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,279 | 812,280 | u896838289 | cpp |
p03000 | #define rep(i, n) for (int i = 0; i < (int)n; i++)
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef LOCAL
// 以降 cin の入力元が 'xxx.txt' になる
std::ifstream in("b.txt");
std::cin.rdbuf(in.rdbuf());
#endif
int n, x;
cin >> n >> x;
int d = 0;
int ans = 1;
vector<int> l(n);
rep(i, n) cin >> l[i];
for (int i = 0;; i++) {
d = d + l[i];
if (d > x) {
break;
}
ans++;
}
cout << ans;
return 0;
}
| #define rep(i, n) for (int i = 0; i < (int)n; i++)
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef LOCAL
// 以降 cin の入力元が 'xxx.txt' になる
std::ifstream in("b.txt");
std::cin.rdbuf(in.rdbuf());
#endif
int n, x;
cin >> n >> x;
int d = 0;
int ans = 1;
vector<int> l(n);
rep(i, n) cin >> l[i];
for (int i = 0; i < n; i++) {
d = d + l[i];
// cout << "i:" << i << " l:" << l[i] << " d:" << d << endl;
if (d > x) {
break;
}
ans++;
}
cout << ans;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 812,286 | 812,287 | u234248338 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, ans = 0, D = 0, L;
cin >> N >> X;
for (int i = 0; D <= X; i++) {
cin >> L;
D += L;
ans++;
if (i = N)
break;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, ans = 0, D = 0, L;
cin >> N >> X;
for (int i = 0; D <= X; i++) {
cin >> L;
D += L;
ans++;
if (i == N)
break;
}
cout << ans << endl;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 812,309 | 812,310 | u028572059 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, l[101], now = 0, ans = 0, idx = 0;
cin >> n >> x;
for (int i = 0; i < n; i++)
cin >> l[i];
while (now <= x && idx < n) {
now += l[idx];
idx++;
ans++;
}
cout << ans;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x, l[101], now = 0, ans = 0, idx = 0;
cin >> n >> x;
for (int i = 0; i < n; i++)
cin >> l[i];
while (now <= x && idx <= n) {
now += l[idx];
idx++;
ans++;
}
cout << ans;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 812,321 | 812,322 | u628758223 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> temp(N);
for (int i = 0; i < N; i++)
cin >> temp[i];
int count = 0;
int coor = 0;
for (int i = 0; i < N; i++) {
coor += temp[i];
if (coor >= X)
count++;
}
cout << 1 + count << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> temp(N);
for (int i = 0; i < N; i++)
cin >> temp[i];
int count = 0;
int coor = 0;
for (int i = 0; i < N; i++) {
coor += temp[i];
if (coor <= X)
count++;
}
cout << 1 + count << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,330 | 812,331 | u079736142 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L[i];
}
int hight = 0;
int cnt = 1;
for (int i = 0; i < N; i++) {
hight += L[i];
cnt++;
if (hight > X) {
break;
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L[i];
}
int hight = 0;
int cnt = 1;
for (int i = 0; i < N; i++) {
hight += L[i];
cnt++;
if (hight > X) {
cnt--;
break;
}
}
cout << cnt << endl;
return 0;
}
| [
"expression.unary.arithmetic.add"
] | 812,334 | 812,335 | u904123392 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L[i];
}
int hight = 0;
int cnt = 1;
for (int i = 0; i < N; i++) {
hight += L[i];
cnt++;
if (hight > X) {
break;
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N);
for (int i = 0; i < N; i++) {
cin >> L[i];
}
int hight = 0;
int cnt = 1;
for (int i = 0; i < N; i++) {
hight += L[i];
cnt++;
if (hight > X) {
cnt--;
break;
}
}
cout << cnt << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 812,334 | 812,336 | u904123392 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <random>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, x;
cin >> n >> x;
int d[n + 1];
d[0] = 0;
rep(i, n) {
int l;
cin >> l;
d[i + 1] = d[i] + l;
}
int ans = 0;
rep(i, n) if (d[i] <= x) ans++;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <random>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, x;
cin >> n >> x;
int d[n + 1];
d[0] = 0;
rep(i, n) {
int l;
cin >> l;
d[i + 1] = d[i] + l;
}
int ans = 0;
rep(i, n + 1) if (d[i] <= x) ans++;
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,337 | 812,338 | u654115954 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x;
cin >> n >> x;
long long int l[n], d[n + 1];
for (int i = 0; i < n; i++)
cin >> l[i];
d[0] = 0;
for (long long int i = 1; i < n; i++)
d[i] = d[i - 1] + l[i - 1];
long long int k = 0;
for (long long int i = 0; i < n + 1; i++) {
if (d[i] <= x)
k++;
}
cout << k;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x;
cin >> n >> x;
long long int l[n], d[n + 1];
for (int i = 0; i < n; i++)
cin >> l[i];
d[0] = 0;
for (long long int i = 1; i < n + 1; i++)
d[i] = d[i - 1] + l[i - 1];
long long int k = 0;
for (long long int i = 0; i < n + 1; i++) {
if (d[i] <= x)
k++;
}
cout << k;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,372 | 812,373 | u796786871 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
#define maxn 200005
#define fr(i, j, k) for (int i = j; i < k; i++)
#define f(n) fr(i, 0, n)
#define f1(n) fr(i, 1, n + 1)
#define ms(i) memset(i, 0, sizeof(i));
#define ms1(i) memset(i, -1, sizeof(i));
#define F first
#define S second
int main() {
int n, k;
while (cin >> n >> k) {
int cur = 0;
int ans = 1;
f(n) {
int add;
cin >> add;
cur += add;
if (cur <= add)
ans++;
else
break;
}
cout << ans << endl;
exit(0);
}
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
#define maxn 200005
#define fr(i, j, k) for (int i = j; i < k; i++)
#define f(n) fr(i, 0, n)
#define f1(n) fr(i, 1, n + 1)
#define ms(i) memset(i, 0, sizeof(i));
#define ms1(i) memset(i, -1, sizeof(i));
#define F first
#define S second
int main() {
int n, k;
while (cin >> n >> k) {
int cur = 0;
int ans = 1;
f(n) {
int add;
cin >> add;
cur += add;
if (cur <= k)
ans++;
else
break;
}
cout << ans << endl;
exit(0);
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 812,374 | 812,375 | u308590217 | cpp |
p03000 | #include <iostream>
#include <algorithm>
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <map>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP2(i, s, n) for (int i = s; i < n; i++)
#define REP_1(i, n) for (int i = 1; i < n + 1; i++)
#define bitSearch(bit, n) for (int bit = 0; bit < (1 << N); bit++)
using namespace std;
void printAns(int a) { cout << a << endl; }
void yesno(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YESNO(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
typedef long long ll;
typedef unsigned long ul;
typedef long double ld;
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;
}
ll INF = 10000000;
ll mod = 1000000007; // 10^9+7
//番号ズレ注意！！
int main() {
int N, X, L[110];
cin >> N >> X;
int D[110] = {0};
int ans = 0;
REP(i, N) {
cin >> L[i];
D[i + 1] = D[i] + L[i];
if (D[i] <= X) {
ans += 1;
} else {
break;
}
}
cout << ans << endl;
} | #include <iostream>
#include <algorithm>
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <map>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP2(i, s, n) for (int i = s; i < n; i++)
#define REP_1(i, n) for (int i = 1; i < n + 1; i++)
#define bitSearch(bit, n) for (int bit = 0; bit < (1 << N); bit++)
using namespace std;
void printAns(int a) { cout << a << endl; }
void yesno(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YESNO(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
typedef long long ll;
typedef unsigned long ul;
typedef long double ld;
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;
}
ll INF = 10000000;
ll mod = 1000000007; // 10^9+7
//番号ズレ注意！！
int main() {
int N, X, L[110];
cin >> N >> X;
int D[110] = {0};
int ans = 1;
REP(i, N) {
cin >> L[i];
D[i + 1] = D[i] + L[i];
if (D[i + 1] <= X) {
ans += 1;
} else {
break;
}
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.branch.if.condition.change"
] | 812,378 | 812,379 | u741556152 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, count = 0;
cin >> N >> X;
vector<int> D(N + 1);
D.at(0) = 0;
for (int i = 0; i < N; i++) {
cin >> X;
D.at(i + 1) = D.at(i) + X;
}
// for (int i = 0; i < N;i++)
// cout << L.at(i) << endl;
for (int i = 0; i <= N; i++) {
if (D.at(i) <= X) {
count++;
// cout << "hoge" << endl;
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, count = 0;
cin >> N >> X;
vector<int> D(N + 1);
D.at(0) = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
D.at(i + 1) = D.at(i) + x;
}
// for (int i = 0; i < N;i++)
// cout << L.at(i) << endl;
for (int i = 0; i <= N; i++) {
// cout << D.at(i) << endl;
if (D.at(i) <= X) {
count++;
// cout << "hoge" << endl;
}
}
cout << count << endl;
}
| [
"variable_declaration.add",
"identifier.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 812,416 | 812,417 | u995485610 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define pb push_back
#define mp make_pair
#define ll long long int
#define vi vector<int>
#define vl vector<ll>
#define ppi pair<int, int>
#define ppl pair<ll, ll>
#define all(x) x.begin(), x.end()
#define ii int, int
#define mm map<ii>
#define ff first
#define ss second
#define forn(i, a, b) for (int i = a; i < b; i++)
#define forr(i, a, b) for (int i = a; i >= b; i--)
#define forv(i, m) for (auto i : m)
#define imx INT_MAX
#define imn INT_MIN
#define inf LONG_MAX
#define minf LONG_MIN
#define endl "\n"
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define sze size()
#define rvs reverse
#define itr iterator
/*
#define MODM(a,b,md) ((a%md)*(b%md))%md
#define MODA(a,b,md) ((a%md)+(b%md))%md
#define ull unsigned long long int
#define si short int
*/
/*
bool compare(int a,int b) {return a > b;}
bool compare1(ppi a,ppi b) {return a.ff > b.ff;}
bool compare2(ppi a,ppi b) {return a.ss < b.ss;}
ll Npower(ll a,ll b) {ll product = 1; while(b){if(b&1){product = product*a;}a =
a*a;b = b>>1;} return product;} ll power(ll a,ll b,ll md) {ll product = 1;
while(b){if(b&1){product = MODM(product,a,md);}a = MODM(a,a,md);b = b>>1;}
return product%md;} ll GCD(ll a,ll b) {return b==0 ? a:GCD(b,a%b);} ll LCM(ll
a,ll b) {return (a/GCD(a,b))*b; }
*/
int main() {
fast
int n,
x;
cin >> n >> x;
int count = 0;
int sum = 0, k;
forn(i, 0, n) {
cin >> k;
sum += k;
if (sum <= x)
count++;
}
cout << count;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define pb push_back
#define mp make_pair
#define ll long long int
#define vi vector<int>
#define vl vector<ll>
#define ppi pair<int, int>
#define ppl pair<ll, ll>
#define all(x) x.begin(), x.end()
#define ii int, int
#define mm map<ii>
#define ff first
#define ss second
#define forn(i, a, b) for (int i = a; i < b; i++)
#define forr(i, a, b) for (int i = a; i >= b; i--)
#define forv(i, m) for (auto i : m)
#define imx INT_MAX
#define imn INT_MIN
#define inf LONG_MAX
#define minf LONG_MIN
#define endl "\n"
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define sze size()
#define rvs reverse
#define itr iterator
/*
#define MODM(a,b,md) ((a%md)*(b%md))%md
#define MODA(a,b,md) ((a%md)+(b%md))%md
#define ull unsigned long long int
#define si short int
*/
/*
bool compare(int a,int b) {return a > b;}
bool compare1(ppi a,ppi b) {return a.ff > b.ff;}
bool compare2(ppi a,ppi b) {return a.ss < b.ss;}
ll Npower(ll a,ll b) {ll product = 1; while(b){if(b&1){product = product*a;}a =
a*a;b = b>>1;} return product;} ll power(ll a,ll b,ll md) {ll product = 1;
while(b){if(b&1){product = MODM(product,a,md);}a = MODM(a,a,md);b = b>>1;}
return product%md;} ll GCD(ll a,ll b) {return b==0 ? a:GCD(b,a%b);} ll LCM(ll
a,ll b) {return (a/GCD(a,b))*b; }
*/
int main() {
fast
int n,
x;
cin >> n >> x;
int count = 1;
int sum = 0, k;
forn(i, 0, n) {
cin >> k;
sum += k;
if (sum <= x)
count++;
}
cout << count;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,442 | 812,443 | u460819600 | cpp |
p03000 | #include <iostream>
using namespace std;
int main(void) {
int N, X;
cin >> N >> X;
long long int L[N];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
long long int D[N];
D[0] = 0;
for (int i = 1; i < N; i++) {
D[i] = D[i - 1] + L[i - 1];
}
int counter = 0;
for (int i = 0; i < N; i++) {
if (D[i] <= X) {
counter++;
}
}
cout << counter << endl;
} | #include <iostream>
using namespace std;
int main(void) {
int N, X;
cin >> N >> X;
long long int L[N + 1];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
long long int D[N];
D[0] = 0;
for (int i = 1; i <= N; i++) {
D[i] = D[i - 1] + L[i - 1];
}
int counter = 0;
for (int i = 0; i <= N; i++) {
if (D[i] <= X) {
counter++;
}
}
cout << counter << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,460 | 812,461 | u036238364 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, X, D = 0, j = 2, count = 1;
cin >> N >> X;
vector<int> L(N + 1);
for (int i = 1; i < N + 1; i++) {
cin >> L[i];
}
while (D + L[j - 1] <= X && j < N + 1) {
D += L[j - 1];
count++;
j++;
}
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, X, D = 0, j = 2, count = 1;
cin >> N >> X;
vector<int> L(N + 1);
for (int i = 1; i < N + 1; i++) {
cin >> L[i];
}
while (D + L[j - 1] <= X && j < N + 2) {
D += L[j - 1];
count++;
j++;
}
cout << count << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.condition.change"
] | 812,464 | 812,465 | u703503553 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, X, D = 0, j = 2, count = 1;
cin >> N >> X;
vector<int> L(N + 1);
for (int i = 1; i < N + 1; i++) {
cin >> L[i];
}
while (D + L[j - 1] <= X) {
D += L[j - 1];
count++;
j++;
}
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, X, D = 0, j = 2, count = 1;
cin >> N >> X;
vector<int> L(N + 1);
for (int i = 1; i < N + 1; i++) {
cin >> L[i];
}
while (D + L[j - 1] <= X && j < N + 2) {
D += L[j - 1];
count++;
j++;
}
cout << count << endl;
return 0;
} | [
"control_flow.loop.condition.change"
] | 812,466 | 812,465 | u703503553 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#define LL long long
#define inf 0x3f3f3f3f
using namespace std;
const int MAXN = 1000005;
int D[105], L[105];
int main() {
// freopen("../in.txt","r",stdin);
int N, X;
cin >> N >> X;
D[1] = 0;
for (int i = 1; i <= N; i++)
cin >> L[i];
for (int i = 2; i <= N + 1; i++) {
D[i] = D[i - 1] + L[i - 1];
}
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (D[i] <= X)
cnt++;
else
break;
}
cout << cnt << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#define LL long long
#define inf 0x3f3f3f3f
using namespace std;
const int MAXN = 1000005;
int D[105], L[105];
int main() {
// freopen("../in.txt","r",stdin);
int N, X;
cin >> N >> X;
D[1] = 0;
for (int i = 1; i <= N; i++)
cin >> L[i];
for (int i = 2; i <= N + 1; i++) {
D[i] = D[i - 1] + L[i - 1];
}
int cnt = 0;
for (int i = 1; i <= N + 1; i++) {
if (D[i] <= X)
cnt++;
else
break;
}
cout << cnt << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,488 | 812,489 | u481292708 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#define LL long long
#define inf 0x3f3f3f3f
using namespace std;
const int MAXN = 1000005;
int D[105], L[105];
int main() {
// freopen("../in.txt","r",stdin);
int N, X;
cin >> N >> X;
D[1] = 0;
for (int i = 1; i <= N; i++)
cin >> L[i];
for (int i = 2; i <= N; i++) {
D[i] = D[i - 1] + L[i - 1];
}
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (D[i] <= X)
cnt++;
else
break;
}
cout << cnt << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <set>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#define LL long long
#define inf 0x3f3f3f3f
using namespace std;
const int MAXN = 1000005;
int D[105], L[105];
int main() {
// freopen("../in.txt","r",stdin);
int N, X;
cin >> N >> X;
D[1] = 0;
for (int i = 1; i <= N; i++)
cin >> L[i];
for (int i = 2; i <= N + 1; i++) {
D[i] = D[i - 1] + L[i - 1];
}
int cnt = 0;
for (int i = 1; i <= N + 1; i++) {
if (D[i] <= X)
cnt++;
else
break;
}
cout << cnt << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,490 | 812,489 | u481292708 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n;
int count = 1;
int d = 0;
int l;
for (int i = 0; i < n; i++) {
cin >> l;
d += l;
if (d <= x)
count++;
}
cout << count << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int count = 1;
int d = 0;
int l;
for (int i = 0; i < n; i++) {
cin >> l;
d += l;
if (d <= x)
count++;
}
cout << count << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,493 | 812,494 | u639203570 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L_i;
for (int i{0}; i < N; ++i) {
int tmp;
cin >> tmp;
L_i.push_back(tmp);
}
int count{1};
int d{0};
for (int i{1}; i < N; ++i) {
d = d + L_i[i];
if (d > X)
break;
count++;
}
cout << count << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L_i;
for (int i{0}; i < N; ++i) {
int tmp;
cin >> tmp;
L_i.push_back(tmp);
}
int count{1};
int d{0};
for (int i{0}; i < N; ++i) {
d = d + L_i[i];
if (d > X)
break;
count++;
}
cout << count << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,495 | 812,496 | u989899651 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, l[101] = {};
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
long long int d[101] = {};
for (int i = 1; i < n; i++) {
d[i] = d[i - 1] + l[i - 1];
}
int ct = 1;
for (int i = 1; i < n; i++) {
if (d[i] <= x) {
ct++;
} else {
break;
}
}
cout << ct << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n, x, l[101] = {};
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
long long int d[101] = {};
for (int i = 1; i < n + 1; i++) {
d[i] = d[i - 1] + l[i - 1];
}
int ct = 1;
for (int i = 1; i < n + 1; i++) {
if (d[i] <= x) {
ct++;
} else {
break;
}
}
cout << ct << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,502 | 812,503 | u632679464 | cpp |
p03000 | #include <iostream>
using namespace std;
#define N 101
int main() {
int n, x, l[N] = {};
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
int ct = 1;
long long int d = 0;
for (int i = 1; i < n; i++) {
d = d + l[i - 1];
if (d <= x) {
ct++;
} else {
break;
}
}
cout << ct << endl;
}
| #include <iostream>
using namespace std;
#define N 101
int main() {
int n, x, l[N] = {};
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
int ct = 1;
long long int d = 0;
for (int i = 1; i < n + 1; i++) {
d = d + l[i - 1];
if (d <= x) {
ct++;
} else {
break;
}
}
cout << ct << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,504 | 812,505 | u632679464 | cpp |
p03000 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
//素因数分解
vector<pair<ll, int>> factorize(ll n) {
vector<pair<ll, int>> res;
for (ll i = 2; i * i <= n; i++) {
if (n % i)
continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)
res.emplace_back(n, 1);
return res;
}
int main() {
int N, X;
cin >> N >> X;
int L[N];
for (int i = 0; i < N; i++)
cin >> L[i];
int ans = 1, D = 0;
for (int i = 1; i < N; i++) {
D = D + L[i - 1];
if (D <= X)
ans++;
}
cout << ans << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
//素因数分解
vector<pair<ll, int>> factorize(ll n) {
vector<pair<ll, int>> res;
for (ll i = 2; i * i <= n; i++) {
if (n % i)
continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)
res.emplace_back(n, 1);
return res;
}
int main() {
int N, X;
cin >> N >> X;
int L[N];
for (int i = 0; i < N; i++)
cin >> L[i];
int ans = 1, D = 0;
for (int i = 1; i <= N; i++) {
D = D + L[i - 1];
if (D <= X)
ans++;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,517 | 812,518 | u355371431 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
for (int i = 0; i < n; i++)
cin >> l.at(i);
int count = 1;
int y = 0;
for (int i = 0; i <= n; i++) {
y += l.at(i);
if (y > x)
count++;
else
break;
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
for (int i = 0; i < n; i++)
cin >> l.at(i);
int count = 1;
int y = 0;
for (int i = 0; i < n; i++) {
y += l.at(i);
if (y <= x)
count++;
else
break;
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 812,521 | 812,520 | u191476275 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int cur = 0;
int res = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
cur += x;
if (cur <= L)
++res;
}
cout << res;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
cin >> N >> L;
int cur = 0;
int res = 1;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
cur += x;
if (cur <= L)
++res;
}
cout << res;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,523 | 812,524 | u427589390 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 1; i < N; i++) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
for (int i = 0; i < N + 1; i++) {
if (D[i] <= X)
ans++;
}
cout << ans;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; i++) {
if (D[i] <= X)
ans++;
}
cout << ans;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 812,527 | 812,528 | u544511937 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 1; i < N + 1; i++) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
for (int i = 0; i < N + 1; i++) {
if (D[i] <= X)
ans++;
}
cout << ans;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; i++) {
if (D[i] <= X)
ans++;
}
cout << ans;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"expression.operation.binary.change"
] | 812,529 | 812,528 | u544511937 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 1; i < N + 1; i++) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
for (int i = 0; i < N; i++) {
if (D[i] <= X)
ans++;
}
cout << ans;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; i++) {
if (D[i] <= X)
ans++;
}
cout << ans;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"expression.operation.binary.change"
] | 812,530 | 812,528 | u544511937 | cpp |
p03000 | #include <cstdio>
#include <iostream>
using namespace std;
int n, x, pos, l;
int main() {
scanf("%d%d", &n, &x);
for (register int i = 1; i <= n; i++) {
scanf("%d", &l);
pos += l;
if (pos > x) {
cout << i - 1 << endl;
return 0;
}
}
cout << n << endl;
} | #include <cstdio>
#include <iostream>
using namespace std;
int n, x, pos, l;
int main() {
scanf("%d%d", &n, &x);
for (register int i = 1; i <= n; i++) {
scanf("%d", &l);
pos += l;
if (pos > x) {
cout << i << endl;
return 0;
}
}
cout << n + 1 << endl;
} | [
"expression.operation.binary.remove"
] | 812,555 | 812,556 | u131977721 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.