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 8
values |
|---|---|---|---|---|---|---|---|
p03032 | #include <bits/stdc++.h>
using namespace std;
int arr[55];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int R = min(n, k);
int ans = 0;
for (int i = 1; i <= R; i++) {
for (int j = 1; j <= R; j++) {
if (i + j > R) {
break;
}
vector... | #include <bits/stdc++.h>
using namespace std;
int arr[55];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int R = min(n, k);
int ans = 0;
for (int i = 0; i <= R; i++) {
for (int j = 0; j <= R; j++) {
if (i + j > R) {
break;
}
vector... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 844,132 | 844,133 | u009824133 | cpp |
p03032 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef lon... | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef lon... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,138 | 844,139 | u730476362 | cpp |
p03032 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef lon... | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef lon... | [
"control_flow.loop.for.condition.change"
] | 844,138 | 844,140 | u730476362 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l < min(n, k); l++) {
for (int r = 0; r < min(n - l, k - l); r++) {
ll tmp = 0;
vector<ll> sub;
... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l <= min(n, k); l++) {
for (int r = 0; r <= min(n - l, k - l); r++) {
ll tmp = 0;
vector<ll> sub... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,157 | 844,158 | u127194462 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l < min(n, k); l++) {
for (int r = 0; l + r < min(n, k); r++) {
ll tmp = 0;
vector<ll> sub;
... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n);
ll ans = 0;
for (int i = 0; i < n; i++)
cin >> v[i];
for (int l = 0; l <= min(n, k); l++) {
for (int r = 0; l + r <= min(n, k); r++) {
ll tmp = 0;
vector<ll> sub;
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,159 | 844,160 | u127194462 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::v... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::v... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,163 | 844,164 | u303039933 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::v... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using ll = long long;
int main() {
int N, K;
std::cin >> N >> K;
std::v... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,165 | 844,164 | u303039933 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i ... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,168 | 844,169 | u614063956 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i ... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (long long i ... | [
"expression.operation.binary.add"
] | 844,170 | 844,169 | u614063956 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define ALL(v) v.beg... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define ALL(v) v.beg... | [
"expression.operation.binary.add"
] | 844,171 | 844,172 | u505831576 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V;
int v;
int ans = 0;
for (int i = 0; i < N; i++) {
cin >> v;
V.push_back(v);... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V;
int v;
int ans = 0;
for (int i = 0; i < N; i++) {
cin >> v;
V.push_back(v);... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,200 | 844,201 | u982234424 | cpp |
p03032 | #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
//------------------------------... | #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
//------------------------------... | [
"expression.operation.binary.add"
] | 844,204 | 844,205 | u055131803 | cpp |
p03032 | #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
//------------------------------... | #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
//------------------------------... | [
"control_flow.continue.remove",
"control_flow.break.add"
] | 844,206 | 844,205 | u055131803 | cpp |
p03032 | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n)... | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n)... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 844,207 | 844,208 | u840105874 | cpp |
p03032 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | [
"expression.operation.binary.add"
] | 844,227 | 844,228 | u906208439 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
ll n, K, temp, ans;
int v[51];
vector<int> pq_v;
int main() {
cin >> n >> K;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
ans = 0;
for (int i = 1; i <= K; i++) {
for (int j = 0; j <= i; j++) {
priorit... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
ll n, K, temp, ans;
int v[51];
vector<int> pq_v;
int main() {
cin >> n >> K;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
ans = 0;
for (int i = 1; i <= min(n, K); i++) {
for (int j = 0; j <= i; j++) {
... | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,229 | 844,230 | u263858205 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int mod = 1e9;
const int maxn = 55;
int a[maxn], n, k;
int g(int l, int r) {
if (l + r > k || l + r == 0)
return -mod;
vi v;
for (int i = 0; i < l; i+... | #include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int mod = 1e9;
const int maxn = 55;
int a[maxn], n, k;
int g(int l, int r) {
if (l + r > k || l + r > n || l + r == 0)
return -mod;
vi v;
for (int i =... | [
"control_flow.branch.if.condition.change"
] | 844,236 | 844,237 | u348155686 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | [
"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"
] | 844,242 | 844,243 | u430974466 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | [
"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"
] | 844,244 | 844,243 | u430974466 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<LL>;
using VVI = vector<VI>;
using VB = vector<bool>;
using VS = vector<string>;
using PII = pair<LL, LL>;
using VP = vector<PII>;
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(x, c) for (auto x :... | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<LL>;
using VVI = vector<VI>;
using VB = vector<bool>;
using VS = vector<string>;
using PII = pair<LL, LL>;
using VP = vector<PII>;
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(x, c) for (auto x :... | [
"expression.operation.binary.add"
] | 844,250 | 844,251 | u816800341 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int val = 0;
vector<int> V;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.emplace_back(v);
}
int maxval = 0;
for (int i = 0; i <... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int val = 0;
vector<int> V;
for (int i = 0; i < N; i++) {
int v;
cin >> v;
V.emplace_back(v);
}
int maxval = 0;
for (int i = 0; i <... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,252 | 844,253 | u213451288 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> ... | [
"expression.operator.change"
] | 844,256 | 844,257 | u317711717 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | [
"expression.operation.binary.remove"
] | 844,258 | 844,259 | u475675023 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = acos(-1);
#define FOR(i, a, b) for (ll i = (a), __last_##i = (b); i < __last_##i; i++)
#define RFOR(i, a, b) for (ll i = (b)-1, __last_##i = (a); i >= __last_##i; i--)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#d... | [
"expression.operation.binary.add"
] | 844,260 | 844,259 | u475675023 | cpp |
p03032 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | [] | 844,261 | 844,262 | u031448582 | cpp |
p03032 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | [] | 844,263 | 844,264 | u031448582 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
#define rep(i, n) for (... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
#define rep(i, n) for (... | [
"expression.operation.binary.add"
] | 844,265 | 844,266 | u116670634 | cpp |
p03032 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 52;
const ... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 52;
const ... | [
"call.remove",
"call.arguments.change"
] | 844,273 | 844,274 | u499373855 | cpp |
p03032 | #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 = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = (n)-1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#defi... | #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 = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = (n)-1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#defi... | [
"expression.operation.binary.add"
] | 844,281 | 844,282 | u128527648 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int n, k, ans = 0;
deque<int> d;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
d.push_back(x);
}
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j > k)
continue;
int u = k - i - j... | #include <bits/stdc++.h>
using namespace std;
int n, k, ans = 0;
deque<int> d;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
d.push_back(x);
}
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++) {
if (i + j > k)
continue;
int u = k - i - j... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 844,290 | 844,291 | u954081460 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> v(N + 1);
for (int i = 1; i <= N; ++i) {
cin >> v[i];
}
ll res = 0;
priority_queue<ll, vector<ll>, greater<ll>> que;
for (int l = 0; l <= N; ++l) {
for (int r = N + 1; r > 0; -... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> v(N + 1);
for (int i = 1; i <= N; ++i) {
cin >> v[i];
}
ll res = 0;
priority_queue<ll, vector<ll>, greater<ll>> que;
for (int l = 0; l <= N; ++l) {
for (int r = N + 1; r > 0; -... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,292 | 844,293 | u203927510 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i... | [
"expression.operation.binary.remove"
] | 844,296 | 844,297 | u007637377 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i... | [
"expression.operation.binary.remove",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 844,298 | 844,297 | u007637377 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b)... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b)... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,309 | 844,310 | u561013007 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b)... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
inline int max(int a, int b) {
if (b > a)
swap(a, b);
return a;
}
inline int min(int a, int b) {
if (a > b)
swap(a, b)... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,311 | 844,310 | u561013007 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int N, K;
int64_t ans;
int main() {
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++)
cin >> V[i];
ans = 0;
int R = min(N, K);
for (int A = 0; A < R; A++) {
for (int B = 0; B < R - A; B++) {
vector<int> v;
int64_t res = 0;
... | #include <bits/stdc++.h>
using namespace std;
int N, K;
int64_t ans;
int main() {
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++)
cin >> V[i];
ans = 0;
int R = min(N, K);
for (int A = 0; A <= R; A++) {
for (int B = 0; B <= R - A; B++) {
vector<int> v;
int64_t res = 0;
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,320 | 844,321 | u992875223 | cpp |
p03032 | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_D main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LONG_MAX / 2)
const int ... | #ifdef _DEBUG
#include "MyLib.h"
#else
#define main_D main
#include "bits/stdc++.h"
#include <regex>
#define _USE_MATH_DEFINES
#include <math.h>
#define FOR(i, s, e) for (int i = int(s); i < int(e); ++i)
#define REP(i, e) FOR(i, 0, e)
#define INF (INT_MAX / 2)
#define EPS (1.0e-8)
#define LINF (LONG_MAX / 2)
const int ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,334 | 844,335 | u404244809 | cpp |
p03032 | #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
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a... | #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
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a... | [
"control_flow.branch.if.condition.change"
] | 844,340 | 844,341 | u889695981 | cpp |
p03032 | #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
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a... | #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
#define ld float
#define rep(i, a, b) for (ll i = a; i < b; i += 1)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define sz(a) int((a... | [
"control_flow.branch.if.condition.change"
] | 844,342 | 844,341 | u889695981 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y)... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y)... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,356 | 844,357 | u825215512 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y)... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y)... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,358 | 844,357 | u825215512 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y)... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y)... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.break.remove",
"control_flow.continue.add"
] | 844,359 | 844,357 | u825215512 | cpp |
p03032 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drep2(j, n) for (int j = (n)-1; j >= 0; --j)
#define ... | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drep2(j, n) for (int j = (n)-1; j >= 0; --j)
#define ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,360 | 844,361 | u340293807 | cpp |
p03032 | #include <algorithm>
#include <deque>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
/* editorial */
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (in... | #include <algorithm>
#include <deque>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
/* editorial */
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, K;
cin >> N >> K;
vector<int> V(N);
for (int i = 0; i < N; i++) {
cin >> V[i];
}
int ans = 0;
for (in... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,362 | 844,363 | u341347211 | cpp |
p03032 | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V1(N);
vector<int> V2(N);
for (int i = 0; i < N; i++) {
cin >> V1[i];
V2[N - 1 - i] = V1[i];
}
int ans = 0;
for (int i = 1; i <= K; i++) {
for (int j = 0; j <= i; j++) {
int res = K - i;
... | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V1(N);
vector<int> V2(N);
for (int i = 0; i < N; i++) {
cin >> V1[i];
V2[N - 1 - i] = V1[i];
}
int ans = 0;
for (int i = 1; i <= min(N, K); i++) {
for (int j = 0; j <= i; j++) {
int res = ... | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,368 | 844,369 | u365956698 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld... | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld... | [
"assignment.change"
] | 844,372 | 844,373 | u251847465 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld... | #include <bits/stdc++.h>
using namespace std;
using Data = pair<long, int>;
int main() {
int i, j, h, N, K, L, R, ans = 0, cnt = 0, kcnt;
long val;
scanf("%d", &N);
scanf("%d", &K);
vector<long> v(100), lv(100, 0), rv(100, 0);
vector<Data> order(100, Data(0, 0));
for (i = 1; i <= N; i++) {
scanf("%ld... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.change"
] | 844,374 | 844,373 | u251847465 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
// 問題点全部プラスでK回取り出せばいいときうまく行かない(K-1回しか取り出してくれない)
int main() {
int N, K;
cin >> N >> K;
vector<ll> vec(N);
priority_queue<ll, vector<ll>, greater<ll>> pque;
ll ans = 0;
for (int i = 0; i < N; i++)
cin >> vec.at(i);
for (int A = 0... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
// 問題点全部プラスでK回取り出せばいいときうまく行かない(K-1回しか取り出してくれない)
int main() {
int N, K;
cin >> N >> K;
vector<ll> vec(N);
priority_queue<ll, vector<ll>, greater<ll>> pque;
ll ans = 0;
for (int i = 0; i < N; i++)
cin >> vec.at(i);
for (int A = 0... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,377 | 844,378 | u889812821 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rer(i, l, u) for (... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,382 | 844,383 | u484962958 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int solve(vector<int> v, int max_del_num) {
sort(v.begin(), v.end());
int sum = 0;
for (int x : v)
sum += x;
for (int i = 0; i < max_del_num && i < v.size(); ++i) {
if (v[i] < 0) {
sum -= v[i];
} else
break;
}
return sum;
}
int main() {
... | #include <bits/stdc++.h>
using namespace std;
int solve(vector<int> v, int max_del_num) {
sort(v.begin(), v.end());
int sum = 0;
for (int x : v)
sum += x;
for (int i = 0; i < max_del_num && i < v.size(); ++i) {
if (v[i] < 0) {
sum -= v[i];
} else
break;
}
return sum;
}
int main() {
... | [
"control_flow.loop.for.condition.change"
] | 844,386 | 844,387 | u914762730 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define boost \
ios_base::sync_with_stdio(0); \
cin.tie(0); ... | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define boost \
ios_base::sync_with_stdio(0); \
cin.tie(0); ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,388 | 844,389 | u202858603 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> v(N, 0);
for (int i = 0; i < N; i++)
cin >> v[i];
int ans = 0;
for (int l = 0; l < K; l++) {
for (int r = 0; r < K - l; r++) {
if (l + r > N)
continue;
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> v(N, 0);
for (int i = 0; i < N; i++)
cin >> v[i];
int ans = 0;
for (int l = 0; l <= K; l++) {
for (int r = 0; r <= K - l; r++) {
if (l + r > N)
continue;... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,399 | 844,400 | u547844563 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n);
vector<bool> ju(n, false);
vector<pair<int, int>> da(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
da[i].first = p[i];
da[i].second = i;
}
int ans = 0;
// sort(da.begin(), da.end());
f... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n);
vector<bool> ju(n, false);
vector<pair<int, int>> da(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
da[i].first = p[i];
da[i].second = i;
}
int ans = 0;
// sort(da.begin(), da.end());
f... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 844,401 | 844,402 | u057079894 | cpp |
p03032 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
using INT64 = long long;
int main(void) {
IOS int n, k;
cin >> n >> k;
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
using INT64 = long long;
int main(void) {
IOS int n, k;
cin >> n >> k;
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,403 | 844,404 | u330661451 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
vector<int> v;
int main(int argc, char const *argv[]) {
int N, K;
cin >> N >> K;
int Joutmax = min(N, K);
long long ans = 0;
for (int i = 0; i < N; i++) {
int temp;
cin ... | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
vector<int> v;
int main(int argc, char const *argv[]) {
int N, K;
cin >> N >> K;
int Joutmax = min(N, K);
long long ans = 0;
for (int i = 0; i < N; i++) {
int temp;
cin ... | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 844,424 | 844,425 | u636137609 | cpp |
p03032 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n, k;
ll max = 0;
cin >> n >> k;
vector<ll> v(n);
for (ll i = 0; i < n; i++)
cin >> v[i];
for (ll i = 0; i <= k; i++) {
for (ll j = 0; j <= i; j++) {
vector<ll> have;
for (ll l = 0; l < j; l++) {
... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n, k;
ll max = 0;
cin >> n >> k;
vector<ll> v(n);
for (ll i = 0; i < n; i++)
cin >> v[i];
for (ll i = 0; i <= min(n, k); i++) {
for (ll j = 0; j <= i; j++) {
vector<ll> have;
for (ll l = 0; l < j; l++) {
... | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,428 | 844,429 | u201316840 | cpp |
p03032 | #include <bits/stdc++.h>
#define SORT(a) sort(a.begin(), a.end())
#define RSORT(a) sort(a.rbegin(), a.rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n; 0 <= i; i--)
#define FOR(i, start, end) for (int i = start; i < end; i++)
#define FORSTEP(i, start, end, step) for (int i = start... | #include <bits/stdc++.h>
#define SORT(a) sort(a.begin(), a.end())
#define RSORT(a) sort(a.rbegin(), a.rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n; 0 <= i; i--)
#define FOR(i, start, end) for (int i = start; i < end; i++)
#define FORSTEP(i, start, end, step) for (int i = start... | [
"control_flow.branch.if.condition.change",
"call.add",
"call.arguments.add"
] | 844,430 | 844,431 | u324303263 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int calc(vector<int> V, int a, int b, int k) {
vector<int> v;
if (a == 0) {
if (b > 0)
v = vector<int>(V.end() - b, V.end());
else
return 0;
} else {
v = vector<int>(V.begin(), V.begin() + a);
if (b > 0)
v.insert(v.end(), V.end() - b... | #include <bits/stdc++.h>
using namespace std;
int calc(vector<int> V, int a, int b, int k) {
vector<int> v;
if (a == 0) {
if (b > 0)
v = vector<int>(V.end() - b, V.end());
else
return 0;
} else {
v = vector<int>(V.begin(), V.begin() + a);
if (b > 0)
v.insert(v.end(), V.end() - b... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,436 | 844,437 | u326609687 | cpp |
p03032 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,440 | 844,441 | u711985352 | cpp |
p03032 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 844,442 | 844,443 | u711985352 | cpp |
p03033 | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long Int;
typedef pair<Int, Int> P;
typedef pair<Int, P> P2;
const int inf = 2147483647;
struct LazySegTree {
private:
int n;
vector<Int> node, lazy;
vector<bool> lazyflag;
public:
La... | #include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long Int;
typedef pair<Int, Int> P;
typedef pair<Int, P> P2;
const int inf = 2147483647;
struct LazySegTree {
private:
int n;
vector<Int> node, lazy;
vector<bool> lazyflag;
public:
La... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change",
"call.function.change",
"expression.unary.arithmetic.add"
] | 844,490 | 844,491 | u440213743 | cpp |
p03033 | // https://atcoder.jp/contests/abc128/tasks/abc128_e
/*<head>*/
// #include "Template.hpp"
/*</head>*/
/*<body>*/
/* #region header */
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
#include <bits/stdc++.h>
using namespace std;
/* #region macro */
#ifdef BTK
#define D... | // https://atcoder.jp/contests/abc128/tasks/abc128_e
/*<head>*/
// #include "Template.hpp"
/*</head>*/
/*<body>*/
/* #region header */
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
#include <bits/stdc++.h>
using namespace std;
/* #region macro */
#ifdef BTK
#define D... | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,511 | 844,512 | u613658617 | cpp |
p03032 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int ... | [
"control_flow.loop.for.condition.change"
] | 844,534 | 844,535 | u656771711 | cpp |
p03032 | #include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
// template<typename key, typename val>
// using ordered_tree =
// tree<key, val, greater<>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ... | #include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
// using namespace __gnu_pbds;
// template<typename key, typename val>
// using ordered_tree =
// tree<key, val, greater<>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long ... | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 844,541 | 844,542 | u432090061 | cpp |
p03032 | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#... | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#... | [
"control_flow.loop.for.condition.change"
] | 844,543 | 844,544 | u462405902 | cpp |
p03032 | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#... | #include <stdio.h>
#include <stdlib.h>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unordered_set>
#define _USE_MATH_DEFINES
#include <math.h>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <queue>
#... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,545 | 844,544 | u462405902 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
int ans = 0;
int term = 0;
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i < min(N, K); i++) {
for (int j = 0; j < min(N, K) - i; j++) {
term = 0;
vector<int> tmp(i... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
int ans = 0;
int term = 0;
for (int i = 0; i < N; i++) {
cin >> V[i];
}
for (int i = 0; i <= min(N, K); i++) {
for (int j = 0; j <= min(N, K) - i; j++) {
term = 0;
vector<int> tmp... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,555 | 844,556 | u912534104 | cpp |
p03032 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, limit;
cin >> n >> limit;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int ret = 0;
for (int i = 0; i < min(limit, n); i++) {
for (int j = 0; j <= i; j++) {
vector<int> now;
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, limit;
cin >> n >> limit;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int ret = 0;
for (int i = 0; i <= min(limit, n); i++) {
for (int j = 0; j <= i; j++) {
vector<int> now;
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 844,559 | 844,560 | u412908746 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define REP(var, n) for (int var = 0; var < (n); var++)
#define RREP(var, n) for (auto var = n - 1; var != static_cast<int>(-1); var--)
#define FOR(var, a, b) for (auto var = (a); var < (b); var++)
#define RFOR(var, a, b) for (auto var = b - 1; var != a; var--)
typedef l... | #include <bits/stdc++.h>
using namespace std;
#define REP(var, n) for (int var = 0; var < (n); var++)
#define RREP(var, n) for (auto var = n - 1; var != static_cast<int>(-1); var--)
#define FOR(var, a, b) for (auto var = (a); var < (b); var++)
#define RFOR(var, a, b) for (auto var = b - 1; var != a; var--)
typedef l... | [
"expression.operation.binary.add"
] | 844,569 | 844,570 | u249955257 | cpp |
p03032 | #include <bits/stdc++.h>
/// TONI BO$$ was here
/// #MLC
using namespace std;
int v[102];
int main() {
int n, k, i, rez, a, b, sum, kaux;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++)
scanf("%d", &v[i]);
rez = INT_MIN;
for (a = 0; a <= n; a++)
for (b = 0; b <= n && a + b <= k && n + 1 - b > a; b++)... | #include <bits/stdc++.h>
/// TONI BO$$ was here
/// #MLC
using namespace std;
int v[102];
int main() {
int n, k, i, rez, a, b, sum, kaux;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++)
scanf("%d", &v[i]);
rez = INT_MIN;
for (a = 0; a <= n; a++)
for (b = 0; b <= n && a + b <= k && n + 1 - b > a; b++)... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,575 | 844,576 | u503211001 | cpp |
p03032 | #include <bits/stdc++.h>
#ifdef NON_SUBMIT
#define TEST(n) (n)
#define tout cerr
#else
#define TEST(n) ((void)0)
#define tout cin
#endif
using namespace std;
vector<int> A;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
TEST(freopen("input.txt", "r", stdin));
TEST(freopen("output... | #include <bits/stdc++.h>
#ifdef NON_SUBMIT
#define TEST(n) (n)
#define tout cerr
#else
#define TEST(n) ((void)0)
#define tout cin
#endif
using namespace std;
vector<int> A;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
TEST(freopen("input.txt", "r", stdin));
TEST(freopen("output... | [
"variable_declaration.type.change"
] | 844,577 | 844,578 | u548859367 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) ... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 844,585 | 844,586 | u382880969 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
int n, k;
int v[50];
void take_input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i != n; ++i)
cin >> v[i];
}
int simulate(int l, int r) {
if (l > n || r > n)
return 0;
vector<int> tmp;
for (int i = 0; i != l; ++i)
... | #include <bits/stdc++.h>
using namespace std;
int n, k;
int v[50];
void take_input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i != n; ++i)
cin >> v[i];
}
int simulate(int l, int r) {
if (l + r > n)
return 0;
vector<int> tmp;
for (int i = 0; i != l; ++i)
t... | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 844,587 | 844,588 | u776338097 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define all(x) begin(x), end(x)
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vi a(n);
for (int i = 0; i <... | #include <bits/stdc++.h>
using namespace std;
#define all(x) begin(x), end(x)
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vi a(n);
for (int i = 0; i <... | [
"call.add",
"call.arguments.change"
] | 844,589 | 844,590 | u906129425 | cpp |
p03032 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define fore(x, c) for (auto &&x : c)
#define rep(i, a, n) for (int i = a, i##len = (int)(... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define fore(x, c) for (auto &&x : c)
#define rep(i, a, n) for (int i = a, i##len = (int)(... | [
"variable_declaration.type.change"
] | 844,610 | 844,611 | u133129810 | cpp |
p03032 | // KALAM
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 17, K = 200 + 17;
int dp[N][N][K];
int n, k, a[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
for (int f = 1; f <= k; ++f)
dp[i][i][f] = max(a[f], 0);... | // KALAM
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 17, K = 200 + 17;
int dp[N][N][K];
int n, k, a[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
for (int f = 1; f <= k; ++f)
dp[i][i][f] = max(a[i], 0);... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 844,618 | 844,619 | u154653457 | cpp |
p03032 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map... | [
"call.add",
"call.arguments.change"
] | 844,626 | 844,627 | u917944707 | cpp |
p03033 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
vector<int> parent(N);
int find(int u) {
if (parent[u] == u)
return u;
return parent[u] = find(parent[u]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < N... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
vector<int> parent(N);
int find(int u) {
if (parent[u] == u)
return u;
return parent[u] = find(parent[u]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < N... | [
"assignment.change",
"expression.unary.arithmetic.add"
] | 844,691 | 844,692 | u929156598 | cpp |
p03033 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
const ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
const ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 844,695 | 844,696 | u277556971 | cpp |
p03021 | // E.cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2020;
// f[u] is the sum of depth;
int n, head[MAX_N], current, siz[MAX_N], f[MAX_N];
char S[MAX_N];
struct edge {
int to, nxt;
} edges[MAX_N << 1];
void addpath(int src, int dst) {
edges[current].to = dst, edges[current].nxt = head[src]... | // E.cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2020;
// f[u] is the sum of depth;
int n, head[MAX_N], current, siz[MAX_N], f[MAX_N];
char S[MAX_N];
struct edge {
int to, nxt;
} edges[MAX_N << 1];
void addpath(int src, int dst) {
edges[current].to = dst, edges[current].nxt = head[src]... | [
"identifier.change",
"expression.operation.binary.change"
] | 844,701 | 844,702 | u730011912 | cpp |
p03021 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 2005, INF = 1 << 30;
bool exist[MAX];
vector<int> G[MAX];
int depth[MAX], cnt[MAX];
vector<pair<int, int>> dis;
void DFS(int u, int p) {
for (int to : G[u]) {
if (to == p)
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int mod = 1000000007, MAX = 2005, INF = 1 << 30;
bool exist[MAX];
vector<int> G[MAX];
int depth[MAX], cnt[MAX];
vector<pair<int, int>> dis;
void DFS(int u, int p) {
for (int to : G[u]) {
if (to == p)
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 844,719 | 844,720 | u133391510 | cpp |
p03021 | #include <bits/stdc++.h>
typedef long long ll;
const int N = 5005;
int n, c[N], head[N], nxt[N], ver[N], cnt;
ll sum[N], max[N], min[N];
char s[N];
inline void add(int u, int v) {
nxt[++cnt] = head[u];
ver[cnt] = v;
head[u] = cnt;
}
void solve(int x, int f) {
max[x] = min[x] = 0;
sum[x] = c[x];
int max_... | #include <bits/stdc++.h>
typedef long long ll;
const int N = 5005;
int n, c[N], head[N], nxt[N], ver[N], cnt;
ll sum[N], max[N], min[N];
char s[N];
inline void add(int u, int v) {
nxt[++cnt] = head[u];
ver[cnt] = v;
head[u] = cnt;
}
void solve(int x, int f) {
max[x] = min[x] = 0;
sum[x] = c[x];
int max_... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 844,725 | 844,726 | u778968609 | cpp |
p03021 | #include <bits/stdc++.h>
using namespace std;
const int Maxn = 2005;
int n, cnt, head[Maxn];
long long sum[Maxn], w[Maxn];
string str;
long long ans = 0x3f3f3f3f3f3f3f3fLL;
struct edg {
int nxt, to;
} edge[2 * Maxn];
void add(int x, int y) {
edge[++cnt] = (edg){head[x], y};
head[x] = cnt;
}
void dfs1(int u, int ... | #include <bits/stdc++.h>
using namespace std;
const int Maxn = 2005;
int n, cnt, head[Maxn];
long long sum[Maxn], w[Maxn];
string str;
long long ans = 0x3f3f3f3f3f3f3f3fLL;
struct edg {
int nxt, to;
} edge[2 * Maxn];
void add(int x, int y) {
edge[++cnt] = (edg){head[x], y};
head[x] = cnt;
}
void dfs1(int u, int ... | [
"literal.number.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 844,732 | 844,733 | u032193798 | cpp |
p03021 | #include <cstdio>
#include <iostream>
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define REP(u) for (int i = hd[u], v; v = e[i].v, i; i = e[i].n)
using namespace std;
const int N = 2020, INF = 1000010000;
int n, ans, fl, u, v;
int hd[N], fa[N], sz[N], f[N], g[N], we[N];
char s[N];
struct edge {
int n, v;
} e[N... | #include <cstdio>
#include <iostream>
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define REP(u) for (int i = hd[u], v; v = e[i].v, i; i = e[i].n)
using namespace std;
const int N = 2020, INF = 1000010000;
int n, ans, fl, u, v;
int hd[N], fa[N], sz[N], f[N], g[N], we[N];
char s[N];
struct edge {
int n, v;
} e[N... | [
"assignment.change"
] | 844,738 | 844,739 | u599057573 | cpp |
p03021 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2010;
const ll inf = 1e18;
int n, sz[N];
char s[N];
ll ds[N], dz[N], sn[N];
vector<int> g[N];
void dfs(int u, int fa) {
sz[u] = s[u] - '0';
ll sum = ds[u] = sn[u] = 0, mx = 0;
for (int v : g[u]) {
if (v == fa)
continue;
... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2010;
const ll inf = 1e18;
int n, sz[N];
char s[N];
ll ds[N], dz[N], sn[N];
vector<int> g[N];
void dfs(int u, int fa) {
sz[u] = s[u] - '0';
ll sum = ds[u] = sn[u] = 0, mx = 0;
for (int v : g[u]) {
if (v == fa)
continue;
... | [] | 844,758 | 844,759 | u323092931 | cpp |
p03021 | /*raghav0307 - Raghav Gupta*/
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define fast_io() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); ... | /*raghav0307 - Raghav Gupta*/
#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define fast_io() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 844,766 | 844,767 | u855714015 | cpp |
p03021 | #include "bits/stdc++.h"
using namespace std;
string s;
vector<int> g[2002];
int dp[2002];
int tot[2002];
int sum[2002];
void dfs(int x, int par) {
sum[x] = 0;
tot[x] = s[x] - '0';
for (int i : g[x]) {
if (i - par) {
dfs(i, x);
tot[x] += tot[i];
sum[x] += tot[i] + sum[i];
}
}
}
bool m... | #include "bits/stdc++.h"
using namespace std;
string s;
vector<int> g[2002];
int dp[2002];
int tot[2002];
int sum[2002];
void dfs(int x, int par) {
sum[x] = 0;
tot[x] = s[x] - '0';
for (int i : g[x]) {
if (i - par) {
dfs(i, x);
tot[x] += tot[i];
sum[x] += tot[i] + sum[i];
}
}
}
bool m... | [
"assignment.change"
] | 844,772 | 844,773 | u669432519 | cpp |
p03021 | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef long double ld;
typedef complex<ld... | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef long double ld;
typedef complex<ld... | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 844,774 | 844,775 | u025222195 | cpp |
p03021 | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <casser... | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <casser... | [
"assignment.change"
] | 844,783 | 844,784 | u378419207 | cpp |
p03021 | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[... | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[... | [
"call.arguments.change"
] | 844,785 | 844,786 | u924885571 | cpp |
p03021 | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[... | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define N 2010
ll n;
string s;
vector<ll> g[N];
ll f[N], e[N], siz[... | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 844,787 | 844,786 | u924885571 | cpp |
p03021 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define itn int
#define make_unique(x) \
sort((x).begin(), (x).end()); \
(x).erase(unique((x).begin(), (x).end()), (x).end())
using namespace std;
... | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define itn int
#define make_unique(x) \
sort((x).begin(), (x).end()); \
(x).erase(unique((x).begin(), (x).end()), (x).end())
using namespace std;
... | [
"assignment.change"
] | 844,790 | 844,791 | u984947419 | cpp |
p03034 | #include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reve... | #include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reve... | [
"literal.number.change",
"call.arguments.change",
"control_flow.loop.for.condition.change"
] | 844,808 | 844,807 | u283869437 | cpp |
p03034 | #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include ... | #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 844,817 | 844,818 | u419874471 | cpp |
p03034 | #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include ... | #include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,819 | 844,820 | u419874471 | cpp |
p03034 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef ... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,852 | 844,853 | u986399983 | cpp |
p03034 | //
// abc128_f.cpp
//
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
int main() {
int n;
cin >> n;
vector<int> seq(n);
for (int i = 0; i < n; ++i) {
cin >> seq[i];
}
long long ret = 0;
for (int j = ... | //
// abc128_f.cpp
//
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
int main() {
int n;
cin >> n;
vector<int> seq(n);
for (int i = 0; i < n; ++i) {
cin >> seq[i];
}
long long ret = 0;
for (int j = ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 844,866 | 844,867 | u038229929 | cpp |
p03034 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
ll N, M, a, b, c, t, ans, q[100007], qw[100007];
int main() {
scanf("%lld", &N);
rep(i, 1, N) scanf("%lld", &q[i]);
rep(i, 1, N) {
ll p1 = 1, p2 = N, s = 0;
while (p1 + i < N) {
p1 +=... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
ll N, M, a, b, c, t, ans, q[100007], qw[100007];
int main() {
scanf("%lld", &N);
rep(i, 1, N) scanf("%lld", &q[i]);
rep(i, 1, N) {
ll p1 = 1, p2 = N, s = 0;
while (p1 + i < N) {
p1 +=... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 844,869 | 844,870 | u371175444 | cpp |
p03034 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
usi... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
usi... | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 844,871 | 844,872 | u591883167 | cpp |
p03034 | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (LL i = (l); i < (r); ++i)
#define incII(i, l, r) for (LL i = (l); i <= (r); ++i)
#define decID(i, l, r) for (LL i = (r)-1; i >= (l); --i)
#define decII(i, l, r) for (LL i = (r); ... | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for (LL i = (l); i < (r); ++i)
#define incII(i, l, r) for (LL i = (l); i <= (r); ++i)
#define decID(i, l, r) for (LL i = (r)-1; i >= (l); --i)
#define decII(i, l, r) for (LL i = (r); ... | [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 844,892 | 844,893 | u568652083 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.