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;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define mod 1000000007
typedef long long ll;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
rep(i, n) { cin >> l[i]; }
int ans = 1, d = 0;
rep2(i, 0, n + 2) {
d = d + l[i];
if (d > x) {
break;
}
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define mod 1000000007
typedef long long ll;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
rep(i, n) { cin >> l[i]; }
int ans = 1, d = 0;
rep(i, n) {
d = d + l[i];
if (d > x) {
break;
}
ans++;
}
cout << ans << endl;
} | [
"call.arguments.change",
"expression.operation.binary.remove"
] | 812,559 | 812,560 | u931071094 | 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 d = 0;
int count = 1;
for (int i = 2; i <= n; i++) {
if (d + l[i - 1] > x) {
break;
}
count++;
d = d + l[i - 1];
}
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[i];
}
int d = 0;
int count = 1;
for (int i = 2; i <= n + 1; i++) {
if (d + l[i - 2] > x) {
break;
}
count++;
d = d + l[i - 2];
}
cout << count << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 812,561 | 812,562 | u931071094 | cpp |
p03000 | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define scin(a) scanf("%d", &a);
#define scdo(a) scanf("%lf", &a);
#define scch(a) scanf("%s", a);
#define anin(a) printf("%d\n", a);
#define ando(a) printf("%lf\n", a);
#define anch(a) printf("%s\n", a);
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int main(void) {
int N, X, H(0), i;
scin(N) scin(X) long int L[N];
rep(i, 0, N) scin(L[i]) for (i = 0; H <= X; i++) { H += L[i]; }
if (i < N)
anin(i) else anin(N) return 0;
} | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define scin(a) scanf("%d", &a);
#define scdo(a) scanf("%lf", &a);
#define scch(a) scanf("%s", a);
#define anin(a) printf("%d\n", a);
#define ando(a) printf("%lf\n", a);
#define anch(a) printf("%s\n", a);
int asc(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int main(void) {
int N, X, H(0), i;
scin(N) scin(X) long int L[N];
rep(i, 0, N) scin(L[i]) for (i = 0; H <= X; i++) { H += L[i]; }
if (i < N + 1)
anin(i) else anin(N + 1) return 0;
} | [
"control_flow.branch.if.condition.change"
] | 812,563 | 812,564 | u456658814 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main(void) {
int n, x;
cin >> n >> x;
int l[n];
rep(i, n) { cin >> l[i]; }
int count = 0;
long long ans = 0;
rep(i, n) {
if (ans > x)
break;
ans += l[i];
count++;
}
cout << count << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main(void) {
int n, x;
cin >> n >> x;
int l[n];
rep(i, n) { cin >> l[i]; }
int count = 0;
int ans = 0;
rep(i, n + 1) {
if (ans > x)
break;
ans += l[i];
count++;
}
cout << count << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change"
] | 812,568 | 812,569 | u326152409 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main(void) {
int n, x;
cin >> n >> x;
int l[n];
rep(i, n) { cin >> l[i]; }
int count = 0;
int ans = 0;
rep(i, n) {
if (ans > x)
break;
ans += l[i];
count++;
}
cout << count << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main(void) {
int n, x;
cin >> n >> x;
int l[n];
rep(i, n) { cin >> l[i]; }
int count = 0;
int ans = 0;
rep(i, n + 1) {
if (ans > x)
break;
ans += l[i];
count++;
}
cout << count << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,570 | 812,569 | u326152409 | 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 d = 0;
int ans;
for (int i = 0; i < n; i++) {
d += l.at(i);
if (x < d) {
ans = i + 1;
break;
}
}
cout << ans << 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 d = 0;
int ans = n + 1; //最後まで座標xを超えなければans=n+1
for (int i = 0; i < n; i++) {
d += l.at(i);
if (x < d) {
ans = i + 1;
break;
}
}
cout << ans << endl;
} | [
"variable_declaration.value.change"
] | 812,571 | 812,572 | u661308718 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
#define dup(x, y) (((x) + (y)-1) / (y))
#define sz(x) (int)(x).size()
#define MOD 1000000007
#define pint pair<int, int>
#define pdouble pair<double, double>
using namespace std;
typedef long long ll;
int main() {
int n, x;
cin >> n >> x;
vector<int> a(n);
rep(i, n) cin >> a[i];
int p = 0;
int ans = 0;
rep(i, n) {
p += a[i];
if (p <= x) {
ans++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
#define dup(x, y) (((x) + (y)-1) / (y))
#define sz(x) (int)(x).size()
#define MOD 1000000007
#define pint pair<int, int>
#define pdouble pair<double, double>
using namespace std;
typedef long long ll;
int main() {
int n, x;
cin >> n >> x;
vector<int> a(n);
rep(i, n) cin >> a[i];
int p = 0;
int ans = 1;
rep(i, n) {
p += a[i];
if (p <= x) {
ans++;
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,573 | 812,574 | u319093540 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i < N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,580 | 812,581 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i < N; ++i) {
if (L[i] <= X)
++ans;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,582 | 812,581 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 1; i < N; ++i) {
if (L[i] <= X)
++ans;
}
cout << ans << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | [
"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"
] | 812,583 | 812,581 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 1; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 1; i < N; ++i) {
if (L[i] <= X)
++ans;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | [
"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"
] | 812,584 | 812,581 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i < N; ++i) {
if (L[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,585 | 812,581 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i < N; ++i) {
if (L[i] <= X)
ans++;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,580 | 812,586 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i < N; ++i) {
if (L[i] <= X)
++ans;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,582 | 812,586 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 1; i < N; ++i) {
if (L[i] <= X)
++ans;
}
cout << ans << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"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"
] | 812,583 | 812,586 | u506858457 | cpp |
p03000 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i < N; ++i) {
if (L[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
L[0] = 0;
for (int i = 0; i < N; ++i) {
int x;
cin >> x;
L[i + 1] = L[i] + x;
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
if (L[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,585 | 812,586 | u506858457 | cpp |
p03000 | #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int n, x;
cin >> n >> x;
int L[n];
int sum = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> L[i];
// cout << sum << endl;
sum = sum + L[i];
if (sum < x) {
ans++;
}
}
cout << ans + 1 << endl;
}
| #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int n, x;
cin >> n >> x;
int L[n];
int sum = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> L[i];
// cout << sum << endl;
sum = sum + L[i];
if (sum <= x) {
ans++;
}
}
cout << ans + 1 << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,599 | 812,600 | u840810569 | cpp |
p03000 | #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int n, x;
cin >> n >> x;
int L[n];
int sum = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> L[i];
// cout << sum << endl;
sum = sum + L[i];
if (sum > x)
ans++;
}
cout << ans + 1 << endl;
}
| #include <iostream>
using namespace std;
int main(void) {
// Your code here!
int n, x;
cin >> n >> x;
int L[n];
int sum = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> L[i];
// cout << sum << endl;
sum = sum + L[i];
if (sum <= x) {
ans++;
}
}
cout << ans + 1 << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,601 | 812,600 | u840810569 | 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 now = 0;
int ans = 0;
for (int i = 1; i < N; i++) {
now = now + L[i - 1];
if (now <= X)
ans++;
}
cout << ans + 1 << endl;
} | #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 now = 0;
int ans = 0;
// cout << now << endl;
for (int i = 1; i < N + 1; i++) {
now = now + L[i - 1];
// cout << now << endl;
if (now <= X)
ans++;
}
cout << ans + 1 << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,604 | 812,605 | u840810569 | cpp |
p03000 | #include <math.h> /*計算*/
#include <stdio.h> /*入出力*/
#include <stdlib.h> /*標準ライブラリ*/
#include <string.h> /*文字列*/
/*
ご指導ご鞭撻のほどよろしくお願いいたします。
@oct0pus_G
*/
int main(void) {
int N, X;
int L[100] = {0};
int D = 0;
scanf("%d%d", &N, &X);
for (size_t i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (size_t i = 0; i < N; i++) {
D += L[i];
if (D >= X) {
printf("%d\n", i + 1);
return 0;
}
}
printf("%d\n", N);
return 0;
} | #include <math.h> /*計算*/
#include <stdio.h> /*入出力*/
#include <stdlib.h> /*標準ライブラリ*/
#include <string.h> /*文字列*/
/*
ご指導ご鞭撻のほどよろしくお願いいたします。
@oct0pus_G
*/
int main(void) {
int N, X;
int L[100] = {0};
int D = 0;
scanf("%d%d", &N, &X);
for (size_t i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (size_t i = 0; i < N; i++) {
D += L[i];
if (D > X) {
printf("%d\n", i + 1);
return 0;
}
}
printf("%d\n", N + 1);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,606 | 812,607 | u484407086 | cpp |
p03000 | #include <math.h> /*計算*/
#include <stdio.h> /*入出力*/
#include <stdlib.h> /*標準ライブラリ*/
#include <string.h> /*文字列*/
/*
ご指導ご鞭撻のほどよろしくお願いいたします。
@oct0pus_G
*/
int main(void) {
int N, X;
int L[100] = {0};
int D = 0;
scanf("%d%d", &N, &X);
for (size_t i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (size_t i = 0; i < N; i++) {
D += L[i];
if (D > X) {
printf("%d\n", i + 1);
return 0;
}
}
printf("%d\n", N);
return 0;
}
| #include <math.h> /*計算*/
#include <stdio.h> /*入出力*/
#include <stdlib.h> /*標準ライブラリ*/
#include <string.h> /*文字列*/
/*
ご指導ご鞭撻のほどよろしくお願いいたします。
@oct0pus_G
*/
int main(void) {
int N, X;
int L[100] = {0};
int D = 0;
scanf("%d%d", &N, &X);
for (size_t i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (size_t i = 0; i < N; i++) {
D += L[i];
if (D > X) {
printf("%d\n", i + 1);
return 0;
}
}
printf("%d\n", N + 1);
return 0;
} | [
"expression.operation.binary.add"
] | 812,608 | 812,607 | u484407086 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0, cnt = 1, L = 0;
for (int i = 1; i < N; i++) {
cin >> L;
if (D + L <= X)
cnt++;
D = D + L;
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0, cnt = 1, L = 0;
for (int i = 0; i < N; i++) {
cin >> L;
if (D + L <= X)
cnt++;
D = D + L;
}
cout << cnt << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 812,611 | 812,612 | u204523044 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0, cnt = 1, L = 0;
for (int i = 1; i <= N; i++) {
cin >> L;
if (D + L < X)
cnt++;
D = D + L;
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0, cnt = 1, L = 0;
for (int i = 0; i < N; i++) {
cin >> L;
if (D + L <= X)
cnt++;
D = D + L;
}
cout << cnt << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 812,613 | 812,612 | u204523044 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0, cnt = 1, L = 0;
for (int i = 1; i < N; i++) {
cin >> L;
if (D + L < X)
cnt++;
D = D + L;
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0, cnt = 1, L = 0;
for (int i = 0; i < N; i++) {
cin >> L;
if (D + L <= X)
cnt++;
D = D + L;
}
cout << cnt << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,614 | 812,612 | u204523044 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ifaxb(a, x, b) if (a < x && x < b) // 比較は昇順
#define vi vector<int>
#define vii vector<vi>
#define vs vector<string>
#define vss vector<vs>
#define all(x) x.begin(), x.end()
#define pi 3.1415926536
#define ff first
#define ss second
#define pq priority_queue
#define ipair pair<int, int> s
#define lpair pair<LL, LL>
#define MP make_pair
#define INF 2147483647
#define _INF -2147483647
#define MM multimap
#define PB push_back
#define MAXN 100004
using namespace std;
typedef long long ll;
int main() {
int N, X;
cin >> N >> X;
vi D(N + 1);
D[0] = 0;
rep(i, 0, N) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
rep(i, 0, N + 1) {
if (D[i] <= X) {
ans++;
}
cout << ans << endl;
return 0;
}
} | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ifaxb(a, x, b) if (a < x && x < b) // 比較は昇順
#define vi vector<int>
#define vii vector<vi>
#define vs vector<string>
#define vss vector<vs>
#define all(x) x.begin(), x.end()
#define pi 3.1415926536
#define ff first
#define ss second
#define pq priority_queue
#define ipair pair<int, int> s
#define lpair pair<LL, LL>
#define MP make_pair
#define INF 2147483647
#define _INF -2147483647
#define MM multimap
#define PB push_back
#define MAXN 100004
using namespace std;
typedef long long ll;
int main() {
int N, X;
cin >> N >> X;
vi D(N + 1);
D[0] = 0;
rep(i, 0, N) {
int x;
cin >> x;
D[i + 1] = D[i] + x;
}
int ans = 0;
rep(i, 0, N + 1) {
if (D[i] <= X) {
ans++;
}
}
cout << ans << endl;
return 0;
} | [] | 812,621 | 812,622 | u075520262 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int ans = 0;
long long sum = 0;
;
int n;
int ni;
for (ni = 0; ni < N; ni++) {
cin >> n;
sum += n;
if (sum > X) {
ni++;
break;
}
}
ans = ni;
printf("%d", ans);
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int ans = 0;
long long sum = 0;
;
int n;
int ni;
for (ni = 0; ni < N; ni++) {
cin >> n;
sum += n;
if (sum > X) {
break;
}
}
ans = ni + 1;
printf("%d", ans);
return 0;
}
| [
"expression.unary.arithmetic.remove",
"assignment.change"
] | 812,623 | 812,624 | u388763757 | cpp |
p03000 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
int main() {
int n, x, nr;
cin >> n >> x;
vector<int> v;
rep(i, n) {
cin >> nr;
v.pb(nr);
}
int d = 0;
int bounces = 0;
for (int i = 1; i < n; i++) {
d = d + v[i - 1];
if (d >= x) {
break;
}
bounces++;
}
cout << bounces + 1;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
int main() {
int n, x, nr;
cin >> n >> x;
vector<int> v;
rep(i, n) {
cin >> nr;
v.pb(nr);
}
int d = 0;
int bounces = 0;
for (int i = 1; i < n + 1; i++) {
d = d + v[i - 1];
if (d > x) {
break;
}
bounces++;
}
cout << bounces + 1;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,625 | 812,626 | u391340825 | cpp |
p03000 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
int main() {
int n, x, nr;
cin >> n >> x;
vector<int> v;
rep(i, n) {
cin >> nr;
v.pb(nr);
}
int d = 0;
int bounces = 0;
for (int i = 1; i < n; i++) {
d = d + v[i - 1];
if (d > x) {
break;
}
bounces++;
}
cout << bounces + 1;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
int main() {
int n, x, nr;
cin >> n >> x;
vector<int> v;
rep(i, n) {
cin >> nr;
v.pb(nr);
}
int d = 0;
int bounces = 0;
for (int i = 1; i < n + 1; i++) {
d = d + v[i - 1];
if (d > x) {
break;
}
bounces++;
}
cout << bounces + 1;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,627 | 812,626 | u391340825 | 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 ad = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
ad += L[i];
if (ad >= 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 ad = 0;
int ans = 1;
for (int i = 0; i < N; i++) {
ad += L[i];
if (X >= ad) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 812,632 | 812,633 | u106782100 | cpp |
p03000 | #include <stdio.h>
int main() {
int N, X, L[10010], sum = 0, count = 0;
scanf("%d%d", &N, &X);
for (int i = 0; i <= N; i++) {
scanf("%d", &L[i]);
}
for (int i = 0; i <= N; i++) {
sum += L[i];
if (sum < X) {
count++;
}
}
printf("%d", count + 1);
return 0;
}
| #include <stdio.h>
int main() {
int N, X, L[10010], sum = 0, count = 0;
scanf("%d%d", &N, &X);
for (int i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum <= X) {
count++;
}
}
printf("%d", count + 1);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 812,645 | 812,646 | u195269284 | cpp |
p03000 | #include <stdio.h>
int main() {
int N, X, L[10010], sum = 0, count = 0;
scanf("%d%d", &N, &X);
for (int i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum < X) {
count++;
}
}
printf("%d", count + 1);
return 0;
}
| #include <stdio.h>
int main() {
int N, X, L[10010], sum = 0, count = 0;
scanf("%d%d", &N, &X);
for (int i = 0; i < N; i++) {
scanf("%d", &L[i]);
}
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum <= X) {
count++;
}
}
printf("%d", count + 1);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,647 | 812,646 | u195269284 | cpp |
p03000 | #include <bits/stdc++.h>
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;
vector<int> L(n);
vector<int> D(n);
rep(i, n) { cin >> L[i]; }
int ans = 1;
for (int i = 1; i < n; i++) {
D[i] = D[i - 1] + L[i - 1];
if (D[i] > x) {
break;
}
ans++;
}
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
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;
vector<int> L(n);
vector<int> D(n + 1);
rep(i, n) { cin >> L[i]; }
int ans = 1;
for (int i = 1; i <= n; i++) {
D[i] = D[i - 1] + L[i - 1];
if (D[i] > x) {
break;
}
ans++;
}
printf("%d\n", ans);
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,656 | 812,657 | u590000849 | cpp |
p03000 | #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, X;
cin >> N >> X;
int L[N];
REP(i, N) cin >> L[i];
int cnt = 0;
int D = 0;
int i = 0;
while (D <= X && i < N) {
D += L[i];
i++;
cnt++;
}
cout << cnt << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
// typedef
//------------------------------------------
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<PII> VP;
// REPEAT
//------------------------------------------
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define RFOR(i, m, n) for (int i = m; i > n; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, m) RFOR(i, m, 0)
// container util
//------------------------------------------
#define pb(a) push_back(a)
#define fst first
#define snd second
#define SORT(V) sort((V).begin(), (V).end())
#define REV(V) reverse((V).begin(), (V).end())
// constant
//------------------------------------------
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// grobal variable
//------------------------------------------
// def function, class
//------------------------------------------
// main
//------------------------------------------
signed main() {
int N, X;
cin >> N >> X;
int L[N];
REP(i, N) cin >> L[i];
int cnt = 0;
int D = 0;
int i = 0;
while (D <= X && i <= N) {
D += L[i];
i++;
cnt++;
}
cout << cnt << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 812,658 | 812,659 | u055131803 | 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 td = 0;
for (int i = 0; i < n; i++) {
td += l[i];
if (td < x)
ans++;
else
break;
}
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 td = 0;
for (int i = 0; i < n; i++) {
td += l[i];
if (td <= x)
ans++;
else
break;
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,664 | 812,665 | u568419568 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, x;
cin >> n >> x;
ll sum = 0;
for (int i = 1; i <= n; i++) {
int r;
cin >> r;
sum += r;
if (sum > x) {
cout << i << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, x;
cin >> n >> x;
ll sum = 0;
for (int i = 1; i <= n; i++) {
int r;
cin >> r;
sum += r;
if (sum > x) {
cout << i << endl;
return 0;
}
}
cout << n + 1 << endl;
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 812,668 | 812,669 | u708590262 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using pii = pair<int, int>;
#define fix10 cout << fixed << setprecision(10);
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
rep(i, n) { cin >> l.at(i); }
int count = 1;
int d = 0;
rep(i, n) {
d += l.at(i);
if (d <= x)
count++;
else {
cout << count;
return 0;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using pii = pair<int, int>;
#define fix10 cout << fixed << setprecision(10);
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n);
rep(i, n) { cin >> l.at(i); }
int count = 1;
int d = 0;
rep(i, n) {
d += l.at(i);
if (d <= x)
count++;
else {
cout << count;
return 0;
}
}
cout << count;
} | [] | 812,672 | 812,673 | u184335045 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0;
int i = 0;
while (i < N) {
int L;
cin >> L;
D += L;
if (D > X) {
break;
}
i++;
}
cout << i << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D = 0;
int i = 0;
while (i < N) {
int L;
cin >> L;
D += L;
if (D > X) {
break;
}
i++;
}
cout << i + 1 << endl;
}
| [
"expression.operation.binary.add"
] | 812,678 | 812,679 | u817769480 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, answer = 0;
cin >> N >> X;
vector<int> L(N), D(N + 1);
D.at(0) = 0;
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
for (int i = 0; i < N; i++) {
D.at(i + 1) = D.at(i) + L.at(i);
}
for (int i = 0; i < N; i++) {
if (D.at(i) <= X) {
answer++;
}
}
cout << answer << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, answer = 0;
cin >> N >> X;
vector<int> L(N), D(N + 1);
D.at(0) = 0;
for (int i = 0; i < N; i++) {
cin >> L.at(i);
}
for (int i = 0; i < N; i++) {
D.at(i + 1) = D.at(i) + L.at(i);
}
for (int i = 0; i <= N; i++) {
if (D.at(i) <= X) {
answer++;
}
}
cout << answer << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,680 | 812,681 | u852770206 | 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];
}
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
int ans = 0;
for (int i = 0; i < N; i++) {
if (D[i] <= X) {
ans++;
}
}
cout << ans << 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[i];
}
vector<int> D(N + 1);
D[0] = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
int ans = 0;
for (int i = 0; i < N + 1; i++) {
if (D[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,694 | 812,695 | u914086391 | cpp |
p03000 | #include <stdio.h>
int main(void) {
int N, X, D = 0;
scanf("%d %d", &N, &X);
int L;
for (int i = 0; i < N; i++) {
scanf("%d", &L);
D += L;
if (D > X) {
printf("%d", i + 1);
return 0;
}
}
printf("%d", N);
return 0;
}
| #include <stdio.h>
int main(void) {
int N, X, D = 0;
scanf("%d %d", &N, &X);
int L;
for (int i = 0; i < N; i++) {
scanf("%d", &L);
D += L;
if (D > X) {
printf("%d", i + 1);
return 0;
}
}
printf("%d", N + 1);
return 0;
}
| [
"expression.operation.binary.add"
] | 812,714 | 812,715 | u651802048 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n + 1);
l[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
int d = 0, c = 0;
for (int i = 1; i <= n; i++) {
d = d + l[i - 1];
if (d < x + 1)
c++;
else
break;
}
cout << c << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> l(n + 1);
l[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
int d = 0, c = 0;
for (int i = 1; i < n + 2; i++) {
d = d + l[i - 1];
if (d < x + 1)
c++;
else
break;
}
cout << c << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,716 | 812,717 | u666121874 | cpp |
p03000 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int N, X;
vector<int> L;
vector<int> D;
int main() {
cin >> N >> X;
L.resize(N + 1);
D.resize(N + 1);
int counter = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
L[i] = x;
if (i == 0) {
D[i] = 0;
} else {
D[i] = D[i - 1] + L[i - 1];
}
if (D[i] <= X) {
counter++;
}
}
cout << counter << endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int N, X;
vector<int> L;
vector<int> D;
int main() {
cin >> N >> X;
L.resize(N + 1);
D.resize(N + 1);
int counter = 0;
for (int i = 0; i < N + 1; i++) {
int x;
cin >> x;
L[i] = x;
if (i == 0) {
D[i] = 0;
} else {
D[i] = D[i - 1] + L[i - 1];
}
if (D[i] <= X) {
counter++;
}
}
cout << counter << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,729 | 812,730 | u820164965 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
vector<int> t(111), u(111);
int n, x;
int main() {
cin >> n >> x;
for (int i = 0; i < n; i++)
cin >> t[i];
u[0] = 0;
for (int i = 1; i <= n; i++) {
u[i] = u[i - 1] + t[i - 1];
// cout <<u[i]<<" ";
}
for (int i = 0; i <= n; i++)
if (u[i] > x) {
cout << i << endl;
return 0;
}
cout << n << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
vector<int> t(111), u(111);
int n, x;
int main() {
cin >> n >> x;
for (int i = 0; i < n; i++)
cin >> t[i];
u[0] = 0;
for (int i = 1; i <= n; i++) {
u[i] = u[i - 1] + t[i - 1];
// cout <<u[i]<<" ";
}
for (int i = 0; i <= n; i++)
if (u[i] > x) {
cout << i << endl;
return 0;
}
cout << n + 1 << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,742 | 812,743 | u514602572 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int bounce[N + 1];
bounce[0] = 0;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
bounce[i + 1] = bounce[i] + L;
}
int ans = 0;
for (int i = 0; i < N; i++) {
if (bounce[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int bounce[N + 1];
bounce[0] = 0;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
bounce[i + 1] = bounce[i] + L;
}
int ans = 0;
for (int i = 0; i < N + 1; i++) {
if (bounce[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,757 | 812,758 | u873269440 | cpp |
p03000 | #include <bits/stdc++.h>
#define lli long long int
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, cnt = 1;
cin >> n >> x;
int a[n + 5];
a[0] = 0;
for (int i = 1; i < n; i++) {
cin >> a[i];
a[i] += a[i - 1];
if (a[i] <= x)
cnt++;
}
cout << cnt << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define lli long long int
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, cnt = 1;
cin >> n >> x;
int a[n + 5];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
if (a[i] <= x)
cnt++;
}
cout << cnt << "\n";
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,770 | 812,771 | u842407954 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i, l, t;
int a = 0;
vector<int> d(101);
cin >> n >> x;
for (i = 0; i < n; i = i + 1) {
cin >> l;
d.at(i + 1) = d.at(i) + l;
}
for (i = 0; i < n; i = i + 1) {
if (d.at(i) <= x)
a += 1;
}
cout << a << endl;
;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i, l, t;
int a = 0;
vector<int> d(101);
cin >> n >> x;
for (i = 0; i < n; i = i + 1) {
cin >> l;
d.at(i + 1) = d.at(i) + l;
}
for (i = 0; i <= n; i = i + 1) {
if (d.at(i) <= x)
a += 1;
}
cout << a << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,774 | 812,775 | u854243627 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[100];
for (int i = 1; i <= n; i++)
cin >> l[i];
int d[10000];
d[0] = 0;
for (int i = 1; i <= n; i++) {
d[i] = d[i - 1] + l[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (d[i] <= x)
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[100];
for (int i = 1; i <= n; i++)
cin >> l[i];
int d[10000];
d[0] = 0;
for (int i = 1; i <= n; i++) {
d[i] = d[i - 1] + l[i];
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (d[i] <= x)
ans++;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,776 | 812,777 | u525137785 | 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 sum = 0, ans = 0;
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum > X) {
break;
}
ans += 1;
}
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 sum = 0;
int ans = 1;
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum > X) {
break;
}
ans += 1;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,778 | 812,779 | u358859892 | 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 sum = 0, ans = 0;
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum > X) {
break;
}
ans += 1;
}
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 sum = 0, ans = 1;
for (int i = 0; i < N; i++) {
sum += L[i];
if (sum > X) {
break;
}
ans += 1;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,778 | 812,780 | u358859892 | cpp |
p03000 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define INF (1 << 30)
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
const long long mod = 1e9 + 7;
using namespace std;
using ll = __int64_t;
using ull = unsigned long long;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int DX[] = {1, 1, 0, -1, -1, -1, 0, 1};
int DY[] = {0, -1, -1, -1, 0, 1, 1, 1};
bool comp(const pair<int, ll> &p1, const pair<int, ll> &p2) {
return p1.second > p2.second;
}
void solve() {
int n, x, res = 0;
int l[100], d[100];
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
d[0] = 0;
for (int i = 1; i < n; i++) {
d[i] = d[i - 1] + l[i - 1];
}
for (int i = 0; i < n; i++) {
if (d[i] <= x) {
res++;
}
}
cout << res << endl;
}
int main() {
solve();
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define INF (1 << 30)
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
const long long mod = 1e9 + 7;
using namespace std;
using ll = __int64_t;
using ull = unsigned long long;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int DX[] = {1, 1, 0, -1, -1, -1, 0, 1};
int DY[] = {0, -1, -1, -1, 0, 1, 1, 1};
bool comp(const pair<int, ll> &p1, const pair<int, ll> &p2) {
return p1.second > p2.second;
}
void solve() {
int n, x, res = 0;
int l[100], d[100];
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> l[i];
}
d[0] = 0;
for (int i = 1; i <= n; i++) {
d[i] = d[i - 1] + l[i - 1];
}
for (int i = 0; i <= n; i++) {
if (d[i] <= x) {
res++;
}
}
cout << res << endl;
}
int main() {
solve();
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,783 | 812,784 | u679071005 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l;
int d = 0, counter = 0;
for (int i = 0; i < n; i++) {
counter++;
cin >> l;
d += l;
if (d > x)
break;
}
cout << counter;
} | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l;
int d = 0, counter = 0;
for (int i = 0; i <= n; i++) {
counter++;
cin >> l;
d += l;
if (d > x)
break;
}
cout << counter;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,789 | 812,790 | u865979946 | cpp |
p03000 | #include <iostream>
#include <string>
#include <vector>
using ll = unsigned long long;
using namespace std;
int main(void) {
int n, x;
cin >> n >> x;
int *l = new int[n + 1];
int *j = new int[n + 1];
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
int k = 0;
j[0] = 0;
while (k < n) {
j[k + 1] = j[k] + l[k];
if (j[k] > x) {
break;
}
++k;
}
cout << k << endl;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
using ll = unsigned long long;
using namespace std;
int main(void) {
int n, x;
cin >> n >> x;
int *l = new int[n + 1];
int *j = new int[n + 1];
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
int k = 0;
j[0] = 0;
while (k < n) {
j[k + 1] = j[k] + l[k];
// cout << "j[" << k+1 << "]=" << j[k+1] << endl;
if (j[k + 1] > x) {
break;
}
++k;
}
cout << k + 1 << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 812,794 | 812,795 | u871841829 | cpp |
p03000 | #include <algorithm>
#include <array>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define Get(ty, ...) \
ty __VA_ARGS__; \
cins(__VA_ARGS__);
#define GetArray(ty, v, n) \
vector<ty> v(n); \
cin_arr(v, n);
#define ci cin
#define co cout
#define en endl;
#define Arr(f, arr, pred) f(arr.begin(), arr.end(), pred)
#define Arr2(f, arr) f(arr.begin(), arr.end())
#define ArrExpr(f, arr, expr) \
f(arr.begin(), arr.end(), [](auto x) { return expr; })
#define Acc(init, arr, pred) accumulate(arr.begin(), arr.end(), init, pred)
void cins() {}
template <class Head, class... Tail> void cins(Head &head, Tail &...tail) {
cin >> head;
cins(tail...);
}
template <class Arr> void cin_arr(Arr &v, int n) {
for (int i = 0; i < n; i++)
cin >> v[i];
}
int main() {
Get(int, n, x);
GetArray(int, v, n);
int count = 1;
int nowX = 0;
for (int y : v) {
nowX += y;
if (nowX <= x) {
count++;
break;
}
}
co << count << en;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define Get(ty, ...) \
ty __VA_ARGS__; \
cins(__VA_ARGS__);
#define GetArray(ty, v, n) \
vector<ty> v(n); \
cin_arr(v, n);
#define ci cin
#define co cout
#define en endl;
#define Arr(f, arr, pred) f(arr.begin(), arr.end(), pred)
#define Arr2(f, arr) f(arr.begin(), arr.end())
#define ArrExpr(f, arr, expr) \
f(arr.begin(), arr.end(), [](auto x) { return expr; })
#define Acc(init, arr, pred) accumulate(arr.begin(), arr.end(), init, pred)
void cins() {}
template <class Head, class... Tail> void cins(Head &head, Tail &...tail) {
cin >> head;
cins(tail...);
}
template <class Arr> void cin_arr(Arr &v, int n) {
for (int i = 0; i < n; i++)
cin >> v[i];
}
int main() {
Get(int, n, x);
GetArray(int, v, n);
int count = 1;
int nowX = 0;
for (int y : v) {
nowX += y;
if (nowX <= x) {
count++;
} else {
break;
}
}
co << count << en;
}
| [
"control_flow.branch.else.add"
] | 812,805 | 812,806 | u258855829 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int sum = 0;
int count = 0;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
sum += temp;
if (sum > x) {
break;
}
count++;
}
cout << count;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int sum = 0;
int count = 1;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
sum += temp;
if (sum > x) {
break;
}
count++;
}
cout << count;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,813 | 812,814 | u117615163 | cpp |
p03000 | #include "bits/stdc++.h"
using namespace std;
int main() {
int n, x, i, d = 0;
cin >> n >> x;
vector<int> l(n);
for (i = 0; i < n; i++)
cin >> l[i];
for (i = 2; i < n + 1; i++) {
d = d + l[i - 2];
if (x < d)
break;
}
cout << i - 1 << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
int main() {
int n, x, i, d = 0;
cin >> n >> x;
vector<int> l(n);
for (i = 0; i < n; i++)
cin >> l[i];
for (i = 2; i <= n + 1; i++) {
d = d + l[i - 2];
if (x < d)
break;
}
cout << i - 1 << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,815 | 812,816 | u038841188 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define Rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define int long long
using namespace std;
signed main() {
int x, y, z = 0, w, i, j = 1;
cin >> x >> y;
std::vector<int> v(x);
rep(i, x) { cin >> v[i]; }
Rep(i, x) {
if (v[i] + z <= y) {
z += v[i];
j++;
}
}
cout << j << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define repone(i, n) for (int i = 1; i < (int)(n); ++i)
#define Rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define int long long
using namespace std;
signed main() {
int x, y, z = 0, w, i, j = 1;
cin >> x >> y;
std::vector<int> v(x);
rep(i, x) { cin >> v[i]; }
Rep(i, x) {
if (v[i] + z <= y) {
z += v[i];
j++;
} else {
break;
}
}
cout << j << endl;
return 0;
}
| [
"control_flow.branch.else.add"
] | 812,834 | 812,835 | u893330446 | cpp |
p03000 | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <deque>
#include <forward_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
int main() {
int n, x;
std::cin >> n >> x;
std::vector<int> L(n + 1);
L[0] = 0;
for (int i = 1; i < n + 1; i++) {
std::cin >> L[i];
}
int ans = 0;
for (int i = 0; i < n + 1; i++) {
ans += L[i];
if (ans > x) {
std::cout << i << std::endl;
break;
} else if (i == n) {
std::cout << i << std::endl;
}
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <deque>
#include <forward_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
int main() {
int n, x;
std::cin >> n >> x;
std::vector<int> L(n + 1);
L[0] = 0;
for (int i = 1; i < n + 1; i++) {
std::cin >> L[i];
}
int ans = 0;
for (int i = 0; i < n + 1; i++) {
ans += L[i];
if (ans > x) {
std::cout << i << std::endl;
break;
} else if (i == n) {
std::cout << i + 1 << std::endl;
}
}
return 0;
} | [
"expression.operation.binary.add"
] | 812,845 | 812,846 | u133607477 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e4;
int a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int d = 0, ans = 1;
for (int i = 1; i < n; i++) {
d = d + a[i - 1];
if (d > x)
break;
ans++;
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e4;
int a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int d = 0, ans = 1;
for (int i = 1; i <= n; i++) {
d = d + a[i - 1];
if (d > x)
break;
ans++;
}
cout << ans;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,853 | 812,854 | u382773334 | cpp |
p03000 | #include <stdio.h>
int main(void) {
int i, n, x, c = 0, a = 0;
scanf("%d%d", &n, &x);
int l[n];
for (i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (i = 0; i < n; i++) {
a += l[i];
if (a < x)
c++;
}
printf("%d", c + 1);
return 0;
} | #include <stdio.h>
int main(void) {
int i, n, x, c = 0, a = 0;
scanf("%d%d", &n, &x);
int l[n];
for (i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (i = 0; i < n; i++) {
a += l[i];
if (a <= x)
c++;
}
printf("%d", c + 1);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,855 | 812,856 | u351322912 | cpp |
p03000 | // gauravsinghh
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define ld long double
#define db double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int, int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define on cout << "\n"
#define o2(a, b) cout << a << " " << b
#define os cout << " "
#define bitcount __builtin_popcount
#define gcd __gcd
#define endl "\n"
#define present(s, x) (s.find(x) != s.end())
#define cpresent(s, x) (find(all(s), x) != s.end())
#define ford(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define fors(container, it, a, b) \
for (__typeof(container.begin()) it = a; it != b; it++)
#define MOD 1000000007
#define EPSILON 1e-9
#define PI 3.14159265358979323846
#define inf 999999999999999999
#define siz 100005
#define fbo find_by_order
#define ook order_of_key
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (int i = a; i <= b; i++)
#define ffo(i, a, b) for (int i = a; i >= b; i--)
#define MAX 100005
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
//#pragma GCC target ("avx2")
//#pragma GCC optimization ("O3")
//#pragma GCC optimization ("unroll-loops")
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool comp(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return ((a.ss < b.ss) || (a.ss == b.ss && a.ff < b.ff));
}
signed main() {
IOS
// io_set();
ll n,
k;
cin >> n >> k;
vector<ll> v(n);
v[0] = 0;
fo(i, 1, n - 1) {
cin >> v[i];
v[i] += v[i - 1];
}
ll x = upb(all(v), k) - v.begin();
cout << x << endl;
return 0;
}
| // gauravsinghh
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define ld long double
#define db double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int, int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define on cout << "\n"
#define o2(a, b) cout << a << " " << b
#define os cout << " "
#define bitcount __builtin_popcount
#define gcd __gcd
#define endl "\n"
#define present(s, x) (s.find(x) != s.end())
#define cpresent(s, x) (find(all(s), x) != s.end())
#define ford(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define fors(container, it, a, b) \
for (__typeof(container.begin()) it = a; it != b; it++)
#define MOD 1000000007
#define EPSILON 1e-9
#define PI 3.14159265358979323846
#define inf 999999999999999999
#define siz 100005
#define fbo find_by_order
#define ook order_of_key
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (int i = a; i <= b; i++)
#define ffo(i, a, b) for (int i = a; i >= b; i--)
#define MAX 100005
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
//#pragma GCC target ("avx2")
//#pragma GCC optimization ("O3")
//#pragma GCC optimization ("unroll-loops")
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool comp(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return ((a.ss < b.ss) || (a.ss == b.ss && a.ff < b.ff));
}
signed main() {
IOS
// io_set();
ll n,
k;
cin >> n >> k;
vector<ll> v(n + 1);
v[0] = 0;
fo(i, 1, n) {
cin >> v[i];
v[i] += v[i - 1];
}
ll x = upb(all(v), k) - v.begin();
cout << x << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 812,865 | 812,866 | u480527921 | 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 ans = 1;
int D = 0;
for (int i = 0; i < N; i++) {
D += L[i];
if (D < X) {
ans++;
}
}
cout << ans << endl;
return 0;
} | #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 ans = 1;
int D = 0;
for (int i = 0; i < N; i++) {
D += L[i];
if (D <= X) {
ans++;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,877 | 812,878 | u855985627 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <complex> // complex<double> a(1.2 , 2.3);// real(): 1.2, imag()2.3
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define MOD 1000000007
#define ll long long
#define ld long double
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define rep(i, n) FOR(i, 0, n)
#define pb push_back
#define mp make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rmsame(a) sort(all(a)), a.erase(unique(all(a)), a.end())
#define rmvector(a, b) \
rep(i, a.size()) rep(j, b.size()) if (a[i] == b[j]) { \
a.erase(a.begin() + i); \
i--; \
break; \
}
#define first_more_idx(ve, num) \
upper_bound(all(ve), num) - ve.begin() // idx = first_more_idx(ve,num); if(idx
// = ve.size()) , then not exist
#define first_lessequal_idx(ve, num) lower_bound(all(ve), num) - ve.begin()
#define pq_pair_tB \
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>>
#define pq_pair_ts priority_queue<pair<ll, ll>> // only sort first param
template <typename X> bool exist(vector<X> vec, X item) {
return find(all(vec), item) != vec.end();
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll power(ll x, ll n) {
if (n == 0)
return 1;
return (n % 2) ? x * power(x, n - 1) % MOD : power(x * x % MOD, n / 2);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, X;
cin >> N >> X;
vector<ll> A;
ll now = 0;
A.pb(now);
rep(i, N) {
ll inp;
cin >> inp;
now += inp;
A.pb(now);
}
rep(i, N) {
if (A[i] > X) {
cout << i << endl;
return 0;
}
}
cout << N + 1 << endl;
// cout << fixed << setprecision(16) << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <complex> // complex<double> a(1.2 , 2.3);// real(): 1.2, imag()2.3
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define MOD 1000000007
#define ll long long
#define ld long double
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define rep(i, n) FOR(i, 0, n)
#define pb push_back
#define mp make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rmsame(a) sort(all(a)), a.erase(unique(all(a)), a.end())
#define rmvector(a, b) \
rep(i, a.size()) rep(j, b.size()) if (a[i] == b[j]) { \
a.erase(a.begin() + i); \
i--; \
break; \
}
#define first_more_idx(ve, num) \
upper_bound(all(ve), num) - ve.begin() // idx = first_more_idx(ve,num); if(idx
// = ve.size()) , then not exist
#define first_lessequal_idx(ve, num) lower_bound(all(ve), num) - ve.begin()
#define pq_pair_tB \
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>>
#define pq_pair_ts priority_queue<pair<ll, ll>> // only sort first param
template <typename X> bool exist(vector<X> vec, X item) {
return find(all(vec), item) != vec.end();
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll power(ll x, ll n) {
if (n == 0)
return 1;
return (n % 2) ? x * power(x, n - 1) % MOD : power(x * x % MOD, n / 2);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, X;
cin >> N >> X;
vector<ll> A;
ll now = 0;
A.pb(now);
rep(i, N) {
ll inp;
cin >> inp;
now += inp;
A.pb(now);
}
rep(i, A.size()) {
if (A[i] > X) {
cout << i << endl;
return 0;
}
}
cout << N + 1 << endl;
// cout << fixed << setprecision(16) << ans << endl;
return 0;
}
| [
"call.add"
] | 812,890 | 812,891 | u866107333 | cpp |
p03000 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <thread>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double D;
typedef complex<D> P;
const ll E = 1e18 + 7;
const ll MOD = 1000000007;
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(0);
#define REP(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define fill(x, y) memset(x, y, sizeof(x))
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define F first
#define S second
template <class... A> void prints() { cout << endl; }
template <class... A> void prints_rest() { cout << endl; }
template <class T, class... A>
void prints_rest(const T &first, const A &...rest) {
cout << " " << first;
prints_rest(rest...);
}
template <class T, class... A> void prints(const T &first, const A &...rest) {
cout << first;
prints_rest(rest...);
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
int main() {
int n, x;
cin >> n >> x;
int L[n];
int d = 0;
rep(i, n) {
cin >> L[i];
d += L[i];
if (d > x) {
prints(i + 1);
return 0;
}
}
prints(n);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <thread>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double D;
typedef complex<D> P;
const ll E = 1e18 + 7;
const ll MOD = 1000000007;
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(0);
#define REP(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define fill(x, y) memset(x, y, sizeof(x))
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define F first
#define S second
template <class... A> void prints() { cout << endl; }
template <class... A> void prints_rest() { cout << endl; }
template <class T, class... A>
void prints_rest(const T &first, const A &...rest) {
cout << " " << first;
prints_rest(rest...);
}
template <class T, class... A> void prints(const T &first, const A &...rest) {
cout << first;
prints_rest(rest...);
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
int main() {
int n, x;
cin >> n >> x;
int L[n];
int d = 0;
rep(i, n) {
cin >> L[i];
d += L[i];
if (d > x) {
prints(i + 1);
return 0;
}
}
prints(n + 1);
return 0;
}
| [
"expression.operation.binary.add"
] | 812,892 | 812,893 | u598755311 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int n, x, l[105];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) {
scanf("%d", &l[i]);
l[i] += l[i - 1];
}
printf("%d\n", upper_bound(l + 1, l + n + 1, x) - (l + 1));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, x, l[105];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) {
scanf("%d", &l[i]);
l[i] += l[i - 1];
}
printf("%d\n", upper_bound(l + 1, l + n + 1, x) - l);
return 0;
} | [
"call.arguments.change"
] | 812,894 | 812,895 | u147067618 | cpp |
p03000 | //#include <bits/stdc++.h>
//#include <stdio.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 // 2000000000
#define LINF 1000000000000000000 // 9000000000000000000
#define DINF 1000000000000000.0
#define PI 3.14159265358979
#define MAXI 7500000
//.size()はunsigned int 0-1をするとオーバーフローする
using namespace std;
typedef long long int ll;
typedef pair<double, int> P;
// int dy[5] = { 0,0,1,-1,0 };
// int dx[5] = { 1,-1,0,0,0 };
int dy[5] = {-1, 0, 1, 0, 0};
int dx[5] = {0, -1, 0, 1, 0};
struct edge {
int to;
double cost;
};
int main(void) {
int n, x;
int l[101];
int count = 0;
int high = 0;
cin >> n >> x;
FOR(i, 1, n) { cin >> l[i]; }
FOR(i, 1, n) {
high += l[i];
if (high <= x) {
count++;
}
}
cout << count << endl;
}
| //#include <bits/stdc++.h>
//#include <stdio.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 // 2000000000
#define LINF 1000000000000000000 // 9000000000000000000
#define DINF 1000000000000000.0
#define PI 3.14159265358979
#define MAXI 7500000
//.size()はunsigned int 0-1をするとオーバーフローする
using namespace std;
typedef long long int ll;
typedef pair<double, int> P;
// int dy[5] = { 0,0,1,-1,0 };
// int dx[5] = { 1,-1,0,0,0 };
int dy[5] = {-1, 0, 1, 0, 0};
int dx[5] = {0, -1, 0, 1, 0};
struct edge {
int to;
double cost;
};
int main(void) {
int n, x;
int l[101];
int count = 1;
int high = 0;
cin >> n >> x;
FOR(i, 1, n) { cin >> l[i]; }
FOR(i, 1, n) {
high += l[i];
if (high <= x) {
count++;
}
}
cout << count << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,896 | 812,897 | u057611820 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vi l(n + 1, 0);
REP(i, n) cin >> l[i + 1];
int d = 0;
int ans = 0;
while (ans < n + 1 && d <= x) {
d += l[ans++];
}
cout << ans - 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vi l(n + 1, 0);
REP(i, n) cin >> l[i];
int d = 0;
int ans = 0;
while (ans < n + 1 && d <= x) {
d += l[ans++];
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 812,898 | 812,899 | u949798495 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vi l(n + 1, 0);
REP(i, n) cin >> l[i + 1];
int d = 0;
int ans = 0;
while (ans < n + 1 && d <= x) {
d += l[ans++];
}
cout << ans - 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vi l(n + 2, 0);
REP(i, n) cin >> l[i + 1];
int d = 0;
int ans = 0;
while (ans < n + 2 && d <= x) {
d += l[ans++];
}
cout << ans - 1 << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.condition.change"
] | 812,898 | 812,900 | u949798495 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vi l(n + 1, 0);
REP(i, n) cin >> l[i + 1];
int d = 0;
int ans = 0;
while (ans < n + 1 && d <= x) {
d += l[ans++];
ans++;
}
cout << ans - 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vi l(n + 2, 0);
REP(i, n) cin >> l[i + 1];
int d = 0;
int ans = 0;
while (ans < n + 2 && d <= x) {
d += l[ans++];
}
cout << ans - 1 << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.condition.change",
"expression.unary.arithmetic.remove"
] | 812,901 | 812,900 | u949798495 | cpp |
p03000 | //#include <boost/multiprecision/cpp_dec_float.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
// namespace mp = boost::multiprecision;
// using llll = mp::cpp_int;
// 仮数部が1024ビットの浮動小数点数型(TLEしたら小さくする)
// using Real = mp::number<mp::cpp_dec_float<1024>>;
using ll = long long;
const double EPS = 1e-10;
const ll MOD = 7 + (1e+9);
int main() {
ll n, x;
cin >> n >> x;
vector<ll> v(n + 1, 0);
ll ans = 0;
for (ll i = 0; i < n; i++) {
cin >> v[i + 1];
v[i + 1] += v[i];
}
for (ll i = 0; i < n; i++) {
if (v[i] <= x)
ans++;
}
cout << ans << endl;
}
| //#include <boost/multiprecision/cpp_dec_float.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
// namespace mp = boost::multiprecision;
// using llll = mp::cpp_int;
// 仮数部が1024ビットの浮動小数点数型(TLEしたら小さくする)
// using Real = mp::number<mp::cpp_dec_float<1024>>;
using ll = long long;
const double EPS = 1e-10;
const ll MOD = 7 + (1e+9);
int main() {
ll n, x;
cin >> n >> x;
vector<ll> v(n + 1, 0);
ll ans = 0;
for (ll i = 0; i < n; i++) {
cin >> v[i + 1];
v[i + 1] += v[i];
}
for (ll i = 0; i < n + 1; i++) {
if (v[i] <= x)
ans++;
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,904 | 812,905 | u569367525 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define ll long long int
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D[N + 1];
D[0] = 0;
int ans = 0;
rep(i, 0, N) {
int L;
cin >> L;
D[i + 1] = D[i] + L;
if (D[i + 1] > X) {
ans = i + 1;
break;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define ll long long int
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int D[N + 1];
D[0] = 0;
int ans = N + 1;
rep(i, 0, N) {
int L;
cin >> L;
D[i + 1] = D[i] + L;
if (D[i + 1] > X) {
ans = i + 1;
break;
}
}
cout << ans << endl;
} | [
"identifier.replace.add",
"literal.replace.remove"
] | 812,906 | 812,907 | u352200121 | cpp |
p03000 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, x, L, ans;
cin >> N >> X;
L = 0;
ans = 0;
for (int i = 0; i < N; i++) {
cin >> x;
L += x;
if (L < X) {
ans += 1;
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, x, L, ans;
cin >> N >> X;
L = 0;
ans = 1;
for (int i = 0; i < N; i++) {
cin >> x;
L += x;
if (L <= X) {
ans += 1;
}
}
cout << ans;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 812,908 | 812,909 | u947426792 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, x, L, ans;
cin >> N >> X;
L = 0;
ans = 0;
for (int i = 0; i < N; i++) {
cin >> x;
L += x;
if (L < X) {
ans += i;
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, x, L, ans;
cin >> N >> X;
L = 0;
ans = 1;
for (int i = 0; i < N; i++) {
cin >> x;
L += x;
if (L <= X) {
ans += 1;
}
}
cout << ans;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.replace.remove",
"literal.replace.add"
] | 812,910 | 812,909 | u947426792 | cpp |
p03000 | #include <iostream>
using namespace std;
int main(void) {
int N, X, L[10000];
cin >> N >> X;
int i, j;
for (i = 0; i < N; i++) {
cin >> L[i];
}
int D[10001];
for (j = 0; j < N + 1; j++) {
D[0] = 0;
D[j + 1] = D[j] + L[j];
if (D[j + 1] > X) {
break;
}
}
cout << j + 1;
}
| #include <iostream>
using namespace std;
int main(void) {
int N, X, L[100];
cin >> N >> X;
int i, j;
for (i = 0; i < N; i++) {
cin >> L[i];
}
int D[100];
for (j = 0; j < N; j++) {
D[0] = 0;
D[j + 1] = D[j] + L[j];
if (D[j + 1] > X) {
break;
}
}
cout << j + 1;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 812,918 | 812,919 | u968313090 | 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;
vector<int> L(N), D(N);
rep(i, N) cin >> L[i];
int ans = 1;
for (int i = 1; i < N; ++i) {
D[i] = D[i - 1] + L[i - 1];
if (D[i] <= X) {
ans++;
}
}
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;
vector<int> L(N), D(N + 1);
rep(i, N) cin >> L[i];
int ans = 1;
for (int i = 1; i <= N; ++i) {
D[i] = D[i - 1] + L[i - 1];
if (D[i] <= X) {
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,924 | 812,925 | u887207211 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define REP(i, a, n) for (int i = a; i < n; ++i)
#define REPR(i, a, n) for (int i = a; i > n; --i)
#define RUP(a, b) ((a + b - 1) / (b))
#define ALL(v) (v).begin(), (v).end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define MOD 1000000007
#define INF LLONG_MAX
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> Tiii;
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef vector<string> Vs;
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;
}
template <class T> void YesNo(T a) { cout << (a ? "Yes" : "No") << endl; }
template <class T> void YESNO(T a) { cout << (a ? "YES" : "NO") << endl; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void uniq(vector<int> &vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
void start() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
}
signed main() {
start();
int n, x, ans = 1;
cin >> n >> x;
Vi l(n), a(n + 1);
REP(i, 0, n) cin >> l[i];
a[0] = 0;
REP(i, 1, n) {
a[i] = a[i - 1] + l[i - 1];
if (a[i] <= x)
ans++;
else
break;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
#define REP(i, a, n) for (int i = a; i < n; ++i)
#define REPR(i, a, n) for (int i = a; i > n; --i)
#define RUP(a, b) ((a + b - 1) / (b))
#define ALL(v) (v).begin(), (v).end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define MOD 1000000007
#define INF LLONG_MAX
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> Tiii;
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef vector<string> Vs;
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;
}
template <class T> void YesNo(T a) { cout << (a ? "Yes" : "No") << endl; }
template <class T> void YESNO(T a) { cout << (a ? "YES" : "NO") << endl; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void uniq(vector<int> &vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
void start() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
}
signed main() {
start();
int n, x, ans = 1;
cin >> n >> x;
Vi l(n), a(n + 1);
REP(i, 0, n) cin >> l[i];
a[0] = 0;
REP(i, 1, n + 1) {
a[i] = a[i - 1] + l[i - 1];
if (a[i] <= x)
ans++;
else
break;
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 812,948 | 812,949 | u635484372 | cpp |
p03000 | #include <bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
using namespace std;
int static fast = []() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
return 0;
}();
int main() {
int N, X;
cin >> N >> X;
vector<int> arr(N, 0);
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
int ans = 1;
int pos = 0;
for (int i = 0; i < N; i++) {
if (pos + arr[i] <= X) {
pos += arr[i];
ans += 1;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
using namespace std;
int static fast = []() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
return 0;
}();
int main() {
int N, X;
cin >> N >> X;
vector<int> arr(N, 0);
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
int ans = 1;
int pos = 0;
for (int i = 0; i < N; i++) {
if (pos + arr[i] <= X) {
pos += arr[i];
ans += 1;
} else {
break;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.else.add"
] | 812,950 | 812,951 | u067694854 | cpp |
p03000 | #include <iostream>
int main() {
int N, X;
int L[100] = {}, D[101] = {};
std::cin >> N >> X;
int counter = 0;
for (int i = 0; i < N; i++) {
std::cin >> L[i];
if (D[i] <= X) {
counter++;
} else {
break;
}
D[i + 1] = D[i] + L[i];
}
std::cout << counter << std::endl;
} | #include <iostream>
int main() {
int N, X;
int L[100] = {}, D[101] = {};
std::cin >> N >> X;
int counter = 0;
for (int i = 0; i < N + 1; i++) {
std::cin >> L[i];
if (D[i] <= X) {
counter++;
} else {
break;
}
D[i + 1] = D[i] + L[i];
}
std::cout << counter << std::endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 812,952 | 812,953 | u632628124 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int N, X;
int bound_count = 0;
int zahyou = 0;
cin >> N >> X;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
zahyou += L;
if (zahyou <= X)
bound_count += 1;
else
break;
}
cout << bound_count;
} | #include <iostream>
using namespace std;
int main() {
int N, X;
int bound_count = 1;
int zahyou = 0;
cin >> N >> X;
for (int i = 0; i < N; i++) {
int L;
cin >> L;
zahyou += L;
if (zahyou <= X)
bound_count += 1;
else
break;
}
cout << bound_count;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,954 | 812,955 | u104740664 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N, X;
int L[110];
int main() {
cin >> N >> X;
for (int i = 0; i < N; i++)
cin >> L[i];
int l = 0;
int cnt = 0;
for (int i = 0; i < N; i++) {
l += L[i];
if (l <= X)
cnt++;
}
cout << cnt << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N, X;
int L[110];
int main() {
cin >> N >> X;
for (int i = 0; i < N; i++)
cin >> L[i];
int l = 0;
int cnt = 1;
for (int i = 0; i < N; i++) {
l += L[i];
if (l <= X)
cnt++;
}
cout << cnt << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,956 | 812,957 | u489053642 | cpp |
p03000 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <limits>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
#define rep(i, N) for (int i = 0; i < N; i++)
int main() {
int n, x, temp, dist, ans;
ans = dist = 0;
cin >> n >> x;
rep(i, n) {
ans++;
cin >> temp;
dist += temp;
if (dist > x) {
cout << ans << endl;
return 0;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <limits>
#include <numeric>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
#define rep(i, N) for (int i = 0; i < N; i++)
int main() {
int n, x, temp, dist, ans;
ans = dist = 0;
cin >> n >> x;
rep(i, n) {
ans++;
cin >> temp;
dist += temp;
if (dist > x) {
cout << ans << endl;
return 0;
}
}
cout << ans + 1 << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 812,962 | 812,963 | u003860320 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 1000000007
#define all(v) v.begin(), v.end()
#define pb push_back
#define size(v) (int)v.size()
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
ll power_mod(ll a, ll x) {
if (x == 0)
return 1;
ll y = power_mod(a, x / 2);
ll ans = (y * y) % mod;
if (x % 2)
ans = (ans * a) % mod;
return ans;
}
ll inv(ll a) { return power_mod(a, mod - 2); }
ll power(ll a, ll x) {
if (x == 0)
return 1;
ll y = power(a, x / 2);
ll ans = (y * y);
if (x % 2)
ans *= a;
return ans;
}
int main() {
int n, x;
cin >> n >> x;
int res = 0;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
int curr = 0;
for (int i = 1; i <= n; i++) {
curr += a[i];
if (curr <= x)
res++;
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 1000000007
#define all(v) v.begin(), v.end()
#define pb push_back
#define size(v) (int)v.size()
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
ll power_mod(ll a, ll x) {
if (x == 0)
return 1;
ll y = power_mod(a, x / 2);
ll ans = (y * y) % mod;
if (x % 2)
ans = (ans * a) % mod;
return ans;
}
ll inv(ll a) { return power_mod(a, mod - 2); }
ll power(ll a, ll x) {
if (x == 0)
return 1;
ll y = power(a, x / 2);
ll ans = (y * y);
if (x % 2)
ans *= a;
return ans;
}
int main() {
int n, x;
cin >> n >> x;
int res = 1;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
int curr = 0;
for (int i = 1; i <= n; i++) {
curr += a[i];
if (curr <= x)
res++;
}
cout << res << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 812,964 | 812,965 | u742642200 | 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 dist, count, sum = 0;
for (int i = 0; i < N; i++) {
sum += l[i];
if (sum > X) {
break;
}
count += 1;
}
cout << count << 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 count = 1;
int sum = 0;
for (int i = 0; i < N; i++) {
sum += l[i];
if (sum > X) {
break;
}
count += 1;
}
cout << count << endl;
return 0;
}
| [
"variable_declaration.remove",
"variable_declaration.add"
] | 812,966 | 812,967 | u894411949 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int a, b, c, d = 0, cou = 0;
cin >> a >> b;
for (int i = 0; i < a; i++) {
cin >> c;
d += c;
if (b >= d)
cou++;
}
cout << cou << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c, d = 0, cou = 1;
cin >> a >> b;
for (int i = 0; i < a; i++) {
cin >> c;
d += c;
if (b >= d)
cou++;
}
cout << cou << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 812,983 | 812,984 | u705030113 | cpp |
p03000 | #include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll N, X;
cin >> N >> X;
ll L[N];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
ll D[N + 1];
D[0] = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
ll count = 0;
for (int i = 0; i < N; i++) {
if (D[i] <= X) {
count++;
}
}
cout << count << endl;
}
| #include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll N, X;
cin >> N >> X;
ll L[N];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
ll D[N + 1];
D[0] = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
ll count = 0;
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"
] | 812,996 | 812,997 | u948515969 | cpp |
p03000 | #include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll N, X;
cin >> N >> X;
ll L[N];
for (ll i = 0; i < N; i++) {
cin >> L[i];
}
ll D[N + 1];
D[0] = 0;
for (ll i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
ll count = 0;
for (ll i = 0; i < N; i++) {
if (D[i] <= X) {
count += 1;
}
}
cout << count << endl;
}
| #include <iostream>
using namespace std;
typedef long long ll;
int main(void) {
ll N, X;
cin >> N >> X;
ll L[N];
for (int i = 0; i < N; i++) {
cin >> L[i];
}
ll D[N + 1];
D[0] = 0;
for (int i = 0; i < N; i++) {
D[i + 1] = D[i] + L[i];
}
ll count = 0;
for (int i = 0; i <= N; i++) {
if (D[i] <= X) {
count++;
}
}
cout << count << endl;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 812,998 | 812,997 | u948515969 | cpp |
p03000 | // TOPSIC001_0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef int _loop_int;
#define REP(i, n) for (_loop_int i = 0; i < (_loop_int)(n); ++i)
#define FOR(i, a, b) for (_loop_int i = (_loop_int)(a); i < (_loop_int)(b); ++i)
#define FORR(i, a, b) \
for (_loop_int i = (_loop_int)(b)-1; i >= (_loop_int)(a); --i)
#define DEBUG(x) cout << #x << ": " << x << endl
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << " " << v[i]; \
cout << endl
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a = min((a), (b))
#define CHMAX(a, b) a = max((a), (b))
// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
// floating
typedef double Real;
const Real EPS = 1e-11;
#define EQ0(x) (abs(x) < EPS)
#define EQ(a, b) (abs(a - b) < EPS)
typedef complex<Real> P;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
REP(i, N) cin >> L.at(i);
int ans = 0;
long sum = 0;
for (int i = 0; i < N; i++) {
// cout << sum << endl;
if (sum <= X)
ans++;
sum += L.at(i);
}
cout << ans << endl;
return 0;
}
| // TOPSIC001_0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef int _loop_int;
#define REP(i, n) for (_loop_int i = 0; i < (_loop_int)(n); ++i)
#define FOR(i, a, b) for (_loop_int i = (_loop_int)(a); i < (_loop_int)(b); ++i)
#define FORR(i, a, b) \
for (_loop_int i = (_loop_int)(b)-1; i >= (_loop_int)(a); --i)
#define DEBUG(x) cout << #x << ": " << x << endl
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << " " << v[i]; \
cout << endl
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a = min((a), (b))
#define CHMAX(a, b) a = max((a), (b))
// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
// floating
typedef double Real;
const Real EPS = 1e-11;
#define EQ0(x) (abs(x) < EPS)
#define EQ(a, b) (abs(a - b) < EPS)
typedef complex<Real> P;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
REP(i, N) cin >> L.at(i);
int ans = 0;
long sum = 0;
for (int i = 0; i <= N; i++) {
if (sum <= X)
ans++;
sum += L.at(i);
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 813,003 | 813,004 | u245710867 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, n;
cin >> x >> n;
int ans = 0;
int c1 = 0;
for (int i = 0; i < x; i++) {
int rr;
cin >> rr;
if (c1 + rr <= n) {
ans++;
c1 += rr;
} else {
c1 += rr;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int x, n;
cin >> x >> n;
int ans = 1;
int c1 = 0;
for (int i = 0; i < x; i++) {
int rr;
cin >> rr;
if (c1 + rr <= n) {
ans++;
c1 += rr;
} else {
c1 += rr;
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 813,009 | 813,010 | u432205669 | cpp |
p03000 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = 0; i < b; i++)
#define REP(i, a, b) for (int i = 0; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) \
cout << (f ? "Yes" : "No") << endl // fが真の場合Yesを出力、偽の場合Noを出力
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
signed main() {
int n, x;
cin >> n >> x;
int l, ans = 0;
int now = 0;
rep(i, n) {
cin >> l;
if (now <= x)
ans++;
else
break;
now += l;
}
cout << ans << endl;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = 0; i < b; i++)
#define REP(i, a, b) for (int i = 0; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) \
cout << (f ? "Yes" : "No") << endl // fが真の場合Yesを出力、偽の場合Noを出力
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
signed main() {
int n, x;
cin >> n >> x;
int l, ans = 0;
int now = 0;
rep(i, n + 1) {
cin >> l;
if (now <= x)
ans++;
else
break;
now += l;
}
cout << ans << endl;
}
| [
"expression.operation.binary.add"
] | 813,011 | 813,012 | u775507068 | cpp |
p03000 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = 0; i < b; i++)
#define REP(i, a, b) for (int i = 0; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) \
cout << (f ? "Yes" : "No") << endl // fが真の場合Yesを出力、偽の場合Noを出力
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
signed main() {
int n, x;
cin >> n >> x;
int l, ans = 0;
int now = 0;
rep(i, n) {
cin >> l;
if (n <= x)
ans++;
else
break;
now += l;
}
cout << ans << endl;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = 0; i < b; i++)
#define REP(i, a, b) for (int i = 0; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) \
cout << (f ? "Yes" : "No") << endl // fが真の場合Yesを出力、偽の場合Noを出力
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod = 1e9 + 7;
signed main() {
int n, x;
cin >> n >> x;
int l, ans = 0;
int now = 0;
rep(i, n + 1) {
cin >> l;
if (now <= x)
ans++;
else
break;
now += l;
}
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 813,013 | 813,012 | u775507068 | cpp |
p03000 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[n + 10];
rep(i, n) { cin >> l[i]; }
int d[n + 10];
int cnt = 1;
d[0] = 0;
for (int i = 1; i < n; i++) {
d[i] = d[i - 1] + l[i - 1];
if (d[i] <= x)
cnt++;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int l[n + 10];
rep(i, n) { cin >> l[i]; }
int d[n + 10];
int cnt = 1;
d[0] = 0;
for (int i = 1; i < n + 1; i++) {
d[i] = d[i - 1] + l[i - 1];
if (d[i] <= x)
cnt++;
}
cout << cnt << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 813,015 | 813,016 | u479032944 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x, sum = 0, cnt = 0;
cin >> n >> x;
int l[n];
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i < n; i++) {
if (sum <= x) {
cnt++;
}
sum += l[i];
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x, sum = 0, cnt = 0;
cin >> n >> x;
int l[n];
for (int i = 0; i < n; i++) {
cin >> l[i];
}
for (int i = 0; i <= n; i++) {
if (sum <= x) {
cnt++;
}
sum += l[i];
}
cout << cnt << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 813,023 | 813,024 | u561790111 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
for (int i = 0; i <= N; ++i)
cin >> L[i];
int jumpNb = 1;
long d = 0;
int i = 0;
while (i <= N && d <= X) {
d += L[i];
if (d <= X)
jumpNb++;
else
break;
i++;
}
cout << jumpNb << "\n";
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 jumpNb = 1;
long d = 0;
int i = 0;
while (i < N && d <= X) {
d += L[i];
if (d <= X)
jumpNb++;
else
break;
i++;
}
cout << jumpNb << "\n";
return 0;
}
| [
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.loop.condition.change"
] | 813,030 | 813,031 | u425389149 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
vector<int> L(N + 1);
for (int i = 0; i <= N; ++i)
cin >> L[i];
int jumpNb = 1;
int d = 0;
int i = 0;
while (i <= N && d <= X) {
d += L[i];
if (d <= X)
jumpNb++;
else
break;
i++;
}
cout << jumpNb << "\n";
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 jumpNb = 1;
long d = 0;
int i = 0;
while (i < N && d <= X) {
d += L[i];
if (d <= X)
jumpNb++;
else
break;
i++;
}
cout << jumpNb << "\n";
return 0;
}
| [
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change",
"control_flow.loop.condition.change"
] | 813,032 | 813,031 | u425389149 | cpp |
p03000 | //#pragma comment(linker, "/stack:247474112")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define pii pair<int, int>
#define ff first
#define ss second
#define pb(x) push_back(x)
#define mp make_pair
#define sz(x) x.size()
#define clr(x) x.clear()
#define mem(x, y) memset(x, y, sizeof x)
#define all(a) a.begin(), a.end()
#define endl "\n"
#define si(x) scanf("%d", &x)
#define sii(x, y) scanf("%d%d", &x, &y)
#define siii(x, y, z) scanf("%d%d%d ", &x, &y, &z)
#define rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, n) for (int i = 1; i <= n; i++)
#define forn(i, x, n) for (int i = x; i <= n; i++)
#define repit(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define dbg(args...) \
do { \
cerr << #args << ' '; \
print(args); \
} while (0); \
cerr << endl;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
const ll mod = (ll)1e9 + 7;
// const int inf = 1e9 ;
const long long infL = 1e18;
int setbit(int n, int pos) { return n = n | (1 << pos); }
int resetbit(int n, int pos) { return n = n & ~(1 << pos); }
bool checkbit(int n, int pos) { return (bool)(n & (1 << pos)); }
template <typename T> T mul(T x, T y) {
x %= mod;
y %= mod;
return (x * y) % mod;
}
template <typename T> T add(T x, T y) {
x %= mod;
y %= mod;
return (x + y) % mod;
}
template <typename T> T modPow(T x, T k, T mod) {
if (k == 0)
return 1;
if (k & 1) {
return ((x % mod) * modPow(x, k - 1, mod) % mod) % mod;
} else {
T ret = modPow(x, k / 2, mod);
ret %= mod;
return (ret * ret) % mod;
}
}
template <typename T> T ext_gcd(T num1, T num2, T &X, T &Y) {
T r2, r1, q2, q1, x2, x1, y2, y1, x, y, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = num1, r1 = num2; r1 != 0;
y2 = y1, y1 = y, x2 = x1, x1 = x, r2 = r1, r1 = r) {
q1 = r2 / r1;
x = x2 - q1 * x1;
y = y2 - q1 * y1;
r = r2 % r1;
}
X = x2;
Y = y2;
return r2;
}
template <typename T> T modInv(T x, T m) {
return modPow(x, m - 2, m);
} // long long ret, t ;// ext_gcd( x, m ,ret ,t ) ;// ret %= m ;// if(ret<0)
// ret += m ; // return ret;}
template <typename T> void print(const T &v) { cerr << v << ' '; }
template <typename T1, typename... T2>
void print(const T1 &first, const T2 &...rest) {
print(first);
print(rest...);
}
// debuging ...
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "[ " << p.first << ", " << p.second << " ]";
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, sz(v)) os << v[i] << ' ';
return os << " ]";
}
// int dx[] = {0 , 0 ,+1, -1 } ;
// int dy[] = {-1, +1,0 , 0 };
const int M = (int)1e6 + 77;
const int mx = (int)700;
// const ll N = 1e75 ;
//// code from here ...
ll d[M + 2], L[M + 2];
void solve() {
ll n, q, x, cnt = 0;
cin >> n >> x;
repi(i, n) cin >> L[i];
d[0] = 0;
for (int i = 1; i <= n; i++) {
d[i] = L[i - 1] + d[i - 1];
// dbg(d[i],cnt ) ;
if (d[i] > x)
break;
cnt++;
}
cout << cnt;
}
int main() {
// ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int t = 1, c = 0; // si( t) ;
// clock_t s = clock() ;
while (t--) {
solve();
}
// double e = (clock() -s )/(CLOCKS_PER_SEC*1.0 ) ;
// cerr << "exec time : " << e << endl ;;
}
| //#pragma comment(linker, "/stack:247474112")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define pii pair<int, int>
#define ff first
#define ss second
#define pb(x) push_back(x)
#define mp make_pair
#define sz(x) x.size()
#define clr(x) x.clear()
#define mem(x, y) memset(x, y, sizeof x)
#define all(a) a.begin(), a.end()
#define endl "\n"
#define si(x) scanf("%d", &x)
#define sii(x, y) scanf("%d%d", &x, &y)
#define siii(x, y, z) scanf("%d%d%d ", &x, &y, &z)
#define rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, n) for (int i = 1; i <= n; i++)
#define forn(i, x, n) for (int i = x; i <= n; i++)
#define repit(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define dbg(args...) \
do { \
cerr << #args << ' '; \
print(args); \
} while (0); \
cerr << endl;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
const ll mod = (ll)1e9 + 7;
// const int inf = 1e9 ;
const long long infL = 1e18;
int setbit(int n, int pos) { return n = n | (1 << pos); }
int resetbit(int n, int pos) { return n = n & ~(1 << pos); }
bool checkbit(int n, int pos) { return (bool)(n & (1 << pos)); }
template <typename T> T mul(T x, T y) {
x %= mod;
y %= mod;
return (x * y) % mod;
}
template <typename T> T add(T x, T y) {
x %= mod;
y %= mod;
return (x + y) % mod;
}
template <typename T> T modPow(T x, T k, T mod) {
if (k == 0)
return 1;
if (k & 1) {
return ((x % mod) * modPow(x, k - 1, mod) % mod) % mod;
} else {
T ret = modPow(x, k / 2, mod);
ret %= mod;
return (ret * ret) % mod;
}
}
template <typename T> T ext_gcd(T num1, T num2, T &X, T &Y) {
T r2, r1, q2, q1, x2, x1, y2, y1, x, y, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = num1, r1 = num2; r1 != 0;
y2 = y1, y1 = y, x2 = x1, x1 = x, r2 = r1, r1 = r) {
q1 = r2 / r1;
x = x2 - q1 * x1;
y = y2 - q1 * y1;
r = r2 % r1;
}
X = x2;
Y = y2;
return r2;
}
template <typename T> T modInv(T x, T m) {
return modPow(x, m - 2, m);
} // long long ret, t ;// ext_gcd( x, m ,ret ,t ) ;// ret %= m ;// if(ret<0)
// ret += m ; // return ret;}
template <typename T> void print(const T &v) { cerr << v << ' '; }
template <typename T1, typename... T2>
void print(const T1 &first, const T2 &...rest) {
print(first);
print(rest...);
}
// debuging ...
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "[ " << p.first << ", " << p.second << " ]";
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, sz(v)) os << v[i] << ' ';
return os << " ]";
}
// int dx[] = {0 , 0 ,+1, -1 } ;
// int dy[] = {-1, +1,0 , 0 };
const int M = (int)1e6 + 77;
const int mx = (int)700;
// const ll N = 1e75 ;
//// code from here ...
ll d[M + 2], L[M + 2];
void solve() {
ll n, q, x, cnt = 1;
cin >> n >> x;
repi(i, n) cin >> L[i];
d[0] = 0;
for (int i = 2; i <= n + 1; i++) {
d[i] = L[i - 1] + d[i - 1];
// dbg(d[i],cnt ) ;
if (d[i] > x)
break;
cnt++;
}
cout << cnt;
}
int main() {
// ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int t = 1, c = 0; // si( t) ;
// clock_t s = clock() ;
while (t--) {
solve();
}
// double e = (clock() -s )/(CLOCKS_PER_SEC*1.0 ) ;
// cerr << "exec time : " << e << endl ;;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 813,038 | 813,039 | u003576582 | cpp |
p03000 | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
for (int i = 0; i <= x && ++ans < n;) {
int in;
cin >> in;
i += in;
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int ans = 0;
for (int i = 0; i <= x && ++ans < n + 1;) {
int in;
cin >> in;
i += in;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 813,040 | 813,041 | u450908524 | cpp |
p03000 | #include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod = 1000000007;
int main() {
int n, x;
int p = 0, a;
int count = 0;
cin >> n >> x;
while (p <= x && count < n) {
cin >> a;
p += a;
count++;
}
cout << count;
return 0;
}
| #include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod = 1000000007;
int main() {
int n, x;
int p = 0, a;
int count = 0;
cin >> n >> x;
while (p <= x && count <= n) {
cin >> a;
p += a;
count++;
}
cout << count;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 813,044 | 813,045 | u410866813 | cpp |
p03000 | #include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod = 1000000007;
int main() {
int n, x;
int p = 0, i = 0, a;
int count = 0;
cin >> n >> x;
while (p <= x && i < n) {
cin >> a;
p += a;
count++;
}
cout << count;
return 0;
}
| #include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int i = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int i = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int i = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod = 1000000007;
int main() {
int n, x;
int p = 0, a;
int count = 0;
cin >> n >> x;
while (p <= x && count <= n) {
cin >> a;
p += a;
count++;
}
cout << count;
return 0;
}
| [
"variable_declaration.remove"
] | 813,046 | 813,045 | u410866813 | cpp |
p03000 | #include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define pii pair<int, int>
#define ll long long
#define el '\n'
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
int ar[n + 1];
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
int cur = 0;
for (int i = 2; i <= n + 1; i++) {
cur += ar[i - 1];
if (cur > x) {
cout << i - 1 << el;
break;
}
}
cout << n + 1 << el;
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define pii pair<int, int>
#define ll long long
#define el '\n'
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
int ar[n + 1];
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
int cur = 0;
for (int i = 2; i <= n + 1; i++) {
cur += ar[i - 1];
if (cur > x) {
cout << i - 1 << el;
return 0;
}
}
cout << n + 1 << el;
return 0;
} | [
"control_flow.break.remove",
"control_flow.return.add",
"function.return_value.change"
] | 813,047 | 813,048 | u287988203 | 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];
}
vector<int> D(N + 1);
int cnt;
D[0] = 0;
for (cnt = 1; cnt < N; cnt++) {
D[cnt] = D[cnt - 1] + L[cnt - 1];
if (D[cnt] > X)
break;
}
cout << cnt << 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];
}
vector<int> D(N + 1);
int cnt;
D[0] = 0;
for (cnt = 1; cnt < N + 1; cnt++) {
D[cnt] = D[cnt - 1] + L[cnt - 1];
if (D[cnt] > X)
break;
}
cout << cnt << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 813,049 | 813,050 | u475690012 | cpp |
p03000 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, L;
cin >> N >> X;
int i = 1, D = 0;
for (; i <= N; i++) {
cin >> L;
D = D + L;
if (D < X)
continue;
break;
}
cout << i << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, X, L;
cin >> N >> X;
int i = 1, D = 0;
for (; i <= N; i++) {
cin >> L;
D = D + L;
if (D > X)
break;
}
cout << i << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 813,053 | 813,054 | u303454114 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.