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 |
|---|---|---|---|---|---|---|---|
p03201 | #include <bits/stdc++.h>
using namespace std;
#define SC scanf
#define PR printf
#define pb push_back
#define mp make_pair
#define SZ(v) ((int)(v).size())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1000000000
#define ll long long
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef pair<int,... | #include <bits/stdc++.h>
using namespace std;
#define SC scanf
#define PR printf
#define pb push_back
#define mp make_pair
#define SZ(v) ((int)(v).size())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1000000000
#define ll long long
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef pair<int,... | [
"call.arguments.add",
"call.arguments.change"
] | 995,279 | 995,280 | u069799734 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define SC scanf
#define PR printf
#define pb push_back
#define mp make_pair
#define SZ(v) ((int)(v).size())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1000000000
#define ll long long
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef pair<int,... | #include <bits/stdc++.h>
using namespace std;
#define SC scanf
#define PR printf
#define pb push_back
#define mp make_pair
#define SZ(v) ((int)(v).size())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF 1000000000
#define ll long long
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef pair<int,... | [
"call.add",
"call.arguments.change"
] | 995,281 | 995,280 | u069799734 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
long long t[40];
int cnt = 0;
int n, a[200000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
sort(a, a + n);
long long last = 2;
while (1) {
if (last > a[n - 1] * 2)
break;
t[cnt++] = las... | #include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
long long t[40];
int cnt = 0;
int n, a[200000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
sort(a, a + n);
long long last = 1;
while (1) {
if (last > a[n - 1] * 2)
break;
t[cnt++] = las... | [
"literal.number.change",
"variable_declaration.value.change"
] | 995,286 | 995,287 | u201808715 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define LB long double
#define ull unsigned long long
#define x first
#define y second
#define pb push_back
#define pf push_front
#define mp make_pair
#define Pair pair<int, int>
#define pLL pair<LL, LL>
#define pii pair<double, double>
#define LOWBIT(... | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define LB long double
#define ull unsigned long long
#define x first
#define y second
#define pb push_back
#define pf push_front
#define mp make_pair
#define Pair pair<int, int>
#define pLL pair<LL, LL>
#define pii pair<double, double>
#define LOWBIT(... | [
"identifier.change",
"call.arguments.change"
] | 995,288 | 995,289 | u540005219 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define LB long double
#define ull unsigned long long
#define x first
#define y second
#define pb push_back
#define pf push_front
#define mp make_pair
#define Pair pair<int, int>
#define pLL pair<LL, LL>
#define pii pair<double, double>
#define LOWBIT(... | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define LB long double
#define ull unsigned long long
#define x first
#define y second
#define pb push_back
#define pf push_front
#define mp make_pair
#define Pair pair<int, int>
#define pLL pair<LL, LL>
#define pii pair<double, double>
#define LOWBIT(... | [
"identifier.change",
"call.arguments.change"
] | 995,290 | 995,289 | u540005219 | cpp |
p03201 | // cpy frm Chris' sol
#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 fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define all(x) (... | // cpy frm Chris' sol
#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 fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define all(x) (... | [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 995,291 | 995,292 | u034671639 | cpp |
p03201 | // cpy frm Chris' sol
#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 fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define all(x) (... | // cpy frm Chris' sol
#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 fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
#define all(x) (... | [
"variable_declaration.type.change"
] | 995,293 | 995,294 | u034671639 | cpp |
p03201 | #include <algorithm>
#include <cstdio>
#include <set>
int as[200005];
int invert(int X) {
int k = 0;
while ((1 << k) <= X)
k++;
// printf("invert(%d)=%d\n",X,(1<<k)-X);
return (1 << k) - X;
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &as[i]);
}
std::sort... | #include <algorithm>
#include <cstdio>
#include <set>
int as[200005];
int invert(int X) {
int k = 0;
while ((1 << k) <= X)
k++;
// printf("invert(%d)=%d\n",X,(1<<k)-X);
return (1 << k) - X;
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &as[i]);
}
std::sort... | [
"variable_declaration.value.change"
] | 995,312 | 995,313 | u163053295 | cpp |
p03201 |
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, b, a) for (int i = b; i >= a; i--)
#define pb push_back
using namespace std;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
typedef vector<int> vi;
typedef long long ll;
const ll mod = 998244353;
ll powmod(ll a, ... |
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, b, a) for (int i = b; i >= a; i--)
#define pb push_back
using namespace std;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
typedef vector<int> vi;
typedef long long ll;
const ll mod = 998244353;
ll powmod(ll a, ... | [
"identifier.change",
"call.function.change",
"call.arguments.change",
"call.arguments.add"
] | 995,319 | 995,320 | u792485593 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
typedef long long ll;
int main() {
int ... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
typedef long long ll;
int main() {
int ... | [] | 995,321 | 995,322 | u336011173 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 8;
long long a[N], n, x, cnt, t;
set<long long> s;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
t = 1;
if (s.find(a[i]) != s.end()) {
... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 8;
long long a[N], n, x, cnt, t;
multiset<long long> s;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
t = 1;
if (s.find(a[i]) != s.end()... | [
"variable_declaration.type.change"
] | 995,326 | 995,327 | u989469621 | cpp |
p03201 |
// in the name of Allah ;
#include <bits/stdc++.h>
using namespace std;
const int lg = 40;
int t[lg], n;
set<int> st;
void init() {
t[0] = 1;
for (int i = 0; i < lg - 1; i++)
t[i + 1] = t[i] * 2;
}
void input() {
cin >> n;
int x;
for (int i = 0; i < n; i++)
cin >> x, st.insert(x);
}
int main() {
in... |
// in the name of Allah ;
#include <bits/stdc++.h>
using namespace std;
const int lg = 40;
int t[lg], n;
multiset<int> st;
void init() {
t[0] = 1;
for (int i = 0; i < lg - 1; i++)
t[i + 1] = t[i] * 2;
}
void input() {
cin >> n;
int x;
for (int i = 0; i < n; i++)
cin >> x, st.insert(x);
}
int main() {... | [
"variable_declaration.type.change",
"call.add",
"call.arguments.change"
] | 995,328 | 995,329 | u513193415 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, ans;
multiset<ll> st;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
ll x;
scanf("%lld", &x);
st.insert(x);
}
while (!st.empty()) {
ll v = *--st.end();
st.erase(--st.end());
for (int i = 0; i <= 32; ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, ans;
multiset<ll> st;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
ll x;
scanf("%lld", &x);
st.insert(x);
}
while (!st.empty()) {
ll v = *--st.end();
st.erase(--st.end());
for (int i = 0; i <= 32; ... | [
"expression.operation.binary.remove"
] | 995,336 | 995,337 | u842695276 | cpp |
p03201 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef ... | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 995,340 | 995,341 | u399527088 | cpp |
p03201 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef ... | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 995,340 | 995,343 | u399527088 | cpp |
p03201 |
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include ... |
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include ... | [
"literal.number.change",
"call.arguments.change"
] | 995,346 | 995,347 | u516353059 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
unordered_map<int, int> mp;
for (int x : a) {
mp[x]++;
}
sort(a, a + n);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
long x = a[i];
if (mp[x] == ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
unordered_map<int, int> mp;
for (int x : a) {
mp[x]++;
}
sort(a, a + n);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (mp[x] == 0)... | [
"variable_declaration.type.primitive.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 995,353 | 995,354 | u280512618 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
unordered_map<int, int> mp;
for (int x : a) {
mp[x]++;
}
sort(a, a + n);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (mp[x] == 0)... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
unordered_map<int, int> mp;
for (int x : a) {
mp[x]++;
}
sort(a, a + n);
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (mp[x] == 0)... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 995,355 | 995,354 | u280512618 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
ll pow2[33];
ll A[maxn];
ll B[maxn];
int oth[maxn];
vector<int> mch[maxn];
bool less2(int a, int b) { return mch[a].size() < mch[b].size(); }
int I;
bool less3(int a, int b) {
// if(a==I)return 1;
// if(b==I)return 0;
r... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
ll pow2[33];
ll A[maxn];
ll B[maxn];
int oth[maxn];
vector<int> mch[maxn];
bool less2(int a, int b) { return mch[a].size() < mch[b].size(); }
int I;
bool less3(int a, int b) {
// if(a==I)return 1;
// if(b==I)return 0;
r... | [
"misc.opposites",
"identifier.change",
"call.function.change"
] | 995,356 | 995,357 | u135208615 | cpp |
p03201 | #include <bits/stdc++.h>
#include <random>
//-------------------------------------------------------------------------
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define prv(v) \
for (auto i : v) { ... | #include <bits/stdc++.h>
#include <random>
//-------------------------------------------------------------------------
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define prv(v) \
for (auto i : v) { ... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 995,366 | 995,367 | u437672192 | cpp |
p03201 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstring>
#include <iostream>
#include <math.h>
#include <numeric>
#include <regex>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using dbl = double;
using pii = pair<int, int>;
using pl4 = pair<ll, ll>;
using vi ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstring>
#include <iostream>
#include <math.h>
#include <numeric>
#include <regex>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using dbl = double;
using pii = pair<int, int>;
using pl4 = pair<ll, ll>;
using vi ... | [
"control_flow.branch.if.condition.change"
] | 995,373 | 995,374 | u172929647 | cpp |
p03201 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstring>
#include <iostream>
#include <math.h>
#include <numeric>
#include <regex>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using dbl = double;
using pii = pair<int, int>;
using pl4 = pair<ll, ll>;
using vi ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstring>
#include <iostream>
#include <math.h>
#include <numeric>
#include <regex>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using dbl = double;
using pii = pair<int, int>;
using pl4 = pair<ll, ll>;
using vi ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 995,375 | 995,374 | u172929647 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k = 2;
whi... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k = 2;
whi... | [] | 995,379 | 995,380 | u943004959 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k = 2;
whi... | [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 995,381 | 995,382 | u943004959 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k = 2;
whi... | [
"variable_declaration.type.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 995,383 | 995,382 | u943004959 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k = 2;
whi... | [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 995,384 | 995,382 | u943004959 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 995,381 | 995,385 | u943004959 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 995,383 | 995,385 | u943004959 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | #include <bits/stdc++.h>
using namespace std;
#define llong long long int
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a[200001];
cin >> n;
unordered_map<llong, llong> M;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++M[a[i]];
}
vector<llong> P2;
llong k ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 995,384 | 995,385 | u943004959 | cpp |
p03201 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int ll;
int N, a[200001];
void solve() {
map<int, int> M;
for (int i = 0; i < N; i++) {
cin >> a[i];
M[a[i]]++;
}
sort(a, a + N);
int ret = 0;
int pw = 1 << 30;
for (int i = N - 1; i ... | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int ll;
int N, a[200001];
void solve() {
map<int, int> M;
for (int i = 0; i < N; i++) {
cin >> a[i];
M[a[i]]++;
}
sort(a, a + N);
int ret = 0;
int pw = 1 << 30;
for (int i = N - 1; i ... | [] | 995,393 | 995,394 | u610253537 | cpp |
p03201 | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
map<int, int> M;
int n, a[1 << 18], ans;
main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
M[a[i]]++;
}
sort(a, a + n);
for (int i = n; i--;)
if (M[a[i]]-- > 0)
for (int j = 1; 1 << j > a[i]; j++)
... | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
map<int, int> M;
int n, a[1 << 18], ans;
main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
M[a[i]]++;
}
sort(a, a + n);
for (int i = n; i--;)
if (M[a[i]]-- > 0)
for (int j = 32; 1L << j > a[i]; j--)
... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"control_flow.branch.if.condition.change"
] | 995,398 | 995,399 | u657913472 | cpp |
p03201 | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl... | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 995,413 | 995,414 | u816910105 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
using ull = uint64_t;
using ll = int64_t;
using ld = long double;
const int N = 200228;
int a[N];
map<int, int> m;
int main() {
#ifdef BZ
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(... | #include <bits/stdc++.h>
using namespace std;
using ull = uint64_t;
using ll = int64_t;
using ld = long double;
const int N = 200228;
int a[N];
map<int, int> m;
int main() {
#ifdef BZ
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(... | [
"expression.operation.binary.remove"
] | 995,426 | 995,425 | u609667271 | cpp |
p03198 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 995,429 | 995,430 | u294531924 | cpp |
p03198 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"assignment.variable.change"
] | 995,431 | 995,430 | u294531924 | cpp |
p03198 | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_... | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 995,438 | 995,439 | u360980679 | cpp |
p03198 | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 17;
const ll INF = 1e18;
int n, a[maxn];
ll f[maxn], g[maxn], ans = INF;
inline int getint() {
char ch = getchar();
... | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 17;
const ll INF = 1e18;
int n, a[maxn];
ll f[maxn], g[maxn], ans = INF;
inline int getint() {
char ch = getchar();
... | [
"expression.operation.binary.remove"
] | 995,440 | 995,441 | u885026599 | cpp |
p03198 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#define int long long
#define PI pair<ll, ll>
#define f first
#define s second
using namespace std;
typedef long long ll;
ll n, A[400010], L[400010], R[400010];
signed main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++)
scanf(... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#define int long long
#define PI pair<ll, ll>
#define f first
#define s second
using namespace std;
typedef long long ll;
ll n, A[400010], L[400010], R[400010];
signed main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++)
scanf(... | [
"control_flow.branch.if.add"
] | 995,442 | 995,443 | u280475878 | cpp |
p03198 | #include <bits/stdc++.h>
using namespace std;
#define sz(a) (int)(a).size()
#define rep(i, a, b) for (int i = (a), _b = (b); i < _b; ++i)
#define debug(a) cerr << #a << ": " << (a) << '\n';
#define debug_arr(arr, n) \
{ ... | #include <bits/stdc++.h>
using namespace std;
#define sz(a) (int)(a).size()
#define rep(i, a, b) for (int i = (a), _b = (b); i < _b; ++i)
#define debug(a) cerr << #a << ": " << (a) << '\n';
#define debug_arr(arr, n) \
{ ... | [] | 995,448 | 995,449 | u752952720 | cpp |
p03198 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int(i) = (a); (i) <= (b); (i)++)
#define ROF(i, a, b) for (int(i) = (a); (i) >= (b); (i)--)
#define REP(i, n) FOR(i, 0, (n)-1)
#define sqr(x) ((x) * (x))
#define all(x) (x).begin(), (x).end()
#defi... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int(i) = (a); (i) <= (b); (i)++)
#define ROF(i, a, b) for (int(i) = (a); (i) >= (b); (i)--)
#define REP(i, n) FOR(i, 0, (n)-1)
#define sqr(x) ((x) * (x))
#define all(x) (x).begin(), (x).end()
#defi... | [
"expression.operation.binary.remove"
] | 995,450 | 995,451 | u923961984 | cpp |
p03198 | #include <bits/stdc++.h>
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <time.h>
#include <vector>
#define dibs reserv... | #include <bits/stdc++.h>
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <time.h>
#include <vector>
#define dibs reserv... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 995,458 | 995,459 | u642082255 | cpp |
p03198 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define pb push_back
#define fi first
#define se second
#define Mod 1000000007
int main() {
ll i, j, k;
ll n;
cin >> n;
long double a[n], b[n];
for (i = 0; i < n; i++) {
ll x;
cin >> x;
a[i] = x;
b[i] ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define pb push_back
#define fi first
#define se second
#define Mod 1000000007
int main() {
ll i, j, k;
ll n;
cin >> n;
long double a[n], b[n];
for (i = 0; i < n; i++) {
ll x;
cin >> x;
a[i] = x;
b[i] ... | [] | 995,460 | 995,461 | u586567203 | cpp |
p03198 | #include <algorithm>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
static const int INF = 1000000000;
vector<ll> solve(const vector<ll> &a) {
const int n = a.size();
vector<ll> incr(n);
stack<pii> istack;
istack.... | #include <algorithm>
#include <iostream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
static const int INF = 1000000000;
vector<ll> solve(const vector<ll> &a) {
const int n = a.size();
vector<ll> incr(n);
stack<pii> istack;
istack.... | [] | 995,464 | 995,465 | u424163068 | cpp |
p03198 | #include <iostream>
#include <stack>
#include <utility>
#define llint long long
using namespace std;
typedef pair<llint, llint> P;
llint n;
llint a[200005];
llint b[200005], cap[200005];
stack<P> stk;
llint l[200005], r[200005];
llint check(llint p) {
llint ret = 0;
for (int i = p + 1; i <= n; i++) {
if (b[i... | #include <iostream>
#include <stack>
#include <utility>
#define llint long long
using namespace std;
typedef pair<llint, llint> P;
llint n;
llint a[200005];
llint b[200005], cap[200005];
stack<P> stk;
llint l[200005], r[200005];
llint check(llint p) {
llint ret = 0;
for (int i = p + 1; i <= n; i++) {
if (b[i... | [
"identifier.change",
"control_flow.loop.condition.change"
] | 995,466 | 995,467 | u319282133 | cpp |
p03198 | #ifndef BZ
#pragma GCC optimize "-O3"
#endif
#include <bits/stdc++.h>
#define FASTIO
#define ALL(v) (v).begin(), (v).end()
#define rep(i, l, r) for (int i = (l); i < (r); ++i)
#ifdef FASTIO
#define scanf abacaba
#define printf abacaba
#endif
typedef long long ll;
typedef long double ld;
typedef unsigned long long ul... | #ifndef BZ
#pragma GCC optimize "-O3"
#endif
#include <bits/stdc++.h>
#define FASTIO
#define ALL(v) (v).begin(), (v).end()
#define rep(i, l, r) for (int i = (l); i < (r); ++i)
#ifdef FASTIO
#define scanf abacaba
#define printf abacaba
#endif
typedef long long ll;
typedef long double ld;
typedef unsigned long long ul... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 995,470 | 995,471 | u953484888 | cpp |
p03198 | #include <bits/stdc++.h>
using namespace std;
int main() {
int_fast64_t N;
scanf("%lld", &N);
vector<int_fast64_t> a(N), b(N), c(N), d(N);
for (int i = 0; i < N; ++i)
scanf("%lld", &a[i]);
b[N - 1] = 0;
{
stack<int_fast64_t> stc;
for (int_fast64_t i = N - 2; i >= 0; --i) {
b[i] = b[i + 1]... | #include <bits/stdc++.h>
using namespace std;
int main() {
int_fast64_t N;
scanf("%lld", &N);
vector<int_fast64_t> a(N), b(N), c(N), d(N);
for (int i = 0; i < N; ++i)
scanf("%lld", &a[i]);
b[N - 1] = 0;
{
stack<int_fast64_t> stc;
for (int_fast64_t i = N - 2; i >= 0; --i) {
b[i] = b[i + 1]... | [
"expression.operation.binary.remove",
"assignment.change"
] | 995,472 | 995,473 | u462437857 | cpp |
p03199 | #include "bits/stdc++.h"
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0);
#define pb push_back
#define eb emplace_back
#define ins insert
#define f first
#define s second
... | #include "bits/stdc++.h"
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0);
#define pb push_back
#define eb emplace_back
#define ins insert
#define f first
#define s second
... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,476 | 995,477 | u059492462 | cpp |
p03199 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
constexpr ll mod = 998244353;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
friend o... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
constexpr ll mod = 998244353;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
friend o... | [
"control_flow.loop.for.condition.change",
"call.arguments.change",
"control_flow.branch.if.condition.change",
"call.arguments.add",
"identifier.change",
"variable_access.subscript.index.change"
] | 995,482 | 995,481 | u623954643 | cpp |
p03199 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
constexpr ll mod = 998244353;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
friend o... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
constexpr ll mod = 998244353;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
friend o... | [
"control_flow.loop.for.condition.change",
"call.arguments.change",
"control_flow.branch.if.condition.change",
"call.arguments.add",
"identifier.change",
"variable_access.subscript.index.change"
] | 995,482 | 995,483 | u623954643 | cpp |
p03199 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set... | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set... | [
"call.arguments.change",
"control_flow.branch.if.condition.change",
"call.arguments.add"
] | 995,484 | 995,485 | u021034020 | cpp |
p03199 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll pw(ll x, ll y) {
ll res = 1;
while (y) {
if (y & 1)
res = res * x % M;
x = x * x % ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 998244353
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
ll pw(ll x, ll y) {
ll res = 1;
while (y) {
if (y & 1)
res = res * x % M;
x = x * x % M... | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 995,497 | 995,498 | u743900647 | cpp |
p03199 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#define ll long long
#define pii pair<int, int>
using namespace std;
map<pii, int> mp;
int read() {
char ch = getchar();
int f = 0, x = 1;
while (ch < '0' || ch > '9') {
if (ch == '-')
x = -1;
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#define ll long long
#define pii pair<int, int>
using namespace std;
map<pii, int> mp;
int read() {
char ch = getchar();
int f = 0, x = 1;
while (ch < '0' || ch > '9') {
if (ch == '-')
x = -1;
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 995,503 | 995,504 | u565895053 | cpp |
p03199 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <s... | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <s... | [
"expression.operator.change"
] | 995,513 | 995,514 | u202239169 | cpp |
p03199 | #include <bits/stdc++.h>
using namespace std;
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define abs(a) max((a), -(a))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repe(i, n) rep(i, (n) + 1)
#define per(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define pere(i,... | #include <bits/stdc++.h>
using namespace std;
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define abs(a) max((a), -(a))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repe(i, n) rep(i, (n) + 1)
#define per(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define pere(i,... | [
"control_flow.branch.else.add"
] | 995,519 | 995,520 | u405923605 | cpp |
p03202 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
vector<long long> a;
bool check(int k) {
map<int, int> mp;
for (int i = 1; i < a.size(); i++) {
if (a[i] <= a[i - 1])
continue;
if (k == 1)
return false;
if (a[i] <= a[i - 1]) {
int p = a[... | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
vector<long long> a;
bool check(int k) {
map<int, int> mp;
for (int i = 1; i < a.size(); i++) {
if (a[i] > a[i - 1])
continue;
if (k == 1)
return false;
if (a[i] <= a[i - 1]) {
int p = a[i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,523 | 995,524 | u480806810 | cpp |
p03202 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
constexpr int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr int... | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
constexpr int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr int... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 995,525 | 995,526 | u745250049 | cpp |
p03202 | // includes {{{
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
// }}}
// #include<bits/stdc++.h>
using namespace std;
using ll = long lon... | // includes {{{
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
// }}}
// #include<bits/stdc++.h>
using namespace std;
using ll = long lon... | [
"expression.unary.arithmetic.add"
] | 995,535 | 995,536 | u884379688 | cpp |
p03202 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>... | [
"assignment.change"
] | 995,539 | 995,540 | u180421499 | cpp |
p03202 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>... | [
"assignment.change",
"control_flow.loop.for.initializer.change"
] | 995,541 | 995,540 | u180421499 | cpp |
p03202 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
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 < ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
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 < ... | [
"assignment.value.change",
"expression.operation.binary.change"
] | 995,542 | 995,543 | u462560753 | cpp |
p03202 | #include <algorithm>
#include <deque>
#include <set>
#include <stdio.h>
using namespace std;
using ll = long long;
class Int2 {
public:
int chara, count;
Int2(int chara, int count) {
this->chara = chara;
this->count = count;
}
};
int n, a[200000];
bool incr(deque<Int2> &c, int x) {
if (c.back().chara +... | #include <algorithm>
#include <deque>
#include <set>
#include <stdio.h>
using namespace std;
using ll = long long;
class Int2 {
public:
int chara, count;
Int2(int chara, int count) {
this->chara = chara;
this->count = count;
}
};
int n, a[200000];
bool incr(deque<Int2> &c, int x) {
if (c.back().chara +... | [
"control_flow.branch.if.add",
"control_flow.branch.if.condition.change",
"control_flow.return.add"
] | 995,550 | 995,551 | u196520288 | cpp |
p03202 | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unistd.h>
#include <vector>
#ifndef ONLINE_JUDGE
#define... | #include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unistd.h>
#include <vector>
#ifndef ONLINE_JUDGE
#define... | [
"expression.operation.binary.add"
] | 995,552 | 995,553 | u787843430 | cpp |
p03202 | #include <bits/stdc++.h>
#include <iomanip>
#define DEBUG 1
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i, a, b) for (int i = (... | #include <bits/stdc++.h>
#include <iomanip>
#define DEBUG 1
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LD, LD> PLDLD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<char> VB;
#define FOR(i, a, b) for (int i = (... | [
"control_flow.branch.if.condition.change"
] | 995,557 | 995,558 | u284759714 | cpp |
p03202 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005;
int n;
int a[N];
bool f(int c) {
vector<pair<int, int>> s;
int last = 0;
for (int i = 0; i < n; i++) {
if (a[i] > last) {
s.emplace_back(1, a[i] - last);
} else {
int rem = last - a[i];
while ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005;
int n;
int a[N];
bool f(int c) {
vector<pair<int, int>> s;
int last = 0;
for (int i = 0; i < n; i++) {
if (a[i] > last) {
s.emplace_back(1, a[i] - last);
} else {
int rem = last - a[i];
while ... | [
"control_flow.branch.if.add"
] | 995,559 | 995,560 | u805692198 | cpp |
p03202 | #include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
int a[MAXN];
ll p[55];
int n;
bool judge(int c) {
memset(p, 0, sizeof(p));
int now = 0;
for (int i = 1; i <= n; i++... | #include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
int a[MAXN];
ll p[35];
int n;
bool judge(int c) {
memset(p, 0, sizeof(p));
int now = 0;
for (int i = 1; i <= n; i++... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"misc.opposites",
"expression.operator.compare.change"
] | 995,561 | 995,562 | u374828698 | cpp |
p03202 | #include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
int a[MAXN];
ll p[35];
int n;
bool judge(int c) {
memset(p, 0, sizeof(p));
int now = 0;
for (int i = 1; i <= n; i++... | #include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
int a[MAXN];
ll p[35];
int n;
bool judge(int c) {
memset(p, 0, sizeof(p));
int now = 0;
for (int i = 1; i <= n; i++... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,563 | 995,562 | u374828698 | cpp |
p03202 | #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
... | #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
... | [
"control_flow.loop.condition.change",
"assignment.variable.change",
"identifier.change"
] | 995,564 | 995,565 | u115888500 | cpp |
p03202 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 5000010;
int n, a[N], len[N], v[N];
bool check(int x) {
int top = 1;
len[1] = a[1];
v[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] > a[i - 1]) {
len[++top] = a[i];
v[top] = 1;
} e... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 5000010;
int n, a[N], len[N], v[N];
bool check(int x) {
int top = 1;
len[1] = a[1];
v[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] > a[i - 1]) {
len[++top] = a[i];
v[top] = 1;
} e... | [
"assignment.change"
] | 995,568 | 995,569 | u108109251 | cpp |
p03202 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool judge(long long N, vector<long long> A, long long c) {
stack<pair<long long, long long>> S;
long long L = A[0];
S.push(make_pair(L, 0));
for (int i = 1; i < N; ++i) {
/*
stack<pair<ll,ll>> T = S;
while(!T.empty()) {
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool judge(long long N, vector<long long> A, long long c) {
stack<pair<long long, long long>> S;
long long L = A[0];
S.push(make_pair(L, 0));
for (int i = 1; i < N; ++i) {
/*
stack<pair<ll,ll>> T = S;
while(!T.empty()) {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,570 | 995,571 | u183530284 | cpp |
p03202 | // int n;
// bool solve(vi arr, int mid){
// if(mid == 1)
// return arr.size() == 1;
// vpii coll,fin;
// for(auto cur : arr){
// if(coll.empty() || coll.back().first != cur)
// coll.pb(mp(cur,1));
// else
// coll.back().second++;
// }
// for(auto cur : coll){
// if(fin.empty() || fin.back().first > cur.first)
... | // int n;
// bool solve(vi arr, int mid){
// if(mid == 1)
// return arr.size() == 1;
// vpii coll,fin;
// for(auto cur : arr){
// if(coll.empty() || coll.back().first != cur)
// coll.pb(mp(cur,1));
// else
// coll.back().second++;
// }
// for(auto cur : coll){
// if(fin.empty() || fin.back().first < cur.first)
... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,572 | 995,573 | u399542755 | cpp |
p03202 | // int n;
// bool solve(vi arr, int mid){
// if(mid == 1)
// return arr.size() == 1;
// vpii coll,fin;
// for(auto cur : arr){
// if(coll.empty() || coll.back().first != cur)
// coll.pb(mp(cur,1));
// else
// coll.back().second++;
// }
// for(auto cur : coll){
// if(fin.empty() || fin.back().first > cur.first)
... | // int n;
// bool solve(vi arr, int mid){
// if(mid == 1)
// return arr.size() == 1;
// vpii coll,fin;
// for(auto cur : arr){
// if(coll.empty() || coll.back().first != cur)
// coll.pb(mp(cur,1));
// else
// coll.back().second++;
// }
// for(auto cur : coll){
// if(fin.empty() || fin.back().first < cur.first)
... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 995,574 | 995,573 | u399542755 | cpp |
p03202 | // int n;
// bool solve(vi arr, int mid){
// if(mid == 1)
// return arr.size() == 1;
// vpii coll,fin;
// for(auto cur : arr){
// if(coll.empty() || coll.back().first != cur)
// coll.pb(mp(cur,1));
// else
// coll.back().second++;
// }
// for(auto cur : coll){
// if(fin.empty() || fin.back().first > cur.first)
... | // int n;
// bool solve(vi arr, int mid){
// if(mid == 1)
// return arr.size() == 1;
// vpii coll,fin;
// for(auto cur : arr){
// if(coll.empty() || coll.back().first != cur)
// coll.pb(mp(cur,1));
// else
// coll.back().second++;
// }
// for(auto cur : coll){
// if(fin.empty() || fin.back().first < cur.first)
... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 995,575 | 995,573 | u399542755 | cpp |
p03202 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namesp... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namesp... | [
"expression.operation.binary.remove"
] | 995,576 | 995,577 | u287305727 | cpp |
p03202 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namesp... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namesp... | [
"expression.operation.binary.remove"
] | 995,578 | 995,577 | u287305727 | cpp |
p03202 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namesp... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namesp... | [
"expression.operation.binary.remove"
] | 995,579 | 995,577 | u287305727 | cpp |
p03202 | #include <cstdio>
#include <map>
std::map<int, int> mp;
int n, a[201000];
bool check(int x) {
mp.clear();
int len = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > len) {
len = a[i];
std::map<int, int>::iterator it = mp.end();
if (it != mp.begin()) {
--it;
while (it->first > l... | #include <cstdio>
#include <map>
std::map<int, int> mp;
int n, a[201000];
bool check(int x) {
mp.clear();
int len = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > len) {
len = a[i];
std::map<int, int>::iterator it = mp.end();
if (it != mp.begin()) {
--it;
while (it->first > a... | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 995,580 | 995,581 | u220632857 | cpp |
p03202 | /*+lmake
* STD = c++14
* DEFINE += WAAUTOMATON
*/
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#ifdef WAAUTOMATON
#define debug(args...) \
{ ... | /*+lmake
* STD = c++14
* DEFINE += WAAUTOMATON
*/
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#ifdef WAAUTOMATON
#define debug(args...) \
{ ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,588 | 995,589 | u275407061 | cpp |
p03202 | #include <bits/stdc++.h>
#define N 200004
#define pp pair<int, int>
#define mp make_pair
#define pb push_back
#define ff first
#define dd second
using namespace std;
int n;
int maxi = 1;
int tab[N];
void removeDigits(set<pp> &digits, int sz) {
while (!digits.empty() and digits.rbegin()->ff >= sz)
digits.erase(*... | #include <bits/stdc++.h>
#define N 200004
#define pp pair<int, int>
#define mp make_pair
#define pb push_back
#define ff first
#define dd second
using namespace std;
int n;
int maxi = 1;
int tab[N];
void removeDigits(set<pp> &digits, int sz) {
while (!digits.empty() and digits.rbegin()->ff >= sz)
digits.erase(*... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,596 | 995,597 | u460095023 | cpp |
p03201 | /* 2^30极限 */
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fi first
#define sec second
#define opr iterator
typedef long long ll;
using namespace std;
int ok[31];
int num[100001];
int n;
int prev[100001];
vector<int> odd;
bool check(int a, int b) { return !(!(~((a ^ b) ^ 1))); }
int findodd... | /* 2^30极限 */
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fi first
#define sec second
#define opr iterator
typedef long long ll;
using namespace std;
int ok[31];
int num[100001];
int n;
int prev[100001];
vector<int> odd;
bool check(int a, int b) { return !(!(~((a ^ b) ^ 1))); }
int findodd... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 995,611 | 995,612 | u597691811 | cpp |
p03201 | /**
* Username : adhoc_king
* Name : adhoc_king
* Institute : IIT Bombay
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
// #include <deque>
// #include <queue>
// #include <ar... | /**
* Username : adhoc_king
* Name : adhoc_king
* Institute : IIT Bombay
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
// #include <deque>
// #include <queue>
// #include <ar... | [
"variable_declaration.type.change"
] | 995,617 | 995,618 | u140739684 | cpp |
p03201 | /**
* Username : adhoc_king
* Name : adhoc_king
* Institute : IIT Bombay
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
// #include <deque>
// #include <queue>
// #include <ar... | /**
* Username : adhoc_king
* Name : adhoc_king
* Institute : IIT Bombay
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
// #include <deque>
// #include <queue>
// #include <ar... | [
"variable_declaration.type.change",
"call.add",
"call.arguments.change"
] | 995,619 | 995,618 | u140739684 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 10;
int n;
int st[maxi];
map<int, int> mp;
int a[maxi];
int main() {
cin >> n;
st[0] = 1;
for (int i = 1; i <= 30; i++)
st[i] = st[i - 1] * 2;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mp[a[i]]++;
}
sort(a + 1, a... | #include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 10;
int n;
int st[maxi];
map<int, int> mp;
int a[maxi];
int main() {
cin >> n;
st[0] = 1;
for (int i = 1; i <= 30; i++)
st[i] = st[i - 1] * 2;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mp[a[i]]++;
}
sort(a + 1, a... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.change"
] | 995,620 | 995,621 | u020344863 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pint;
typedef pair<ll, int> P;
// typedef tuple<int,int,int> T;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2147483600; // 10^9
ll MOD = 1000000007;
ll r(ll x) {
ll xdash = x;
int cnt = 0;
while (xdash... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pint;
typedef pair<ll, int> P;
// typedef tuple<int,int,int> T;
ll INFL = 1000000000000000010; // 10^18 = 2^60
int INF = 2147483600; // 10^9
ll MOD = 1000000007;
ll r(ll x) {
ll xdash = x;
int cnt = 0;
while (xdash... | [
"call.add"
] | 995,622 | 995,623 | u633284019 | cpp |
p03201 | #include <bits/stdc++.h>
#define syosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd... | #include <bits/stdc++.h>
#define syosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd... | [] | 995,624 | 995,625 | u434747175 | cpp |
p03201 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | [
"assignment.change"
] | 995,626 | 995,627 | u394033362 | cpp |
p03201 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 995,628 | 995,627 | u394033362 | cpp |
p03201 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 995,629 | 995,627 | u394033362 | cpp |
p03201 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, ans = 0;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 995,630 | 995,627 | u394033362 | cpp |
p03201 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#inc... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#inc... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 995,633 | 995,634 | u112723190 | cpp |
p03201 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <set>
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 200005;
typedef long long ll;
multiset<ll> q;
int n;
ll ans;
ll a[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a... | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <set>
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 200005;
typedef long long ll;
multiset<ll> q;
int n;
ll ans;
ll a[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a... | [
"call.arguments.change"
] | 995,635 | 995,636 | u827214941 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
int main() {
size_t N;
scanf("%ld", &N);
deque<pair<int_fast64_t, int_fast64_t>> a(
N, pair<int_fast64_t, int_fast64_t>(0, 1));
for (size_t i = 0; i < N; ++i)
scanf("%ld", &(a[i].first));
sort(a.begin(), a.end());
uint_fast64_t A(0);
for (; a.emp... | #include <bits/stdc++.h>
using namespace std;
int main() {
size_t N;
scanf("%ld", &N);
deque<pair<int_fast64_t, int_fast64_t>> a(
N, pair<int_fast64_t, int_fast64_t>(0, 1));
for (size_t i = 0; i < N; ++i)
scanf("%ld", &(a[i].first));
sort(a.begin(), a.end());
uint_fast64_t A(0);
for (; !a.em... | [
"expression.operation.unary.add",
"call.arguments.change"
] | 995,637 | 995,638 | u462437857 | cpp |
p03201 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <stdio.h>
#include <string>
#include <vector>
#define FORi(N) for (ll i = 0; i < N; ++i)
#define FORj(N) for (ll i = 0; i < N; ++i)
#define FABi(a, b) for (ll i = a; i <= b; ++i)
... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <stdio.h>
#include <string>
#include <vector>
#define FORi(N) for (ll i = 0; i < N; ++i)
#define FORj(N) for (ll i = 0; i < N; ++i)
#define FABi(a, b) for (ll i = a; i <= b; ++i)
... | [
"assignment.value.change"
] | 995,651 | 995,652 | u373586461 | cpp |
p03201 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
#define file(x) \
freopen(x ".in", "r", stdin); ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
#define file(x) \
freopen(x ".in", "r", stdin); ... | [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add"
] | 995,657 | 995,658 | u178311310 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
long long N, A[200009], cnt;
multiset<long long> S;
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A, A + N);
for (int i = N - 1; i >= 0; i--) {
bool flag = false;
for (int j = 0; j < 32; j++) {
long long ret = (1LL << j) - A[... | #include <bits/stdc++.h>
using namespace std;
long long N, A[200009], cnt;
multiset<long long> S;
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A, A + N);
for (int i = N - 1; i >= 0; i--) {
bool flag = false;
for (int j = 0; j < 32; j++) {
long long ret = (1LL << j) - A[... | [
"control_flow.break.add"
] | 995,661 | 995,662 | u483737025 | cpp |
p03201 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
ll n, a;
ll nibeki(ll q) {
ll r = 1;
while (true) {
r *= 2;
if (r > q) {
break;
}
}
return r;
}
int main() {
cin >> n;
multiset<ll> mst;
for (ll i = 0;... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
ll n, a;
ll nibeki(ll q) {
ll r = 1;
while (true) {
r *= 2;
if (r > q) {
break;
}
}
return r;
}
int main() {
cin >> n;
multiset<ll> mst;
for (ll i = 0;... | [
"call.add",
"call.arguments.change"
] | 995,663 | 995,664 | u388697579 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<pi> vpi;
typedef set<int> si;
typedef long double ld;
#define mp make_pair
#define pb push_back
#define f first
#define s second
ll INF = 1e15;
ll MOD = 1e9;
#d... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<pi> vpi;
typedef set<int> si;
typedef long double ld;
#define mp make_pair
#define pb push_back
#define f first
#define s second
ll INF = 1e15;
ll MOD = 1e9;
#d... | [
"identifier.change",
"call.function.change"
] | 995,669 | 995,670 | u938024002 | cpp |
p03201 | #include <algorithm>
#include <set>
#include <stdio.h>
#define N 200002
using namespace std;
int A[N], ans = 0;
set<int> s;
set<int>::iterator it;
int main() {
int i, nm, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &A[i]);
s.insert(A[i]);
}
sort(A + 1, A + 1 + n);
for (nm = 1; nm < A[... | #include <algorithm>
#include <set>
#include <stdio.h>
#define N 200002
using namespace std;
int A[N], ans = 0;
multiset<int> s;
multiset<int>::iterator it;
int main() {
int i, nm, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &A[i]);
s.insert(A[i]);
}
sort(A + 1, A + 1 + n);
for (nm = ... | [
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 995,677 | 995,678 | u075260459 | cpp |
p03201 | /* Accepted. */
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <set>
using namespace std;
#define MAXN 200006
int n;
multiset<int> S;
int main() {
cin >> n;
for (int i = 0, t; i < n; ++i)
scanf("%d", &t), S.insert(t);
int ans = 0;
while (!S.empty()) {... | /* Accepted. */
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <set>
using namespace std;
#define MAXN 200006
int n;
multiset<int> S;
int main() {
cin >> n;
for (int i = 0, t; i < n; ++i)
scanf("%d", &t), S.insert(t);
int ans = 0;
while (!S.empty()) {... | [
"call.arguments.add"
] | 995,679 | 995,680 | u390140944 | cpp |
p03201 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int main() {
// cout.precision(10);
map<ll, ll> mp;
ll N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
mp[A[i]]++;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int main() {
// cout.precision(10);
map<ll, ll> mp;
ll N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
mp[A[i]]++;
... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 995,681 | 995,682 | u980655160 | cpp |
p03201 | #include <cstdio>
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
ll n, s, x;
multiset<ll> v;
int main() {
ll i, t;
multiset<ll>::iterator it;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%lld", &t);
v.insert(t);
}
while (!v.empty()) {
x = *v.rbegin();
v.erase(v.... | #include <cstdio>
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
ll n, s, x;
multiset<ll> v;
int main() {
ll i, t;
multiset<ll>::iterator it;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%lld", &t);
v.insert(t);
}
while (!v.empty()) {
x = *v.rbegin();
v.erase(v.... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 995,683 | 995,684 | u255657363 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.