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 |
|---|---|---|---|---|---|---|---|
p03126 | #include <stdio.h>
int c[30], cnt;
int main() {
int N, M;
scanf("%d%d", &N, &M);
int K[31], A[30][30];
int i, j;
for (i = 0; i < N; i++) {
scanf("%d", &K[i]);
for (j = 0; j < K[i]; j++) {
scanf("%d", &A[i][j]);
c[A[i][j]]++;
}
}
for (i = 0; i < N; i++) {
if (c[i + 1] == N)
... | #include <stdio.h>
int c[30], cnt;
int main() {
int N, M;
scanf("%d%d", &N, &M);
int K[31], A[30][30];
int i, j;
for (i = 0; i < N; i++) {
scanf("%d", &K[i]);
for (j = 0; j < K[i]; j++) {
scanf("%d", &A[i][j]);
c[A[i][j]]++;
}
}
for (i = 0; i < M; i++) {
if (c[i + 1] == N)
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,583 | 928,584 | u792455295 | cpp |
p03126 | #include <bits/stdc++.h>
using namespace std;
int n, m, t, tt;
int a[32];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> t;
for (int j = 0; j < t; j++) {
cin >> tt;
a[tt]++;
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
if (a[i] == n) {
ans++;
}
}
c... | #include <bits/stdc++.h>
using namespace std;
int n, m, t, tt;
int a[32];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> t;
for (int j = 0; j < t; j++) {
cin >> tt;
a[tt]++;
}
}
int ans = 0;
for (int i = 1; i <= m; i++) {
if (a[i] == n) {
ans++;
}
}
... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,594 | 928,595 | u547457320 | cpp |
p03126 | #include <iostream>
using namespace std;
int a[35];
int main() {
int n, m, num;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int flag;
cin >> num;
for (int j = 1; j <= num; ++j) {
cin >> flag;
a[flag]++;
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == n) {
... | #include <iostream>
using namespace std;
int a[35];
int main() {
int n, m, num;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int flag;
cin >> num;
for (int j = 1; j <= num; ++j) {
cin >> flag;
a[flag]++;
}
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
if (a[i] == n) {
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,647 | 928,648 | u493225326 | cpp |
p03126 | #include <iostream>
#include <stdio.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m, t = 0, y = 0;
cin >> n;
cin >> m;
int a[n][m] = {0}, x[n] = {0};
for (int i = 0; i < n; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> a[i][... | #include <iostream>
#include <stdio.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m, t = 0, y = 0;
cin >> n;
cin >> m;
int a[n][m] = {0}, x[m] = {0};
for (int i = 0; i < n; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> a[i][... | [
"identifier.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,653 | 928,654 | u187606204 | cpp |
p03126 | #include <bits/stdc++.h>
using namespace std;
//#define READ_NUMBER(i) scanf("%d",i)
int main() {
int N, M, K, nA, Anm;
int count = 0;
cin >> N >> M;
int array[M];
for (int j = 0; j < M; j++) {
array[j] = 0;
}
if (N == 1) {
cin >> K;
cout << K << endl;
} else {
for (int i = 0; i < N; i... | #include <bits/stdc++.h>
using namespace std;
//#define READ_NUMBER(i) scanf("%d",i)
int main() {
int N, M, K, nA, Anm;
int count = 0;
cin >> N >> M;
int array[M];
//配列のリセット
for (int j = 0; j < M; j++) {
array[j] = 0;
}
// N = 1 の時はK1個が答えになる
if (N == 1) {
cin >> K;
cout << K << endl;
... | [
"assignment.change"
] | 928,665 | 928,666 | u796853866 | cpp |
p03126 | #include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
vector<int> split(string data);
int main() {
int n, m;
cin >> n >> m;
cin.ignore();
int result[m] = {}; // initialized 0
for (size_t i = 0; i < n; i++) {
string s;
getline(cin, s);
vector<int> list = ... | #include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
vector<int> split(string data);
int main() {
int n, m;
cin >> n >> m;
cin.ignore();
int result[m] = {}; // initialized 0
for (size_t i = 0; i < n; i++) {
string s;
getline(cin, s);
vector<int> list = ... | [
"expression.operation.binary.add"
] | 928,688 | 928,689 | u820315626 | cpp |
p03126 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int M, N, K, A, *foods, count;
cin >> N >> M;
foods = new int[M];
for (int i = 0; i < N; i++) {
cin >> K;
for (int j = 0; j < K; j++) {
cin >> A;
foods[A - 1]++;... | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int M, N, K, A, *foods, count = 0;
cin >> N >> M;
foods = new int[M];
for (int i = 0; i < N; i++) {
cin >> K;
for (int j = 0; j < K; j++) {
cin >> A;
foods[A - 1... | [
"variable_declaration.value.change"
] | 928,694 | 928,695 | u732491975 | cpp |
p03126 | /* B */
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int *like = new int[m];
for (int i = 0; i < m; i++) {
like[i] = 0;
}
for (int t = 0; t < n; t++) {
int k;
int tmp;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> tmp;
like[tmp - 1]++;
... | /* B */
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int *like = new int[m];
for (int i = 0; i < m; i++) {
like[i] = 0;
}
for (int t = 0; t < n; t++) {
int k;
int tmp;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> tmp;
like[tmp - 1]++;
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,710 | 928,711 | u147762850 | cpp |
p03126 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M;
vector<int> favorite;
cin >> N >> M;
favorite.resize(M);
fill(favorite.begin(), favorite.end(), 0);
for (int i = 0; i < N; i++) {
int K;
cin >> K;
for (int j = 0; j < K; j++) {
int A;
cin >> A;
favorite... | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M;
vector<int> favorite;
cin >> N >> M;
favorite.resize(M + 1);
fill(favorite.begin(), favorite.end(), 0);
for (int i = 0; i < N; i++) {
int K;
cin >> K;
for (int j = 0; j < K; j++) {
int A;
cin >> A;
favo... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change"
] | 928,714 | 928,715 | u021940499 | cpp |
p03126 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> v(M);
for (int i = 0; i < N; i++) {
int K;
cin >> K;
vector<int> foods(K);
for (int j = 0; j < K; j++)
cin >> foods[j];
for (int f : foo... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> v(M);
for (int i = 0; i < N; i++) {
int K;
cin >> K;
vector<int> foods(K);
for (int j = 0; j < K; j++)
cin >> foods[j];
for (int f : foo... | [
"expression.operation.binary.add"
] | 928,722 | 928,723 | u562767072 | cpp |
p03126 | #include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
template <typename T> void show(T a) {
for (auto i : a) {
cout << i << " ";
}
cout << endl;
}
template <typename T> void s... | #include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
template <typename T> void show(T a) {
for (auto i : a) {
cout << i << " ";
}
cout << endl;
}
template <typename T> void s... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,724 | 928,725 | u367592430 | cpp |
p03126 | #include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
template <typename T> void show(T a) {
for (auto i : a) {
cout << i << " ";
}
cout << endl;
}
template <typename T> void s... | #include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
template <typename T> void show(T a) {
for (auto i : a) {
cout << i << " ";
}
cout << endl;
}
template <typename T> void s... | [
"identifier.change",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 928,726 | 928,725 | u367592430 | cpp |
p03126 | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int N, M;
cin >> N >> M;
std::vector<int> v(N + 1, 0);
for (int i = 0; i < M; i++) {
int K;
cin >> K;
for (int j = 0; j < K; j++) {
int a;
cin >> a;
v[a]++;
}
}
int ans = 0;
for (int i = ... | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int N, M;
cin >> M >> N;
std::vector<int> v(N + 1, 0);
for (int i = 0; i < M; i++) {
int K;
cin >> K;
for (int j = 0; j < K; j++) {
int a;
cin >> a;
v[a]++;
}
}
int ans = 0;
for (int i = ... | [
"expression.operation.binary.remove"
] | 928,733 | 928,734 | u942774736 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define inf 1001001001001001001
#define mod 1000000007
#define mod2 998244353
#define pi acos(-1)
#define all(v) v.begin(), v.end()
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define inf 1001001001001001001
#define mod 1000000007
#define mod2 998244353
#define pi acos(-1)
#define all(v) v.begin(), v.end()
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 928,737 | 928,738 | u948222358 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
long long M = gcd(A.at(0), A.at(1));
for (int i = 2; i < N; i++) {
M = gcd(M, A.at(2));
}
cout << M << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
long long M = gcd(A.at(0), A.at(1));
for (int i = 2; i < N; i++) {
M = gcd(M, A.at(i));
}
cout << M << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 928,757 | 928,758 | u714624983 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
long long M = gcd(A.at(0), A.at(1));
for (int i = 2; i < N; i++) {
M = gcd(M, A.at(2));
}
cout << M << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
long long M = gcd(A.at(0), A.at(1));
for (int i = 2; i < N; i++) {
M = gcd(M, A.at(i));
}
cout << M << endl;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 928,759 | 928,758 | u714624983 | cpp |
p03127 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, m) for (int i = n; i < m; i++)
#define reps(i, n) for (int i = 1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
using namespace std;
using ll = long long;
ll mod = 100... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, m) for (int i = n; i < m; i++)
#define reps(i, n) for (int i = 1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
using namespace std;
using ll = long long;
ll mod = 100... | [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change"
] | 928,919 | 928,918 | u467480147 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define sort(s) sort(s.begin(), s.end())
#define reverse(s) reverse(s.begin(), s.end())
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
const ll mod = 1e9 + 7;
//最大公約数
ll gcd(ll a, ll b) { return b ?... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define sort(s) sort(s.begin(), s.end())
#define reverse(s) reverse(s.begin(), s.end())
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
const ll mod = 1e9 + 7;
//最大公約数
ll gcd(ll a, ll b) { return b ?... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 928,956 | 928,957 | u584787460 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll mod = 1000000007;
const int MAX_N = 1000; // n の最大値
// nCk を取得
double nCk(int n, int k) {
double res = 1.0;
for (int i = 0; i < n; i++) {
res *= 0.5;
}
for (int i = 0; i < k; i++) {
res *= (d... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll mod = 1000000007;
const int MAX_N = 1000; // n の最大値
// nCk を取得
double nCk(int n, int k) {
double res = 1.0;
for (int i = 0; i < n; i++) {
res *= 0.5;
}
for (int i = 0; i < k; i++) {
res *= (d... | [
"variable_declaration.value.change"
] | 929,095 | 929,096 | u722640678 | cpp |
p03127 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int func1(int a, int b) {
if (b == 0) {
return a;
}
return func1(b, a % b);
}
int main() {
int n;
cin >> n;
int max = 1;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) ... | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int func1(int a, int b) {
if (b == 0) {
return a;
}
return func1(b, a % b);
}
int main() {
int n;
cin >> n;
int max = 0;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) ... | [
"literal.number.change",
"variable_declaration.value.change"
] | 929,232 | 929,233 | u130834452 | cpp |
p03127 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int func1(int a, int b) {
if (b == 0) {
return a;
}
return func1(b, b % a);
}
int main() {
int n;
cin >> n;
int max = 1;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) ... | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int func1(int a, int b) {
if (b == 0) {
return a;
}
return func1(b, a % b);
}
int main() {
int n;
cin >> n;
int max = 0;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) ... | [
"expression.operation.binary.remove",
"literal.number.change",
"variable_declaration.value.change"
] | 929,234 | 929,233 | u130834452 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int gcd_euclid(int u, int v) {
int r;
while (0 != v) {
r = u % v;
u = v;
v = r; /* swap */
}
return u;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int j = 1; j < n; j++) {
a[j] = gcd_e... | #include <bits/stdc++.h>
using namespace std;
int gcd_euclid(int u, int v) {
int r;
while (0 != v) {
r = u % v;
u = v;
v = r; /* swap */
}
return u;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int j = 1; j < n; j++) {
a[j] = gcd_e... | [
"expression.operation.binary.add"
] | 929,238 | 929,239 | u593555034 | cpp |
p03127 | #include <iostream>
#include <vector>
using namespace std;
// 2変数の最大公約数を求める関数
int gcd_func(int a, int b) {
// 2変数の剰余が0になったら、『割られる数』＝『最大公約数』
if (b == 0) {
return a;
}
return gcd_func(b, a % b);
}
int main() {
// Nは10の5乗なので、int型
int N;
cin >> N;
// Aは10の9乗なので、long型
vector<long> A(N);
for (int ... | #include <iostream>
#include <vector>
using namespace std;
// 2変数の最大公約数を求める関数
int gcd_func(int a, int b) {
// 2変数の剰余が0になったら、『割られる数』＝『最大公約数』
if (b == 0) {
return a;
}
return gcd_func(b, a % b);
}
int main() {
// Nは10の5乗なので、int型
int N;
cin >> N;
// Aは10の9乗なので、long型
vector<long> A(N);
for (int ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 929,284 | 929,285 | u865500049 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ll N;
cin >> N;
vector<ll> A(N);
for (ll i = 0; i < N; i++) {
cin >> A[i];
}
ll B = 0;
for (ll i = 1; i < N; i++) {
B = gcd(A[i -... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ll N;
cin >> N;
vector<ll> A(N);
for (ll i = 0; i < N; i++) {
cin >> A[i];
}
ll B = 0;
for (ll i = 0; i < N; i++) {
B = gcd(A[i],... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.remove"
] | 929,311 | 929,312 | u584139221 | cpp |
p03127 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, a[100005] = {};
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, a[100005] = {};
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i... | [
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 929,325 | 929,326 | u151855078 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int GCD(int x, int y) { return x ? GCD(y % x, x) : y; }
int main() {
int n;
cin >> n;
vector<int> k;
for (int i = 0; i < n; i++)
cin >> k.at(i);
int s = k[0];
for (int i = 0; i < n; i++)
s = GCD(s, k.at(i));
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int GCD(int x, int y) { return x ? GCD(y % x, x) : y; }
int main() {
int n;
cin >> n;
vector<int> k(n);
for (int i = 0; i < n; i++)
cin >> k.at(i);
int s = k[0];
for (int i = 0; i < n; i++)
s = GCD(s, k.at(i));
cout << s << endl;
}
| [] | 929,339 | 929,340 | u813174766 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rreps(i, e, n) for (int i = (n)-1; i >= (e); i--)
#d... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rreps(i, e, n) for (int i = (n)-1; i >= (e); i--)
#d... | [
"expression.operation.binary.remove"
] | 929,365 | 929,366 | u225581241 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int my(int x, int y) {
if (x < y)
swap(x, y);
while (y > 0) {
int z = y;
y = x % z;
x = z;
}
return x;
}
int main() {
int n;
cin >> n;
vector<int> mon(n);
for (int i = 0; i < n; i++)
cin >> mon.at(i);
int x = mon.at(0);
for (int i = ... | #include <bits/stdc++.h>
using namespace std;
int my(int x, int y) {
if (x < y)
swap(x, y);
while (y > 0) {
int z = y;
y = x % z;
x = z;
}
return x;
}
int main() {
int n;
cin >> n;
vector<int> mon(n);
for (int i = 0; i < n; i++)
cin >> mon.at(i);
int x = mon.at(0);
for (int i = ... | [
"call.arguments.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.add"
] | 929,483 | 929,484 | u057079894 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int my(int x, int y) {
if (x < y)
swap(x, y);
while (y > 0) {
int z = y;
y = x % z;
x = z;
}
return x;
}
int main() {
int n;
cin >> n;
vector<int> mon(n);
for (int i = 0; i < n; i++)
cin >> mon.at(i);
int x = mon.at(0);
for (int i = ... | #include <bits/stdc++.h>
using namespace std;
int my(int x, int y) {
if (x < y)
swap(x, y);
while (y > 0) {
int z = y;
y = x % z;
x = z;
}
return x;
}
int main() {
int n;
cin >> n;
vector<int> mon(n);
for (int i = 0; i < n; i++)
cin >> mon.at(i);
int x = mon.at(0);
for (int i = ... | [
"call.arguments.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.add"
] | 929,485 | 929,484 | u057079894 | cpp |
p03108 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#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--)
#defi... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#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--)
#defi... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 929,562 | 929,563 | u324303263 | cpp |
p03108 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#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--)
#defi... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#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--)
#defi... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 929,562 | 929,564 | u324303263 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"variable_declaration.type.change"
] | 929,598 | 929,599 | u640323045 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"variable_declaration.type.change",
"call.add",
"call.arguments.change"
] | 929,600 | 929,599 | u640323045 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"variable_declaration.type.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 929,598 | 929,601 | u640323045 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <ve... | [
"variable_declaration.type.change",
"call.add",
"call.arguments.change"
] | 929,602 | 929,601 | u640323045 | cpp |
p03108 | // 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 <list>
#include <map>
#include... | // 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 <list>
#include <map>
#include... | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 929,640 | 929,641 | u468878441 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
#define... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
#define... | [
"assignment.value.change",
"identifier.change"
] | 929,646 | 929,647 | u921177152 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
#define... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
#define... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 929,648 | 929,647 | u921177152 | cpp |
p03108 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
class UnionFind {
public:
//親の番号、親だった場合は-(size)
vector<int> Parent;
// Parentの値を全て-1にする
Uni... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
class UnionFind {
public:
//親の番号、親だった場合は-(size)
vector<int> Parent;
// Parentの値を全て-1にする
Uni... | [
"control_flow.loop.for.initializer.change"
] | 929,665 | 929,666 | u806800460 | cpp |
p03108 | #include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
// 親の番号を格納する。親だったら-(その集合のサイズ)
vector<int> Parent; //
// 作るときはParentの値を全て-1にする。
// こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる。
int root(int A) {
if (Parent[A] < 0)
return A; ... | #include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
// 親の番号を格納する。親だったら-(その集合のサイズ)
vector<int> Parent; //
// 作るときはParentの値を全て-1にする。
// こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる。
int root(int A) {
if (Parent[A] < 0)
return A; ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 929,691 | 929,689 | u934246119 | cpp |
p03108 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
return par[x] = root(par[x]);
}
bool... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
... | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"variable_declaration.type.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 929,720 | 929,717 | u074445770 | cpp |
p03108 | #include <algorithm>
#include <iostream>
#include <vector>
#define pi pair<int, int>
using namespace std;
class UnionFind {
public:
vector<int> parent;
UnionFind(int N) : parent(vector<int>(N, -1)) {}
int root(int A) {
if (parent[A] < 0)
return A;
return parent[A] = root(parent[A]);
}
int s... | #include <algorithm>
#include <iostream>
#include <vector>
#define pi pair<int, int>
using namespace std;
class UnionFind {
public:
vector<int> parent;
UnionFind(int N) : parent(vector<int>(N, -1)) {}
int root(int A) {
if (parent[A] < 0)
return A;
return parent[A] = root(parent[A]);
}
int s... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 929,723 | 929,724 | u501724534 | cpp |
p03108 | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#include <immintrin.h>
#include <iostream>
#include <random>
#include <unordered_map>
#include <unordered_set>
using namespace std;
//呪文
#define DUMPOUT cerr
#define dump(...) \
DUMPOUT << " "; ... | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#include <immintrin.h>
#include <iostream>
#include <random>
#include <unordered_map>
#include <unordered_set>
using namespace std;
//呪文
#define DUMPOUT cerr
#define dump(...) \
DUMPOUT << " "; ... | [
"identifier.change",
"io.output.change"
] | 929,750 | 929,751 | u034865202 | cpp |
p03108 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) <<... | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) <<... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 929,768 | 929,769 | u895971408 | cpp |
p03108 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) <<... | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) <<... | [
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 929,770 | 929,769 | u895971408 | cpp |
p03108 | // ABC 055 D
#include <bits/stdc++.h>
using namespace std;
// container util
//------------------------------------------
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define EACH(i, c) \
for (t... | // ABC 055 D
#include <bits/stdc++.h>
using namespace std;
// container util
//------------------------------------------
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define EACH(i, c) \
for (t... | [
"type_conversion.add"
] | 929,773 | 929,772 | u513290715 | cpp |
p03108 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class UnionFind {
public:
/* 親の番号を格納する。親だった場合は-(その集合のサイズ) */
vector<int> Parent;
// 作る時はParentの値を全て-1にする
// こうすると全てバラバラになる
UnionFind(int N) {
Parent = vector<int>(N, -1); // 要素数Nのベクトルの要素を全て... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class UnionFind {
public:
/* 親の番号を格納する。親だった場合は-(その集合のサイズ) */
vector<int> Parent;
// 作る時はParentの値を全て-1にする
// こうすると全てバラバラになる
UnionFind(int N) {
Parent = vector<int>(N, -1); // 要素数Nのベクトルの要素を全て... | [
"assignment.value.change",
"identifier.change"
] | 929,774 | 929,775 | u813102292 | cpp |
p03108 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class UnionFind {
public:
/* 親の番号を格納する。親だった場合は-(その集合のサイズ) */
vector<int> Parent;
// 作る時はParentの値を全て-1にする
// こうすると全てバラバラになる
UnionFind(int N) {
Parent = vector<int>(N, -1); // 要素数Nのベクトルの要素を全て... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class UnionFind {
public:
/* 親の番号を格納する。親だった場合は-(その集合のサイズ) */
vector<int> Parent;
// 作る時はParentの値を全て-1にする
// こうすると全てバラバラになる
UnionFind(int N) {
Parent = vector<int>(N, -1); // 要素数Nのベクトルの要素を全て... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"function.return_value.change",
"call.arguments.add",
"assignment.value.change",
"identifier.change"
] | 929,776 | 929,775 | u813102292 | cpp |
p03127 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll MOD = 1e9 + 7;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll a[100000];
int main() {
int n;
ll ans = 0;
cin >>... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll MOD = 1e9 + 7;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int a[100000];
int main() {
int n;
int ans = 0;
c... | [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 929,812 | 929,813 | u863507492 | cpp |
p03127 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll MOD = 1e9 + 7;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int a[100000];
int main() {
int n;
int ans = 0;
c... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll MOD = 1e9 + 7;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int a[100000];
int main() {
int n;
int ans = 0;
c... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 929,814 | 929,813 | u863507492 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int now = gcd(a[0], a[1]);
for (int i = 1; i < n - 1; i... | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int now = gcd(a[0], a[1]);
for (int i = 1; i < n - 1; i... | [
"assignment.change"
] | 929,935 | 929,936 | u410878763 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long int i = 0; i < n; ++i)
typedef long long int ll;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n;
cin >> n;
vector<ll> ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long int i = 0; i < n; ++i)
typedef long long int ll;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n;
cin >> n;
vector<ll> ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 929,978 | 929,979 | u376817785 | cpp |
p03127 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
using namespace std;
int main() {
int n, num[110000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
}
int x = 1;
for (int j = 0; j < n; j++) {
x = __gcd(num[j], x);
}
c... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
using namespace std;
int main() {
int n, num[110000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
}
int x = num[0];
for (int j = 0; j < n; j++) {
x = __gcd(num[j], x);
... | [
"identifier.replace.add",
"literal.replace.remove"
] | 930,004 | 930,005 | u127856129 | cpp |
p03127 | #include <algorithm>
#include <iostream>
#include <numeric>
using namespace std;
long long int n;
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int main() {
cin >> n;
long long int a[1000000];
for (int i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);... | #include <algorithm>
#include <iostream>
#include <numeric>
using namespace std;
long long int n;
int gcd(int a, int b) {
while (b != 0) {
int t = b;
b = a % b;
a = t;
}
return a;
}
int main() {
cin >> n;
long long int a[1000000];
for (int i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);... | [
"expression.operation.binary.add"
] | 930,021 | 930,022 | u809700806 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
int N, A;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> N >> A;
int ans = 0;
for (int i = 1; i < N; i++) {
cin >> A;
ans = gcd(ans, A);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int N, A;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> N >> A;
int ans = A;
for (int i = 1; i < N; i++) {
cin >> A;
ans = gcd(ans, A);
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 930,034 | 930,035 | u691170040 | cpp |
p03127 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, P> P3;
const ll MOD = ll(1e9) + 7;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-11;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define R... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, P> P3;
const ll MOD = ll(1e9) + 7;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-11;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define R... | [
"expression.operation.binary.remove",
"identifier.change",
"function.return_value.change"
] | 930,045 | 930,046 | u271063202 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const long long LINF = 1e18;
const long long MOD = 1e9 + 7;
int d[] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
signed main() {... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const long long LINF = 1e18;
const long long MOD = 1e9 + 7;
int d[] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
signed main() {... | [
"variable_declaration.value.change"
] | 930,091 | 930,092 | u366398972 | cpp |
p03128 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int h[10] = {6, 2, 5, 5, 4, 5, 6... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int h[10] = {6, 2, 5, 5, 4, 5, 6... | [
"assignment.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 930,093 | 930,094 | u003026289 | cpp |
p03128 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int h[10] = {6, 2, 5, 5, 4, 5, 6... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int h[10] = {6, 2, 5, 5, 4, 5, 6... | [
"assignment.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 930,095 | 930,094 | u003026289 | cpp |
p03128 | //#pragma once
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib> // srand,rand
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdl... | //#pragma once
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib> // srand,rand
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdl... | [
"expression.operation.binary.remove"
] | 930,105 | 930,106 | u058317639 | cpp |
p03128 | ///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <typeinfo>
#include <vector>
using namespace std;
//////////////////////////////////////////////////////... | ///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <typeinfo>
#include <vector>
using namespace std;
//////////////////////////////////////////////////////... | [] | 930,120 | 930,121 | u167931717 | cpp |
p03128 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int nMatch[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string append(string s, string t) {
if (s == "")
return t;
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] < t[0]) {
s.insert(i, t);
break;
}
}
return... | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int nMatch[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string append(string s, string t) {
if (s == "")
return t;
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] <= t[0]) {
s.insert(i, t);
break;
}
}
retu... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 930,181 | 930,182 | u119098168 | cpp |
p03128 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, ... | [
"literal.number.change",
"call.arguments.change"
] | 930,187 | 930,188 | u853721692 | cpp |
p03128 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, ... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"call.arguments.change"
] | 930,189 | 930,188 | u853721692 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
#define rep1(i, N) for (int i = 1; i < int(N); ++i)
#define all(a) (a).begin(), (a).end()
#define print(v) \
{ ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
#define rep1(i, N) for (int i = 1; i < int(N); ++i)
#define all(a) (a).begin(), (a).end()
#define print(v) \
{ ... | [
"literal.number.change"
] | 930,218 | 930,219 | u106297876 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
vector<int> maxvec(vector<int> &a, vector<int> &b) {
if (a[0] > b[0])
return a;
if (a[0] < b[0])
return b;
for (int i = 9; i >= 1; i--) {
if (a[i] > b[i])
return a;
if (a[i] < b[i])
return b;
}
return a;
}
int main() {
int N, M;
... | #include <bits/stdc++.h>
using namespace std;
vector<int> maxvec(vector<int> &a, vector<int> &b) {
if (a[0] > b[0])
return a;
if (a[0] < b[0])
return b;
for (int i = 9; i >= 1; i--) {
if (a[i] > b[i])
return a;
if (a[i] < b[i])
return b;
}
return a;
}
int main() {
int N, M;
... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 930,286 | 930,287 | u544437817 | cpp |
p03128 | #include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int match[10] = {10, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int N, M;
cin >> N >> M;
vector<int> A(M);
for (int i = 0; i < M; i++... | #include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int match[10] = {10, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int N, M;
cin >> N >> M;
vector<int> A(M);
for (int i = 0; i < M; i++... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 930,311 | 930,312 | u494037974 | cpp |
p03128 | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int N, M;
bool used[10] = {}; // used[i]: iを使う
int cost[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string n_to_s = "0123456789";
string dp[10001]; // dp[i]:i本の中で作れる数の各桁の数字の内訳
bool comp_str(string a, string b) {
// aがbより大きい数字を作れるのならtrue そうで... | #include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int N, M;
bool used[10] = {}; // used[i]: iを使う
int cost[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string n_to_s = "0123456789";
string dp[10001]; // dp[i]:i本の中で作れる数の各桁の数字の内訳
bool comp_str(string a, string b) {
// aがbより大きい数字を作れるのならtrue そうで... | [
"variable_declaration.value.change"
] | 930,317 | 930,318 | u107077805 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using pi = pair<int32, int32>;
using pll = pair<int64, int64>;
using vi = vector<int32>;
using vvi = vector<vector<int32>>;
using vll = vector<int64>;
using l... | #include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using pi = pair<int32, int32>;
using pll = pair<int64, int64>;
using vi = vector<int32>;
using vvi = vector<vector<int32>>;
using vll = vector<int64>;
using l... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 930,340 | 930,341 | u572532976 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vector<int>>;
#define fix20 cout << fixed << setprecision(20);
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define MOD 1000000007
int dic[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
bool compare(vi atk, int j, vi def) {
int ... | #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vector<int>>;
#define fix20 cout << fixed << setprecision(20);
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define MOD 1000000007
int dic[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
bool compare(vi atk, int j, vi def) {
int ... | [
"control_flow.branch.if.add"
] | 930,386 | 930,387 | u184335045 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
#define int long long
string INF = "-";
int match[9] = {2, 5, 5, 4, 5, 6, 3, 7, 6};
string dp[10001]; //マッチi本で作れる最大数
string chmax(string s, string t) {
if (s == INF)
return t;
if (s.size() < t.size())
return t;
if (s.size() == s.size() && s < t)
return ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
string INF = "-";
int match[9] = {2, 5, 5, 4, 5, 6, 3, 7, 6};
string dp[10001 + 9]; //マッチi本で作れる最大数
string chmax(string s, string t) {
if (s == INF)
return t;
if (s.size() < t.size())
return t;
if (s.size() == s.size() && s < t)
ret... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 930,424 | 930,423 | u344122377 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string MINF = "-";
void chmax(string &a, string b) {
if (a == MINF)
a = b;
else if (b.size() > a.size())
a = b;
else if (b.size() < a.size())
return;
else if (a < b)
a = b;
}
int main() {
int N, M;
cin >> N >> M;
vecto... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string MINF = "-";
void chmax(string &a, string b) {
if (a == MINF)
a = b;
else if (b.size() > a.size())
a = b;
else if (b.size() < a.size())
return;
else if (a < b)
a = b;
}
int main() {
int N, M;
cin >> N >> M;
vecto... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 930,454 | 930,455 | u052332717 | cpp |
p03128 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define re... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define re... | [
"literal.number.change"
] | 930,467 | 930,468 | u426855695 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define BR "\n"
#define SP " "
#define SHOW(x) \
for (int i = 0; i < x.size(); i++) { \
cout << x[i] << SP; ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define BR "\n"
#define SP " "
#define SHOW(x) \
for (int i = 0; i < x.size(); i++) { \
cout << x[i] << SP; ... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 930,479 | 930,478 | u339233484 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define BR "\n"
#define SP " "
#define SHOW(x) \
for (int i = 0; i < x.size(); i++) { \
cout << x[i] << SP; ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define BR "\n"
#define SP " "
#define SHOW(x) \
for (int i = 0; i < x.size(); i++) { \
cout << x[i] << SP; ... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 930,480 | 930,478 | u339233484 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define BR "\n"
#define SP " "
#define SHOW(x) \
for (int i = 0; i < x.size(); i++) { \
cout << x[i] << SP; ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define BR "\n"
#define SP " "
#define SHOW(x) \
for (int i = 0; i < x.size(); i++) { \
cout << x[i] << SP; ... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 930,481 | 930,478 | u339233484 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;
const int num[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string dp[2][10010];
bool c... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFF = 1e18;
const int num[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string dp[2][10010];
bool c... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 930,484 | 930,485 | u029876051 | cpp |
p03128 | #include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#defi... | #include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#defi... | [
"literal.number.change"
] | 930,490 | 930,491 | u649310245 | cpp |
p03128 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
#define dame ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
#define dame ... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 930,494 | 930,495 | u791593901 | cpp |
p03128 | #include <algorithm> // minmax, sort, swap
#include <climits> // INT_MIN, LLONG_MIN
#include <cmath> // long, trig, pow
#include <cstdio> // printf, scanf
#include <iomanip> // cout<<setprecision(n)
#include <iostream> // cin, cout, cerr, clog
#include <map> // key-value pa... | #include <algorithm> // minmax, sort, swap
#include <climits> // INT_MIN, LLONG_MIN
#include <cmath> // long, trig, pow
#include <cstdio> // printf, scanf
#include <iomanip> // cout<<setprecision(n)
#include <iostream> // cin, cout, cerr, clog
#include <map> // key-value pa... | [
"variable_declaration.value.change"
] | 930,498 | 930,499 | u128456980 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
#define int long long
// 1,2,3,4,5,6,7,8,9
// 2,5,5,4,5,6,3,7,6
// 2,3,4,5,6,7
// 1,7,4,5,9,8
using P = pair<int, int>;
map<int, int> mx;
vector<int> num = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int vnum = 10020;
int dp[vnum];
int dig[vnum];
signed main() {
int n, m;
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
// 1,2,3,4,5,6,7,8,9
// 2,5,5,4,5,6,3,7,6
// 2,3,4,5,6,7
// 1,7,4,5,9,8
using P = pair<int, int>;
map<int, int> mx;
vector<int> num = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int vnum = 10020;
int dp[vnum];
int dig[vnum];
signed main() {
int n, m;
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 930,510 | 930,511 | u731175398 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
#define int long long
// 1,2,3,4,5,6,7,8,9
// 2,5,5,4,5,6,3,7,6
// 2,3,4,5,6,7
// 1,7,4,5,9,8
using P = pair<int, int>;
map<int, int> mx;
vector<int> num = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int vnum = 10020;
int dp[vnum];
int dig[vnum];
signed main() {
int n, m;
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
// 1,2,3,4,5,6,7,8,9
// 2,5,5,4,5,6,3,7,6
// 2,3,4,5,6,7
// 1,7,4,5,9,8
using P = pair<int, int>;
map<int, int> mx;
vector<int> num = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int vnum = 10020;
int dp[vnum];
int dig[vnum];
signed main() {
int n, m;
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 930,512 | 930,511 | u731175398 | cpp |
p03128 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int Match[] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int N, M;
void traceback(vector<int> A, vector<int> dp) {
int pos = N;
int dig = dp[N];
while (pos != 0) {
for (int i = A.size() - 1; i >= 0; i--) {
if (pos - Match[A[i]] < 0)
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int Match[] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int N, M;
void traceback(vector<int> A, vector<int> dp) {
int pos = N;
int dig = dp[N];
while (pos != 0) {
for (int i = A.size() - 1; i >= 0; i--) {
if (pos - Match[A[i]] < 0)
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 930,558 | 930,559 | u564056510 | cpp |
p03128 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; --i)
#define yesno(flg) \
if (flg) { \
cout << "Yes" << endl; ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; --i)
#define yesno(flg) \
if (flg) { \
cout << "Yes" << endl; ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 930,604 | 930,605 | u707053380 | cpp |
p03128 | #include <algorithm>
#include <array>
#include <cstring>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
const int MOD = 1000000007;
const int INF = 1000000000;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
t... | #include <algorithm>
#include <array>
#include <cstring>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
const int MOD = 1000000007;
const int INF = 1000000000;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
t... | [
"literal.number.change",
"assignment.value.change"
] | 930,637 | 930,638 | u945017646 | cpp |
p03128 | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x, to) for (x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), ... | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x, to) for (x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), ... | [
"call.arguments.change"
] | 930,680 | 930,681 | u452725238 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
N - K >= K - 1 ? cout << "Yes" << endl : cout << "No" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
N - K >= K - 1 ? cout << "YES" << endl : cout << "NO" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 930,688 | 930,689 | u211175911 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for (int i = (int)(n); i > 0; i--)
#define pb push_back
#define ts ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for (int i = (int)(n); i > 0; i--)
#define pb push_back
#define ts ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 930,692 | 930,693 | u851044959 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statis... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statis... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 930,697 | 930,698 | u750630712 | cpp |
p03129 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
int ... | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
int ... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 930,699 | 930,700 | u730499268 | cpp |
p03129 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
int ... | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
int ... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 930,701 | 930,700 | u730499268 | cpp |
p03129 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n >= 2 * k + 1) {
cout << "YES";
} else {
cout << "NO";
}
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n >= 2 * k - 1) {
cout << "YES";
} else {
cout << "NO";
}
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 930,715 | 930,716 | u520276780 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N / 2 + 1) >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1) / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 930,723 | 930,724 | u345589723 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define sort(s) sort(s.begin(), s.end())
#define reverse(s) reverse(s.begin(), s.end())
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
const ll mod = 1e9 + 7;
//最大公約数
ll gcd(ll a, ll b) { return b ?... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pb push_back
#define sort(s) sort(s.begin(), s.end())
#define reverse(s) reverse(s.begin(), s.end())
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
const ll mod = 1e9 + 7;
//最大公約数
ll gcd(ll a, ll b) { return b ?... | [
"control_flow.branch.if.condition.change",
"expression.operator.arithmetic.change",
"expression.operator.compare.change"
] | 930,725 | 930,726 | u584787460 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for (ll(i) = 0LL; (i) < (ll)(n); (i)++)
#define rep2(i, s, e) for (ll(i) = (ll)(s); (i) < (ll)(e); (i)++)
#define repi(i, n) for (ll(i) = 0LL; (i) <= ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for (ll(i) = 0LL; (i) < (ll)(n); (i)++)
#define rep2(i, s, e) for (ll(i) = (ll)(s); (i) < (ll)(e); (i)++)
#define repi(i, n) for (ll(i) = 0LL; (i) <= ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 930,727 | 930,728 | u196953553 | cpp |
p03129 | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
strin... | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
strin... | [
"control_flow.branch.if.condition.change",
"call.add"
] | 930,729 | 930,730 | u610897920 | cpp |
p03129 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k... | [
"expression.operation.binary.add"
] | 930,731 | 930,732 | u283907492 | cpp |
p03129 | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define intmax INT_MAX
#de... | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define intmax INT_MAX
#de... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 930,743 | 930,744 | u125669112 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (3 * k - 2 <= n) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (2 * k - 1 <= n) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 930,755 | 930,756 | u714796740 | cpp |
p03129 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if ((n + k - 1) / k >= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if ((n + 1) / 2 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 930,761 | 930,762 | u071396528 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.