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 |
|---|---|---|---|---|---|---|---|
p03231 | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// 最大公約数を計算( gcd.cpp 参照)
ll gcd(ll a,... | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// 最大公約数を計算( gcd.cpp 参照)
ll gcd(ll a,... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 1,021,973 | 1,021,969 | u011438316 | cpp |
p03231 | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// 最大公約数を計算( gcd.cpp 参照)
ll gcd(ll a,... | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// 最大公約数を計算( gcd.cpp 参照)
ll gcd(ll a,... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 1,021,971 | 1,021,975 | u011438316 | cpp |
p03231 | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// 最大公約数を計算( gcd.cpp 参照)
ll gcd(ll a,... | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// 最大公約数を計算( gcd.cpp 参照)
ll gcd(ll a,... | [
"assignment.change"
] | 1,021,973 | 1,021,975 | u011438316 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n, m, l, g, i;
string s, t;
cin >> n >> m >> s >> t;
g = __gcd(n, m);
l = n * m / g;
for (i = 0; i < g - 1; i++) {
if (s.at(i * n / g) != t.at(i * m / g)) {
cout << -1 << endl;
return 0;
}
}
cout << ... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n, m, l, g, i;
string s, t;
cin >> n >> m >> s >> t;
g = __gcd(n, m);
l = n * m / g;
for (i = 0; i < g; i++) {
if (s.at(i * n / g) != t.at(i * m / g)) {
cout << -1 << endl;
return 0;
}
}
cout << l <<... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,021,976 | 1,021,977 | u666712170 | cpp |
p03231 | #include <iostream>
using namespace std;
long long fpb(long long a, long long b) {
if (b == 0)
return a;
return fpb(b, a % b);
}
long long findkpk(long long a, long long b) { return a * b / fpb(a, b); }
int main() {
bool correct = true;
int N, M;
string S, T;
cin >> N >> M >> S >> T;
long long kp... | #include <iostream>
using namespace std;
long long fpb(long long a, long long b) {
if (b == 0)
return a;
return fpb(b, a % b);
}
long long findkpk(long long a, long long b) { return a * b / fpb(a, b); }
int main() {
bool correct = true;
int N, M;
string S, T;
cin >> N >> M >> S >> T;
long long kp... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,021,992 | 1,021,993 | u018679195 | cpp |
p03231 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <cmath>
#include <ctime>
#include <map>
#include <math.h>
#include <typeinfo>
#define R(i, n) for (int i = 0; i < n; i++)
#define S(a) scanf("%d", &a)
#define S2(a, b) scanf("%... | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <cmath>
#include <ctime>
#include <map>
#include <math.h>
#include <typeinfo>
#define R(i, n) for (int i = 0; i < n; i++)
#define S(a) scanf("%d", &a)
#define S2(a, b) scanf("%... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,022,031 | 1,022,032 | u469783285 | cpp |
p03231 | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b)... | #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b)... | [
"assignment.add"
] | 1,022,035 | 1,022,036 | u688789047 | cpp |
p03231 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
... | [
"expression.operation.binary.remove"
] | 1,022,037 | 1,022,038 | u641900703 | cpp |
p03231 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
... | [
"expression.operation.binary.remove"
] | 1,022,039 | 1,022,038 | u641900703 | cpp |
p03231 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace {
ll GCD(ll a, ll ... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
namespace {
ll GCD(ll a, ll ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 1,022,099 | 1,022,100 | u227117171 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (ll i = j; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define INF (1000000000)
#define MOD (1000000007)
#define MAX (100000)
#define pii pair<int, int>
/////////////////////////////////////////////////////////
class XY... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (ll i = j; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define INF (1000000000)
#define MOD (1000000007)
#define MAX (100000)
#define pii pair<int, int>
/////////////////////////////////////////////////////////
class XY... | [
"variable_declaration.type.change",
"identifier.change",
"expression.operation.binary.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,022,107 | 1,022,106 | u855985627 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
typedef long long 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 * b) / gcd(a, b)); }
int main() {
ll N, M;
cin >> N >> M;
string S, T;
cin >> S >> T;
ll L = lcm(N, M);
ll g ... | #include <bits/stdc++.h>
using namespace std;
typedef long long 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 * b) / gcd(a, b)); }
int main() {
ll N, M;
cin >> N >> M;
string S, T;
cin >> S >> T;
ll L = lcm(N, M);
ll g ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,022,132 | 1,022,133 | u904123392 | cpp |
p03231 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb ... | [
"io.output.change",
"call.arguments.add"
] | 1,022,136 | 1,022,137 | u698883164 | cpp |
p03231 | #include <bits/stdc++.h>
#define ll long long
#define rep(s, g) for (int i = s; i < g; i++)
using namespace std;
int gc(ll n, ll m) {
if (m == 0)
return n;
return gc(m, n % m);
}
int main() {
string s, t;
ll n, m;
cin >> n >> m >> s >> t;
int i = 1;
while (i < gc(n, m)) {
if (s[n / gc(n, m) * i] ... | #include <bits/stdc++.h>
#define ll long long
#define rep(s, g) for (int i = s; i < g; i++)
using namespace std;
int gc(ll n, ll m) {
if (m == 0)
return n;
return gc(m, n % m);
}
int main() {
string s, t;
ll n, m;
cin >> n >> m >> s >> t;
int i = 0;
while (i < gc(n, m)) {
if (s[n / gc(n, m) * i] ... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,022,138 | 1,022,139 | u445015174 | cpp |
p03231 | #include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9 + 7)
#define inf (int)(3e18 + 7)
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i < n; i++)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(v) v.begin(), v.end()
#define mkp make_pair
#define... | #include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9 + 7)
#define inf (int)(3e18 + 7)
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i < n; i++)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(v) v.begin(), v.end()
#define mkp make_pair
#define... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 1,022,144 | 1,022,145 | u147049801 | cpp |
p03231 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF = (long long)1E17;
#define i_7 (long long)(1E9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return ... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF = (long long)1E17;
#define i_7 (long long)(1E9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 1,022,157 | 1,022,158 | u222293734 | cpp |
p03231 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF = (long long)1E17;
#define i_7 (long long)(1E9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return ... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF = (long long)1E17;
#define i_7 (long long)(1E9 + 7)
long mod(long a) {
long long c = a % i_7;
if (c >= 0)
return c;
return ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 1,022,159 | 1,022,158 | u222293734 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,022,162 | 1,022,161 | u491550356 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,022,163 | 1,022,161 | u491550356 | cpp |
p03231 | #include <iostream>
#include <string>
long sc(long long x, long long y) {
if (x < y) {
int z = x;
x = y;
y = z;
}
if (x % y == 0)
return (y);
return (sc(y, x % y));
}
using namespace std;
int main() {
long long n, m, a, b, c;
string s, t;
cin >> n;
cin >> m;
getline(cin, s);
getline(... | #include <iostream>
#include <string>
long sc(long long x, long long y) {
if (x < y) {
int z = x;
x = y;
y = z;
}
if (x % y == 0)
return (y);
return (sc(y, x % y));
}
using namespace std;
int main() {
long long n, m, a, b, c;
string s, t;
cin >> n;
cin >> m;
getline(cin, s);
getline(... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 1,022,215 | 1,022,216 | u805950813 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int gcd(int a, int b) {
int r, tmp;
/* 自然数 a > b を確認・入替 */
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
/* ユークリッドの互除法 */
r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
/* 最大公約数を出力 */
return b;
}
int ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
ll r, tmp;
/* 自然数 a > b を確認・入替 */
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
/* ユークリッドの互除法 */
r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
/* 最大公約数を出力 */
return b;
}
int main... | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 1,022,245 | 1,022,246 | u853947407 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define ll long long
#define _GLIBCXX_DEBUG
const ll MOD = 1000000007;
const int MAX = 510000;
// 最大公約数
ll gcd(ll m, ll n) {
if (n == 0)
return abs(m);
else
return gcd(n, m % n);
}
// 最小公倍数
ll lcm(ll m, ll n) { return abs(m) ... | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define ll long long
#define _GLIBCXX_DEBUG
const ll MOD = 1000000007;
const int MAX = 510000;
// 最大公約数
ll gcd(ll m, ll n) {
if (n == 0)
return abs(m);
else
return gcd(n, m % n);
}
// 最小公倍数
ll lcm(ll m, ll n) { return abs(m) ... | [
"control_flow.continue.remove",
"control_flow.break.add"
] | 1,022,254 | 1,022,255 | u852770206 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
while (a && b) {
if (a > b)
a = a % b;
else
b = b % a;
}
return a + b;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
ll k ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
while (a && b) {
if (a > b)
a = a % b;
else
b = b % a;
}
return a + b;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
ll k ... | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,022,267 | 1,022,268 | u543584809 | cpp |
p03231 | #include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <util... | #include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <util... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,022,323 | 1,022,324 | u342051078 | cpp |
p03231 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int gcd(int x, int y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
int main() {
int n, m;
strin... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int gcd(int x, int y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
int main() {
int n, m;
strin... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,022,361 | 1,022,362 | u828388155 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, ans = -1;
cin >> N >> M;
string s, t;
cin >> s >> t;
long long L, a = N, b = M, c = a % b;
while (c != 0) {
a = b, b = c, c = a % b;
}
L = N * M / b;
int x = L / N, y = L / M, z = min(N / y, M / x);
for (int i = 0; i <= z; i++)... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M, ans = -1;
cin >> N >> M;
string s, t;
cin >> s >> t;
long long L, a = N, b = M, c = a % b;
while (c != 0) {
a = b, b = c, c = a % b;
}
L = N * M / b;
int x = L / N, y = L / M, z = min(N / y, M / x);
for (int i = 0; i < z;... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"misc.off_by_one"
] | 1,022,383 | 1,022,382 | u071282706 | cpp |
p03231 | #include "bits/stdc++.h"
using namespace std;
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(x) (x).begin(), (x).end() //昇順
#define RALL(x) (x).rbegin(), (x).rend() // 降順
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
const long long mod = 1e... | #include "bits/stdc++.h"
using namespace std;
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(x) (x).begin(), (x).end() //昇順
#define RALL(x) (x).rbegin(), (x).rend() // 降順
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
const long long mod = 1e... | [
"identifier.change",
"control_flow.loop.condition.change"
] | 1,022,397 | 1,022,398 | u718774863 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll f(ll a, ll b) {
ll n;
while (a % b != 0) {
n = a % b;
a = b;
b = n;
}
return b;
}
int main() {
int i, j, cnt = 0;
ll n, m;
string s, t;
cin >> n >> m;
cin >> s >> t;
ll d = f(n, m);
for (i = 1; i <= d; i++) {
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll f(ll a, ll b) {
ll n;
while (a % b != 0) {
n = a % b;
a = b;
b = n;
}
return b;
}
int main() {
int i, j, cnt = 0;
ll n, m;
string s, t;
cin >> n >> m;
cin >> s >> t;
ll d = f(n, m);
for (i = 0; i < d; i++) {
i... | [
"literal.number.change",
"assignment.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"
] | 1,022,399 | 1,022,400 | u952130512 | cpp |
p03231 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll... | [
"expression.operation.binary.remove"
] | 1,022,420 | 1,022,421 | u031448582 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long> a(N);
for (int i = 0; i < N; i++)
cin >> a[i];
sort(a.begin(), a.end());
// reverse(a.begin(),a.begin());
vector<long> c(N);
c[N / 2] = a[0];
int j = 0, k = 0;
for (int i = 0; i < N / 2; i++) {
if (i % ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long> a(N);
for (int i = 0; i < N; i++)
cin >> a[i];
sort(a.begin(), a.end());
// reverse(a.begin(),a.begin());
vector<long> c(N);
c[N / 2] = a[0];
int j = 0, k = 0;
for (int i = 0; i < N / 2; i++) {
if (i ... | [
"call.function.change",
"call.arguments.change"
] | 1,022,428 | 1,022,429 | u223172354 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL a[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
LL ans = 0;
if (n % 2 == 1) {
int num = (n - 1) / 2;
for (int i = n; i >= n - (n - 1) / 2 + 1; i--) {
ans... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL a[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
LL ans = 0;
if (n % 2 == 1) {
int num = (n - 1) / 2;
for (int i = n; i >= n - (n - 1) / 2 + 1; i--) {
ans... | [
"assignment.change"
] | 1,022,430 | 1,022,431 | u816631826 | cpp |
p03229 | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//#define rep(i, n) for (ll i = 0; i < (n); ++i)... | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//#define rep(i, n) for (ll i = 0; i < (n); ++i)... | [
"call.function.change"
] | 1,022,436 | 1,022,437 | u564182781 | cpp |
p03229 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
signed main(void) {
int n;
ll sum, ans;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(a.rbegin(), a.rend());
sum = 0;
if (n % 2 == 1) {
sum = a[n /... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
signed main(void) {
int n;
ll sum, ans;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(a.rbegin(), a.rend());
sum = 0;
if (n % 2 == 1) {
sum = a[n /... | [
"identifier.change",
"io.output.change"
] | 1,022,440 | 1,022,441 | u890331732 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define sqrep(i, cc, n) for (long long i = cc; i * i <= n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
#define lrep(i, cc, n) for (long long i = cc; i < n; ++i)
#define sqrep(i, cc, n) for (long long i = cc; i * i <= n; ++i)
#define rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,022,442 | 1,022,443 | u330518333 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
long long A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A, A + N);
long long ans = 0;
long long ansmax = 0;
if (N % 2 == 1) {
for (int i = 0; i <= N / 2 - 1; i++) {
ans += A[N - 1 - i] * 2;
}
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
long long A[N];
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A, A + N);
long long ans = 0;
long long ansmax = 0;
if (N % 2 == 1) {
for (int i = 0; i <= N / 2 - 1; i++) {
ans += A[N - 1 - i] * 2;
}
... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,022,444 | 1,022,445 | u469315559 | cpp |
p03229 | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main(void) {
int64_t N;
cin >> N;
vector<int64_t> A(N);
rep(i, N) cin >> A[i];
sort(A.begin(), A.end());
int64_t answer = 0;
if (N % 2) {
int l0 = 0;
int r0 = N - 1... | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main(void) {
int64_t N;
cin >> N;
vector<int64_t> A(N);
rep(i, N) cin >> A[i];
sort(A.begin(), A.end());
int64_t answer = 0;
if (N % 2) {
int l0 = 0;
int r0 = N - 1... | [
"control_flow.loop.for.update.change",
"assignment.change"
] | 1,022,446 | 1,022,447 | u004707990 | cpp |
p03229 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,461 | 1,022,462 | u980909653 | cpp |
p03229 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,463 | 1,022,462 | u980909653 | cpp |
p03229 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typede... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,464 | 1,022,462 | u980909653 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; i++)
cin >> a.at(i);
sort(a.begin(), a.end());
deque<ll> aq;
for (int i = 0; i < n; i++)
aq.push_back(a.at(i));
// min-start
ll mi = 0;
deque<ll> aqmi = a... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; i++)
cin >> a.at(i);
sort(a.begin(), a.end());
deque<ll> aq;
for (int i = 0; i < n; i++)
aq.push_back(a.at(i));
// min-start
ll mi = 0;
deque<ll> aqmi = a... | [
"identifier.change",
"call.arguments.change"
] | 1,022,465 | 1,022,466 | u582684800 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int64_t> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
sort(A.begin(), A.end());
int64_t ans = 0;
if (N % 2 == 0) {
for (int i = 0; i < (N / 2) - 1; i++)
ans += (-2 * A.at(i));
ans -= A.at((N / 2) - 1)... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int64_t> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
sort(A.begin(), A.end());
int64_t ans = 0;
if (N % 2 == 0) {
for (int i = 0; i < (N / 2) - 1; i++)
ans += (-2 * A.at(i));
ans -= A.at((N / 2) - 1)... | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 1,022,473 | 1,022,474 | u101018317 | cpp |
p03229 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ... | [
"expression.operation.unary.add",
"expression.operation.unary.arithmetic.remove"
] | 1,022,479 | 1,022,480 | u889915625 | cpp |
p03229 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ... | [
"expression.operation.unary.arithmetic.remove"
] | 1,022,481 | 1,022,480 | u889915625 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
#define lli long long
#define all(i) i.begin(), i.end()
#define rall(i) i.rbegin(), i.rend()
#define rep0(i, j) for (int i = 0; i < j; i++)
#define rep1(i, j) for (int i = 1; i <= j; i++)
#define rep0d(i, j) for (int i = j - 1; i >= 0; i--)
#define MOD 1000000007
#define M... | #include <bits/stdc++.h>
using namespace std;
#define lli long long
#define all(i) i.begin(), i.end()
#define rall(i) i.rbegin(), i.rend()
#define rep0(i, j) for (int i = 0; i < j; i++)
#define rep1(i, j) for (int i = 1; i <= j; i++)
#define rep0d(i, j) for (int i = j - 1; i >= 0; i--)
#define MOD 1000000007
#define M... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,486 | 1,022,487 | u950603962 | cpp |
p03229 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
// output
#define SPBR(w, n) std::cout << (w... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
// output
#define SPBR(w, n) std::cout << (w... | [
"call.add",
"call.arguments.change",
"function.return_value.change"
] | 1,022,490 | 1,022,491 | u812973725 | cpp |
p03229 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vec... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vec... | [
"expression.operation.unary.logical.remove",
"control_flow.branch.if.condition.change"
] | 1,022,492 | 1,022,493 | u009414205 | cpp |
p03229 | //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using intpair = pair<int, int>... | //#include <bits/stdc++.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using intpair = pair<int, int>... | [
"assignment.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,494 | 1,022,495 | u195036695 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define erep(i, n) for (int i = 0; i <= n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define erep1(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
#define vint vector<int>
#define vvint vector<vector<int>>
#de... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define erep(i, n) for (int i = 0; i <= n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define erep1(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
#define vint vector<int>
#define vvint vector<vector<int>>
#de... | [
"expression.operation.binary.remove",
"assignment.change"
] | 1,022,496 | 1,022,497 | u613960672 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ll long long
#define all(x) begin(x), end(x)
#define toInt(x) (x - '0')
#define pll pair<ll, ll>
#define pli pair<ll, int>
const long long INF = 1LL << 60;
const int inf = 1 << 30;
const int mod = 1e9 + 7;
template... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for (int i = a; i < n; i++)
#define ll long long
#define all(x) begin(x), end(x)
#define toInt(x) (x - '0')
#define pll pair<ll, ll>
#define pli pair<ll, int>
const long long INF = 1LL << 60;
const int inf = 1 << 30;
const int mod = 1e9 + 7;
template... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,022,498 | 1,022,499 | u654427816 | cpp |
p03229 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main(void) {
int n;
cin >> n;
vector<ll> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
/*小さい奴を真ん中にする場合*/
deque<ll> que1;
rep(i, n) que1.push_back(v[i]);
ll ans1 = 0;
ll l... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main(void) {
int n;
cin >> n;
vector<ll> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
/*小さい奴を真ん中にする場合*/
deque<ll> que1;
rep(i, n) que1.push_back(v[i]);
ll ans1 = 0;
ll l... | [
"assignment.value.change",
"identifier.change"
] | 1,022,500 | 1,022,501 | u247576416 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<string> vstr;
typedef pair<ll, ll> pll;
typedef vector<pll> vp;
typedef map<ll, ll> mll;
typedef map<string, ll> mstrll;
#defin... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<string> vstr;
typedef pair<ll, ll> pll;
typedef vector<pll> vp;
typedef map<ll, ll> mll;
typedef map<string, ll> mstrll;
#defin... | [
"call.arguments.change",
"expression.operation.binary.remove"
] | 1,022,541 | 1,022,542 | u303059352 | cpp |
p03231 | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using l... | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using l... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 1,022,545 | 1,022,546 | u090994275 | cpp |
p03231 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; ... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,022,549 | 1,022,550 | u228214259 | cpp |
p03231 | #include <iostream>
using namespace std;
long long n, m, g, ans;
string s, t;
int gcd(int p, int q) { return q ? gcd(q, p % q) : p; }
int main() {
cin >> n >> m >> s >> t;
g = gcd(n, m);
ans = n / g * m;
n /= g, m /= g;
for (int i = 0; i < g - 1; i++) {
if (s[i * n] != t[i * m]) {
ans = -1;
b... | #include <iostream>
using namespace std;
long long n, m, g, ans;
string s, t;
int gcd(int p, int q) { return q ? gcd(q, p % q) : p; }
int main() {
cin >> n >> m >> s >> t;
g = gcd(n, m);
ans = n / g * m;
n /= g, m /= g;
for (int i = 0; i < g; i++) {
if (s[i * n] != t[i * m]) {
ans = -1;
break... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,022,551 | 1,022,552 | u093170535 | cpp |
p03231 | #include <iostream>
using namespace std;
int n, m, g, ans;
string s, t;
int gcd(int p, int q) { return q ? gcd(q, p % q) : p; }
int main() {
cin >> n >> m >> s >> t;
g = gcd(n, m);
ans = n / g * m;
n /= g, m /= g;
for (int i = 0; i < g - 1; i++) {
if (s[i * n] != t[i * m]) {
ans = -1;
break;
... | #include <iostream>
using namespace std;
long long n, m, g, ans;
string s, t;
int gcd(int p, int q) { return q ? gcd(q, p % q) : p; }
int main() {
cin >> n >> m >> s >> t;
g = gcd(n, m);
ans = n / g * m;
n /= g, m /= g;
for (int i = 0; i < g; i++) {
if (s[i * n] != t[i * m]) {
ans = -1;
break... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,022,553 | 1,022,552 | u093170535 | cpp |
p03231 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <utility>
#include <vector>
#define ALL(obj) (obj).be... | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <utility>
#include <vector>
#define ALL(obj) (obj).be... | [
"control_flow.loop.for.condition.change",
"call.add",
"expression.operation.binary.change",
"call.arguments.change"
] | 1,022,554 | 1,022,555 | u789417951 | cpp |
p03231 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#define lol(i, n) for (ll i = 0; i < n; i++)
#define mod 1000000007
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
b %= a;
if (b == 0)
return a;
return gcd(a, b);
}
int mai... | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#define lol(i, n) for (ll i = 0; i < n; i++)
#define mod 1000000007
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (a > b)
swap(a, b);
b %= a;
if (b == 0)
return a;
return gcd(a, b);
}
int mai... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,022,558 | 1,022,559 | u924885571 | cpp |
p03231 | #include <iostream>
#include <string>
using namespace std;
typedef long long LL;
LL gcd(LL a, LL b) { return (b ? gcd(b, a % b) : a); }
LL lcm(LL a, LL b) { return a * b / gcd(a, b); }
int main() {
LL n, m;
string s, t;
while (cin >> n >> m) {
cin >> s;
cin >> t;
LL l = lcm(n, m), l_n = l / n, l... | #include <iostream>
#include <string>
using namespace std;
typedef long long LL;
LL gcd(LL a, LL b) { return (b ? gcd(b, a % b) : a); }
LL lcm(LL a, LL b) { return a * b / gcd(a, b); }
int main() {
LL n, m;
string s, t;
while (cin >> n >> m) {
cin >> s;
cin >> t;
LL l = lcm(n, m), l_n = l / n, l... | [
"control_flow.loop.condition.change",
"expression.unary.arithmetic.add"
] | 1,022,588 | 1,022,589 | u210777698 | cpp |
p03231 | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
... | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,022,596 | 1,022,597 | u907049739 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vll = vector<vl>;
using vb = vector<bool>;
using vs = vector<string>;
using msi = map<string, int>;
using mii = map<int, int>;
using psi = pair<string, int>;
using pii = pair<... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vll = vector<vl>;
using vb = vector<bool>;
using vs = vector<string>;
using msi = map<string, int>;
using mii = map<int, int>;
using psi = pair<string, int>;
using pii = pair<... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,022,637 | 1,022,636 | u591883167 | cpp |
p03231 | #include <cstdio>
#define maxn 100010
char s[maxn], t[maxn];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, m;
scanf("%d%d%s%s", &n, &m, s, t);
int x, y, g;
long long l;
g = gcd(n, m);
l = (long long)n * m / g;
x = n / g, y = m / g;
bool valid = true;
for (int i = 1; i <= ... | #include <cstdio>
#define maxn 100010
char s[maxn], t[maxn];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, m;
scanf("%d%d%s%s", &n, &m, s, t);
int x, y, g;
long long l;
g = gcd(n, m);
l = (long long)n * m / g;
x = n / g, y = m / g;
bool valid = true;
for (int i = 0; i < g... | [
"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"
] | 1,022,644 | 1,022,645 | u210490856 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
bool flag = true;
long long n, m, l, a, b, c;
char s[100005], t[100005];
scanf("%d%d%s%s", &n, &m, &s, &t);
l = n / gcd(n, m) * m;
a = l / n;
b = l / m... | #include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
bool flag = true;
long long n, m, l, a, b, c;
char s[100005], t[100005];
scanf("%lld%lld%s%s", &n, &m, &s, &t);
l = n / gcd(n, m) * m;
a = l / n;
b = l... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,022,648 | 1,022,649 | u217290283 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
long long n, m;
char a[100010], b[100010];
int main(void) {
cin >> n >> m;
scanf("%s%s", a, b);
if (a[0] != b[0])
return cout << -1, 0;
long long d = __gcd(n, m);
long long L = n / d * m;
for (long long i = 0; i <= d; i++) {
long long x = i * L / n;
... | #include <bits/stdc++.h>
using namespace std;
long long n, m;
char a[100010], b[100010];
int main(void) {
cin >> n >> m;
scanf("%s%s", a, b);
if (a[0] != b[0])
return cout << -1, 0;
long long d = __gcd(n, m);
long long L = n / d * m;
for (long long i = 0; i < n; i++) {
long long x = i * L / n;
i... | [
"control_flow.loop.for.condition.change",
"literal.number.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,022,652 | 1,022,653 | u084404419 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
int main() {
int n, m;
scanf("%d%d", &n, &m);
string s, t;
cin >> s >> t;
int g = gcd(n, m);
int N = n / g, M = m / g;
int pn = N, pm = M;
while (N < n && M < m) {
if (s[N] != t[M]) {
... | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
int main() {
int n, m;
scanf("%d%d", &n, &m);
string s, t;
cin >> s >> t;
int g = gcd(n, m);
int N = n / g, M = m / g;
int pn = N, pm = M;
N = M = 0;
while (N < n && M < m) {
if (s[N] != ... | [
"assignment.add"
] | 1,022,659 | 1,022,660 | u281082833 | cpp |
p03231 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
using ull = unsigned long long;
ull gcd(ull a, ull b) {
if (a > b) {
swap(a, b);
}
ull r = b % a;
while (r != 0) {
b = a;
a = r;
r = b % a;
}
return a;
}
int main() {
ull N, M;
cin >> N ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
using ull = unsigned long long;
ull gcd(ull a, ull b) {
if (a > b) {
swap(a, b);
}
ull r = b % a;
while (r != 0) {
b = a;
a = r;
r = b % a;
}
return a;
}
int main() {
ull N, M;
cin >> N ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,022,675 | 1,022,676 | u273834941 | cpp |
p03231 | #include <algorithm>
#include <map>
#include <stdio.h>
#include <utility>
#include <vector>
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) { return b ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll N, M;
char S[100001];
char T[100001];
map<ll, char> m;
int main() {
scanf(... | #include <algorithm>
#include <map>
#include <stdio.h>
#include <utility>
#include <vector>
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll N, M;
char S[100001];
char T[100001];
map<ll, char> m;
int main() {
scanf(... | [] | 1,022,694 | 1,022,695 | u669844881 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
string S, T;
int main() {
long long N, M;
scanf("%lld%lld", &N, &M);
cin >> S >> T;
if (N > M)
swap(N, M), swap(S, T);
long long G = __gcd(N, M);
long long ans = N / G * M;
long long sg = ans / N, tg = ans / M, si = 0, ti = 0;
while (si < ans && ti < a... | #include <bits/stdc++.h>
using namespace std;
string S, T;
int main() {
long long N, M;
scanf("%lld%lld", &N, &M);
cin >> S >> T;
if (N > M)
swap(N, M), swap(S, T);
long long G = __gcd(N, M);
long long ans = N / G * M;
long long sg = ans / N, tg = ans / M, si = 0, ti = 0;
while (si < ans && ti < a... | [
"control_flow.branch.if.condition.change"
] | 1,022,705 | 1,022,707 | u052065730 | cpp |
p03232 | #include <bits/stdc++.h>
#define rep(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define foreach(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); ++itr)
using namespace std;
const int mod = 1e9 + 7;
int n, i, j, f[100005], inv[100005], ans;
in... | #include <bits/stdc++.h>
#define rep(i, n) for ((i) = 1; (i) <= (n); (i)++)
#define foreach(c, itr) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); ++itr)
using namespace std;
const int mod = 1e9 + 7;
int n, i, j, f[100005], inv[100005], ans;
in... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,815 | 1,022,817 | u878185566 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define rollcall cout << "I'm Sucu." ... | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define rollcall cout << "I'm Sucu." ... | [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,022,715 | 1,022,721 | u691493208 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define rollcall cout << "I'm Sucu." ... | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define rollcall cout << "I'm Sucu." ... | [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,022,728 | 1,022,721 | u691493208 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, tmp;
long vec_size;
long small, big;
vector<long> vec;
small = big = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> tmp;
vec.push_back(tmp);
}
sort(vec.begin(), vec.end());
vec_size = vec.size();
for (int i = 0; i... | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, tmp;
long vec_size;
long small, big;
vector<long> vec;
small = big = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> tmp;
vec.push_back(tmp);
}
sort(vec.begin(), vec.end());
vec_size = vec.size();
for (int i = 0; i... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,022,717 | 1,022,719 | u771365068 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, tmp;
int vec_size;
long small, big;
vector<int> vec;
small = big = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> tmp;
vec.push_back(tmp);
}
sort(vec.begin(), vec.end());
vec_size = vec.size();
for (int i = 0; i < ... | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, tmp;
long vec_size;
long small, big;
vector<long> vec;
small = big = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> tmp;
vec.push_back(tmp);
}
sort(vec.begin(), vec.end());
vec_size = vec.size();
for (int i = 0; i... | [
"variable_declaration.type.primitive.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,022,722 | 1,022,719 | u771365068 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,022,768 | 1,022,771 | u624678037 | cpp |
p03229 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < ... | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < ... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.change"
] | 1,022,724 | 1,022,727 | u834415466 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
long long ans = 0;
long left = a[0];
long right = a[0];
int first = 1;
int last = n - 1;
while (first <= last) {
long v1 = ... | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n;
cin >> n;
long a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
long long ans = 0;
long left = a[0];
long right = a[0];
int first = 1;
int last = n - 1;
while (first <= last) {
long v1 = ... | [
"assignment.variable.change",
"identifier.change"
] | 1,022,730 | 1,022,731 | u313766957 | cpp |
p03229 | #include <bits/stdc++.h>
#define fi first
#define se second
#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)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = ma... | #include <bits/stdc++.h>
#define fi first
#define se second
#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)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = ma... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,754 | 1,022,757 | u791593901 | cpp |
p03231 | #include <bits/stdc++.h>
#define MAX_N 200007
using namespace std;
typedef long long ll;
ll N, M, T, k, q, p;
char s[MAX_N], t[MAX_N], top;
// map<ll, char> ans;
map<ll, int> vis;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
scanf("%lld%lld", &N, &M);
scanf("%s%s", s + 1, t + 1);
T = ... | #include <bits/stdc++.h>
#define MAX_N 200007
using namespace std;
typedef long long ll;
ll N, M, T, k, q, p, top;
char s[MAX_N], t[MAX_N];
// map<ll, char> ans;
map<ll, int> vis;
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
scanf("%lld%lld", &N, &M);
scanf("%s%s", s + 1, t + 1);
T = ... | [
"variable_declaration.add",
"variable_declaration.remove"
] | 1,022,829 | 1,022,832 | u456636587 | cpp |
p03229 | #include <bits/stdc++.h>
#define fi first
#define se second
#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)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = ma... | #include <bits/stdc++.h>
#define fi first
#define se second
#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)
#define rng(a) a.begin(), a.end()
#define maxs(x, y) (x = ma... | [
"variable_declaration.type.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,022,761 | 1,022,757 | u791593901 | cpp |
p03231 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#define FOR(i, n) for (int i = 0; i < n; i++)
using namespace std;
long long Lcm(int a, int b) { return (long long)a / __gcd(a, b) * b; }
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
str... | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#define FOR(i, n) for (int i = 0; i < n; i++)
using namespace std;
long long Lcm(int a, int b) { return (long long)a / __gcd(a, b) * b; }
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
str... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 1,022,844 | 1,022,846 | u389759492 | cpp |
p03229 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <float.h>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#inclu... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <float.h>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#inclu... | [
"variable_declaration.remove"
] | 1,022,777 | 1,022,780 | u566864240 | cpp |
p03231 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#define FOR(i, n) for (int i = 0; i < n; i++)
using namespace std;
long long Lcm(int a, int b) { return (long long)a / __gcd(a, b) * b; }
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
str... | #include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#define FOR(i, n) for (int i = 0; i < n; i++)
using namespace std;
long long Lcm(int a, int b) { return (long long)a / __gcd(a, b) * b; }
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
str... | [
"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"
] | 1,022,848 | 1,022,846 | u389759492 | cpp |
p03229 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define pr(num) cout << num << endl
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define pr(num) cout << num << endl
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(... | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,022,783 | 1,022,786 | u768152935 | cpp |
p03229 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define pr(num) cout << num << endl
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define pr(num) cout << num << endl
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(... | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 1,022,789 | 1,022,786 | u768152935 | cpp |
p03229 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
long long n, k[100005], ans;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> k[i];
}
sort(k, k + n);
int a = 0, b = n * 1, aa, bb;
ans = k[n - 1] - k[0];
wh... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
long long n, k[100005], ans;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> k[i];
}
sort(k, k + n);
int a = 0, b = n - 1, aa, bb;
ans = k[n - 1] - k[0];
wh... | [
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 1,022,790 | 1,022,791 | u539402331 | cpp |
p03231 | // warm heart, wagging tail,and a smile just for you!
// ▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓
// ... | // warm heart, wagging tail,and a smile just for you!
// ▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓
// ▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓
// ... | [
"control_flow.loop.condition.change"
] | 1,022,875 | 1,022,879 | u239493918 | cpp |
p03229 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
int n;
int a[200000];
int tmp[300000];
void init() {
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);
}
void work() {
int t = n / 2;
long long sum =
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
int n;
int a[200000];
int tmp[300000];
void init() {
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);
}
void work() {
int t = (n - 1) / 2;
long long su... | [] | 1,022,812 | 1,022,814 | u806661586 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define pb push_back
#define eb emplace_back
#define rep(i, a, b) for (auto i = (a); i != (b); ++i)
#define REP(i, n) rep(i, 0, n)
#define all(v) (v).begin(), (v).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ... | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define pb push_back
#define eb emplace_back
#define rep(i, a, b) for (auto i = (a); i != (b); ++i)
#define REP(i, n) rep(i, 0, n)
#define all(v) (v).begin(), (v).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,022,932 | 1,022,933 | u317996173 | cpp |
p03231 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.... | [
"assignment.add"
] | 1,022,937 | 1,022,947 | u349496321 | cpp |
p03229 | #include "bits/stdc++.h"
using namespace std;
typedef long long mLL;
int main() {
int N;
scanf("%d", &N);
mLL A[N], smaller = 0, bigger = 0;
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
sort(A, A + N);
int K = N / 2;
if (N % 2) {
for (int i = 0; i < K - 1; i++)
smaller += A[i];... | #include "bits/stdc++.h"
using namespace std;
typedef long long mLL;
int main() {
int N;
scanf("%d", &N);
mLL A[N], smaller = 0, bigger = 0;
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
sort(A, A + N);
int K = N / 2;
if (N % 2) {
for (int i = 0; i < K; i++)
smaller += A[i];
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 1,022,878 | 1,022,880 | u585586208 | cpp |
p03231 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int n, m, ans;
string s, t;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s >> t;
ans = n * m / __gcd(n, m);
int N = ans / m, M = ans / n;
for (int i = 1; i <= n; ++i) {
if ((i * M) % N ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
int n, m, ans;
string s, t;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s >> t;
ans = n * m / __gcd(n, m);
int N = ans / m, M = ans / n;
for (int i = 0; i < n; ++i) {
if ((i * M) % N =... | [
"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"
] | 1,022,981 | 1,022,983 | u760290068 | cpp |
p03231 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#define int long long
using namespace std;
int n, m;
char S[100010], T[100010];
signed main() {
scanf("%lld%lld", &n, &m);
scanf("%s%s", S + 1, T + 1);
int g = __gcd(n, m);
int flag = 1;
for (int i = 0; i < g; i++)
if (S[n / g ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#define int long long
using namespace std;
int n, m;
char S[100010], T[100010];
signed main() {
scanf("%lld%lld", &n, &m);
scanf("%s%s", S + 1, T + 1);
int g = __gcd(n, m);
int flag = 1;
for (int i = 0; i < g; i++)
if (S[n / g ... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 1,022,985 | 1,022,987 | u021249344 | cpp |
p03229 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define vint vector<int>
#define vvint vector<vint>
#define ct(a) cout << a << endl
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define vint vector<int>
#define vvint vector<vint>
#define ct(a) cout << a << endl
... | [
"assignment.change"
] | 1,022,902 | 1,022,904 | u243196226 | cpp |
p03231 | /*
#include <boost/functional/hash.hpp>
#include <boost/multiprecision/cpp_int.hpp>
typedef boost::multiprecision::cpp_int mlint;
*/
#include <bits/stdc++.h>
using namespace std;
#define debug 0
#define print(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define fcout(d) cout << fixed << setprecisi... | /*
#include <boost/functional/hash.hpp>
#include <boost/multiprecision/cpp_int.hpp>
typedef boost::multiprecision::cpp_int mlint;
*/
#include <bits/stdc++.h>
using namespace std;
#define debug 0
#define print(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define fcout(d) cout << fixed << setprecisi... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,023,010 | 1,023,013 | u629015299 | cpp |
p03231 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | [
"expression.operation.binary.remove"
] | 1,023,017 | 1,023,021 | u202928696 | cpp |
p03231 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | [
"expression.operation.binary.remove"
] | 1,023,023 | 1,023,021 | u202928696 | cpp |
p03231 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 1,023,024 | 1,023,021 | u202928696 | cpp |
p03229 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int N;
vector<int> A;
int solve() {
vector<int> ansv;
long long ans = 0;
sort(A.begin(), A.end());
int small = 1;
int large = N - 2;
ansv.push_back(A[0]);
ansv.push_back(A[N - 1]);
bool flag = true;
for (int i = 0; i... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int N;
vector<int> A;
int solve() {
vector<int> ansv;
long long ans = 0;
sort(A.begin(), A.end());
int small = 1;
int large = N - 2;
ansv.push_back(A[0]);
ansv.push_back(A[N - 1]);
bool flag = true;
for (int i = 0; i... | [
"control_flow.branch.if.condition.change"
] | 1,022,941 | 1,022,942 | u540433787 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const double PI = 3.14159265358979323846;
typedef vector<int> vint;
typedef pair<int, int> pint;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int N;
int A[110000];
signed main() {
cin >> N;
for (int i = 0; i <... | #include <bits/stdc++.h>
using namespace std;
#define int long long
const double PI = 3.14159265358979323846;
typedef vector<int> vint;
typedef pair<int, int> pint;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int N;
int A[110000];
signed main() {
cin >> N;
for (int i = 0; i <... | [
"assignment.change",
"expression.operation.binary.remove"
] | 1,022,950 | 1,022,952 | u450832845 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxx = 1e5 + 7;
const int Inf = 1 << 30;
int n;
ll a[maxx];
int main() {
while (cin >> n && n) {
ll ans = 0;
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + 1 + n);
int l = 1, r ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxx = 1e5 + 7;
const int Inf = 1 << 30;
int n;
ll a[maxx];
int main() {
while (cin >> n && n) {
ll ans = 0;
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + 1 + n);
int l = 1, r ... | [
"expression.operation.binary.remove"
] | 1,022,954 | 1,022,957 | u817240026 | cpp |
p03229 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int a[200010];
deque<int> dq, dq2;
signed main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
dq.push_back(a[0]);
int right = n - 1, left = 1;
int cnt = 1;
for (int i = 0; i < n; i++) {
i... | #include <bits/stdc++.h>
using namespace std;
#define int long long
int a[200010];
deque<int> dq, dq2;
signed main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
dq.push_back(a[0]);
int right = n - 1, left = 1;
int cnt = 1;
for (int i = 0; i < n; i++) {
i... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,022,978 | 1,022,980 | u344122377 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.