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 |
|---|---|---|---|---|---|---|---|
p03212 | #include <iostream>
using namespace std;
const size_t array[3] = {3, 5, 7};
bool checkVal(size_t val) {
bool checkers[3] = {false, false, false};
while (0 < val) {
size_t temp = val % 10;
if (temp == 3)
checkers[0] = true;
else if (temp == 5)
checkers[1] = true;
else
checkers[2] ... | #include <iostream>
using namespace std;
const size_t array[3] = {3, 5, 7};
bool checkVal(size_t val) {
bool checkers[3] = {false, false, false};
while (0 < val) {
size_t temp = val % 10;
if (temp == 3)
checkers[0] = true;
else if (temp == 5)
checkers[1] = true;
else
checkers[2] ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 1,008,660 | 1,008,661 | u074059110 | cpp |
p03212 | #include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend... | #include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend... | [
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 1,008,666 | 1,008,667 | u788341294 | cpp |
p03212 | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
lint cng(lint a) {
lint y = 0;
for (int i = 1; a > 0; i *= 10) {
lint x = a % 10;
if (x == 1)
x = 3;
else if (x == 2)
x = 5;
else if (x == 3)
x = 7;
y += i * x;
a /= 10;
}
// cout << y << endl;
re... | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
lint cng(lint a) {
lint y = 0;
for (int i = 1; a > 0; i *= 10) {
lint x = a % 10;
if (x == 1)
x = 3;
else if (x == 2)
x = 5;
else if (x == 3)
x = 7;
y += i * x;
a /= 10;
}
// cout << y << endl;
re... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,008,675 | 1,008,676 | u104741254 | cpp |
p03212 | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, ... | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, ... | [] | 1,008,677 | 1,008,678 | u102602414 | cpp |
p03212 | #include <bits/stdc++.h>
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
using namespace std;
typedef long long ll;
int ans = 0;
int n;
void go(int len, ll cur, int msk) {
if (len == 10)
return;
if (msk == 7 && cur < n) {
ans++;
}
go(len + 1, cur * 10 + 3, msk | 1);
go(len + 1, cur ... | #include <bits/stdc++.h>
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
using namespace std;
typedef long long ll;
int ans = 0;
int n;
void go(int len, ll cur, int msk) {
if (len == 10)
return;
if (msk == 7 && cur <= n) {
ans++;
}
go(len + 1, cur * 10 + 3, msk | 1);
go(len + 1, cur... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,008,683 | 1,008,684 | u484655382 | cpp |
p03212 | // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#incl... | // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#incl... | [
"control_flow.branch.if.condition.change"
] | 1,008,709 | 1,008,710 | u010004797 | cpp |
p03212 | #include <iostream>
using namespace std;
long N;
long ret;
int dfs(long x, int mask) {
if (x > N)
return 0;
if (mask == 7)
ret++;
dfs(x * 10 + 3, mask | 1);
dfs(x * 10 + 5, mask | 2);
dfs(x * 10 + 7, mask | 4);
}
int main() {
cin >> N;
ret = 0;
dfs(0, 0);
cout << ret << "¥n";
return 0;
}
| #include <iostream>
using namespace std;
long N;
long ret;
int dfs(long x, int mask) {
if (x > N)
return 0;
if (mask == 7)
ret++;
dfs(x * 10 + 3, mask | 1);
dfs(x * 10 + 5, mask | 2);
dfs(x * 10 + 7, mask | 4);
}
int main() {
cin >> N;
ret = 0;
dfs(0, 0);
cout << ret << endl;
return 0;
}
| [
"io.output.change"
] | 1,008,717 | 1,008,718 | u353464699 | cpp |
p03212 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
void solve() {
int N;
cin >> N;
set<long long int> Set;
Set.insert(0);
for (int i = 0; i < 10; ++i) {
set<long long int> SetNext;
... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
void solve() {
int N;
cin >> N;
set<long long int> Set;
Set.insert(0);
for (int i = 0; i < 10; ++i) {
set<long long int> SetNext;
... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,008,721 | 1,008,722 | u057619905 | cpp |
p03212 | #include <cstdio>
long long n, ans;
void dfs(long long a, int f) {
if (a > n)
return;
if (f == 7)
++ans;
a *= 10;
dfs(a + 3, f | 1);
dfs(a + 5, f | 2);
dfs(a + 7, f | 4);
}
int main() {
scanf("%lld", &ans);
dfs(0, 0);
printf("%lld\n", ans);
return 0;
} | #include <cstdio>
long long n, ans;
void dfs(long long a, int f) {
if (a > n)
return;
if (f == 7)
++ans;
a *= 10;
dfs(a + 3, f | 1);
dfs(a + 5, f | 2);
dfs(a + 7, f | 4);
}
int main() {
scanf("%lld", &n);
dfs(0, 0);
printf("%lld\n", ans);
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 1,008,737 | 1,008,738 | u708618797 | cpp |
p03212 | #include <iostream>
using u64 = unsigned long long;
u64 n, ans;
void dfs(u64 a, int f) {
if (a > n)
return;
if (f == 7)
++ans;
a *= 10;
dfs(a + 3, f | 1);
dfs(a + 5, f | 2);
dfs(a + 7, f | 4);
}
int main() {
std::cin >> n;
dfs(0, 0);
std::cout << --ans << std::endl;
return 0;
}
| #include <iostream>
using u64 = unsigned long long;
u64 n, ans;
void dfs(u64 a, int f) {
if (a > n)
return;
if (f == 7)
++ans;
a *= 10;
dfs(a + 3, f | 1);
dfs(a + 5, f | 2);
dfs(a + 7, f | 4);
}
int main() {
std::cin >> n;
dfs(0, 0);
std::cout << ans << std::endl;
return 0;
}
| [] | 1,008,739 | 1,008,740 | u708618797 | cpp |
p03212 | #include <algorithm>
#include <iostream>
#include <vector>
static const std::vector<size_t> list = {
357, 375, 537, 573, 735, 753, 3357,
3375, 3537, 3557, 3573, 3575, 3577, 3735,
3753, 3755, 3757, 3775, 5337, 5357, ... | #include <algorithm>
#include <iostream>
#include <vector>
static const std::vector<size_t> list = {
357, 375, 537, 573, 735, 753, 3357,
3375, 3537, 3557, 3573, 3575, 3577, 3735,
3753, 3755, 3757, 3775, 5337, 5357, ... | [
"assignment.change"
] | 1,008,741 | 1,008,742 | u749907841 | cpp |
p03212 | #include <iostream>
#include <vector>
using namespace std;
bool check(int num) {
vector<bool> flags(3, false);
while (num > 0) {
int tmp = num % 10;
switch (tmp) {
case 3:
flags[0] = true;
break;
case 5:
flags[1] = true;
break;
case 7:
flags[2] = true;
break... | #include <iostream>
#include <vector>
using namespace std;
bool check(int num) {
vector<bool> flags(3, false);
while (num > 0) {
int tmp = num % 10;
switch (tmp) {
case 3:
flags[0] = true;
break;
case 5:
flags[1] = true;
break;
case 7:
flags[2] = true;
break... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,008,752 | 1,008,753 | u964185015 | cpp |
p03212 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sta... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sta... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,008,754 | 1,008,755 | u587248350 | cpp |
p03212 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> num753;
void append(ll n) {
if (n < 1e9) {
num753.push_back(n);
append(n * 10 + 3);
append(n * 10 + 5);
append(n * 10 + 7);
}
}
int main() {
int N;
cin >> N;
append(0);
int n = num753.size();
int ans = 0;
f... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> num753;
void append(ll n) {
if (n < 1e9) {
num753.push_back(n);
append(n * 10 + 3);
append(n * 10 + 5);
append(n * 10 + 7);
}
}
int main() {
int N;
cin >> N;
append(0);
int n = num753.size();
int ans = 0;
f... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,008,758 | 1,008,759 | u119098168 | cpp |
p03212 | #include <algorithm>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define rep(index, num) for (int index = 0; index < num; index++)
#define rep1(index, num) for (int index = 1; index... | #include <algorithm>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define rep(index, num) for (int index = 0; index < num; index++)
#define rep1(index, num) for (int index = 1; index... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 1,008,769 | 1,008,770 | u222030240 | cpp |
p03213 | #include <bits/stdc++.h>
#define rep(a, n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
using ll = long long;
typedef pair<ll, ll> P;
typedef pair<P, ll> PP;
using Graph = vector<vector<ll>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
retur... | #include <bits/stdc++.h>
#define rep(a, n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
using ll = long long;
typedef pair<ll, ll> P;
typedef pair<P, ll> PP;
using Graph = vector<vector<ll>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
retur... | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 1,008,779 | 1,008,780 | u045408189 | cpp |
p03213 | #include <bits/stdc++.h>
#define rep(a, n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
using ll = long long;
typedef pair<ll, ll> P;
typedef pair<P, ll> PP;
using Graph = vector<vector<ll>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
retur... | #include <bits/stdc++.h>
#define rep(a, n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
using ll = long long;
typedef pair<ll, ll> P;
typedef pair<P, ll> PP;
using Graph = vector<vector<ll>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
retur... | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 1,008,779 | 1,008,781 | u045408189 | cpp |
p03213 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < (n); ++... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < (n); ++... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,008,782 | 1,008,783 | u596311864 | cpp |
p03213 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
typedef long long LL;
using Graph = vector<... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
typedef long long LL;
using Graph = vector<... | [
"expression.operation.binary.remove"
] | 1,008,792 | 1,008,793 | u606600497 | cpp |
p03213 | #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 all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
template <class T> inline istrea... | #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 all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
template <class T> inline istrea... | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.change"
] | 1,008,794 | 1,008,795 | u274883254 | cpp |
p03213 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define rrep(i, n) for (int i = (int)n - 1; i >= 0; --i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
templat... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define rrep(i, n) for (int i = (int)n - 1; i >= 0; --i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
templat... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 1,008,796 | 1,008,797 | u009414205 | cpp |
p03213 | #include <bits/stdc++.h>
#include <cmath>
const double PI = 3.14159265358979323846;
using namespace std;
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)
// typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e1... | #include <bits/stdc++.h>
#include <cmath>
const double PI = 3.14159265358979323846;
using namespace std;
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)
// typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e1... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,804 | 1,008,805 | u564182781 | cpp |
p03213 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <sys/time.h>
#include... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <sys/time.h>
#include... | [
"assignment.value.change",
"identifier.change"
] | 1,008,808 | 1,008,809 | u441096482 | cpp |
p03213 | #include <iostream>
#include <vector>
using namespace std;
const int N_MAX = 100;
bool P[N_MAX + 1] = {false, false};
void sieve(int n) {
fill(P + 2, P + n + 1, true);
for (int i = 2; i * i <= n; ++i) {
if (P[i]) {
for (int j = i * i; j <= n; j += i) {
P[j] = false;
}
}
}
}
vector<p... | #include <iostream>
#include <vector>
using namespace std;
const int N_MAX = 100;
bool P[N_MAX + 1] = {false, false};
void sieve(int n) {
fill(P + 2, P + n + 1, true);
for (int i = 2; (long long)i * i <= n; ++i) {
if (P[i]) {
for (int j = i * i; j <= n; j += i) {
P[j] = false;
}
}
}
... | [
"control_flow.loop.for.condition.change",
"assignment.value.change",
"identifier.change"
] | 1,008,814 | 1,008,815 | u308012928 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
long kaijo(long n) {
long ret = 1;
for (int i = 1; i <= n; i++) {
ret *= i;
}
return ret;
}
long com(long n, long r) {
long ans = kaijo(n) / kaijo(r) / kaijo(n - r);
return ans;
}
int main() {
int N;
cin >> N;
vector<long> a(N);
if (N <= 9) {
... | #include <bits/stdc++.h>
using namespace std;
long kaijo(long n) {
long ret = 1;
for (int i = 1; i <= n; i++) {
ret *= i;
}
return ret;
}
long com(long n, long r) {
long ans = kaijo(n) / kaijo(r) / kaijo(n - r);
return ans;
}
int main() {
int N;
cin >> N;
vector<long> a(100);
if (N <= 9) {
... | [] | 1,008,816 | 1,008,817 | u223172354 | cpp |
p03213 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const int N = pow(10, 5);
vector<bool> isp(N + 1, true);
void sieve() {
isp[0] = false;
isp[1] = false;
for (int i = 2; pow(i, 2) <= N; i++) {
if (isp[i])
for (int j = 2; i * j <= N; j++)
isp[... | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const int N = pow(10, 5);
vector<bool> isp(N + 1, true);
void sieve() {
isp[0] = false;
isp[1] = false;
for (int i = 2; pow(i, 2) <= N; i++) {
if (isp[i])
for (int j = 2; i * j <= N; j++)
isp[... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"assignment.value.change",
"identifier.change"
] | 1,008,832 | 1,008,833 | u722640678 | cpp |
p03213 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const int N = pow(10, 5);
vector<bool> isp(N + 1, true);
void sieve() {
isp[0] = false;
isp[1] = false;
for (int i = 2; pow(i, 2) <= N; i++) {
if (isp[i])
for (int j = 2; i * j <= N; j++)
isp[... | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const int N = pow(10, 5);
vector<bool> isp(N + 1, true);
void sieve() {
isp[0] = false;
isp[1] = false;
for (int i = 2; pow(i, 2) <= N; i++) {
if (isp[i])
for (int j = 2; i * j <= N; j++)
isp[... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"assignment.value.change",
"identifier.change"
] | 1,008,834 | 1,008,833 | u722640678 | cpp |
p03213 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const int N = pow(10, 5);
vector<bool> isp(N + 1, true);
void sieve() {
isp[0] = false;
isp[1] = false;
for (int i = 2; pow(i, 2) <= N; i++) {
if (isp[i])
for (int j = 2; i * j <= N; j++)
isp[... | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const int N = pow(10, 5);
vector<bool> isp(N + 1, true);
void sieve() {
isp[0] = false;
isp[1] = false;
for (int i = 2; pow(i, 2) <= N; i++) {
if (isp[i])
for (int j = 2; i * j <= N; j++)
isp[... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change"
] | 1,008,835 | 1,008,833 | u722640678 | cpp |
p03213 | #include <bits/stdc++.h>
#define rep2(x, fr, to) for (int(x) = (fr); (x) < (to); (x)++)
#define rep(x, to) for (int(x) = 0; (x) < (to); (x)++)
#define repr(x, fr, to) for (int(x) = (fr); (x) >= (to); (x)--)
#define all(c) (c).begin(), (c).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
... | #include <bits/stdc++.h>
#define rep2(x, fr, to) for (int(x) = (fr); (x) < (to); (x)++)
#define rep(x, to) for (int(x) = 0; (x) < (to); (x)++)
#define repr(x, fr, to) for (int(x) = (fr); (x) >= (to); (x)--)
#define all(c) (c).begin(), (c).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,836 | 1,008,837 | u714564133 | cpp |
p03213 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
map<int, int> ret;
void prime_factor(int n) {
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] += 1;
}
int count(int n) {
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
map<int, int> ret;
void prime_factor(int n) {
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] += 1;
}
int count(int n) {
... | [
"literal.number.change",
"io.output.change"
] | 1,008,838 | 1,008,839 | u639032323 | cpp |
p03213 | #include <iostream>
//#include <iomanip>
//#include <string>
#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vect... | #include <iostream>
//#include <iomanip>
//#include <string>
#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vect... | [
"literal.number.change",
"call.arguments.change"
] | 1,008,842 | 1,008,843 | u993074316 | cpp |
p03213 | #include <iostream>
//#include <iomanip>
//#include <string>
#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vect... | #include <iostream>
//#include <iomanip>
//#include <string>
#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
#include <map>
//#include <queue>
//#include <deque>
//#include <bitset>
//#include <math.h>
using namespace std;
using ll = long long;
// using ld = long double ;
using vll = vect... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.remove",
"assignment.change"
] | 1,008,844 | 1,008,843 | u993074316 | cpp |
p03213 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int a[105];
int main() {
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
int u = i;
... | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int a[105];
int main() {
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
int u = i;
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,008,845 | 1,008,846 | u875377810 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int n;
vector<int> pcnt(110, 0);
int main(... | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int n;
vector<int> pcnt(110, 0);
int main(... | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,008,849 | 1,008,850 | u971089878 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
typedef long long ll;
//
vector<int> primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
vector<int> cnt(25);
int main() {
int n;
cin >> n;
for (int i = 0; i < 25... | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
typedef long long ll;
//
vector<int> primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
vector<int> cnt(25);
int main() {
int n;
cin >> n;
for (int i = 0; i < 25... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,008,851 | 1,008,852 | u369712616 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FO... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FO... | [
"literal.number.change",
"call.arguments.change"
] | 1,008,855 | 1,008,856 | u708550576 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
long long a, b, cnt[100], ans;
void dfs(int x, int a1, bool a2) {
if (a1 == 2 && a2) {
ans++;
return;
}
if (x > 97)
return;
dfs(x + 1, a1, a2);
if (cnt[x] >= 4 && a1 < 2)
dfs(x + 1, a1 + 1, a2);
if (cnt[x] >= 2 && !a2)
dfs(x + 1, a1, 1);
if... | #include <bits/stdc++.h>
using namespace std;
long long a, b, cnt[100], ans;
void dfs(int x, int a1, bool a2) {
if (a1 == 2 && a2) {
ans++;
return;
}
if (x > 97)
return;
dfs(x + 1, a1, a2);
if (cnt[x] >= 4 && a1 < 2)
dfs(x + 1, a1 + 1, a2);
if (cnt[x] >= 2 && !a2)
dfs(x + 1, a1, 1);
if... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,859 | 1,008,860 | u613028067 | cpp |
p03213 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
if (n < 10) {
cout << 0 << endl;
return 0;
}
vector<int> div(n + 1, 0);
for (int i = 2; i <= n; i++) {... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
if (n < 10) {
cout << 0 << endl;
return 0;
}
vector<int> div(n + 1, 0);
for (int i = 2; i <= n; i++) {... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,866 | 1,008,867 | u068713120 | cpp |
p03213 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool prime(int N) {
if (N == 1)
return false;
bool judge = true;
for (int i = 2; i * i <= N; ++i)
if (N % i == 0)
judge = false;
return judge;
}
int main() {
int N;
cin >> N;
vector<int> P;
for (int i = 1; i... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool prime(int N) {
if (N == 1)
return false;
bool judge = true;
for (int i = 2; i * i <= N; ++i)
if (N % i == 0)
judge = false;
return judge;
}
int main() {
int N;
cin >> N;
vector<int> P;
for (int i = 1; i... | [
"assignment.value.change"
] | 1,008,868 | 1,008,869 | u826189900 | cpp |
p03213 | #include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
using namespace std;
using ll = long long;
vector<pair<ll, ll>> prime_factorize(ll n) {
vector<pair<ll, ll>> res;
for ... | #include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
using namespace std;
using ll = long long;
vector<pair<ll, ll>> prime_factorize(ll n) {
vector<pair<ll, ll>> res;
for ... | [
"call.function.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"io.output.change"
] | 1,008,870 | 1,008,871 | u964763428 | cpp |
p03213 | #include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
using namespace std;
using ll = long long;
vector<pair<ll, ll>> prime_factorize(ll n) {
vector<pair<ll, ll>> res;
for ... | #include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define all(x) (x).begin(), (x).end()
#define dump(x) cout << #x << " = " << (x) << endl
using namespace std;
using ll = long long;
vector<pair<ll, ll>> prime_factorize(ll n) {
vector<pair<ll, ll>> res;
for ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 1,008,870 | 1,008,872 | u964763428 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
map<int64_t, int> prime;
void prime_list(int64_t n) {
for (int64_t i = 2; i * i <= n; ++i) {
while (n % i == 0) {
++prime[i];
n = n / i;
}
}
if (n != 1) {
++prime[n];
}
}
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; ++i) {
... | #include <bits/stdc++.h>
using namespace std;
map<int64_t, int> prime;
void prime_list(int64_t n) {
for (int64_t i = 2; i * i <= n; ++i) {
while (n % i == 0) {
++prime[i];
n = n / i;
}
}
if (n != 1) {
++prime[n];
}
}
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; ++i) {
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,879 | 1,008,880 | u304862095 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
#define pb(x) push_back(x)
using vint = vector<int>;
auto getisprime(int n) {
vint isprime(n + 1, true);
isprime[0] = isprime[1] = false;
for (int i = 2; i <= n; i++) {
if (isprime[i]) {
for (int j = i * 2; j <= n; j += i) {
isprime[j] = false;
... | #include <bits/stdc++.h>
using namespace std;
#define pb(x) push_back(x)
using vint = vector<int>;
auto getisprime(int n) {
vint isprime(n + 1, true);
isprime[0] = isprime[1] = false;
for (int i = 2; i <= n; i++) {
if (isprime[i]) {
for (int j = i * 2; j <= n; j += i) {
isprime[j] = false;
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,887 | 1,008,888 | u731368968 | cpp |
p03213 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typ... | [
"assignment.change"
] | 1,008,891 | 1,008,892 | u828388155 | cpp |
p03213 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typ... | [
"assignment.change"
] | 1,008,891 | 1,008,893 | u828388155 | cpp |
p03213 | /*
Author:zeke
pass System Test!
GET AC!!
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include... | /*
Author:zeke
pass System Test!
GET AC!!
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,008,896 | 1,008,897 | u759162415 | cpp |
p03213 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#inc... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#inc... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,008,900 | 1,008,901 | u848736574 | cpp |
p03213 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
ll n, rans, mp2[100];
map<ll, ll> mp;
int main(void) {
cin >> n;
for (int i = 2; i <= n; i++) {
ll L = i;
for (int j = 2; j <= L; j++) {
if (L == 1)
break;
while (L % j == 0 && L != 1) {
// co... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
ll n, rans, mp2[100];
map<ll, ll> mp;
int main(void) {
cin >> n;
for (int i = 2; i <= n; i++) {
ll L = i;
for (int j = 2; j <= L; j++) {
if (L == 1)
break;
while (L % j == 0 && L != 1) {
// co... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 1,008,908 | 1,008,909 | u050428930 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[110] = {0};
for (int i = 2; i <= n; i++) {
int sum = i;
for (int j = 2; j <= i; j++) {
while (sum % i == 0) {
a[j]++;
sum /= j;
}
}
}
int p[100] = {0};
for (int i = 2; i <= n; i... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[110] = {0};
for (int i = 2; i <= n; i++) {
int sum = i;
for (int j = 2; j <= i; j++) {
while (sum % j == 0) {
a[j]++;
sum /= j;
}
}
}
int p[100] = {0};
for (int i = 2; i <= n; i... | [
"identifier.change",
"control_flow.loop.condition.change"
] | 1,008,910 | 1,008,911 | u530329977 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> d(76, 0);
for (int i = 2; i <= n; i++) {
int X = i;
for (int div = 2; div <= i; div++) {
int cnt = 0;
while (X % div == 0) {
cnt++;
X /= div;
}
d[div] += cnt;
}
}
int ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> d(101, 0);
for (int i = 2; i <= n; i++) {
int X = i;
for (int div = 2; div <= i; div++) {
int cnt = 0;
while (X % div == 0) {
cnt++;
X /= div;
}
d[div] += cnt;
}
}
int... | [
"literal.number.change",
"call.arguments.change"
] | 1,008,912 | 1,008,913 | u747390421 | cpp |
p03213 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, s, e) for (int(i) = (s); (i) <= (e); ++(i))
#define all(x) x.begin()... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, s, e) for (int(i) = (s); (i) <= (e); ++(i))
#define all(x) x.begin()... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,916 | 1,008,917 | u521389909 | cpp |
p03213 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define len(x) (int)((x).size())
#define endl '\n'
#define x first
#define y second
#define int long long
#define double long double
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define vi vector<int>
#define vv... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define len(x) (int)((x).size())
#define endl '\n'
#define x first
#define y second
#define int long long
#define double long double
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define vi vector<int>
#define vv... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 1,008,927 | 1,008,928 | u157759251 | cpp |
p03213 | #include <bits/stdc++.h>
int main() {
int prime_list[50]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
long long prime[50]{};
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int num{i};
for (int j = 0; num != 1; j++) {... | #include <bits/stdc++.h>
int main() {
int prime_list[50]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
long long prime[50]{};
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int num{i};
for (int j = 0; num != 1; j++) {... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 1,008,940 | 1,008,941 | u086849314 | cpp |
p03213 | #include "bits/stdc++.h"
#include <string>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)... | #include "bits/stdc++.h"
#include <string>
using namespace std;
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,948 | 1,008,949 | u564412651 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
bool arr[110];
vector<int> vec;
void Eratosthenes() {
for (int i = 0; i < 110; i++) {
arr[i] = true;
}
arr[0] = false;
arr[1] = false;
for (int i = 2; i < 110; i++) {
if (!arr[i]) {
continue;
} else {
for (int j = 2; i * j < 110; j++)... | #include <bits/stdc++.h>
using namespace std;
bool arr[110];
vector<int> vec;
void Eratosthenes() {
for (int i = 0; i < 110; i++) {
arr[i] = true;
}
arr[0] = false;
arr[1] = false;
for (int i = 2; i < 110; i++) {
if (!arr[i]) {
continue;
} else {
for (int j = 2; i * j < 110; j++)... | [
"assignment.change"
] | 1,008,952 | 1,008,953 | u904123392 | cpp |
p03213 | #include <bits/stdc++.h>
#define debug(x) cerr << "\n" << #x << ": " << x << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define INF (1LL << 30)
#define int long long
#define pii pair<long long, long long>
#define MOD 1000000007
#define print(x) cout <<... | #include <bits/stdc++.h>
#define debug(x) cerr << "\n" << #x << ": " << x << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define INF (1LL << 30)
#define int long long
#define pii pair<long long, long long>
#define MOD 1000000007
#define print(x) cout <<... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,960 | 1,008,961 | u265065462 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename... | #include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename... | [
"expression.operation.binary.remove"
] | 1,008,967 | 1,008,968 | u774906517 | cpp |
p03213 | #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 ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,008,969 | 1,008,970 | u222293734 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repl(i, 0, n)
#define each(itr, v) for (auto itr : v)
#define pb(s) push_back(s)
#define maxch(x, y) x = max(x, y)
#define minch(x, y) x = min(x, y)
#define ... | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repl(i, 0, n)
#define each(itr, v) for (auto itr : v)
#define pb(s) push_back(s)
#define maxch(x, y) x = max(x, y)
#define minch(x, y) x = min(x, y)
#define ... | [
"call.arguments.change",
"identifier.replace.remove",
"literal.replace.add"
] | 1,008,971 | 1,008,972 | u819300485 | cpp |
p03213 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
const int mod = 1e9 + 7;
#define ll long long int
const double epsilon = 1e-7;
ll mi(ll x, ll y) {
... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
const int mod = 1e9 + 7;
#define ll long long int
const double epsilon = 1e-7;
ll mi(ll x, ll y) {
... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,008,973 | 1,008,974 | u436045956 | cpp |
p03213 | #include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define pii pair<int, int>
#define ll long long
#define el '\n'
using namespace std;
vector<int> v;
bool isPrime(int a) {
bool res = 1;
for (int i = 2; i * i <= a; i++) {
if (a % i ==... | #include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define pii pair<int, int>
#define ll long long
#define el '\n'
using namespace std;
vector<int> v;
bool isPrime(int a) {
bool res = 1;
for (int i = 2; i * i <= a; i++) {
if (a % i ==... | [
"variable_declaration.add",
"assignment.value.change",
"identifier.change"
] | 1,008,975 | 1,008,976 | u287988203 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
vector<int> soiunsuu(100);
void factorize(int X) {
int i = 2;
while (X > 1) {
while (X % i == 0) {
X /= i;
soiunsuu.at(i)++;
}
i++;
}
}
int main() {
int N;
cin >> N;
for (int n = 1; n <= N; n++) {
factorize(n);
}
int a = 0, b ... | #include <bits/stdc++.h>
using namespace std;
vector<int> soiunsuu(100);
void factorize(int X) {
int i = 2;
while (X > 1) {
while (X % i == 0) {
X /= i;
soiunsuu.at(i)++;
}
i++;
}
}
int main() {
int N;
cin >> N;
for (int n = 1; n <= N; n++) {
factorize(n);
}
int a = 0, b ... | [
"assignment.change"
] | 1,008,977 | 1,008,978 | u649915042 | cpp |
p03213 | #include <iostream>
#include <map>
#include <vector>
auto factorize(int n) {
std::vector<std::pair<int, int>> res;
for (int i = 2; i <= n; i++) {
if ((n % i) == 0) {
int cnt = 0;
while ((n % i) == 0) {
n /= i;
cnt++;
}
res.emplace_back(std::make_pair(i, cnt));
}
... | #include <iostream>
#include <map>
#include <vector>
auto factorize(int n) {
std::vector<std::pair<int, int>> res;
for (int i = 2; i <= n; i++) {
if ((n % i) == 0) {
int cnt = 0;
while ((n % i) == 0) {
n /= i;
cnt++;
}
res.emplace_back(std::make_pair(i, cnt));
}
... | [] | 1,008,983 | 1,008,984 | u408910484 | cpp |
p03213 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#in... | [
"expression.operation.binary.add"
] | 1,008,985 | 1,008,986 | u508571192 | cpp |
p03213 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
template <c... | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
template <c... | [
"literal.number.change",
"io.output.change"
] | 1,008,992 | 1,008,993 | u199371251 | cpp |
p03213 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int N;
cin >> N;
vector<int> prime;
bool hoge;
rep... | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int N;
cin >> N;
vector<int> prime;
bool hoge;
rep... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,008,998 | 1,008,999 | u563710899 | cpp |
p03213 | #include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
#define reps(i, s, n) for (int(i) = (s); (i) < (n); ++(i))
#define rep(i, n) reps(i, 0, n)
#define reptr(i, n) for (int(i) = (n); (i) >= 0; --(i))
#define All(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
const ll MOD =... | #include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
#define reps(i, s, n) for (int(i) = (s); (i) < (n); ++(i))
#define rep(i, n) reps(i, 0, n)
#define reptr(i, n) for (int(i) = (n); (i) >= 0; --(i))
#define All(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
const ll MOD =... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,002 | 1,009,003 | u003019316 | cpp |
p03213 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int N, ans = 0;
cin >> N;
vector<int> num(N + 1);
for (int i = 2; i <= N; i++) {
int tmp = i;
for (int j = 2; j * j <= tmp;... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int N, ans = 0;
cin >> N;
vector<int> num(101);
for (int i = 2; i <= N; i++) {
int tmp = i;
for (int j = 2; j * j <= tmp; j... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,009,004 | 1,009,005 | u394033362 | cpp |
p03213 | // template version 1.6
// {{{ define basic macro
using namespace std;
#include <bits/stdc++.h>
#include <iostream>
// varibable settings
#define int long long
#define INF 1000000000000000000LL
// #define INF 2147483647
#define MOD 1000000007LL
// #define MOD 998244353LL
#define infile "../test/sample-1.in"
#define _o... | // template version 1.6
// {{{ define basic macro
using namespace std;
#include <bits/stdc++.h>
#include <iostream>
// varibable settings
#define int long long
#define INF 1000000000000000000LL
// #define INF 2147483647
#define MOD 1000000007LL
// #define MOD 998244353LL
#define infile "../test/sample-1.in"
#define _o... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"variable_access.subscript.index.change",
"assignment.value.change"
] | 1,009,010 | 1,009,011 | u314057689 | cpp |
p03213 | /**
*
*/
// header {{{
#include <bits/stdc++.h>
using namespace std;
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
#ifdef __SIZEOF_INT128__
using i128 = __int128;
using u128 = unsigned __int128;... | /**
*
*/
// header {{{
#include <bits/stdc++.h>
using namespace std;
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
#ifdef __SIZEOF_INT128__
using i128 = __int128;
using u128 = unsigned __int128;... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,009,012 | 1,009,013 | u254456372 | cpp |
p03213 | /*約数を75個持つということは、
75 → n^75
3*25 → n^2 * m^24
3*5*5 → n^2 * m^4 * l^4
5*15 → n^4 * m^15 */
#include <bits/stdc++.h>
using namespace std;
int ilo(int x, int y) {
if (y == 0)
return 0;
int cnt = 0;
while (x > 0) {
x /= y;
cnt += x;
}
return cnt;
}
int main() {
int N;
cin >> N;
vector<int> p... | /*約数を75個持つということは、
75 → n^74
3*25 → n^2 * m^24
3*5*5 → n^2 * m^4 * l^4
5*15 → n^4 * m^14 */
#include <bits/stdc++.h>
using namespace std;
int ilo(int x, int y) {
if (y == 0)
return 0;
int cnt = 0;
while (x > 0) {
x /= y;
cnt += x;
}
return cnt;
}
int main() {
int N;
cin >> N;
// 2...97
/... | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,009,016 | 1,009,017 | u045811375 | cpp |
p03213 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, n, m) ... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define REP(i, n, m) ... | [
"control_flow.branch.if.condition.change"
] | 1,009,023 | 1,009,024 | u468811760 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef DEBUG
freopen("in.txt", "r", stdin);
#endif
int n;
cin >> n;
if (n <= 9) {
cout << 0 << '\n';
return 0;
}
bool erased[101] = {
false,
}; // 안지워졌으면 소수
vector<int> prime;... | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef DEBUG
freopen("in.txt", "r", stdin);
#endif
int n;
cin >> n;
if (n <= 9) {
cout << 0 << '\n';
return 0;
}
bool erased[101] = {
false,
}; // 안지워졌으면 소수
vector<int> prime;... | [
"literal.number.change",
"assignment.value.change"
] | 1,009,035 | 1,009,036 | u517309493 | cpp |
p03213 | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,047 | 1,009,048 | u208002342 | cpp |
p03213 | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.compare.change"
] | 1,009,049 | 1,009,048 | u208002342 | cpp |
p03213 | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.compare.change"
] | 1,009,050 | 1,009,048 | u208002342 | cpp |
p03213 | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 47}) {
if (N >= i * 2) ... | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> three_cand{};
std::vector<int> five_cand{};
std::vector<int> fifteen_cand{};
std::vector<int> twenty_five_cand{};
// 100 / 2
for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47}) {
if (N >= i *... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.compare.change"
] | 1,009,051 | 1,009,048 | u208002342 | cpp |
p03213 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define N (1000000000 + 7)
ll ... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define N (1000000000 + 7)
ll ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,052 | 1,009,053 | u744305661 | cpp |
p03213 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define N (1000000000 + 7)
ll ... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define N (1000000000 + 7)
ll ... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,009,054 | 1,009,053 | u744305661 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, prime[110], cnt[110];
int main(void) {
cin >> n;
for (int i = 0; i < 110; i++) {
prime[i] = 1;
}
prime[1] = 0;
for (int i = 1; i * i < 110; i++)
if (prime[i])
for (int j = i * 2; j < 110; j += i)
prime[j] = 0;
for (int i =... | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, prime[110], cnt[110];
int main(void) {
cin >> n;
for (int i = 0; i < 110; i++) {
prime[i] = 1;
}
prime[1] = 0;
for (int i = 1; i * i < 110; i++)
if (prime[i])
for (int j = i * 2; j < 110; j += i)
prime[j] = 0;
for (int i =... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,009,057 | 1,009,058 | u314988220 | cpp |
p03213 | #include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
stringstream ss;
bool *prime = new bool[101];
for (int i = 0; i < 101; i++)
prime[i] = true;
prime[0] = false;
prime[1] = false;
for (int i = 2; i < 101; i++) {
if (!p... | #include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
stringstream ss;
bool *prime = new bool[101];
for (int i = 0; i < 101; i++)
prime[i] = true;
prime[0] = false;
prime[1] = false;
for (int i = 2; i < 101; i++) {
if (!p... | [
"expression.operation.binary.remove"
] | 1,009,059 | 1,009,060 | u088893297 | cpp |
p03213 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
const ll mod = 1e9 + 7;
const ll INF = 1e9;
const ll MAXN... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(), x.end()
const ll mod = 1e9 + 7;
const ll INF = 1e9;
const ll MAXN... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,009,061 | 1,009,062 | u700986952 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int c[100] = {};
int ans = 0;
for (int i = 2; i <= N; i++) {
for (int j = i, p = 2; j > 1;) {
if (j % p == 0) {
c[p]++;
j /= p;
} else
p++;
}
int y[1100] = {};
for (int j = 2; j < 10... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int c[100] = {};
int ans = 0;
for (int i = 2; i <= N; i++) {
for (int j = i, p = 2; j > 1;) {
if (j % p == 0) {
c[p]++;
j /= p;
} else
p++;
}
}
int y[1100] = {};
for (int j = 2; j < 10... | [] | 1,009,063 | 1,009,064 | u296096665 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 0, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a + 1; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) repf(i, 0, N)
#define reps(i, N) repfs(i, 0, N)
#define repf(i, a, b) for (int i = a; i < b; i++)
#define repfs(i, a, b) for (int i = a + 1; i <= b; i++)
#define repr(i, N) for (int i = N - 1; i >= 0; i--)
#define reprs(i, N) for (int i = N; i > 0; i--)
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,070 | 1,009,071 | u073946233 | cpp |
p03213 |
#if 1
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#inc... |
#if 1
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#inc... | [
"control_flow.branch.if.condition.change"
] | 1,009,072 | 1,009,073 | u935586669 | cpp |
p03213 | #include "algorithm"
#include "cmath"
#include "iostream"
#include "string"
#include "vector"
typedef long long ll;
using namespace std;
int main(int argc, char const *argv[]) {
ll NN;
std::cin >> NN;
int hyaku = 100;
int ps[hyaku];
int pcas[hyaku];
for (size_t i = 0; i < hyaku; i++) {
ps[i] = 0;
... | #include "algorithm"
#include "cmath"
#include "iostream"
#include "string"
#include "vector"
typedef long long ll;
using namespace std;
int main(int argc, char const *argv[]) {
ll NN;
std::cin >> NN;
int hyaku = 100;
int ps[hyaku];
int pcas[hyaku];
for (size_t i = 0; i < hyaku; i++) {
ps[i] = 0;
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,076 | 1,009,077 | u271986615 | cpp |
p03213 | #include <iostream>
#include <string.h>
using namespace std;
int main() {
int n, m = 0;
int c[25];
const int p[25] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
memset(c, 0, sizeof(c));
cin >> n;
for (int i = 1; i <= n; i++) ... | #include <iostream>
#include <string.h>
using namespace std;
int main() {
int n, m = 0;
int c[25];
const int p[25] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
memset(c, 0, sizeof(c));
cin >> n;
for (int i = 1; i <= n; i++) ... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,086 | 1,009,087 | u597243424 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
LL n;
map<LL, LL> p;
signed main() {
// freopen("in", "r", stdin);
while (~scanf("%lld", &n)) {
LL ret = 0;
p.clear();
for (int i = 1; i <= n; i++) {
int k = i;
for (int j = 2; k && j <= k; j++) {
int tot = 0;
... | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
LL n;
map<LL, LL> p;
signed main() {
// freopen("in", "r", stdin);
while (~scanf("%lld", &n)) {
LL ret = 0;
p.clear();
for (int i = 1; i <= n; i++) {
int k = i;
for (int j = 2; k && j <= k; j++) {
int tot = 0;
... | [
"expression.operation.binary.remove"
] | 1,009,090 | 1,009,091 | u218299820 | cpp |
p03213 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
using namespace std;
const double pi = acos(-1);
#define nyan cout << "(=^•ω•^=)" << endl;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
using namespace std;
const double pi = acos(-1);
#define nyan cout << "(=^•ω•^=)" << endl;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,094 | 1,009,095 | u128258399 | cpp |
p03213 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
using namespace std;
const double pi = acos(-1);
#define nyan cout << "(=^•ω•^=)" << endl;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
using namespace std;
const double pi = acos(-1);
#define nyan cout << "(=^•ω•^=)" << endl;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,096 | 1,009,095 | u128258399 | cpp |
p03213 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int vis[105], prime[105], cnt = 0;
void init() {
for (int i = 2; i <= 100; i++) {
if (vis[i])
continue;
prime[cnt++] = i;
for (int j = 2 * i; j <= 100; j += i) {
vis[j] = 1;
}
}
}
map<int, int> m;
map<int, int>::iterator... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int vis[105], prime[105], cnt = 0;
void init() {
for (int i = 2; i <= 100; i++) {
if (vis[i])
continue;
prime[cnt++] = i;
for (int j = 2 * i; j <= 100; j += i) {
vis[j] = 1;
}
}
}
map<int, int> m;
map<int, int>::iterator... | [
"assignment.change"
] | 1,009,097 | 1,009,098 | u777892860 | cpp |
p03213 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define INF 1e+7
#define MOD 1000000007
using namespace std;... | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define INF 1e+7
#define MOD 1000000007
using namespace std;... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 1,009,104 | 1,009,105 | u251433890 | cpp |
p03213 | #include <iostream>
#include <map>
#include <vector>
#define llint long long
using namespace std;
int n;
bool prime[105];
map<int, int> mp;
int cnt[1005], sum[1005];
vector<int> vec;
int main(void) {
cin >> n;
for (int i = 2; i < 105; i++) {
if (prime[i])
continue;
for (int j = 2 * i; j < 105; j +=... | #include <iostream>
#include <map>
#include <vector>
#define llint long long
using namespace std;
llint n;
bool prime[105];
map<llint, llint> mp;
llint cnt[1005], sum[1005];
vector<int> vec;
int main(void) {
cin >> n;
for (int i = 2; i < 105; i++) {
if (prime[i])
continue;
for (int j = 2 * i; j < 1... | [
"variable_declaration.type.change",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 1,009,112 | 1,009,113 | u319282133 | cpp |
p03214 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
... | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
... | [
"variable_declaration.type.change"
] | 1,009,116 | 1,009,117 | u516525290 | cpp |
p03212 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <numeric>
#include <unordered_map>
#include <vector>
#define rep(it, ifrom, ito) for (auto it = ifrom; it != ito; ++it)
#define all(a) a.begin(), a.end()
using namespace std;
int main(int argc, c... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <numeric>
#include <unordered_map>
#include <vector>
#define rep(it, ifrom, ito) for (auto it = ifrom; it != ito; ++it)
#define all(a) a.begin(), a.end()
using namespace std;
int main(int argc, c... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,009,123 | 1,009,124 | u023515228 | cpp |
p03212 | #include "algorithm"
#include "cmath"
#include "iostream"
#include "string"
#include "vector"
typedef long long ll;
using namespace std;
void sep_next(ll separ[15]) {
// ll separ2[15] = separ;
// separ[0] +=1;
ll asf = 0;
while (separ[asf] == 7) {
asf++;
}
for (size_t i = 0; i < asf + 1; i++) {
if... | #include "algorithm"
#include "cmath"
#include "iostream"
#include "string"
#include "vector"
typedef long long ll;
using namespace std;
void sep_next(ll separ[15]) {
// ll separ2[15] = separ;
// separ[0] +=1;
ll asf = 0;
while (separ[asf] == 7) {
asf++;
}
for (size_t i = 0; i < asf + 1; i++) {
if... | [
"control_flow.break.add"
] | 1,009,125 | 1,009,126 | u271986615 | cpp |
p03212 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c1, c2, c3, c4, ans = 0;
cin >> n;
n = min(n, 777777753);
if (n > 10000000) {
for (i = 33333357; i <= n; i += 2) {
c1 = 0;
c2 = 0;
c3 = 0;
c4 = 0;
j = i;
while (j > 0) {
if (j % 10 == 3) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c1, c2, c3, c4, ans = 0;
cin >> n;
n = min(n, 777777753);
if (n > 100000000) {
for (i = 333333357; i <= n; i += 2) {
c1 = 0;
c2 = 0;
c3 = 0;
c4 = 0;
j = i;
while (j > 0) {
if (j % 10 == 3) {
... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"io.output.change"
] | 1,009,143 | 1,009,144 | u451256159 | cpp |
p03212 | #include <algorithm>
#include <array>
#include <cmath>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>
using namespace std;
using i64 = long long int;
int main() {
int N;
cin >> N;
int cnt[3] = {};
cnt... | #include <algorithm>
#include <array>
#include <cmath>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <utility>
#include <vector>
using namespace std;
using i64 = long long int;
int main() {
int N;
cin >> N;
int cnt[3] = {};
cnt... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 1,009,145 | 1,009,146 | u158253287 | cpp |
p03212 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
vector<ll> ans;
ll n;
void dfs(ll x, ll y, ll z, ll bit) {
if (x == y) {
if (bit != 111)
return;
ans.push_back(z);
} else {
for (int i = 0; i < 3; i++) {
if (i == 0)
... | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
vector<ll> ans;
ll n;
void dfs(ll x, ll y, ll z, ll bit) {
if (x == y) {
if (bit != 111)
return;
ans.push_back(z);
} else {
for (int i = 0; i < 3; i++) {
if (i == 0)
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.value.change"
] | 1,009,147 | 1,009,148 | u475007080 | cpp |
p03212 | // warm heart, wagging tail,and a smile just for you!
// ███████████
// ███╬╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬██╬╬╬╬╬╬███
// ... | // warm heart, wagging tail,and a smile just for you!
// ███████████
// ███╬╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬██╬╬╬╬╬╬███
// ... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,009,149 | 1,009,150 | u239493918 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.