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 9
values |
|---|---|---|---|---|---|---|---|
p03196 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1e9 + 7;
int main() {
ll N, P, P0;
cin >> N >> P;
P0 = P;
ll a = sqrt(P);
vector<ll> s(a + 1, 0);
repl(i, 2, a + 1) {
while (P % i == 0) {
P /= i;
s[i]++;
}
}
ll ans = 1, tmp;
rep(i, a + 1) {
if (s[i] >= N) {
tmp = s[i] / N;
ans *= pow(i, tmp);
}
}
if (N == 1) {
cout << P;
} else {
cout << ans;
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1e9 + 7;
int main() {
ll N, P, P0;
cin >> N >> P;
P0 = P;
ll a = sqrt(P);
vector<ll> s(a + 1, 0);
repl(i, 2, a + 1) {
while (P % i == 0) {
P /= i;
s[i]++;
}
}
ll ans = 1, tmp;
rep(i, a + 1) {
if (s[i] >= N) {
tmp = s[i] / N;
ans *= pow(i, tmp);
}
}
if (N == 1) {
cout << P0;
} else {
cout << ans;
}
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 990,672 | 990,673 | u401139594 | cpp |
p03196 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1e9 + 7;
int main() {
ll N, P, P0;
cin >> N >> P;
P0 = P;
ll a = sqrt(P);
vector<ll> s(a + 1, 0);
repl(i, 2, a + 1) {
while (P % i == 0) {
P /= i;
s[i]++;
}
}
ll ans = 1, tmp;
rep(i, a + 1) {
if (s[i] >= N) {
tmp = s[i] / N;
ans *= i * tmp;
}
}
if (N == 1) {
cout << P0;
} else {
cout << ans;
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1e9 + 7;
int main() {
ll N, P, P0;
cin >> N >> P;
P0 = P;
ll a = sqrt(P);
vector<ll> s(a + 1, 0);
repl(i, 2, a + 1) {
while (P % i == 0) {
P /= i;
s[i]++;
}
}
ll ans = 1, tmp;
rep(i, a + 1) {
if (s[i] >= N) {
tmp = s[i] / N;
ans *= pow(i, tmp);
}
}
if (N == 1) {
cout << P0;
} else {
cout << ans;
}
return 0;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,674 | 990,673 | u401139594 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll N, P;
cin >> N >> P;
ll p = P;
map<ll, ll> prime;
for (ll i = 2; i * i <= P; ++i) {
if (p % i != 0)
continue;
while (p % i == 0) {
prime[i] += 1;
p = p / i;
}
}
if (p != 1) {
prime[p] = 1;
}
ll ans = 1;
for (auto x : prime) {
REP(i, x.second) ans *= x.first;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll N, P;
cin >> N >> P;
ll p = P;
map<ll, ll> prime;
for (ll i = 2; i * i <= P; ++i) {
if (p % i != 0)
continue;
while (p % i == 0) {
prime[i] += 1;
p = p / i;
}
}
if (p != 1) {
prime[p] = 1;
}
ll ans = 1;
for (auto x : prime) {
REP(i, x.second / N) ans *= x.first;
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 990,677 | 990,678 | u450883456 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> pf(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
int main() {
//
int n;
long long p;
cin >> n >> p;
auto f = pf(p);
long long cnt = 1;
for (auto P : f) {
for (int i = 0; i < P.second / n; i++) {
cnt *= P.first;
}
}
//
}
| #include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> pf(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
int main() {
//
int n;
long long p;
cin >> n >> p;
auto f = pf(p);
long long cnt = 1;
for (auto P : f) {
for (int i = 0; i < P.second / n; i++) {
cnt *= P.first;
}
}
cout << cnt;
//
}
| [] | 990,689 | 990,690 | u367131219 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
if (n > k * 2) {
}
return fac[n] / (fac[k] * fac[n - k]);
}
ll dp[201010][2];
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
// long longしか使わない
//素数は1より大きい
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
map<ll, ll> mp;
ll target = p;
for (ll i = 2; i <= sqrt(p) + 1; ++i) {
if (target % i == 0) {
while (target % i == 0) {
mp[i]++;
target /= i;
}
}
}
ll res = 1;
for (auto p : mp) {
ll x = p.first;
ll y = p.second;
if (y >= n) {
res *= x * (y / n);
}
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
if (n > k * 2) {
}
return fac[n] / (fac[k] * fac[n - k]);
}
ll dp[201010][2];
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
// long longしか使わない
//素数は1より大きい
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
map<ll, ll> mp;
ll target = p;
for (ll i = 2; i <= sqrt(p) + 1; ++i) {
if (target % i == 0) {
while (target % i == 0) {
mp[i]++;
target /= i;
}
}
}
ll res = 1;
for (auto p : mp) {
ll x = p.first;
ll y = p.second;
if (y >= n) {
res *= pow(x, y / n);
}
}
cout << res << endl;
return 0;
} | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,705 | 990,706 | u631558039 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
if (n > k * 2) {
}
return fac[n] / (fac[k] * fac[n - k]);
}
ll dp[201010][2];
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
// long longしか使わない
//素数は1より大きい
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
map<ll, ll> mp;
ll target = p;
for (ll i = 2; i <= sqrt(p + 1); ++i) {
if (target % i == 0) {
while (target % i == 0) {
mp[i]++;
target /= i;
}
}
}
ll res = 1;
for (auto p : mp) {
ll x = p.first;
ll y = p.second;
if (y >= n) {
res *= x * (y / n);
}
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
if (n > k * 2) {
}
return fac[n] / (fac[k] * fac[n - k]);
}
ll dp[201010][2];
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
// long longしか使わない
//素数は1より大きい
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
map<ll, ll> mp;
ll target = p;
for (ll i = 2; i <= sqrt(p) + 1; ++i) {
if (target % i == 0) {
while (target % i == 0) {
mp[i]++;
target /= i;
}
}
}
ll res = 1;
for (auto p : mp) {
ll x = p.first;
ll y = p.second;
if (y >= n) {
res *= pow(x, y / n);
}
}
cout << res << endl;
return 0;
} | [
"call.arguments.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,707 | 990,706 | u631558039 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ':' << n << endl;
#define dline cerr << __LINE__ << endl;
using ll = long long;
using ull = unsigned long long;
template <class T, class U> using P = pair<T, U>;
template <class T> using Heap = priority_queue<T>;
template <class T> using heaP = priority_queue<T, vector<T>, greater<T>>;
template <class T, class U> using umap = unordered_map<T, U>;
template <class T> using uset = unordered_set<T>;
template <class T> bool ChangeMax(T &a, const T &b) {
if (a >= b)
return false;
a = b;
return true;
}
template <class T> bool ChangeMin(T &a, const T &b) {
if (a <= b)
return false;
a = b;
return true;
}
template <class T, size_t N, class U> void Fill(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &e : v)
is >> e;
return is;
}
map<ll, ll> mp;
void f(ll x) {
if (x <= 1)
return;
for (ll i = 2; i * i <= x; ++i) {
if (x % i == 0) {
f(i);
f(x / i);
return;
}
}
mp[x]++;
}
int main() {
ll n, p;
cin >> n >> p;
f(p);
ll ans = 1;
for (auto e : mp) {
ans *= e.first * (e.second / n);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ':' << n << endl;
#define dline cerr << __LINE__ << endl;
using ll = long long;
using ull = unsigned long long;
template <class T, class U> using P = pair<T, U>;
template <class T> using Heap = priority_queue<T>;
template <class T> using heaP = priority_queue<T, vector<T>, greater<T>>;
template <class T, class U> using umap = unordered_map<T, U>;
template <class T> using uset = unordered_set<T>;
template <class T> bool ChangeMax(T &a, const T &b) {
if (a >= b)
return false;
a = b;
return true;
}
template <class T> bool ChangeMin(T &a, const T &b) {
if (a <= b)
return false;
a = b;
return true;
}
template <class T, size_t N, class U> void Fill(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &e : v)
is >> e;
return is;
}
map<ll, ll> mp;
void f(ll x) {
if (x <= 1)
return;
for (ll i = 2; i * i <= x; ++i) {
if (x % i == 0) {
f(i);
f(x / i);
return;
}
}
mp[x]++;
}
int main() {
ll n, p;
cin >> n >> p;
f(p);
ll ans = 1;
for (auto e : mp) {
ans *= pow(e.first, (e.second / n));
}
cout << ans << endl;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,708 | 990,709 | u691380397 | cpp |
p03196 | #include <iostream>
#include <utility>
#include <vector>
int main() {
static bool sieve[1000001];
long long n, p;
std::cin >> n >> p;
long long c = 2;
bool end = false;
long long nfact = 0;
long long ans = 1;
if (n == 1) {
std::cout << n << "\n";
return 0;
}
while (p > 1 && c < 1000001 && !end) {
nfact = 0;
while (p % c == 0) {
nfact++;
p /= c;
}
for (int i = 0; i < ((nfact - nfact % n) / n); i++) {
ans *= c;
}
for (int i = c * 2; i < 1000001; i += c) {
sieve[i] = true;
}
for (int i = c + 1; i < 1000001; i++) {
if (!sieve[i]) {
c = i;
break;
}
if (i == 1000000)
end = true;
}
}
std::cout << ans << "\n";
return 0;
} | #include <iostream>
#include <utility>
#include <vector>
int main() {
static bool sieve[1000001];
long long n, p;
std::cin >> n >> p;
long long c = 2;
bool end = false;
long long nfact = 0;
long long ans = 1;
if (n == 1) {
std::cout << p << "\n";
return 0;
}
while (p > 1 && c < 1000001 && !end) {
nfact = 0;
while (p % c == 0) {
nfact++;
p /= c;
}
for (int i = 0; i < ((nfact - nfact % n) / n); i++) {
ans *= c;
}
for (int i = c * 2; i < 1000001; i += c) {
sieve[i] = true;
}
for (int i = c + 1; i < 1000001; i++) {
if (!sieve[i]) {
c = i;
break;
}
if (i == 1000000)
end = true;
}
}
std::cout << ans << "\n";
return 0;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 990,724 | 990,725 | u060431747 | cpp |
p03196 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long int;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll mod = 1e9 + 7;
vector<pair<ll, ll>> prime_factorize(ll N) {
vector<pair<ll, ll>> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
long long ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res.push_back({a, ex});
}
// 最後に残った数について
if (N != 1)
res.push_back({N, 1});
return res;
}
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
vector<pair<ll, ll>> d = prime_factorize(p);
while (!d.empty()) {
pair<ll, ll> g = d.back();
d.pop_back();
if (g.second >= n)
ans *= g.first * (g.second / n);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long int;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll mod = 1e9 + 7;
vector<pair<ll, ll>> prime_factorize(ll N) {
vector<pair<ll, ll>> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
long long ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res.push_back({a, ex});
}
// 最後に残った数について
if (N != 1)
res.push_back({N, 1});
return res;
}
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
vector<pair<ll, ll>> d = prime_factorize(p);
while (!d.empty()) {
pair<ll, ll> g = d.back();
d.pop_back();
if (g.second >= n)
ans *= pow(g.first, g.second / n);
}
cout << ans << endl;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,726 | 990,727 | u167245594 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ld long double
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;
}
using P = pair<long long, long long>;
#define rep(i, n) for (long long i = 0; i < (long long)n; i++)
#define FOR(i, a, b) for (long long i = a; i < b; i++)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((long long)(x).size())
#define COUT(x) cout << x << endl
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define vint vector<int>
#define vvint vector<vector<int>>
#define vstr vector<string>
#define vp vector<pair<int, int>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define SUM(x) accumulate(x.begin(), x.end(), 0)
#define MAX(x) *max_element(x.begin(), x.end())
#define MIN(x) *min_element(x.begin(), x.end())
#define couty cout << "Yes" << endl
#define coutn cout << "No" << endl
#define coutY cout << "YES" << endl
#define coutN cout << "NO" << endl
#define yn(x) cout << (x ? "Yes" : "No") << endl
#define YN(x) cout << (x ? "YES" : "NO") << endl
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
const long long dx[4] = {1, 0, -1, 0};
const long long dy[4] = {0, 1, 0, -1};
const long long INF = 1e12;
const long long MOD = 1e9 + 7;
vp prime_factorize(int n) {
vp ret;
for (int p = 2; p * p <= n; p++) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
num++;
n /= p;
}
ret.PB(MP(p, num));
}
if (n != 1)
ret.PB(MP(n, 1));
return ret;
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, p;
cin >> n >> p;
vp prime = prime_factorize(p);
int res = 1;
// for(auto pr:prime){
// cout<<pr.F<<':'<<pr.S<<endl;
// }
for (auto pr : prime) {
if (pr.S / n >= 1) {
res *= pr.F * (pr.S / n);
// cout<<pr.F<<':'<<pr.S/n<<endl;
// cout<<pr.F*pr.S/n<<endl;
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ld long double
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;
}
using P = pair<long long, long long>;
#define rep(i, n) for (long long i = 0; i < (long long)n; i++)
#define FOR(i, a, b) for (long long i = a; i < b; i++)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((long long)(x).size())
#define COUT(x) cout << x << endl
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define vint vector<int>
#define vvint vector<vector<int>>
#define vstr vector<string>
#define vp vector<pair<int, int>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define SUM(x) accumulate(x.begin(), x.end(), 0)
#define MAX(x) *max_element(x.begin(), x.end())
#define MIN(x) *min_element(x.begin(), x.end())
#define couty cout << "Yes" << endl
#define coutn cout << "No" << endl
#define coutY cout << "YES" << endl
#define coutN cout << "NO" << endl
#define yn(x) cout << (x ? "Yes" : "No") << endl
#define YN(x) cout << (x ? "YES" : "NO") << endl
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
const long long dx[4] = {1, 0, -1, 0};
const long long dy[4] = {0, 1, 0, -1};
const long long INF = 1e12;
const long long MOD = 1e9 + 7;
vp prime_factorize(int n) {
vp ret;
for (int p = 2; p * p <= n; p++) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
num++;
n /= p;
}
ret.PB(MP(p, num));
}
if (n != 1)
ret.PB(MP(n, 1));
return ret;
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, p;
cin >> n >> p;
vp prime = prime_factorize(p);
int res = 1;
// for(auto pr:prime){
// cout<<pr.F<<':'<<pr.S<<endl;
// }
for (auto pr : prime) {
if (pr.S / n > 0) {
// res*=(pr.F*floor(pr.S/n));
res *= pow(pr.F, pr.S / n);
// cout<<pr.F<<':'<<pr.S/n<<endl;
// cout<<pr.F*floor(pr.S/n)<<endl;
}
}
// cout<<4*6*19<<endl;
cout << res << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,732 | 990,733 | u876953939 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
map<long long int, ll> prime_factor(long long int n) {
map<ll, ll> ret;
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
int main() {
ll N, P;
cin >> N >> P;
map<ll, ll> prime = prime_factor(P);
ll output = 1;
for (auto num : prime) {
if (num.second / N > 0) {
output *= num.first * (num.second / N);
}
}
cout << output << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
map<long long int, ll> prime_factor(long long int n) {
map<ll, ll> ret;
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
int main() {
ll N, P;
cin >> N >> P;
map<ll, ll> prime = prime_factor(P);
ll output = 1;
for (auto num : prime) {
if (num.second / N > 0) {
output *= powl(num.first, (num.second / N));
}
}
cout << output << endl;
return 0;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,736 | 990,737 | u412408615 | cpp |
p03196 | // C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
// #include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define ALL(n) begin(n), end(n)
#define IN(a, x, b) (a <= x && x < b)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
const long long MOD = 1000000007;
vector<pair<long long, long long>> prime_factorize(long long N) {
vector<pair<long long, long long>> res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
long long ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res.push_back({a, ex});
}
// 最後に残った数について
if (N != 1)
res.push_back({N, 1});
return res;
}
int main(void) {
ll n;
ll p;
cin >> n >> p;
const auto &res = prime_factorize(p);
ll ans = 1;
REP(i, res.size()) {
// cout << res[i].first << " " << res[i].second << endl;
if ((res[i].second / n) != 0) {
ans *= (res[i].first * (res[i].second / n));
}
}
cout << ans << endl;
return 0;
} | // C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
// #include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define ALL(n) begin(n), end(n)
#define IN(a, x, b) (a <= x && x < b)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
const long long MOD = 1000000007;
vector<pair<long long, long long>> prime_factorize(long long N) {
vector<pair<long long, long long>> res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
long long ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res.push_back({a, ex});
}
// 最後に残った数について
if (N != 1)
res.push_back({N, 1});
return res;
}
int main(void) {
ll n;
ll p;
cin >> n >> p;
const auto &res = prime_factorize(p);
ll ans = 1;
REP(i, res.size()) {
// cout << res[i].first << " " << res[i].second << endl;
if ((res[i].second / n) != 0) {
ans *= pow(res[i].first, (res[i].second / n));
}
}
cout << ans << endl;
return 0;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,746 | 990,747 | u274657603 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int dis2(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int main() {
ll n, p;
cin >> n >> p;
ll g = 1;
for (ll i = 2; i * i <= p; i++)
if (p % i == 0) {
ll c = 0;
while (p % i == 0) {
p /= i;
c++;
}
if (c / n >= 1) {
g *= i * (c / n);
}
}
if (p != 1) {
if (n == 1)
g *= p;
}
cout << g << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int dis2(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int main() {
ll n, p;
cin >> n >> p;
ll g = 1;
for (ll i = 2; i * i <= p; i++)
if (p % i == 0) {
ll c = 0;
while (p % i == 0) {
p /= i;
c++;
}
if (c / n >= 1) {
g *= pow(i, c / n);
}
}
if (p != 1) {
if (n == 1)
g *= p;
}
cout << g << endl;
return 0;
} | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,770 | 990,771 | u765815947 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int dis2(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int main() {
ll n, p;
cin >> n >> p;
ll g = 1;
for (int i = 2; i * i <= p; i++)
if (p % i == 0) {
int c = 0;
while (p % i == 0) {
p /= i;
c++;
}
if (c / n >= 1) {
g *= i * (c / n);
}
}
if (p != 1) {
if (n == 1)
g *= p;
}
cout << g << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> ii;
typedef long long ll;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int dis2(int x1, int y1, int x2, int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int main() {
ll n, p;
cin >> n >> p;
ll g = 1;
for (ll i = 2; i * i <= p; i++)
if (p % i == 0) {
ll c = 0;
while (p % i == 0) {
p /= i;
c++;
}
if (c / n >= 1) {
g *= pow(i, c / n);
}
}
if (p != 1) {
if (n == 1)
g *= p;
}
cout << g << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,772 | 990,771 | u765815947 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (long long i = 0; i < N; i++)
using ll = long long;
/////////////////////////////////////////////////////
// 素因数分解 pair<指数, 乗数>
vector<pair<ll, ll>> prime_factorize(ll N) {
vector<pair<ll, ll>> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
void solve(long long N, long long P) {
vector<pair<ll, ll>> pair = prime_factorize(P);
ll ans = 1;
rep(i, pair.size()) {
if (pair[i].second >= N)
ans *= (pair[i].first * (pair[i].second / N));
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long P;
scanf("%lld", &P);
solve(N, P);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (long long i = 0; i < N; i++)
using ll = long long;
/////////////////////////////////////////////////////
// 素因数分解 pair<指数, 乗数>
vector<pair<ll, ll>> prime_factorize(ll N) {
vector<pair<ll, ll>> res;
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
void solve(long long N, long long P) {
vector<pair<ll, ll>> pair = prime_factorize(P);
ll ans = 1;
rep(i, pair.size()) {
if (pair[i].second >= N)
ans *= (pow(pair[i].first, (pair[i].second / N)));
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long P;
scanf("%lld", &P);
solve(N, P);
return 0;
}
| [
"assignment.value.change",
"expression.operation.binary.change"
] | 990,775 | 990,776 | u314642288 | cpp |
p03196 | #include <bits/stdc++.h>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define lrep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define lrep2(i, a, n) \
for (long long i = (long long)(a); i <= (long long)(n); i++)
#define irrep(i, n) for (int i = (int)(n - 1); i > -1; i--)
#define irrep2(i, a, n) for (int i = (int)(n); i >= (int)(a); i--)
typedef long long ll;
typedef std::vector<int> v_int;
typedef std::vector<v_int> v2_int;
typedef std::vector<ll> v_ll;
typedef std::vector<v_ll> v2_ll;
typedef std::vector<std::string> v_string;
typedef std::vector<v_string> v2_string;
typedef std::vector<bool> v_bool;
typedef std::vector<v_bool> v2_bool;
typedef std::pair<ll, ll> pll;
typedef std::pair<int, int> pii;
const double PI = 3.1415926535897932;
const int INF = (int)1e9;
const ll LINF = 1e18;
const int IMOD = 1000000007;
const int dr[4] = {1, 0, -1, 0};
const int dc[4] = {0, 1, 0, -1};
using namespace std;
static int memo[1000001];
map<ll, ll> PrimeFactorial(ll n) {
map<ll, ll> ret;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
}
if (n > 1) {
ret[n]++;
}
return ret;
}
int main(void) {
ll n, p;
cin >> n >> p;
map<ll, ll> f = PrimeFactorial(p);
ll ans = 1;
for (auto fact : f) {
if (fact.second >= n) {
ans *= fact.first;
}
}
cout << ans << endl;
return 0;
}
/** atcoder **/
| #include <bits/stdc++.h>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define lrep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define lrep2(i, a, n) \
for (long long i = (long long)(a); i <= (long long)(n); i++)
#define irrep(i, n) for (int i = (int)(n - 1); i > -1; i--)
#define irrep2(i, a, n) for (int i = (int)(n); i >= (int)(a); i--)
typedef long long ll;
typedef std::vector<int> v_int;
typedef std::vector<v_int> v2_int;
typedef std::vector<ll> v_ll;
typedef std::vector<v_ll> v2_ll;
typedef std::vector<std::string> v_string;
typedef std::vector<v_string> v2_string;
typedef std::vector<bool> v_bool;
typedef std::vector<v_bool> v2_bool;
typedef std::pair<ll, ll> pll;
typedef std::pair<int, int> pii;
const double PI = 3.1415926535897932;
const int INF = (int)1e9;
const ll LINF = 1e18;
const int IMOD = 1000000007;
const int dr[4] = {1, 0, -1, 0};
const int dc[4] = {0, 1, 0, -1};
using namespace std;
static int memo[1000001];
map<ll, ll> PrimeFactorial(ll n) {
map<ll, ll> ret;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
}
if (n > 1) {
ret[n]++;
}
return ret;
}
int main(void) {
ll n, p;
cin >> n >> p;
map<ll, ll> f = PrimeFactorial(p);
ll ans = 1;
for (auto fact : f) {
irep(i, fact.second / n) { ans *= fact.first; }
}
cout << ans << endl;
return 0;
}
/** atcoder **/
| [
"call.arguments.add",
"control_flow.branch.if.condition.change"
] | 990,783 | 990,784 | u829260400 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
ll m, n;
cin >> m >> n;
map<ll, ll> ord; //素因数とオーダーをマップで管理
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
ll res = 0;
while (n % i == 0) {
n /= i;
res++;
}
ord[i] = res;
}
}
if (n != 1)
ord[n]++;
ll ans = 1;
for (auto p : ord) {
pow(p.first, p.second / m);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
ll m, n;
cin >> m >> n;
map<ll, ll> ord; //素因数とオーダーをマップで管理
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
ll res = 0;
while (n % i == 0) {
n /= i;
res++;
}
ord[i] = res;
}
}
if (n != 1)
ord[n]++;
ll ans = 1;
for (auto p : ord) {
ans *= pow(p.first, (p.second / m));
}
cout << ans << endl;
return 0;
} | [
"assignment.change",
"call.arguments.change"
] | 990,793 | 990,794 | u449123607 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
ll m, n;
cin >> m >> n;
map<ll, ll> ord; //素因数とオーダーをマップで管理
for (ll i = 2; i * i < n; i++) {
if (n % i == 0) {
ll res = 0;
while (n % i == 0) {
n /= i;
res++;
}
ord[i] = res;
}
}
if (n != 1)
ord[n]++;
ll ans = 1;
for (auto p : ord) {
ans *= pow(p.first, (p.second) / m);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
ll m, n;
cin >> m >> n;
map<ll, ll> ord; //素因数とオーダーをマップで管理
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
ll res = 0;
while (n % i == 0) {
n /= i;
res++;
}
ord[i] = res;
}
}
if (n != 1)
ord[n]++;
ll ans = 1;
for (auto p : ord) {
ans *= pow(p.first, (p.second / m));
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,795 | 990,794 | u449123607 | cpp |
p03196 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
ll m, n;
cin >> m >> n;
map<ll, int> ord; //素因数とオーダーをマップで管理
for (ll i = 2; i * i < n; i++) {
if (n % i == 0) {
int res = 0;
while (n % i == 0) {
n /= i;
res++;
}
ord[i] = res;
}
}
if (n != 1)
ord[n]++;
ll ans = 1;
for (auto p : ord) {
ans *= pow(p.first, (p.second) / m);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; i++)
#define rep3(i, n, m) for (ll i = n; i >= m; i--)
#define pb push_back
#define eb emplace_back
#define ppb pop_back
#define mpa make_pair
const ll INF = 1e18;
inline void chmax(ll &a, ll b) { a = max(a, b); }
inline void chmin(ll &a, ll b) { a = min(a, b); }
int main() {
ll m, n;
cin >> m >> n;
map<ll, ll> ord; //素因数とオーダーをマップで管理
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
ll res = 0;
while (n % i == 0) {
n /= i;
res++;
}
ord[i] = res;
}
}
if (n != 1)
ord[n]++;
ll ans = 1;
for (auto p : ord) {
ans *= pow(p.first, (p.second / m));
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.type.change",
"call.arguments.change"
] | 990,796 | 990,794 | u449123607 | cpp |
p03196 | #include "bits/stdc++.h"
#define rep(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
const int mod = 1e9 + 7;
using namespace std;
//素因数分解
map<ll, int> factor(ll n) {
map<ll, int> f;
for (ll i = 2; i * i < n; i++) {
int x = 0;
while (n % i == 0)
n /= i, x++;
if (x != 0)
f[i] = x;
}
if (n != 1)
f[n] = 1;
return f;
}
ll intpow(ll a, ll n) {
if (n == 0)
return 1;
if (n == 1)
return a;
if (n % 2 == 0)
return intpow(a * a, n / 2);
else
return intpow(a * a, n / 2) * a;
}
int main(void) {
ll N, P;
cin >> N >> P;
auto f = factor(P);
ll ans = 1;
for (auto x : f) {
while (x.second >= N) {
ans *= x.first;
x.second -= N;
}
}
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
#define rep(i, N) for (int i = 0; i < N; i++)
typedef long long ll;
const int mod = 1e9 + 7;
using namespace std;
//素因数分解
map<ll, int> factor(ll n) {
map<ll, int> f;
for (ll i = 2; i * i <= n; i++) {
int x = 0;
while (n % i == 0)
n /= i, x++;
if (x != 0)
f[i] = x;
}
if (n != 1)
f[n] = 1;
return f;
}
ll intpow(ll a, ll n) {
if (n == 0)
return 1;
if (n == 1)
return a;
if (n % 2 == 0)
return intpow(a * a, n / 2);
else
return intpow(a * a, n / 2) * a;
}
int main(void) {
ll N, P;
cin >> N >> P;
auto f = factor(P);
ll ans = 1;
for (auto x : f) {
while (x.second >= N) {
ans *= x.first;
x.second -= N;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,803 | 990,804 | u909017535 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define pie 3.141592653589793238462643383279
#define mod 998244353
#define int long long
#define P pair<int, int>
#define all(vec) vec.begin(), vec.end()
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
return kai(x, y) * mod_pow(kai(y, y), mod - 2, mod) % mod;
}
int n, p;
int cnt[1000010];
int ans = 1;
signed main() {
cin >> n >> p;
int q = p;
for (int i = 2; i <= sqrt(q); i++) {
int k = 0;
while (p % i == 0) {
k++;
p /= i;
}
cnt[i] = k;
}
if (1 < p && n == 1)
ans = p;
for (int i = 2; i <= 1000000; i++)
if (n <= cnt[i]) {
ans *= i * (cnt[i] / n);
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define pie 3.141592653589793238462643383279
#define mod 998244353
#define int long long
#define P pair<int, int>
#define all(vec) vec.begin(), vec.end()
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)
return 0;
return kai(x, y) * mod_pow(kai(y, y), mod - 2, mod) % mod;
}
int n, p;
int cnt[1000010];
int ans = 1;
signed main() {
cin >> n >> p;
int q = p;
for (int i = 2; i <= sqrt(q); i++) {
int k = 0;
while (p % i == 0) {
k++;
p /= i;
}
cnt[i] = k;
}
if (1 < p && n == 1)
ans = p;
for (int i = 2; i <= 1000000; i++)
if (n <= cnt[i]) {
ans *= pow(i, cnt[i] / n);
}
cout << ans << endl;
} | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,812 | 990,813 | u277153875 | cpp |
p03196 | // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
vector<vector<long long>> memo;
long long n_num;
long long k_num;
void Resize(long long n, long long k);
};
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long> vll;
// code
// ------------------------------------------------
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> m;
for (ll i = 2; i * i <= p; ++i) {
if (p % i == 0) {
while (p % i == 0) {
m[i]++;
p /= i;
}
}
}
m[1] = n;
ll ans = 1;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
ll buf = itr->second / n;
ans *= pow(itr->first, buf);
}
if (n == 1)
ans = p;
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 1)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
Resize(n, k);
ll ret;
if (memo[n][k] != 0) {
ret = memo[n][k];
} else if (n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
void Combi::Resize(ll n, ll k) {
if (n_num <= n || k_num <= k) {
n_num = (n + 1) * 2;
k_num = (k + 1) * 2;
memo.resize(n_num);
for (auto itr = memo.begin(); itr != memo.end(); ++itr) {
itr->resize(k_num);
}
}
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for (long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
| // include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
vector<vector<long long>> memo;
long long n_num;
long long k_num;
void Resize(long long n, long long k);
};
// define
// ------------------------------------------------
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) int((a).size())
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repe(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define vsort(v) sort((v).begin(), (v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a, b) __gcd((a), (b))
#define LCM(a, b) (a) / GCD((a), (b)) * (b)
#define kiriage(a, b) ((a) + (b)-1) / (b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long> vll;
// code
// ------------------------------------------------
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> m;
ll back = p;
for (ll i = 2; i * i <= p; ++i) {
if (p % i == 0) {
while (p % i == 0) {
m[i]++;
p /= i;
}
}
}
m[1] = n;
ll ans = 1;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
ll buf = itr->second / n;
ans *= pow(itr->first, buf);
}
if (n == 1)
ans = back;
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while (1) {
n = n / 10;
if (n == 1)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while (n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for (auto itr = str.begin(); itr != str.end(); itr++) {
if (65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
Resize(n, k);
ll ret;
if (memo[n][k] != 0) {
ret = memo[n][k];
} else if (n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
void Combi::Resize(ll n, ll k) {
if (n_num <= n || k_num <= k) {
n_num = (n + 1) * 2;
k_num = (k + 1) * 2;
memo.resize(n_num);
for (auto itr = memo.begin(); itr != memo.end(); ++itr) {
itr->resize(k_num);
}
}
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for (long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
| [
"variable_declaration.add",
"assignment.value.change",
"identifier.change"
] | 990,814 | 990,815 | u610897920 | cpp |
p03196 | #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 rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const ll inf = 1001001001;
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
if (n == 1) {
cout << p << endl;
return 0;
}
for (ll i = 2; i * i < p; i++) {
if (p % i != 0)
continue;
ll count = 0;
while (p % i == 0) {
p /= i;
count++;
}
rep(j, 0, count / n) { ans *= i; }
}
cout << ans << endl;
return 0;
} | #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 rrep(i, cc, n) for (long i = cc; i > n; --i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const ll inf = 1001001001;
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
if (n == 1) {
cout << p << endl;
return 0;
}
for (ll i = 2; i * i <= p; i++) {
if (p % i != 0)
continue;
ll count = 0;
while (p % i == 0) {
p /= i;
count++;
}
rep(j, 0, count / n) { ans *= i; }
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,816 | 990,817 | u330518333 | cpp |
p03196 | // #include <bits/stdc++.h>
// #define rep(i,n) for (int i = 0; i < (n); ++i)
// using namespace std;
// typedef long long ll;
//
//
//
// int main(){
// ll n,p;
// std::cin >> n>>p;
// if(n==1){
// std::cout << p << '\n';
// return 0;
// }
//
//
//
// //素数列挙
// ll now=2;
// std::vector<ll> pri(pow(p,(1.0/n))+3,1);
// for (int i = 2; i < pri.size(); i++) {
// if(pri[i]!=1)continue;
// else {
// if(i+i>=pri.size())continue;
// for (int j = i+i; j < pri.size(); j+=i)pri[j]=0;
// }
// }
//
// ll ans=1;
// ll i=1;
// while (1) {
// i++;
// if(pri.size()>i){
//
// if(pri[i]!=1)continue;
// ll temp =i;
// if(p%temp==0){
//
//
//
// int cnt=0;
// while (p%temp==0) {
// cnt++;
// p/=temp;
// }
//
// ans*=pow(i,cnt/n);
//
// }
// }else break;
// }
//
// std::cout << ans << '\n';
// return 0;
// }
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
ll n, p;
std::cin >> n >> p;
if (n == 1) {
std::cout << p << '\n';
return 0;
}
ll now = 2;
std::vector<ll> pri(pow(p, (1.0 / n)) + 3, 1);
for (int i = 2; i < pri.size(); i++) {
if (pri[i] != 1)
continue;
else {
if (i + i >= pri.size())
continue;
for (int j = i + i; j < pri.size(); j += i)
pri[j] = 0;
}
}
// rep(i,pri.size()){
// std::cout<<i <<":"<<pri[i] << '\n';
// }
ll ans = 1;
ll i = 1;
while (1) {
i++;
if (pri.size() > i) {
if (pri[i] != 1)
continue;
ll temp = pow(i, n);
if (p % temp == 0) {
int cnt = 0;
// std::cout <<i<<":"<< temp << '\n';
while (p % temp == 0) {
cnt++;
p /= temp;
}
// std::cout << pow(i,1/cnt) << '\n';
if (temp)
ans *= pow(i, 1 / cnt);
}
} else
break;
}
std::cout << ans << '\n';
return 0;
}
| // #include <bits/stdc++.h>
// #define rep(i,n) for (int i = 0; i < (n); ++i)
// using namespace std;
// typedef long long ll;
//
//
//
// int main(){
// ll n,p;
// std::cin >> n>>p;
// if(n==1){
// std::cout << p << '\n';
// return 0;
// }
//
//
//
// //素数列挙
// ll now=2;
// std::vector<ll> pri(pow(p,(1.0/n))+3,1);
// for (int i = 2; i < pri.size(); i++) {
// if(pri[i]!=1)continue;
// else {
// if(i+i>=pri.size())continue;
// for (int j = i+i; j < pri.size(); j+=i)pri[j]=0;
// }
// }
//
// ll ans=1;
// ll i=1;
// while (1) {
// i++;
// if(pri.size()>i){
//
// if(pri[i]!=1)continue;
// ll temp =i;
// if(p%temp==0){
//
//
//
// int cnt=0;
// while (p%temp==0) {
// cnt++;
// p/=temp;
// }
//
// ans*=pow(i,cnt/n);
//
// }
// }else break;
// }
//
// std::cout << ans << '\n';
// return 0;
// }
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
ll n, p;
std::cin >> n >> p;
if (n == 1) {
std::cout << p << '\n';
return 0;
}
ll now = 2;
std::vector<ll> pri(pow(p, (1.0 / n)) + 3, 1);
for (int i = 2; i < pri.size(); i++) {
if (pri[i] != 1)
continue;
else {
if (i + i >= pri.size())
continue;
for (int j = i + i; j < pri.size(); j += i)
pri[j] = 0;
}
}
// rep(i,pri.size()){
// std::cout<<i <<":"<<pri[i] << '\n';
// }
ll ans = 1;
ll i = 1;
while (1) {
i++;
if (pri.size() > i) {
if (pri[i] != 1)
continue;
ll temp = pow(i, n);
if (p % temp == 0) {
int cnt = 0;
// std::cout <<i<<":"<< temp << '\n';
while (p % temp == 0) {
cnt++;
p /= temp;
}
// std::cout << pow(i,cnt) << '\n';
if (temp)
ans *= pow(i, cnt);
}
} else
break;
}
std::cout << ans << '\n';
return 0;
}
| [
"expression.operation.binary.remove"
] | 990,846 | 990,847 | u280097533 | cpp |
p03196 | #include <bits/stdc++.h>
//----***やべーやつら***----
using namespace std;
#define int long long
//----***型定義***----
using ll = long long;
using P = pair<int, int>;
//----***Like a Pythonista***----
#define REP(ii, jj, nn) for (ll ii = jj; ii < (nn); ii++)
#define RREP(ii, nn, jj) for (ll ii = nn; jj < ii; ii--)
#define each(i, ...) for (auto &&i : __VA_ARGS__)
#define ALL(vec) (vec).begin(), (vec).end()
#define sum(...) accumulate(ALL(__VA_ARGS__), 0LL)
#define dsum(...) accumulate(ALL(__VA_ARGS__), 0.0)
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
template <class T> inline auto max(const T &a) { return *max_element(ALL(a)); }
template <class T> inline auto min(const T &a) { return *min_element(ALL(a)); }
inline ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
inline ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
//----***定数***----
#define MOD 1000000007
#define INF 100000000000000000
#define EPS 1e-9
const vector<vector<int>> DXY = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
//----***パーツ***----
#define fi first
#define se second
#define pb push_back
#define re return
#define br break
//----***入出力***---
void print() { std::cout << "\n"; }
template <class T> void print(const T &x) { std::cout << x << "\n"; }
template <class T, class... Args> void print(const T &x, const Args &...args) {
std::cout << x << " ";
print(args...);
}
#define debug(var) \
do { \
std::cerr << #var << " ↓ " \
<< "\n"; \
view(var); \
} while (0);
#define dbg cerr << "🥺🥺🥺🥺🥺🥺" << endl;
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
view(v);
}
}
//----***初期時読み込み***----
struct initial {
initial() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(15);
};
} initial_;
// 素因数分解
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
++res[i];
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
signed main() {
int N, P;
cin >> N >> P;
map<int, int> pf = prime_factor(P);
int ans = 1;
each(m, pf) {
if (m.se >= N) {
ans *= m.fi * (m.se / N);
}
}
print(ans);
}
| #include <bits/stdc++.h>
//----***やべーやつら***----
using namespace std;
#define int long long
//----***型定義***----
using ll = long long;
using P = pair<int, int>;
//----***Like a Pythonista***----
#define REP(ii, jj, nn) for (ll ii = jj; ii < (nn); ii++)
#define RREP(ii, nn, jj) for (ll ii = nn; jj < ii; ii--)
#define each(i, ...) for (auto &&i : __VA_ARGS__)
#define ALL(vec) (vec).begin(), (vec).end()
#define sum(...) accumulate(ALL(__VA_ARGS__), 0LL)
#define dsum(...) accumulate(ALL(__VA_ARGS__), 0.0)
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
template <class T> inline auto max(const T &a) { return *max_element(ALL(a)); }
template <class T> inline auto min(const T &a) { return *min_element(ALL(a)); }
inline ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
inline ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
//----***定数***----
#define MOD 1000000007
#define INF 100000000000000000
#define EPS 1e-9
const vector<vector<int>> DXY = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
//----***パーツ***----
#define fi first
#define se second
#define pb push_back
#define re return
#define br break
//----***入出力***---
void print() { std::cout << "\n"; }
template <class T> void print(const T &x) { std::cout << x << "\n"; }
template <class T, class... Args> void print(const T &x, const Args &...args) {
std::cout << x << " ";
print(args...);
}
#define debug(var) \
do { \
std::cerr << #var << " ↓ " \
<< "\n"; \
view(var); \
} while (0);
#define dbg cerr << "🥺🥺🥺🥺🥺🥺" << endl;
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
view(v);
}
}
//----***初期時読み込み***----
struct initial {
initial() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(15);
};
} initial_;
// 素因数分解
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
++res[i];
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
signed main() {
int N, P;
cin >> N >> P;
map<int, int> pf = prime_factor(P);
int ans = 1;
each(m, pf) {
// print(m.fi,m.se);
if (m.se >= N) {
ans *= powl(m.fi, (m.se / N));
}
}
print(ans);
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,864 | 990,865 | u526459074 | cpp |
p03196 | /*
PAIN demands to be felt
so do RE, TLE, MLE, SIGSEV & WA
*/
#include <bits/stdc++.h>
using namespace std;
// -----------------<fast IO>------------------
#define CIN \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define FLSH fflush(stdout)
#define fileIO(name) \
freopen(name ".in", "r", stdin); \
freopen(name ".out", "w", stdout);
#define PRECISION(x) cout << fixed << setprecision(x);
#define endl "\n"
// -----------------<Hardware instructions>------------------
#define onecount __builtin_popcount
#define bparity __builtin_parity(x)
#define leading0 __builtin_clz(x)
#define leftmostb __builtin_ctz(x)
// -----------------<Container manipulation / traversal
// macros>------------------
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define sz(x) ((int)((x).size()))
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define forn(i, a, b) for (int(i) = (a); (i) <= (b); (i)++)
#define fill(l, a) memset((l), (a), sizeof(l))
// -----------------<Some common useful functions>------------------
#define maX(a, b) ((a) > (b) ? (a) : (b))
#define miN(a, b) ((a) < (b) ? (a) : (b))
#define checkbit(n, b) ((n >> b) & 1)
#define INDEX(arr, i) (lower_bound(all(arr), i) - arr.begin())
#define in(b, a) ((b).find(a) != (b).end())
// -----------------<TypeDef Start>------------------
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef vector<std::vector<ll>> matrix;
typedef map<ll, ll> mii;
typedef vector<pii> vpii;
// -----------------<Constants>------------------
const int MAXN = 1000005;
const int SQRTN = 1003;
const int LOGN = 22;
const double PI = acos(-1);
const int INF = 1e9;
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
// -----------------<Modular Arithmetic>------------------
template <typename T> T gcd(T a, T b) { return (b ? __gcd(a, b) : a); }
template <typename T> T lcm(T a, T b) { return (a * (b / gcd(a, b))); }
template <typename T> T add(T a, T b, T c = MOD) {
T res = a + b;
return (res >= c ? res - c : res);
}
template <typename T> T mod_neg(T a, T b, T c = MOD) {
T res;
if (abs(a - b) < c)
res = a - b;
else
res = (a - b) % c;
return (res < 0 ? res + c : res);
}
template <typename T> T mul(T a, T b, T c = MOD) {
ll res = (ll)a * b;
return (res >= c ? res % c : res);
}
inline ll mulmod(ll a, ll b, ll m = MOD) {
ll q = (ll)(((ld)a * (ld)b) / (ld)m);
ll r = a * b - q * m;
if (r > m)
r %= m;
if (r < 0)
r += m;
return r;
}
template <typename T> T expo(T e, T n) {
T x = 1, p = e;
while (n) {
if (n & 1)
x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T> T power(T e, T n, T m = MOD) {
T x = 1, p = e;
while (n) {
if (n & 1)
x = mul(x, p, m);
p = mul(p, p, m);
n >>= 1;
}
return x;
}
template <typename T> T extended_euclid(T a, T b, T &x, T &y) {
T xx = 0, yy = 1;
y = 0;
x = 1;
while (b) {
T q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
template <typename T> T mod_inverse(T a, T n = MOD) {
T x, y, z = 0;
T d = extended_euclid(a, n, x, y);
return (d > 1 ? -1 : mod_neg(x, z, n));
}
// ------------------nCr---------------------------
/*
ll modInverse(ll n, ll p){return power(n, p-2);}
ll nCr(ll n, ll r, ll p=MOD){if (r==0) return 1;ll
fac[n+1];fac[0]=1;for(lli=1;i<=n;i++)fac[i]=fac[i-1]*i%p; return
(fac[n]*modInverse(fac[r],p)%p*modInverse(fac[n-r], p)%p)%p;}
*/
//-----------------sieve--------------------------
/*
bool C[MAX];
// ll C[MAX]={0};
//vi V1;
void sieve(){
ll i,j;
for(i=2;i<MAX;i++){if(!C[i]){
// V1.pb(i);
for(j=2*i;j<MAX;j=j+i){C[j]=true;}}}}
*/
//---------------------D-S-U-------------------
/*
long long int parent[MAX];
long long int size[MAX];
void initialise()
{ //cout<<MAX<<" ";
for(long long int i=0;i<MAX;i++)
{
parent[i]=i;
//cout<<i<<" ";
size[i]=1;
}
}
long long int root(long long int x)
{
while(x!=parent[x])
{
parent[x]=parent[parent[x]];
x=parent[x];
}
return x;
}
void union1(long long int x,long long int y)
{
if(size[x]>=size[y])
{
size[x]+=size[y];
parent[y]=x;
}
else
{
size[y]+=size[x];
parent[x]=y;
}
}*/
// --------------------------------------------------</TEMPLATE>--------------------------------------------------
void it_2107() {
ll k = 0, a, b, n = 0, x = 0, m = 0, curr = 0, num = 0, n1 = 0, n2 = 0,
n3 = 0, n4 = 0, i = 0, j = 0;
ll root = 0, sum = 0, diff = 0, q = 0, choice = 0, d = 0, len = 0, beg = 0,
end = 0, pos = 0, cnt = 0;
ll lo = LLONG_MAX, hi = 0, mid = 0, ans = 1, s;
bool flag = false;
string s1, s2, s3, str;
char ch, ch1, ch2, ch3, *ptr;
double dub = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
cin >> n >> root;
vi pff, cntt;
if (root % 2 == 0) {
pff.pb(2);
while (root % 2 == 0) {
root /= 2;
cnt++;
}
cntt.pb(cnt);
n1 = cnt / n;
ans *= pow(2, n1);
}
for (i = 3; i < sqrt(root); i += 2) {
if (root % i == 0) {
pff.pb(i);
cnt = 0;
while (root % i == 0) {
root /= i;
cnt++;
}
cntt.pb(cnt);
n1 = cnt / n;
ans *= pow(i, n1);
}
}
if (root > 1) {
n1 = 1 / n;
ans *= pow(root, n1);
}
cout << ans;
}
int main() {
CIN;
int t = 1;
// cin>>t;
while (t--) {
it_2107();
}
return 0;
}
| /*
PAIN demands to be felt
so do RE, TLE, MLE, SIGSEV & WA
*/
#include <bits/stdc++.h>
using namespace std;
// -----------------<fast IO>------------------
#define CIN \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define FLSH fflush(stdout)
#define fileIO(name) \
freopen(name ".in", "r", stdin); \
freopen(name ".out", "w", stdout);
#define PRECISION(x) cout << fixed << setprecision(x);
#define endl "\n"
// -----------------<Hardware instructions>------------------
#define onecount __builtin_popcount
#define bparity __builtin_parity(x)
#define leading0 __builtin_clz(x)
#define leftmostb __builtin_ctz(x)
// -----------------<Container manipulation / traversal
// macros>------------------
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define sz(x) ((int)((x).size()))
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define forn(i, a, b) for (int(i) = (a); (i) <= (b); (i)++)
#define fill(l, a) memset((l), (a), sizeof(l))
// -----------------<Some common useful functions>------------------
#define maX(a, b) ((a) > (b) ? (a) : (b))
#define miN(a, b) ((a) < (b) ? (a) : (b))
#define checkbit(n, b) ((n >> b) & 1)
#define INDEX(arr, i) (lower_bound(all(arr), i) - arr.begin())
#define in(b, a) ((b).find(a) != (b).end())
// -----------------<TypeDef Start>------------------
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef vector<std::vector<ll>> matrix;
typedef map<ll, ll> mii;
typedef vector<pii> vpii;
// -----------------<Constants>------------------
const int MAXN = 1000005;
const int SQRTN = 1003;
const int LOGN = 22;
const double PI = acos(-1);
const int INF = 1e9;
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
// -----------------<Modular Arithmetic>------------------
template <typename T> T gcd(T a, T b) { return (b ? __gcd(a, b) : a); }
template <typename T> T lcm(T a, T b) { return (a * (b / gcd(a, b))); }
template <typename T> T add(T a, T b, T c = MOD) {
T res = a + b;
return (res >= c ? res - c : res);
}
template <typename T> T mod_neg(T a, T b, T c = MOD) {
T res;
if (abs(a - b) < c)
res = a - b;
else
res = (a - b) % c;
return (res < 0 ? res + c : res);
}
template <typename T> T mul(T a, T b, T c = MOD) {
ll res = (ll)a * b;
return (res >= c ? res % c : res);
}
inline ll mulmod(ll a, ll b, ll m = MOD) {
ll q = (ll)(((ld)a * (ld)b) / (ld)m);
ll r = a * b - q * m;
if (r > m)
r %= m;
if (r < 0)
r += m;
return r;
}
template <typename T> T expo(T e, T n) {
T x = 1, p = e;
while (n) {
if (n & 1)
x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T> T power(T e, T n, T m = MOD) {
T x = 1, p = e;
while (n) {
if (n & 1)
x = mul(x, p, m);
p = mul(p, p, m);
n >>= 1;
}
return x;
}
template <typename T> T extended_euclid(T a, T b, T &x, T &y) {
T xx = 0, yy = 1;
y = 0;
x = 1;
while (b) {
T q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
template <typename T> T mod_inverse(T a, T n = MOD) {
T x, y, z = 0;
T d = extended_euclid(a, n, x, y);
return (d > 1 ? -1 : mod_neg(x, z, n));
}
// ------------------nCr---------------------------
/*
ll modInverse(ll n, ll p){return power(n, p-2);}
ll nCr(ll n, ll r, ll p=MOD){if (r==0) return 1;ll
fac[n+1];fac[0]=1;for(lli=1;i<=n;i++)fac[i]=fac[i-1]*i%p; return
(fac[n]*modInverse(fac[r],p)%p*modInverse(fac[n-r], p)%p)%p;}
*/
//-----------------sieve--------------------------
/*
bool C[MAX];
// ll C[MAX]={0};
//vi V1;
void sieve(){
ll i,j;
for(i=2;i<MAX;i++){if(!C[i]){
// V1.pb(i);
for(j=2*i;j<MAX;j=j+i){C[j]=true;}}}}
*/
//---------------------D-S-U-------------------
/*
long long int parent[MAX];
long long int size[MAX];
void initialise()
{ //cout<<MAX<<" ";
for(long long int i=0;i<MAX;i++)
{
parent[i]=i;
//cout<<i<<" ";
size[i]=1;
}
}
long long int root(long long int x)
{
while(x!=parent[x])
{
parent[x]=parent[parent[x]];
x=parent[x];
}
return x;
}
void union1(long long int x,long long int y)
{
if(size[x]>=size[y])
{
size[x]+=size[y];
parent[y]=x;
}
else
{
size[y]+=size[x];
parent[x]=y;
}
}*/
// --------------------------------------------------</TEMPLATE>--------------------------------------------------
void it_2107() {
ll k = 0, a, b, n = 0, x = 0, m = 0, curr = 0, num = 0, n1 = 0, n2 = 0,
n3 = 0, n4 = 0, i = 0, j = 0;
ll root = 0, sum = 0, diff = 0, q = 0, choice = 0, d = 0, len = 0, beg = 0,
end = 0, pos = 0, cnt = 0;
ll lo = LLONG_MAX, hi = 0, mid = 0, ans = 1, s;
bool flag = false;
string s1, s2, s3, str;
char ch, ch1, ch2, ch3, *ptr;
double dub = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
cin >> n >> root;
vi pff, cntt;
if (root % 2 == 0) {
pff.pb(2);
while (root % 2 == 0) {
root /= 2;
cnt++;
}
cntt.pb(cnt);
n1 = cnt / n;
ans *= pow(2, n1);
}
for (i = 3; i <= sqrt(root); i += 2) {
if (root % i == 0) {
pff.pb(i);
cnt = 0;
while (root % i == 0) {
root /= i;
cnt++;
}
cntt.pb(cnt);
n1 = cnt / n;
ans *= pow(i, n1);
}
}
if (root > 1) {
n1 = 1 / n;
ans *= pow(root, n1);
}
cout << ans;
}
int main() {
CIN;
int t = 1;
// cin>>t;
while (t--) {
it_2107();
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,868 | 990,869 | u342003594 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
ll n, p;
cin >> n >> p;
ll p1 = pow(p, 1.0 / n);
// cout<<p1<<endl;
for (ll i = p1; i >= 1; --i) {
ll tmp = pow(i, n);
if (p % tmp == 0) {
cout << i << endl;
return 0;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
ll n, p;
cin >> n >> p;
ll p1 = pow(p, 1.0 / n);
// cout<<p1<<endl;
for (ll i = p1 + 100; i >= 1; --i) {
ll tmp = pow(i, n);
if (p % tmp == 0) {
cout << i << endl;
return 0;
}
}
return 0;
} | [
"control_flow.loop.for.initializer.change"
] | 990,870 | 990,871 | u933962236 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n, p, i, ans = 1, a;
scanf("%lld %lld\n", &n, &p);
a = p;
for (i = 2; i * i <= p; i++) {
if (a % i != 0) {
continue;
}
ll res = 0;
while (a % i == 0) {
res++;
a = a / i;
}
if (res >= n) {
ans = ans * i * (res / n);
}
}
if (a != 0 && n == 1) {
ans = ans * a;
}
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n, p, i, ans = 1, a;
scanf("%lld %lld\n", &n, &p);
a = p;
for (i = 2; i * i <= p; i++) {
if (a % i != 0) {
continue;
}
ll res = 0;
while (a % i == 0) {
res++;
a = a / i;
}
if (res >= n) {
ans = ans * pow(i, res / n);
}
}
if (a != 0 && n == 1) {
ans = ans * a;
}
printf("%lld\n", ans);
return 0;
} | [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 990,905 | 990,906 | u265187423 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
vector<pair<long long, long long>> prime_foctorize(long long N) {
vector<pair<long long, long long>> res;
for (long long i = 2; i * i < N; i++) {
if (N % i != 0)
continue;
long long ex = 0;
while (N % i == 0) {
ex++;
N /= i;
}
res.push_back({i, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
int main() {
long long N, P;
cin >> N >> P;
const auto &pf = prime_foctorize(P);
long long ans = 1;
for (auto p : pf) {
for (int i = 0; i < p.second / N; ++i)
ans *= p.first;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
vector<pair<long long, long long>> prime_foctorize(long long N) {
vector<pair<long long, long long>> res;
for (long long i = 2; i * i <= N; i++) {
if (N % i != 0)
continue;
long long ex = 0;
while (N % i == 0) {
ex++;
N /= i;
}
res.push_back({i, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
int main() {
long long N, P;
cin >> N >> P;
const auto &pf = prime_foctorize(P);
long long ans = 1;
for (auto p : pf) {
for (int i = 0; i < p.second / N; ++i)
ans *= p.first;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,907 | 990,908 | u533566373 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ll long long
void prime_factorize(ll N, map<ll, ll> &res) {
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res[a] = ex;
}
// 最後に残った数について
if (N != 1)
res[N] = 1;
}
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
map<ll, ll> mp;
prime_factorize(p, mp);
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
ll res = (itr->second) / n;
if (res)
ans *= itr->first * res;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ll long long
void prime_factorize(ll N, map<ll, ll> &res) {
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
res[a] = ex;
}
// 最後に残った数について
if (N != 1)
res[N] = 1;
}
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
map<ll, ll> mp;
prime_factorize(p, mp);
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
// cout << itr->first << ' ' << itr->second << endl;
ll res = (itr->second) / n;
rep(i, res) ans *= itr->first;
}
cout << ans << endl;
return 0;
} | [
"assignment.variable.change",
"call.arguments.add",
"expression.operation.binary.remove"
] | 990,909 | 990,910 | u702686470 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define PI acos(-1)
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
ll mod = 1e9 + 7;
int main() {
fast_io
ll n,
p;
cin >> n >> p;
ll ans = 1;
for (ll i = 2; i * i <= p; i++) {
int num = 0;
while (p % i == 0) {
num++;
p /= i;
}
int cnt = num / n;
for (int j = 0; j < cnt; j++)
ans *= i;
}
if (ans == 1)
ans *= p;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define PI acos(-1)
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
ll mod = 1e9 + 7;
int main() {
fast_io
ll n,
p;
cin >> n >> p;
ll ans = 1;
for (ll i = 2; i * i <= p; i++) {
int num = 0;
while (p % i == 0) {
num++;
p /= i;
}
int cnt = num / n;
for (int j = 0; j < cnt; j++)
ans *= i;
}
if (n == 1)
ans *= p;
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 990,913 | 990,914 | u679159704 | cpp |
p03196 | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
map<int, int> mp;
int ans = 1;
int M = K;
if (N == 1) {
cout << K << endl;
return 0;
}
for (int i = 2; i * i <= K; i++) {
while (M % i == 0) {
mp[i]++;
if (mp[i] >= N) {
ans *= i;
break;
}
M /= i;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
map<int, int> mp;
int ans = 1;
int M = K;
if (N == 1) {
cout << K << endl;
return 0;
}
for (int i = 2; i * i <= K; i++) {
while (M % i == 0) {
mp[i]++;
if (mp[i] >= N) {
ans *= i;
mp[i] = 0;
}
M /= i;
}
}
cout << ans << endl;
} | [
"assignment.variable.change",
"assignment.change"
] | 990,917 | 990,918 | u415916075 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n); 1 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n) + 1; 1 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
cout << ans << endl;
}
| [
"control_flow.loop.for.initializer.change"
] | 990,921 | 990,922 | u050087249 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n); 0 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll n, p;
cin >> n >> p;
ll ans = 0;
for (ll i = pow(p, 1.0 / n) + 1; 1 <= i; i--) {
ll tmp = pow(i, n);
if (p % tmp != 0)
continue;
ans = i;
break;
}
cout << ans << endl;
}
| [
"control_flow.loop.for.initializer.change",
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 990,923 | 990,922 | u050087249 | cpp |
p03196 | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
#define ALL(c) (c).begin(), (c).end()
#define PB push_back
#define MP make_pair
#define SORT_ASC(c) sort(ALL(c))
//#define SORT_DESC(c) sort(ALL(c), greater<typeof(*((c).begin()))>())
#define SORT_DESC(c) sort((c).rbegin(), (c).rend())
#define REV(c) reverse((c).begin(), (c).end())
#define SIZE(a) int((a).size())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ROF(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define PER(i, n) ROF(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int LARGE_INT = 1e9 + 100;
const int INF = 2e9 + 100;
const LL INF_LL = (LL)INF * 300 * 300;
const int MOD = 1e9 + 7;
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL modpow(LL a, LL n) {
LL res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
void Main() {
LL n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return;
}
LL result = 1;
LL p2 = p;
for (LL i = 2; i * i <= p2 + 100; i++) {
LL sum = 0;
while (p % i == 0) {
sum++;
p /= i;
}
if (sum >= n) {
result *= (LL)(sum / n) * i;
}
}
cout << result << endl;
return;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
#define ALL(c) (c).begin(), (c).end()
#define PB push_back
#define MP make_pair
#define SORT_ASC(c) sort(ALL(c))
//#define SORT_DESC(c) sort(ALL(c), greater<typeof(*((c).begin()))>())
#define SORT_DESC(c) sort((c).rbegin(), (c).rend())
#define REV(c) reverse((c).begin(), (c).end())
#define SIZE(a) int((a).size())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ROF(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define PER(i, n) ROF(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int LARGE_INT = 1e9 + 100;
const int INF = 2e9 + 100;
const LL INF_LL = (LL)INF * 300 * 300;
const int MOD = 1e9 + 7;
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL modpow(LL a, LL n) {
LL res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
void Main() {
LL n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return;
}
LL result = 1;
LL p2 = p;
for (LL i = 2; i * i <= p2 + 100; i++) {
LL sum = 0;
while (p % i == 0) {
sum++;
p /= i;
}
if (sum >= n) {
result *= modpow(i, (LL)(sum / n));
}
}
cout << result << endl;
return;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 990,928 | 990,929 | u987591601 | cpp |
p03196 | // int a = stoi(c); 文字列をintへ
//小文字から大文字
// transform(a.begin(), a.end(), a.begin(), ::toupper);
//途中の出力をそのまま残さない
//数値計算 個数以外はdouble
// map<キー,値> p は辞書。p[キー] = 値
// map 全探索
// auto begin = p.begin(), end = p.end();
// for (auto it = begin; it != end; it++) {}
// mapのキー：it->first mapのバリュー：it->second
//絶対値 abs()
//入力は空白で切れる
//大文字判定 isupper(文字) 小文字判定 islower(文字)
// do{}while(next_permutation(ALL(配列)))
// while(N)で回すとき、Nはコピーを作っておく
//小文字に対応する文字コード：S[i] - 'a'
//文字コード→小文字：(char)(数字+'a')
//グラフの距離:隣接行列で扱う
//等価なものに変換する思考
// bool型 初期値はTrue
//島渡りの問題：中間ノードに着目
//配列はvector<>を使う：意味わからないエラーがなくなる。
//背反な事象にちゃんとわける
//チェックリストはマップを使う
//数が大きい時の比較はstring型で行う
//全て0になったか調べたい->0になるたびにcntする
//またはかかつか
//例外処理は最初にする
// x = p^m + q^n...の約数の個数:(n+1)*(m+1)....
// N!のどの素因数で何回割れるか
//⇔1~Nまでの数がそれぞれどの素因数で何回割り切れるかの和
//パズルの問題->一般化して全探索
//数が大きい時のせぐふぉはコードテストで試してみる
//スペルミスに注意
// stack<ll> s;
// s.push(要素);s.top();s.pop();
// queue<ll> q;
// q.push(要素);q.front();q.pop();
//同じ作業繰り返す系の問題：収束先を見つける
//関係性は隣接行列で記録
//過半数：N/2.0で判定
//ある量からある量を引く系の問題：端から定義してやる
#include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < N; i++)
#define ALL(a) (a).begin(), (a).end()
#define ll long long int
using namespace std;
//円周率
const double PI = 3.14159265358979323846;
//割るやつ
const ll M = (pow(10, 9) + 7);
// K進数でのNの桁数
ll dig(ll N, ll K) {
ll dig = 0;
while (N) {
dig++;
N /= K;
}
return dig;
}
// a,bの最大公約数
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
// a,bの最小公倍数
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
// nC2の計算
ll C(ll N) { return N * (N - 1) / 2; }
//階乗計算
ll f(ll n) {
if (n == 0 || n == 1)
return 1;
else
return (n * f(n - 1)) % M;
}
// Nをdで何回割れるか
ll divcnt(ll N, ll d) {
ll ans = 0;
while (1) {
if (N % d == 0) {
ans++;
N /= d;
} else
break;
}
return ans;
}
//素数判定
bool prime(ll num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
//フィボナッチ数列
vector<ll> memo(pow(10, 6) + 1);
ll fibo(ll n) {
if (n == 1)
return 1;
else if (n == 2)
return 1;
else if (memo[n] != 0)
return memo[n];
else
return memo[n] = fibo(n - 1) + f(n - 2);
}
int main() {
double N;
ll P;
cin >> N >> P;
double num = pow(P, 1 / N);
ll C = ceil(num);
for (ll n = num; n >= 1; n--) {
ll x = pow(n, N);
if (P % x == 0) {
cout << n << endl;
return 0;
}
}
} | // int a = stoi(c); 文字列をintへ
//小文字から大文字
// transform(a.begin(), a.end(), a.begin(), ::toupper);
//途中の出力をそのまま残さない
//数値計算 個数以外はdouble
// map<キー,値> p は辞書。p[キー] = 値
// map 全探索
// auto begin = p.begin(), end = p.end();
// for (auto it = begin; it != end; it++) {}
// mapのキー：it->first mapのバリュー：it->second
//絶対値 abs()
//入力は空白で切れる
//大文字判定 isupper(文字) 小文字判定 islower(文字)
// do{}while(next_permutation(ALL(配列)))
// while(N)で回すとき、Nはコピーを作っておく
//小文字に対応する文字コード：S[i] - 'a'
//文字コード→小文字：(char)(数字+'a')
//グラフの距離:隣接行列で扱う
//等価なものに変換する思考
// bool型 初期値はTrue
//島渡りの問題：中間ノードに着目
//配列はvector<>を使う：意味わからないエラーがなくなる。
//背反な事象にちゃんとわける
//チェックリストはマップを使う
//数が大きい時の比較はstring型で行う
//全て0になったか調べたい->0になるたびにcntする
//またはかかつか
//例外処理は最初にする
// x = p^m + q^n...の約数の個数:(n+1)*(m+1)....
// N!のどの素因数で何回割れるか
//⇔1~Nまでの数がそれぞれどの素因数で何回割り切れるかの和
//パズルの問題->一般化して全探索
//数が大きい時のせぐふぉはコードテストで試してみる
//スペルミスに注意
// stack<ll> s;
// s.push(要素);s.top();s.pop();
// queue<ll> q;
// q.push(要素);q.front();q.pop();
//同じ作業繰り返す系の問題：収束先を見つける
//関係性は隣接行列で記録
//過半数：N/2.0で判定
//ある量からある量を引く系の問題：端から定義してやる
#include <bits/stdc++.h>
#define rep(i, N) for (int i = 0; i < N; i++)
#define ALL(a) (a).begin(), (a).end()
#define ll long long int
using namespace std;
//円周率
const double PI = 3.14159265358979323846;
//割るやつ
const ll M = (pow(10, 9) + 7);
// K進数でのNの桁数
ll dig(ll N, ll K) {
ll dig = 0;
while (N) {
dig++;
N /= K;
}
return dig;
}
// a,bの最大公約数
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
// a,bの最小公倍数
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
// nC2の計算
ll C(ll N) { return N * (N - 1) / 2; }
//階乗計算
ll f(ll n) {
if (n == 0 || n == 1)
return 1;
else
return (n * f(n - 1)) % M;
}
// Nをdで何回割れるか
ll divcnt(ll N, ll d) {
ll ans = 0;
while (1) {
if (N % d == 0) {
ans++;
N /= d;
} else
break;
}
return ans;
}
//素数判定
bool prime(ll num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
//フィボナッチ数列
vector<ll> memo(pow(10, 6) + 1);
ll fibo(ll n) {
if (n == 1)
return 1;
else if (n == 2)
return 1;
else if (memo[n] != 0)
return memo[n];
else
return memo[n] = fibo(n - 1) + f(n - 2);
}
int main() {
double N;
ll P;
cin >> N >> P;
double num = pow(P, 1 / N);
ll C = ceil(num);
for (ll n = C; n >= 1; n--) {
ll x = pow(n, N);
if (P % x == 0) {
cout << n << endl;
return 0;
}
}
} | [
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.initializer.change"
] | 990,941 | 990,942 | u565692645 | cpp |
p03196 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
// Optimisations
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("O2")
// shortcuts for functions
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define endl "\n"
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define th(n) cout << n << endl
#define gc getchar_unlocked
#define ms(s, n) memset(s, n, sizeof(s))
#define prec(n) fixed << setprecision(n)
// make it python
#define gcd __gcd
#define append push_back
#define str to_string
#define stringtoll stoll
#define upper(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
// utility functions shortcuts
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define sswap(a, b) \
{ \
a = a ^ b; \
b = a ^ b; \
a = a ^ b; \
}
#define swap(a, b) \
{ \
auto temp = a; \
a = b; \
b = temp; \
}
#define set0(dp) memset(dp, 0, sizeof(dp));
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define SORT(v) sort(all(v))
#define forr(i, n) for (ll i = 0; i < n; i++)
#define formatrix(i, n) for (ll i = 0; i < n; i++, cout << "\n")
#define eof (scanf("%d", &n)) != EOF
// declaration shortcuts
#define vll vector<ll>
#define vvl vector<vector<ll>>
#define vpll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define ppl pair<ll, pll>
#define ull unsigned long long
#define ll long long
#define mll map<ll, ll>
#define sll set<ll>
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define uni(v) v.erase(unique(v.begin(), v.end()), v.end());
#define ini(a, v) memset(a, v, sizeof(a))
template <typename T>
using MinPriorityQueue = priority_queue<T, vector<T>, greater<T>>;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
// Constants
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr ll inf = 1999999999999999997;
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr auto MOD = 1000000007;
constexpr auto MOD9 = 1000000009;
constexpr auto maxn = 200006;
// Debugging
#define n_l '\n'
#define dbg(...) \
cout << "[" << #__VA_ARGS__ << "]: "; \
cout << to_string(__VA_ARGS__) << endl
template <typename T, size_t N> int SIZE(const T (&t)[N]) { return N; }
template <typename T> int SIZE(const T &t) { return t.size(); }
string to_string(string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(char c) { return string({c}); }
template <size_t N> string to_string(bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B> string to_string(pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0)
res += n_l;
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += n_l;
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0)
res += n_l;
return res;
}
void dbgs() { ; }
template <typename Heads, typename... Tails> void dbgs(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgs(T...);
}
#define dbgm(...) \
cout << "[" << #__VA_ARGS__ << "]: "; \
dbgs(__VA_ARGS__); \
cout << endl;
vector<pair<ll, ll>> PrimeFact(ll x) {
vector<pair<ll, ll>> ans;
for (ll i = 2; i * i <= x; i++) {
if (x % i == 0) {
ll cnt = 0;
while (x % i == 0) {
x /= i;
cnt++;
}
ans.pb(i, cnt);
}
}
if (x > 1)
ans.pb(x, 1);
return ans;
}
vector<ll> Divisors(ll x) {
vector<ll> ans;
for (ll i = 1; i * i <= x; i++) {
if (x % i == 0) {
ans.pb(i);
if (x / i != i)
ans.pb(x / i);
}
}
return ans;
}
ll expo(ll base, ll exponent, ll mod) {
ll ans = 1;
while (exponent != 0) {
if (exponent & 1)
ans = (1LL * ans * base) % mod;
base = (1LL * base * base) % mod;
exponent >>= 1;
}
return ans % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, p;
cin >> n >> p;
auto ans = PrimeFact(p);
dbg(ans);
if (n == 1) {
cout << p;
return 0;
}
ll res = 1;
for (auto x : ans) {
ll curr = expo(x.ff, x.ss / n, mod);
res *= curr;
}
th(res);
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
// Optimisations
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("O2")
// shortcuts for functions
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define endl "\n"
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define th(n) cout << n << endl
#define gc getchar_unlocked
#define ms(s, n) memset(s, n, sizeof(s))
#define prec(n) fixed << setprecision(n)
// make it python
#define gcd __gcd
#define append push_back
#define str to_string
#define stringtoll stoll
#define upper(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
// utility functions shortcuts
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define sswap(a, b) \
{ \
a = a ^ b; \
b = a ^ b; \
a = a ^ b; \
}
#define swap(a, b) \
{ \
auto temp = a; \
a = b; \
b = temp; \
}
#define set0(dp) memset(dp, 0, sizeof(dp));
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define SORT(v) sort(all(v))
#define forr(i, n) for (ll i = 0; i < n; i++)
#define formatrix(i, n) for (ll i = 0; i < n; i++, cout << "\n")
#define eof (scanf("%d", &n)) != EOF
// declaration shortcuts
#define vll vector<ll>
#define vvl vector<vector<ll>>
#define vpll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define ppl pair<ll, pll>
#define ull unsigned long long
#define ll long long
#define mll map<ll, ll>
#define sll set<ll>
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define uni(v) v.erase(unique(v.begin(), v.end()), v.end());
#define ini(a, v) memset(a, v, sizeof(a))
template <typename T>
using MinPriorityQueue = priority_queue<T, vector<T>, greater<T>>;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
// Constants
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr ll inf = 1999999999999999997;
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr auto MOD = 1000000007;
constexpr auto MOD9 = 1000000009;
constexpr auto maxn = 200006;
// Debugging
#define n_l '\n'
#define dbg(...) \
cout << "[" << #__VA_ARGS__ << "]: "; \
cout << to_string(__VA_ARGS__) << endl
template <typename T, size_t N> int SIZE(const T (&t)[N]) { return N; }
template <typename T> int SIZE(const T &t) { return t.size(); }
string to_string(string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(char c) { return string({c}); }
template <size_t N> string to_string(bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B> string to_string(pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0)
res += n_l;
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += n_l;
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0)
res += n_l;
return res;
}
void dbgs() { ; }
template <typename Heads, typename... Tails> void dbgs(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgs(T...);
}
#define dbgm(...) \
cout << "[" << #__VA_ARGS__ << "]: "; \
dbgs(__VA_ARGS__); \
cout << endl;
vector<pair<ll, ll>> PrimeFact(ll x) {
vector<pair<ll, ll>> ans;
for (ll i = 2; i * i <= x; i++) {
if (x % i == 0) {
ll cnt = 0;
while (x % i == 0) {
x /= i;
cnt++;
}
ans.pb(i, cnt);
}
}
if (x > 1)
ans.pb(x, 1);
return ans;
}
vector<ll> Divisors(ll x) {
vector<ll> ans;
for (ll i = 1; i * i <= x; i++) {
if (x % i == 0) {
ans.pb(i);
if (x / i != i)
ans.pb(x / i);
}
}
return ans;
}
ll expo(ll base, ll exponent, ll mod) {
ll ans = 1;
while (exponent != 0) {
if (exponent & 1)
ans = (1LL * ans * base) % mod;
base = (1LL * base * base) % mod;
exponent >>= 1;
}
return ans % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, p;
cin >> n >> p;
auto ans = PrimeFact(p);
// dbg(ans);
if (n == 1) {
cout << p;
return 0;
}
ll res = 1;
for (auto x : ans) {
ll curr = expo(x.ff, x.ss / n, mod);
res *= curr;
}
th(res);
}
| [
"call.remove"
] | 990,945 | 990,946 | u996003680 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define MOD 1000000007
#define MOD2 998244353
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
vector<pair<int64_t, int64_t>> prime_factorize(int64_t n) {
vector<pair<int64_t, int64_t>> ret;
for (int64_t i = 2; i * i <= n; i++) {
if (n % i != 0)
continue;
int64_t ex = 0;
while (n % i == 0) {
ex++;
n /= i;
}
ret.push_back({i, ex});
}
if (n != 1)
ret.push_back({n, 1});
return ret;
}
int main() {
Int n, p;
cin >> n >> p;
const auto &pf = prime_factorize(p);
Int ans = 1;
for (auto i : pf) {
if (i.second >= n)
ans *= i.first * (i.second / n);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define MOD 1000000007
#define MOD2 998244353
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
vector<pair<int64_t, int64_t>> prime_factorize(int64_t n) {
vector<pair<int64_t, int64_t>> ret;
for (int64_t i = 2; i * i <= n; i++) {
if (n % i != 0)
continue;
int64_t ex = 0;
while (n % i == 0) {
ex++;
n /= i;
}
ret.push_back({i, ex});
}
if (n != 1)
ret.push_back({n, 1});
return ret;
}
int main() {
Int n, p;
cin >> n >> p;
const auto &pf = prime_factorize(p);
Int ans = 1;
for (auto i : pf) {
if (i.second >= n)
ans *= pow(i.first, (i.second / n));
}
cout << ans << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,955 | 990,956 | u868237899 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, P;
cin >> N >> P;
long long pp;
pp = int(pow(P, 0.5));
vector<long long> prime(pp + 1, 0);
for (long long i = 2; i <= P && i <= pp; i++) {
while (P % i == 0) {
P = P / i;
prime.at(i)++;
}
}
long long ans = 1;
for (long long i = 2; i <= pp; i++) {
ans = ans * pow(i, prime.at(i) / N);
}
if (ans == 1 && N == 1) {
ans = ans * P;
}
printf("%lld\n", ans);
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, P;
cin >> N >> P;
long long pp;
pp = int(pow(P, 0.5));
vector<long long> prime(pp + 1, 0);
for (long long i = 2; i <= P && i <= pp; i++) {
while (P % i == 0) {
P = P / i;
prime.at(i)++;
}
}
long long ans = 1;
for (long long i = 2; i <= pp; i++) {
ans = ans * pow(i, prime.at(i) / N);
}
if (N == 1) {
ans = ans * P;
}
printf("%lld\n", ans);
} | [
"expression.operation.binary.remove"
] | 990,964 | 990,965 | u478462004 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define FOR(i, l, r) for (i = l; i < r; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define P pair<ll, ll>
#define F first
#define S second
#define VEC vector
#define V VEC<ll>
signed main() {
ll N, Q, ans;
cin >> N >> Q;
if (N > 39)
ans = 1;
else if (N == 1)
ans = Q;
else {
ans = pow((double)Q, 1.00000 / (double)N);
while (1) {
ll i, S = 1;
REP(i, N) S *= ans;
if (Q % S == 0)
break;
ans--;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define FOR(i, l, r) for (i = l; i < r; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define P pair<ll, ll>
#define F first
#define S second
#define VEC vector
#define V VEC<ll>
signed main() {
ll N, Q, ans;
cin >> N >> Q;
if (N > 39)
ans = 1;
else if (N == 1)
ans = Q;
else {
ans = 1 + pow((double)Q, 1.00000 / (double)N);
while (1) {
ll i, S = 1;
REP(i, N) S *= ans;
if (Q % S == 0)
break;
ans--;
}
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 990,966 | 990,967 | u820224016 | cpp |
p03196 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#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 ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << '\n'
ll prime(ll n) {
int n_root = sqrt(n);
if (n == 1)
return 1;
else if (n % 2 == 0)
return 2;
for (int i = 3; i < n_root + 1; i += 2) {
if (n % i == 0)
return n / i;
}
return n;
}
int main() {
ll n, p;
cin >> n >> p;
map<ll, int> mp;
while (p > 1) {
ll num = prime(p);
mp[num]++;
p /= num;
}
ll ans = 1;
for (const auto &x : mp) {
ll num1 = x.first;
int num2 = x.second;
if (num2 >= n)
ans *= num1 * (num2 / n);
}
COUT(ans);
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#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 ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << '\n'
ll prime(ll n) {
int n_root = sqrt(n);
if (n == 1)
return 1;
else if (n % 2 == 0)
return 2;
for (int i = 3; i < n_root + 1; i += 2) {
if (n % i == 0)
return i;
}
return n;
}
int main() {
ll n, p;
cin >> n >> p;
map<ll, int> mp;
while (p > 1) {
ll num = prime(p);
mp[num]++;
p /= num;
}
ll ans = 1;
for (const auto &x : mp) {
ll num1 = x.first;
int num2 = x.second;
if (num2 >= n)
ans *= pow(num1, (num2 / n));
}
COUT(ans);
return 0;
} | [
"expression.operation.binary.remove",
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,968 | 990,969 | u459105164 | cpp |
p03196 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#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 ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << '\n'
ll prime(ll n) {
int n_root = sqrt(n);
if (n == 1)
return 1;
else if (n % 2 == 0)
return 2;
for (int i = 3; i < n_root + 1; i += 2) {
if (n % i == 0)
return i;
}
return n;
}
int main() {
ll n, p;
cin >> n >> p;
map<ll, int> mp;
while (p != 1) {
ll num = prime(p);
mp[num]++;
p /= num;
}
ll ans = 1;
for (const auto &x : mp) {
ll num1 = x.first;
int num2 = x.second;
if (num2 >= n)
ans *= num1 * (num2 / n);
}
COUT(ans);
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#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 ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << '\n'
ll prime(ll n) {
int n_root = sqrt(n);
if (n == 1)
return 1;
else if (n % 2 == 0)
return 2;
for (int i = 3; i < n_root + 1; i += 2) {
if (n % i == 0)
return i;
}
return n;
}
int main() {
ll n, p;
cin >> n >> p;
map<ll, int> mp;
while (p > 1) {
ll num = prime(p);
mp[num]++;
p /= num;
}
ll ans = 1;
for (const auto &x : mp) {
ll num1 = x.first;
int num2 = x.second;
if (num2 >= n)
ans *= pow(num1, (num2 / n));
}
COUT(ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,970 | 990,969 | u459105164 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1000000007;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
queue<pair<ll, ll>> que;
for (ll i = 2; i * i <= p; i++) {
if (p % i == 0) {
ll che = 0;
while (p % i == 0) {
p /= i;
che++;
}
que.push(make_pair(i, che));
}
}
if (p != 1) {
que.push(make_pair(p, 1));
}
while (!que.empty()) {
ll num = que.front().first;
ll che = que.front().second;
que.pop();
if (che / n == 0)
continue;
che = che / n;
ans = ans * che * num;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1000000007;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
int main() {
ll n, p;
cin >> n >> p;
ll ans = 1;
queue<pair<ll, ll>> que;
for (ll i = 2; i * i <= p; i++) {
if (p % i == 0) {
ll che = 0;
while (p % i == 0) {
p /= i;
che++;
}
que.push(make_pair(i, che));
}
}
if (p != 1) {
que.push(make_pair(p, 1));
}
while (!que.empty()) {
ll num = que.front().first;
ll che = que.front().second;
que.pop();
if (che / n == 0)
continue;
che = che / n;
ans = ans * pow(num, che);
}
cout << ans << endl;
}
| [
"call.arguments.add"
] | 990,971 | 990,972 | u157433024 | cpp |
p03196 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cout, endl, cin
#include <limits>
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define ll long long
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define int_INF 2147483647
#define pint_INF 2000000000
#define ll_INF 9223372036854775807
#define MOD 1000000007
#define vi vector<int>
#define vvi vector<vector<int>>
#define vll vector<long long>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
using namespace std;
bool is_prime[100000000 + 1]; // Up to 1e8 + 1
vi Eratosthenes(const int N) { // return primes up to N
vector<int> P;
for (int i = 0; i <= N; i++) {
is_prime[i] = true;
}
for (int i = 2; i <= N; i++) {
if (is_prime[i]) {
for (int j = 2 * i; j <= N; j += i) {
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
/*
You will need
vector<int> Erast = Eratosthenes(1000003); //Max is 1e6+3
int length = Erast.size();
*/
int main() {
ll N, P;
cin >> N >> P;
vi Erast = Eratosthenes(1000004);
int length = Erast.size();
if (N == 1) {
cout << P << endl;
} else {
// N > 1
ll ans = 1;
for (int i = 0; i < length; i++) {
if (P % Erast[i] == 0) {
int cnt = 0;
while (P % Erast[i] == 0) {
P /= Erast[i];
cnt++;
}
if (cnt >= N) {
ans *= Erast[i];
}
}
}
cout << ans << endl;
}
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cout, endl, cin
#include <limits>
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define ll long long
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define int_INF 2147483647
#define pint_INF 2000000000
#define ll_INF 9223372036854775807
#define MOD 1000000007
#define vi vector<int>
#define vvi vector<vector<int>>
#define vll vector<long long>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
using namespace std;
bool is_prime[100000000 + 1]; // Up to 1e8 + 1
vi Eratosthenes(const int N) { // return primes up to N
vector<int> P;
for (int i = 0; i <= N; i++) {
is_prime[i] = true;
}
for (int i = 2; i <= N; i++) {
if (is_prime[i]) {
for (int j = 2 * i; j <= N; j += i) {
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
/*
You will need
vector<int> Erast = Eratosthenes(1000003); //Max is 1e6+3
int length = Erast.size();
*/
int main() {
ll N, P;
cin >> N >> P;
vi Erast = Eratosthenes(1000004);
int length = Erast.size();
if (N == 1) {
cout << P << endl;
} else {
// N > 1
ll ans = 1;
for (int i = 0; i < length; i++) {
if (P % Erast[i] == 0) {
int cnt = 0;
while (P % Erast[i] == 0) {
P /= Erast[i];
cnt++;
if (cnt >= N) {
ans *= Erast[i];
cnt = 0;
}
}
}
}
cout << ans << endl;
}
}
| [
"assignment.add"
] | 990,979 | 990,980 | u668785999 | cpp |
p03196 | #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>>
#define vstring vector<string>
#define vdouble vector<double>
#define vll vector<ll>
#define vbool vector<bool>
#define INF 100000000000000009
#define int long long
using P = pair<int, int>;
vector<P> prime_factorize(int n) {
vector<P> res;
for (int p = 2; p * p <= n; p++) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
num++;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
signed main() {
int n, p;
cin >> n >> p;
auto res = prime_factorize(n);
int ans = 1;
for (auto p : res) {
for (int j = 0; j < p.second / n; j++) {
ans *= p.first;
}
}
cout << ans << endl;
} | #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>>
#define vstring vector<string>
#define vdouble vector<double>
#define vll vector<ll>
#define vbool vector<bool>
#define INF 100000000000000009
#define int long long
using P = pair<int, int>;
vector<P> prime_factorize(int n) {
vector<P> res;
for (int p = 2; p * p <= n; p++) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
num++;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
signed main() {
int n, p;
cin >> n >> p;
auto res = prime_factorize(p);
int ans = 1;
for (auto p : res) {
for (int j = 0; j < p.second / n; j++) {
ans *= p.first;
}
}
cout << ans << endl;
} | [
"identifier.change",
"call.arguments.change"
] | 990,983 | 990,984 | u613960672 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)x.size())
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using V = vector<T>;
using P = pair<int, int>;
/*
*/
signed main() {
int n, p;
cin >> n >> p;
V<P> v;
rep(i, 2, p / i + 1) {
int c = 0;
while (p % i == 0) {
c++;
p /= i;
}
if (c)
v.emplace_back(i, c);
}
if (p != 1) {
v.emplace_back(p, 1);
}
int ans = 1;
for (auto i : v) {
if (i.second / n > 0)
ans *= i.first * (i.second / n);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)x.size())
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using V = vector<T>;
using P = pair<int, int>;
/*
*/
signed main() {
int n, p;
cin >> n >> p;
V<P> v;
rep(i, 2, p / i + 1) {
int c = 0;
while (p % i == 0) {
c++;
p /= i;
}
if (c)
v.emplace_back(i, c);
}
if (p != 1) {
v.emplace_back(p, 1);
}
int ans = 1;
for (auto i : v) {
if (i.second / n > 0)
ans *= pow(i.first, (i.second / n));
}
cout << ans << endl;
return 0;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 990,993 | 990,994 | u057866967 | cpp |
p03196 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
// int DP[MEM_SIZE][MEM_SIZE] = {0};
// int GMEM[MEM_SIZE][MEM_SIZE] = {0};
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << std::endl;
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class X> void DEBUG(X d, T e) {
if (DEBUG_OUT == false)
return;
std::cout << d << " ";
DEBUG(e);
};
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
template <typename T> using matrix = vector<vector<T>>;
// FUNCTION
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
void solve(void) {
int N;
cin >> N;
int X;
cin >> X;
map<int, int> mp = prime_factor(X);
map<int, int> mpp;
for (int i = 0; i < mp.size(); i++) {
static auto itr = mp.begin();
if (itr->second >= N) {
mpp[itr->first] = itr->second / N;
}
itr++;
}
int ANS = 1;
for (int i = 0; i < mpp.size(); i++) {
static auto itr = mpp.begin();
ANS *= itr->first * itr->second;
itr++;
}
cout << ANS << endl;
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
// int DP[MEM_SIZE][MEM_SIZE] = {0};
// int GMEM[MEM_SIZE][MEM_SIZE] = {0};
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << std::endl;
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class X> void DEBUG(X d, T e) {
if (DEBUG_OUT == false)
return;
std::cout << d << " ";
DEBUG(e);
};
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
template <typename T> using matrix = vector<vector<T>>;
// FUNCTION
map<int, int> prime_factor(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
void solve(void) {
int N;
cin >> N;
int X;
cin >> X;
map<int, int> mp = prime_factor(X);
map<int, int> mpp;
for (int i = 0; i < mp.size(); i++) {
static auto itr = mp.begin();
if (itr->second >= N) {
mpp[itr->first] = itr->second / N;
}
itr++;
}
int ANS = 1;
for (int i = 0; i < mpp.size(); i++) {
static auto itr = mpp.begin();
ANS *= pow(itr->first, itr->second);
itr++;
}
cout << ANS << endl;
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,007 | 991,008 | u221285045 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define MAX 100000
void inarray(int a[], int n) {
for (int i = 0; i < n; i++)
cin >> a[i];
}
void max_div(ll n);
bool isPrime(ll n);
ll ans, N;
int main() {
ll p;
cin >> N >> p;
ans = 1;
if (N == 1) {
cout << p << endl;
return 0;
}
if (isPrime(p)) {
cout << 1 << endl;
return 0;
}
max_div(p);
cout << ans << endl;
return 0;
}
void max_div(ll n) {
int i = 2;
ll c = 0;
while (n > 1) {
if (n % i == 0) {
c++;
n /= i;
} else {
if (c / N >= 1)
ans *= pow(i, c / N);
if (c > 0) {
if (isPrime(n))
break;
}
i++;
c = 0;
}
}
if (c / N >= 1)
ans *= pow(i, c / N);
}
bool isPrime(ll n) {
if (n < 2)
return false;
if (n == 2)
return true;
if (n % 2 == 0)
return false;
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0)
return false;
}
return true;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define MAX 100000
void inarray(int a[], int n) {
for (int i = 0; i < n; i++)
cin >> a[i];
}
void max_div(ll n);
bool isPrime(ll n);
ll ans, N;
int main() {
ll p;
cin >> N >> p;
ans = 1;
if (N == 1) {
cout << p << endl;
return 0;
}
if (isPrime(p)) {
cout << 1 << endl;
return 0;
}
max_div(p);
cout << ans << endl;
return 0;
}
void max_div(ll n) {
int i = 2;
ll c = 0;
while (n > 1) {
if (n % i == 0) {
c++;
n /= i;
} else {
if (c / N >= 1)
ans *= pow(i, c / N);
if (c > 0) {
if (isPrime(n)) {
c = 0;
break;
}
}
i++;
c = 0;
}
}
if (c / N >= 1)
ans *= pow(i, c / N);
}
bool isPrime(ll n) {
if (n < 2)
return false;
if (n == 2)
return true;
if (n % 2 == 0)
return false;
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0)
return false;
}
return true;
} | [
"assignment.add"
] | 991,015 | 991,016 | u423656246 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void jj(int64_t &p, int prime, int n, int64_t &ans) {
int count = 0;
while (1) {
if (p % prime == 0) {
p /= prime;
count++;
if (count == n) {
ans *= prime;
count = 0;
}
} else {
break;
}
}
}
int main() {
int64_t n, p;
cin >> n >> p;
if (p == 1) {
cout << 1 << endl;
return 0;
}
if (n == 1) {
cout << p << endl;
return 0;
}
int64_t ans = 1;
jj(p, 2, n, ans);
vector<int> prime(1, 2);
for (size_t i = 2; i < sqrt(p); i++) {
bool judge = true;
for (size_t j = 0; j < prime.size(); j++) {
if (i % prime.at(j) == 0) {
judge = false;
break;
}
}
if (judge == 1) {
prime.push_back(i);
jj(p, i, n, ans);
}
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void jj(int64_t &p, int prime, int n, int64_t &ans) {
int count = 0;
while (1) {
if (p % prime == 0) {
p /= prime;
count++;
if (count == n) {
ans *= prime;
count = 0;
}
} else {
break;
}
}
}
int main() {
int64_t n, p;
cin >> n >> p;
if (p == 1) {
cout << 1 << endl;
return 0;
}
if (n == 1) {
cout << p << endl;
return 0;
}
int64_t ans = 1;
jj(p, 2, n, ans);
vector<int> prime(1, 2);
for (size_t i = 2; i < sqrt(p) + 100; i++) {
bool judge = true;
for (size_t j = 0; j < prime.size(); j++) {
if (i % prime.at(j) == 0) {
judge = false;
break;
}
}
if (judge == 1) {
prime.push_back(i);
jj(p, i, n, ans);
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change"
] | 991,030 | 991,031 | u229148215 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
}
for (ll i = 2; i * i <= P_; i++) {
while (P % i == 0) {
P /= i;
V[i]++;
}
}
ll ans = 1;
for (int i = 2; i < V.size(); i++) {
if (V[i] >= N) {
ans *= i * (V[i] / N);
// cout << i << " " << i*(V[i]/N) << endl;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
}
for (ll i = 2; i * i <= P_; i++) {
while (P % i == 0) {
P /= i;
V[i]++;
}
}
ll ans = 1;
for (int i = 2; i < V.size(); i++) {
if (V[i] >= N) {
ans *= pow(i, (V[i] / N));
// cout << i << " " << pow(i,(V[i]/N)) << endl;
}
}
cout << ans << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,034 | 991,035 | u521973174 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
}
for (ll i = 2; i * i <= P_; i++) {
while (P % i == 0) {
P /= i;
V[i]++;
}
}
ll ans = 1;
for (int i = 2; i <= V.size(); i++) {
if (V[i] >= N) {
ans *= i * (V[i] / N);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MAXN = 301;
int main() {
ll N, P, P_;
cin >> N >> P;
P_ = P;
vector<ll> V(sqrt(P) + 1);
if (P == 1) {
cout << 1 << endl;
return 0;
}
if (N == 1) {
cout << P << endl;
return 0;
}
for (ll i = 2; i * i <= P_; i++) {
while (P % i == 0) {
P /= i;
V[i]++;
}
}
ll ans = 1;
for (int i = 2; i < V.size(); i++) {
if (V[i] >= N) {
ans *= pow(i, (V[i] / N));
// cout << i << " " << pow(i,(V[i]/N)) << endl;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.add",
"assignment.value.change",
"call.arguments.change"
] | 991,036 | 991,035 | u521973174 | cpp |
p03196 | #define _LIBCPP_DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
typedef vector<int> vi;
typedef long long ll;
int main() {
ll N, P, an = 1;
cin >> N >> P;
map<ll, ll> m;
rep(i, 2, floor(sqrt(P))) {
while (P % i == 0) {
P /= i;
m[i]++;
}
}
if (P != 1)
m[P]++;
for (auto it : m) {
if (it.first != 0) {
while (it.second >= N) {
an *= it.first;
it.second -= N;
}
}
}
cout << an << endl;
}
| #define _LIBCPP_DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
typedef vector<int> vi;
typedef long long ll;
int main() {
ll N, P, an = 1;
cin >> N >> P;
map<ll, ll> m;
rep(i, 2, floor(sqrt(P)) + 1) {
while (P % i == 0) {
P /= i;
m[i]++;
}
}
if (P != 1)
m[P]++;
for (auto it : m) {
if (it.first != 0) {
while (it.second >= N) {
an *= it.first;
it.second -= N;
}
}
}
cout << an << endl;
}
| [
"expression.operation.binary.add"
] | 991,045 | 991,046 | u293156359 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#define inf (int)(1e9 + 7)
#define abs(x) (x >= 0 ? x : -(x))
#define ceil(a, b) a / b + !!(a % b)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
ll pow(ll a, int b) { return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1; }
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
vector<pair<ll, int>> prime_factorize(ll n) {
ll tmp = n;
vector<pair<ll, int>> v;
for (ll i = 2; i * i <= n; ++i) {
int cnt = 0;
while (tmp % i == 0) {
tmp /= i;
cnt++;
}
if (cnt)
v.eb(i, cnt);
}
if (tmp != 1)
v.eb(tmp, 1);
return v;
}
int main() {
ll n, p;
cin >> n >> p;
auto v = prime_factorize(p);
// rep(i, sz(v)) cout << v[i].F << " " << v[i].S << endl;
ll ans = 1;
for (auto vi : v) {
if (vi.S >= n)
ans *= vi.F * (vi.S / n);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#define inf (int)(1e9 + 7)
#define abs(x) (x >= 0 ? x : -(x))
#define ceil(a, b) a / b + !!(a % b)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
ll pow(ll a, int b) { return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1; }
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
vector<pair<ll, int>> prime_factorize(ll n) {
ll tmp = n;
vector<pair<ll, int>> v;
for (ll i = 2; i * i <= n; ++i) {
int cnt = 0;
while (tmp % i == 0) {
tmp /= i;
cnt++;
}
if (cnt)
v.eb(i, cnt);
}
if (tmp != 1)
v.eb(tmp, 1);
return v;
}
int main() {
ll n, p;
cin >> n >> p;
auto v = prime_factorize(p);
// rep(i, sz(v)) cout << v[i].F << " " << v[i].S << endl;
ll ans = 1;
for (auto vi : v) {
if (vi.S >= n)
ans *= pow(vi.F, vi.S / n);
}
cout << ans << endl;
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,049 | 991,050 | u277556971 | cpp |
p03196 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const int INF = 1001001001;
const ll LINF = 1001001001001001001;
int main() {
ll n, p;
cin >> n >> p;
const ll mx = 1000001;
vector<ll> a(mx, 0);
for (int i = 2; i < mx; i++) {
ll count = 0;
while (p % i == 0) {
p /= i;
count++;
}
a.at(i) = count;
}
ll ans = 1;
for (int i = 2; i < mx; i++) {
if ((a.at(i) / n) == 0)
continue;
ans *= pow(i, (a.at(i) / n));
}
if (n != 1)
cout << ans << endl;
else
cout << p << endl;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const int INF = 1001001001;
const ll LINF = 1001001001001001001;
int main() {
ll n, p;
cin >> n >> p;
ll x = p;
const ll mx = 1000001;
vector<ll> a(mx, 0);
for (int i = 2; i < mx; i++) {
ll count = 0;
while (p % i == 0) {
p /= i;
count++;
}
a.at(i) = count;
}
ll ans = 1;
for (int i = 2; i < mx; i++) {
if ((a.at(i) / n) == 0)
continue;
ans *= pow(i, (a.at(i) / n));
}
if (n != 1)
cout << ans << endl;
else
cout << x << endl;
} | [
"variable_declaration.add",
"identifier.change",
"io.output.change"
] | 991,051 | 991,052 | u628597699 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG //これつけるとA[N]でもいいらしい
// for文のマクロ
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define big 1000000007
#define all(a) sort((a).begin(), (a).end()) //ソートのマクロ
int main() {
double n, p;
cin >> n >> p;
int64_t ans = pow(p, 1 / n);
while ((int64_t)p % (int64_t)pow(ans, n) != 0) {
ans--;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG //これつけるとA[N]でもいいらしい
// for文のマクロ
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define big 1000000007
#define all(a) sort((a).begin(), (a).end()) //ソートのマクロ
int main() {
double n, p;
cin >> n >> p;
int64_t ans = round(pow(p, 1 / n));
// cout<<ans<<endl;
while ((int64_t)p % (int64_t)round(pow(ans, n)) != 0) {
ans--;
}
cout << ans << endl;
} | [
"call.add",
"call.arguments.change",
"control_flow.loop.condition.change"
] | 991,063 | 991,064 | u348231925 | cpp |
p03196 | #include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char> T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1)
cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
#define ALL(qpqpq) (qpqpq).begin(), (qpqpq).end()
#define UNIQUE(wpwpw) \
sort(ALL((wpwpw))); \
(wpwpw).erase(unique(ALL((wpwpw))), (wpwpw).end())
#define LOWER(epepe) transform(ALL((epepe)), (epepe).begin(), TL<char>)
#define UPPER(rprpr) transform(ALL((rprpr)), (rprpr).begin(), TU<char>)
#define FOR(i, tptpt, ypypy) for (LL i = (tptpt); i < (ypypy); i++)
#define REP(i, upupu) FOR(i, 0, upupu)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
LL n, p;
vector<LL> PrimeFact(LL n) {
vector<LL> res;
while (n != 1) {
if (n == 2 || n == 3) {
res.emplace_back(n);
n /= n;
continue;
}
bool prime_flag = false;
for (LL i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.emplace_back(i);
n /= i;
prime_flag = true;
break;
}
}
if (!prime_flag) {
res.emplace_back(n);
n /= n;
}
}
return res;
}
map<LL, int> cnt;
int main() {
INIT;
cin >> n >> p;
vector<LL> v = PrimeFact(p);
REP(i, (int)v.size()) { cnt[v[i]]++; }
LL ans = 1;
for (auto it = cnt.begin(); it != cnt.end(); ++it) {
if ((it->second) >= n) {
ans *= (it->first) * ((it->second) / n);
}
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char> T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1)
cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
#define ALL(qpqpq) (qpqpq).begin(), (qpqpq).end()
#define UNIQUE(wpwpw) \
sort(ALL((wpwpw))); \
(wpwpw).erase(unique(ALL((wpwpw))), (wpwpw).end())
#define LOWER(epepe) transform(ALL((epepe)), (epepe).begin(), TL<char>)
#define UPPER(rprpr) transform(ALL((rprpr)), (rprpr).begin(), TU<char>)
#define FOR(i, tptpt, ypypy) for (LL i = (tptpt); i < (ypypy); i++)
#define REP(i, upupu) FOR(i, 0, upupu)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
LL n, p;
vector<LL> PrimeFact(LL n) {
vector<LL> res;
while (n != 1) {
if (n == 2 || n == 3) {
res.emplace_back(n);
n /= n;
continue;
}
bool prime_flag = false;
for (LL i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.emplace_back(i);
n /= i;
prime_flag = true;
break;
}
}
if (!prime_flag) {
res.emplace_back(n);
n /= n;
}
}
return res;
}
map<LL, int> cnt;
int main() {
INIT;
cin >> n >> p;
vector<LL> v = PrimeFact(p);
REP(i, (int)v.size()) { cnt[v[i]]++; }
LL ans = 1;
for (auto it = cnt.begin(); it != cnt.end(); ++it) {
if ((it->second) >= n) {
ans *= pow((it->first), ((it->second) / n));
}
}
cout << ans << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,083 | 991,084 | u093922224 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//////////////////////////////////////////////////
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
// 素因数分解
map<ll, ll> m;
auto prime_factrize = [&](ll a) -> void {
for (ll i = 2; i * i <= a; i++) {
if (a % i != 0)
continue;
ll cnt = 0;
while (a % i == 0) {
cnt++;
a /= i;
}
m[i] += cnt;
}
if (a > 1)
m[a]++;
};
prime_factrize(p);
ll ans = 1;
for (auto v : m) {
while (v.second >= n) {
ans *= v.first;
v.second /= n;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//////////////////////////////////////////////////
int main() {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
// 素因数分解
map<ll, ll> m;
auto prime_factrize = [&](ll a) -> void {
for (ll i = 2; i * i <= a; i++) {
if (a % i != 0)
continue;
ll cnt = 0;
while (a % i == 0) {
cnt++;
a /= i;
}
m[i] += cnt;
}
if (a > 1)
m[a]++;
};
prime_factrize(p);
ll ans = 1;
for (auto v : m) {
while (v.second >= n) {
ans *= v.first;
v.second -= n;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.change"
] | 991,085 | 991,086 | u374929478 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
ll p;
cin >> p;
map<ll, ll> m;
auto prime_factrize = [&](ll a) -> void {
for (ll i = 2; i * i < a; i++) {
if (a % i != 0)
continue;
ll cnt = 0;
while (a % i == 0) {
cnt++;
a /= i;
}
m[i] += cnt;
}
if (a > 1)
m[a]++;
};
prime_factrize(p);
ll ans = 1;
for (auto v : m) {
ll num = v.first;
ll cnt = v.second;
// cout << num << ' ' << cnt << endl;
for (int i = cnt; i >= n; i -= n) {
ans *= num;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
ll p;
cin >> p;
map<ll, ll> m;
auto prime_factrize = [&](ll a) -> void {
for (ll i = 2; i * i <= a; i++) {
if (a % i != 0)
continue;
ll cnt = 0;
while (a % i == 0) {
cnt++;
a /= i;
}
m[i] += cnt;
}
if (a > 1)
m[a]++;
};
prime_factrize(p);
ll ans = 1;
for (auto v : m) {
ll num = v.first;
ll cnt = v.second;
// cout << num << ' ' << cnt << endl;
for (int i = cnt; i >= n; i -= n) {
ans *= num;
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 991,087 | 991,088 | u374929478 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define print(x) cout << (x) << endl
#define rep(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec), 0LL)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
ll inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
}
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
}
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
}
int ctoi(char c) { return c - '0'; }
bool isOk(ll key, ll value) { return key >= value; }
ll binary_search(vector<ll> a, ll key) {
ll ok = a.size() - 1;
ll ng = 0;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOk(key, a[mid]))
ok = mid;
else
ng = mid;
}
return ok;
}
bool isPrime(ll n) {
for (int i = 2; n >= i * i; ++i) {
if (!(n % i))
return false;
}
return true;
}
vector<ll> primes(ll n) {
vector<ll> v(1, 1);
for (ll i = 2; n >= i * i; ++i) {
if (!(n % i)) {
v.pb(i);
}
}
if (v.size() == 1)
v.pb(n);
return v;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
ll ans = 1;
for (ll i = 2; i * i <= m; ++i) {
int cnt = 0;
while (m % i == 0) {
if (n % ++cnt == 0) {
ans *= i;
}
m /= i;
}
}
if (n == 1)
ans *= m;
print(ans);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define print(x) cout << (x) << endl
#define rep(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec), 0LL)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
ll inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
}
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
}
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
}
int ctoi(char c) { return c - '0'; }
bool isOk(ll key, ll value) { return key >= value; }
ll binary_search(vector<ll> a, ll key) {
ll ok = a.size() - 1;
ll ng = 0;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOk(key, a[mid]))
ok = mid;
else
ng = mid;
}
return ok;
}
bool isPrime(ll n) {
for (int i = 2; n >= i * i; ++i) {
if (!(n % i))
return false;
}
return true;
}
vector<ll> primes(ll n) {
vector<ll> v(1, 1);
for (ll i = 2; n >= i * i; ++i) {
if (!(n % i)) {
v.pb(i);
}
}
if (v.size() == 1)
v.pb(n);
return v;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
ll ans = 1;
for (ll i = 2; i * i <= m; ++i) {
int cnt = 0;
while (m % i == 0) {
if (++cnt % n == 0) {
ans *= i;
}
m /= i;
}
}
if (n == 1)
ans *= m;
print(ans);
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 991,089 | 991,090 | u184572586 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define print(x) cout << (x) << endl
#define rep(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec), 0LL)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
ll inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
}
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
}
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
}
int ctoi(char c) { return c - '0'; }
bool isOk(ll key, ll value) { return key >= value; }
ll binary_search(vector<ll> a, ll key) {
ll ok = a.size() - 1;
ll ng = 0;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOk(key, a[mid]))
ok = mid;
else
ng = mid;
}
return ok;
}
bool isPrime(ll n) {
for (int i = 2; n >= i * i; ++i) {
if (!(n % i))
return false;
}
return true;
}
vector<ll> primes(ll n) {
vector<ll> v(1, 1);
for (ll i = 2; n >= i * i; ++i) {
if (!(n % i)) {
v.pb(i);
}
}
if (v.size() == 1)
v.pb(n);
return v;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
ll ans = 1;
for (ll i = 2; i * i < m; ++i) {
int cnt = 0;
while (m % i == 0) {
if (n % ++cnt) {
ans *= i;
cnt = 0;
}
m /= i;
}
}
if (n == 1)
ans *= m;
print(ans);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define print(x) cout << (x) << endl
#define rep(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec), 0LL)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define test(a) \
cout << "line:" << __LINE__ << "[" << (#a) << ": " << (a) << "]" << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
ll inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
}
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
}
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
}
int ctoi(char c) { return c - '0'; }
bool isOk(ll key, ll value) { return key >= value; }
ll binary_search(vector<ll> a, ll key) {
ll ok = a.size() - 1;
ll ng = 0;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOk(key, a[mid]))
ok = mid;
else
ng = mid;
}
return ok;
}
bool isPrime(ll n) {
for (int i = 2; n >= i * i; ++i) {
if (!(n % i))
return false;
}
return true;
}
vector<ll> primes(ll n) {
vector<ll> v(1, 1);
for (ll i = 2; n >= i * i; ++i) {
if (!(n % i)) {
v.pb(i);
}
}
if (v.size() == 1)
v.pb(n);
return v;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
ll ans = 1;
for (ll i = 2; i * i <= m; ++i) {
int cnt = 0;
while (m % i == 0) {
if (++cnt == n) {
ans *= i;
cnt = 0;
}
m /= i;
}
}
if (n == 1)
ans *= m;
print(ans);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 991,091 | 991,092 | u184572586 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p;
cin >> n >> p;
vector<long long int> divisor(0);
for (int i = 1; i <= sqrt(p); i++) {
if (p % i == 0) {
divisor.push_back(i);
divisor.push_back(p / i);
}
}
sort(divisor.begin(), divisor.end());
double nRoot = pow(p, 1.0 / n);
long long int ans = 1;
for (int i = 0; i < divisor.size(); i++) {
if (divisor[i] > nRoot)
break;
else {
long long int c = pow(divisor[i], n);
if (p % c == 0)
ans = divisor[i];
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p;
cin >> n >> p;
vector<long long int> divisor(0);
for (int i = 1; i <= sqrt(p); i++) {
if (p % i == 0) {
divisor.push_back(i);
divisor.push_back(p / i);
}
}
sort(divisor.begin(), divisor.end());
long long int nRoot = ceil(pow(p, 1.0 / n));
long long int ans = 1;
for (int i = 0; i < divisor.size(); i++) {
if (divisor[i] > nRoot)
break;
else {
long long int c = pow(divisor[i], n);
if (p % c == 0)
ans = divisor[i];
}
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"call.add",
"call.arguments.change"
] | 991,095 | 991,096 | u045368371 | cpp |
p03196 | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, n) for (int i = (a); i < (n); i++)
#define ALL(v) v.begin(), v.end()
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<bool> isp;
void sieve(int N) {
isp.assign(N + 1, true);
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[i * j] = false;
}
}
int main() {
ll n, p;
cin >> n >> p;
int N = pow(p, 0.5) + 1;
// cout << M << endl ;
sieve(N);
map<ll, ll> mi;
ll P = p;
rep(i, N) {
if (isp[i]) {
while (P > 1 && P % i == 0) {
P /= i;
mi[i] += 1;
}
}
}
if (n == 1)
cout << p << endl;
else if (mi.size() == 0)
cout << 1 << endl;
else {
ll ans = 1;
for (const auto &m : mi) {
ll k = m.first, v = m.second;
// cout << k << " " << v << endl;
if (v >= n)
ans *= k * (v / n);
}
cout << ans << endl;
}
} | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, n) for (int i = (a); i < (n); i++)
#define ALL(v) v.begin(), v.end()
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<bool> isp;
void sieve(int N) {
isp.assign(N + 1, true);
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[i * j] = false;
}
}
int main() {
ll n, p;
cin >> n >> p;
int N = pow(p, 0.5) + 1;
// cout << M << endl ;
sieve(N);
map<ll, ll> mi;
ll P = p;
rep(i, N) {
if (isp[i]) {
while (P > 1 && P % i == 0) {
P /= i;
mi[i] += 1;
}
}
}
if (n == 1)
cout << p << endl;
else if (mi.size() == 0)
cout << 1 << endl;
else {
ll ans = 1;
for (const auto &m : mi) {
ll k = m.first, v = m.second;
// cout << k << " " << v << endl;
if (v >= n)
ans *= pow(k, (v / n));
}
cout << ans << endl;
}
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,102 | 991,103 | u846634344 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <string>
#include <tuple>
#include <vector>
template <typename T> bool chmax(T &a, const T &b) {
if (a <= b) {
a = b;
return (true);
} else {
return (false);
}
}
template <typename T> bool chmin(T &a, const T &b) {
if (a >= b) {
a = b;
return (true);
} else {
return (false);
}
}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using Pint = pair<int, int>;
using Pll = pair<ll, ll>;
using Pull = pair<ull, ull>;
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define reps(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rrep(i, n) for (int i = (int)((n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = (int)((n)); i > 0; --i)
#define arep(i, v) for (auto &&i : (v))
template <typename T> T gcd(const T a, const T b) {
return (b ? gcd(b, a % b) : a);
}
template <typename T> T lcm(const T a, const T b) {
return (a / gcd(a, b) * b);
}
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define UNIQUE(c) (c).erase(unique((c).begin(), (c).end()), (c).end())
constexpr ll MOD = 1000000007LL;
template <typename T = ll> constexpr T MAX = numeric_limits<T>::max();
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
template <typename T = ll> class UnionFind {
public:
UnionFind(T n) {
par.resize(n);
siz.resize(n);
rep(i, n) {
par[i] = i;
siz[i] = 1;
}
}
T find(T x) {
if (x == par[x])
return (x);
else
return (par[x] = find(par[x]));
}
void unite(T x, T y) {
T xx = find(x);
T yy = find(y);
if (xx == yy)
return;
if (siz[xx] <= siz[yy])
swap(xx, yy);
par[yy] = xx;
siz[xx] += siz[yy];
}
private:
vector<T> par, siz;
};
template <typename T = ll> class CompareMax {
public:
T operator()(T a, T b) { return (max(a, b)); }
};
template <typename T = ll> class CompareMin {
public:
T operator()(T a, T b) { return (min(a, b)); }
};
template <typename T = ll, typename F = CompareMax<T>, T I = 0> class SegTree {
public:
SegTree(T n) {
N = n;
v.resize(4 * n);
rep(i, 4 * n) v[i] = I;
}
void update(T i, T x) {
i += N - 1;
v[i] = x;
while (i > 0) {
i = (i - 1) / 2;
v[i] = func(v[i * 2 + 1], v[i * 2 + 2]);
}
}
T query(T a, T b, T k, T l, T r) {
if (r <= a || b <= l)
return (I);
if (a <= l && r <= b)
return (v[k]);
else {
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return (func(vl, vr));
}
}
private:
T N;
F func;
vector<T> v;
};
template <typename T = ll> T solveLIS(const vector<T> &v) {
vector<T> dp(v.size(), numeric_limits<T>::max());
rep(i, v.size()) { *lower_bound(ALL(dp), v[i]) = v[i]; }
return (distance(dp.begin(), lower_bound(ALL(dp), numeric_limits<T>::max())));
}
template <typename T = ll> T power(T a, T b, T m = MOD) {
T res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return (res);
}
/*
constexpr ll COMBSIZE = 500010;
ll fact[COMBSIZE];
ll inv[COMBSIZE];
ll inv_fact[COMBSIZE];
template<typename T> void initComb( T n, T m = MOD )
{
fact[0] = fact[1] = inv_fact[0] = inv_fact[1] = 1;
inv[1] = 1;
for ( int i = 2; i < n; i++ ) {
fact[i] = ( fact[i - 1] * i ) % m;
inv[i] = m - inv[m % i] * ( m / i ) % m;
inv_fact[i] = inv_fact[i - 1] * inv[i] % m;
}
}
template<typename T> T comb( T n, T r, T m = MOD )
{
if ( n < r ) return ( 0 );
if ( n < 0 || r < 0 ) return ( 0 );
return ( fact[n] * ( inv_fact[r] * inv_fact[n - r] % m ) % m );
}
*/
/*
regex reg( R"(^(dream|dreamer|erase|eraser)+$)" );
smatch m;
if ( regex_match( s, m, reg ) )
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
*/
/*
cout << setprecision( 16 );
cout << fixed << setprecision( 16 );
*/
template <typename T = int> vector<T> Zalgo(const string &S) {
T N = (T)S.size();
vector<T> res(N);
res[0] = N;
T i = 1, j = 0;
while (i < N) {
while (i + j < N && S[j] == S[i + j])
++j;
res[i] = j;
if (j == 0) {
++i;
continue;
}
int k = 1;
while (i + k < N && k + res[k] < j)
res[i + k] = res[k], ++k;
i += k, j -= k;
}
return (res);
}
void replace(string &s, string t, string r) {
string::size_type p = 0;
while ((p = s.find(t, p)) != string::npos) {
s.replace(p, t.length(), r);
p += r.length();
}
}
int main() {
ll N, P;
cin >> N >> P;
ll tmpP = P;
vector<Pll> v;
for (ll i = 2; i * i <= tmpP; ++i) {
if (P % i == 0) {
ll cnt = 0;
while (P % i == 0) {
P /= i;
++cnt;
}
v.eb(mp(i, cnt));
}
}
v.eb(mp(P, 1));
ll ans = 1;
arep(it, v) {
if (it.S >= N)
ans *= (it.F * (it.S / N));
}
cout << ans << endl;
return (0);
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <string>
#include <tuple>
#include <vector>
template <typename T> bool chmax(T &a, const T &b) {
if (a <= b) {
a = b;
return (true);
} else {
return (false);
}
}
template <typename T> bool chmin(T &a, const T &b) {
if (a >= b) {
a = b;
return (true);
} else {
return (false);
}
}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using Pint = pair<int, int>;
using Pll = pair<ll, ll>;
using Pull = pair<ull, ull>;
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define reps(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rrep(i, n) for (int i = (int)((n)-1); i >= 0; --i)
#define rreps(i, n) for (int i = (int)((n)); i > 0; --i)
#define arep(i, v) for (auto &&i : (v))
template <typename T> T gcd(const T a, const T b) {
return (b ? gcd(b, a % b) : a);
}
template <typename T> T lcm(const T a, const T b) {
return (a / gcd(a, b) * b);
}
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define UNIQUE(c) (c).erase(unique((c).begin(), (c).end()), (c).end())
constexpr ll MOD = 1000000007LL;
template <typename T = ll> constexpr T MAX = numeric_limits<T>::max();
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
template <typename T = ll> class UnionFind {
public:
UnionFind(T n) {
par.resize(n);
siz.resize(n);
rep(i, n) {
par[i] = i;
siz[i] = 1;
}
}
T find(T x) {
if (x == par[x])
return (x);
else
return (par[x] = find(par[x]));
}
void unite(T x, T y) {
T xx = find(x);
T yy = find(y);
if (xx == yy)
return;
if (siz[xx] <= siz[yy])
swap(xx, yy);
par[yy] = xx;
siz[xx] += siz[yy];
}
private:
vector<T> par, siz;
};
template <typename T = ll> class CompareMax {
public:
T operator()(T a, T b) { return (max(a, b)); }
};
template <typename T = ll> class CompareMin {
public:
T operator()(T a, T b) { return (min(a, b)); }
};
template <typename T = ll, typename F = CompareMax<T>, T I = 0> class SegTree {
public:
SegTree(T n) {
N = n;
v.resize(4 * n);
rep(i, 4 * n) v[i] = I;
}
void update(T i, T x) {
i += N - 1;
v[i] = x;
while (i > 0) {
i = (i - 1) / 2;
v[i] = func(v[i * 2 + 1], v[i * 2 + 2]);
}
}
T query(T a, T b, T k, T l, T r) {
if (r <= a || b <= l)
return (I);
if (a <= l && r <= b)
return (v[k]);
else {
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return (func(vl, vr));
}
}
private:
T N;
F func;
vector<T> v;
};
template <typename T = ll> T solveLIS(const vector<T> &v) {
vector<T> dp(v.size(), numeric_limits<T>::max());
rep(i, v.size()) { *lower_bound(ALL(dp), v[i]) = v[i]; }
return (distance(dp.begin(), lower_bound(ALL(dp), numeric_limits<T>::max())));
}
template <typename T = ll> T power(T a, T b, T m = MOD) {
T res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return (res);
}
/*
constexpr ll COMBSIZE = 500010;
ll fact[COMBSIZE];
ll inv[COMBSIZE];
ll inv_fact[COMBSIZE];
template<typename T> void initComb( T n, T m = MOD )
{
fact[0] = fact[1] = inv_fact[0] = inv_fact[1] = 1;
inv[1] = 1;
for ( int i = 2; i < n; i++ ) {
fact[i] = ( fact[i - 1] * i ) % m;
inv[i] = m - inv[m % i] * ( m / i ) % m;
inv_fact[i] = inv_fact[i - 1] * inv[i] % m;
}
}
template<typename T> T comb( T n, T r, T m = MOD )
{
if ( n < r ) return ( 0 );
if ( n < 0 || r < 0 ) return ( 0 );
return ( fact[n] * ( inv_fact[r] * inv_fact[n - r] % m ) % m );
}
*/
/*
regex reg( R"(^(dream|dreamer|erase|eraser)+$)" );
smatch m;
if ( regex_match( s, m, reg ) )
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
*/
/*
cout << setprecision( 16 );
cout << fixed << setprecision( 16 );
*/
template <typename T = int> vector<T> Zalgo(const string &S) {
T N = (T)S.size();
vector<T> res(N);
res[0] = N;
T i = 1, j = 0;
while (i < N) {
while (i + j < N && S[j] == S[i + j])
++j;
res[i] = j;
if (j == 0) {
++i;
continue;
}
int k = 1;
while (i + k < N && k + res[k] < j)
res[i + k] = res[k], ++k;
i += k, j -= k;
}
return (res);
}
void replace(string &s, string t, string r) {
string::size_type p = 0;
while ((p = s.find(t, p)) != string::npos) {
s.replace(p, t.length(), r);
p += r.length();
}
}
int main() {
ll N, P;
cin >> N >> P;
ll tmpP = P;
vector<Pll> v;
for (ll i = 2; i * i <= tmpP; ++i) {
if (P % i == 0) {
ll cnt = 0;
while (P % i == 0) {
P /= i;
++cnt;
}
v.eb(mp(i, cnt));
}
}
v.eb(mp(P, 1));
ll ans = 1;
arep(it, v) {
if (it.S >= N)
ans *= (pow(it.F, (it.S / N)));
}
cout << ans << endl;
return (0);
}
| [
"assignment.value.change",
"expression.operation.binary.change"
] | 991,110 | 991,111 | u408910484 | cpp |
p03196 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rrep(i, n) for (ll i = (ll)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rrepi(i, a, b) for (ll i = (ll)(b); i >= (ll)(a); i--)
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
using namespace std;
map<ll, ll> prime_factor(ll m) {
map<ll, ll> res;
for (ll i = 2; i * i <= m; i++) {
while (m % i == 0) {
res[i]++;
m /= i;
}
}
if (m > 1)
res[m]++;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, p;
cin >> n >> p;
auto ma = prime_factor(p);
ll res = 1;
for (auto tp : ma) {
if (tp.second >= n) {
rep(i, tp.second / n + 1) res *= tp.first;
}
}
cout << res << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rrep(i, n) for (ll i = (ll)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rrepi(i, a, b) for (ll i = (ll)(b); i >= (ll)(a); i--)
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
using namespace std;
map<ll, ll> prime_factor(ll m) {
map<ll, ll> res;
for (ll i = 2; i * i <= m; i++) {
while (m % i == 0) {
res[i]++;
m /= i;
}
}
if (m > 1)
res[m]++;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, p;
cin >> n >> p;
auto ma = prime_factor(p);
ll res = 1;
for (auto tp : ma) {
if (tp.second >= n) {
rep(i, tp.second / n) res *= tp.first;
}
}
cout << res << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 991,118 | 991,119 | u834415466 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> bool cmax(T &a, U b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T, class U> bool cmin(T &a, U b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, p;
cin >> n >> p;
ll ans = 1;
for (int i = 2; i * i <= p; i++) {
int cnt = 0;
while (p % i == 0) {
p /= i;
cnt++;
}
// ans *= pow(i, cnt/n);
rep(i, cnt / n) { ans *= i; }
}
ans *= pow(p, 1 / n);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(i) i.begin(), i.end()
template <class T, class U> bool cmax(T &a, U b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <class T, class U> bool cmin(T &a, U b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, p;
cin >> n >> p;
ll ans = 1;
for (ll i = 2; i * i <= p; i++) {
int cnt = 0;
while (p % i == 0) {
p /= i;
cnt++;
}
// ans *= pow(i, cnt/n);
rep(j, cnt / n) { ans *= i; }
}
ans *= pow(p, 1 / n);
cout << ans << endl;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change",
"identifier.change",
"call.arguments.change"
] | 991,128 | 991,127 | u366644013 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <vector>
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> m;
ll i = 2;
ll tmp = p;
if (n == 1) {
cout << p << endl;
return 0;
}
while (p != 1) {
if (p % i == 0) {
p /= i;
m[i]++;
i = 1;
}
if (sqrt(tmp) < i) {
m[p]++;
break;
}
i++;
}
ll ans = 1;
for (auto x : m) {
if (x.second >= n) {
ans *= (x.first * (x.second / n));
}
}
/*while(i <= sqrt(tmp)){
if(m[i] > 0){
if(n <= m[i]){
ans *= i*(m[i]/n);
m[i] %= n;
}
}
i++;
}*/
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <map>
#include <vector>
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll n, p;
cin >> n >> p;
map<ll, ll> m;
ll i = 2;
ll tmp = p;
if (n == 1) {
cout << p << endl;
return 0;
}
while (p != 1) {
if (p % i == 0) {
p /= i;
m[i]++;
i = 1;
}
if (sqrt(tmp) < i) {
m[p]++;
break;
}
i++;
}
ll ans = 1;
for (auto x : m) {
if (x.second >= n) {
ans *= pow(x.first, (x.second / n));
}
}
cout << ans << endl;
return 0;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,131 | 991,132 | u468862268 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
ll keta(ll a) {
ll ans = 1;
while (1) {
if (a / 10 > 0) {
ans++;
a = a / 10;
}
if (a < 10)
break;
}
return ans;
}
int main(void) {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
ll num = p;
ll ans = 1;
ll count;
for (int i = 2; i <= sqrt(p); i++) {
count = 0;
while (1) {
if (num % i == 0) {
count++;
num = num / i;
// cout<<count<<", "<<num<<" ";
} else {
break;
}
}
if (count >= n)
ans *= i * (count / n);
}
cout << ans << endl;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
ll keta(ll a) {
ll ans = 1;
while (1) {
if (a / 10 > 0) {
ans++;
a = a / 10;
}
if (a < 10)
break;
}
return ans;
}
int main(void) {
ll n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
ll num = p;
ll ans = 1;
ll count;
for (int i = 2; i <= sqrt(p); i++) {
count = 0;
while (1) {
if (num % i == 0) {
count++;
num = num / i;
// cout<<count<<", "<<num<<" ";
} else {
break;
}
}
if (count >= n)
ans *= pow(i, (count / n));
}
cout << ans << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,133 | 991,134 | u939401127 | cpp |
p03196 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
vector<pair<long long, long long>> prime_factorize(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue; //因数じゃない
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1)); // nが素数だった場合
return res;
}
int main() {
ll N;
ll P;
cin >> N >> P;
auto p = prime_factorize(P);
ll ans = 1;
for (auto cur : p) {
/* code */
if (cur.second > N) {
ans *= pow(cur.first, (cur.second / N));
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
vector<pair<long long, long long>> prime_factorize(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue; //因数じゃない
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1)); // nが素数だった場合
return res;
}
int main() {
ll N;
ll P;
cin >> N >> P;
auto p = prime_factorize(P);
ll ans = 1;
for (auto cur : p) {
/* code */
if (cur.second >= N) {
ans *= pow(cur.first, (cur.second / N));
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,150 | 991,151 | u824337972 | cpp |
p03196 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
vector<pair<long long, long long>> prime_factorize(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue; //因数じゃない
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1)); // nが素数だった場合
return res;
}
int main() {
ll N;
ll P;
cin >> N >> P;
auto p = prime_factorize(P);
ll ans = 1;
for (auto cur : p) {
/* code */
if (cur.second > N) {
ans *= cur.first * (cur.second / N);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF (1ll << 60)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using vl = vector<ll>;
using vvl = vector<vl>;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
using ll = long long;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
vector<pair<long long, long long>> prime_factorize(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue; //因数じゃない
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1)); // nが素数だった場合
return res;
}
int main() {
ll N;
ll P;
cin >> N >> P;
auto p = prime_factorize(P);
ll ans = 1;
for (auto cur : p) {
/* code */
if (cur.second >= N) {
ans *= pow(cur.first, (cur.second / N));
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,152 | 991,151 | u824337972 | cpp |
p03196 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
#define For(i, a, b) for (i = a; i < b; i++)
#define bFor(i, a, b) for (i = a; i >= b; i--)
#define rep(i, N) For(i, 0, N)
#define rep1(i, N) For(i, 1, N)
#define brep(i, N) bFor(i, N - 1, 0)
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define pb push_back
#define output(v) \
do { \
bool f = 0; \
for (auto outi : v) { \
cout << (f ? " " : "") << outi; \
f = 1; \
} \
cout << endl; \
} while (0)
const ll mod = 1000000007;
const ll inf = 1LL << 60;
template <class T> inline bool chmax(T &a, T b) {
bool x = a < b;
if (x)
a = b;
return x;
}
template <class T> inline bool chmin(T &a, T b) {
bool x = a > b;
if (x)
a = b;
return x;
}
double distance(ddatas &x, ddatas &y) {
double a = x.first - y.first, b = x.second - y.second;
return sqrt(a * a + b * b);
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + mod) % mod;
}
ll moddevide(ll a, ll b) { return (a * modinv(b)) % mod; }
vec modncrlistp, modncrlistm;
ll modncr(ll n, ll r) {
ll i, size = modncrlistp.size();
if (size <= n) {
modncrlistp.resize(n + 1);
modncrlistm.resize(n + 1);
if (!size) {
modncrlistp[0] = modncrlistm[0] = 1;
size++;
}
For(i, size, n + 1) {
modncrlistp[i] = modncrlistp[i - 1] * i % mod;
modncrlistm[i] = modinv(modncrlistp[i]);
}
}
return modncrlistp[n] * modncrlistm[r] % mod * modncrlistm[n - r] % mod;
}
ll modpow(ll a, ll n) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {
if (!b)
return a;
return (a % b == 0) ? b : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll countdigits(ll n) {
ll ans = 0;
while (n) {
n /= 10;
ans++;
}
return ans;
}
ll sumdigits(ll n) {
ll ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
vec eratosthenes(ll N) {
ll i;
vec ch(N + 1, 1), p;
ch[0] = ch[1] = 0;
rep(i, N + 1) {
if (ch[i]) {
p.pb(i);
for (ll j = 2; i * j <= N; j++) {
ch[i * j] = 0;
}
}
}
return ch;
}
vec primefactorization(ll N) {
ll i = 2;
vec res;
while (i * i <= N) {
while (!(N % i)) {
res.pb(i);
N /= i;
}
i++;
}
if (N - 1)
res.pb(N);
return res;
}
vec diviserlist(ll N) {
ll i;
vec res;
for (i = 1; i * i < N; i++) {
if (N % i == 0) {
res.pb(i);
res.pb(N / i);
}
}
if (i * i == N)
res.pb(i);
vsort(res);
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M, ans = 1;
cin >> M >> N;
vec v = primefactorization(N);
map<ll, ll> mp;
for (auto i : v) {
mp[i]++;
if (mp[i] == M)
ans *= i;
}
cout << ans << endl;
return 0;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
#define For(i, a, b) for (i = a; i < b; i++)
#define bFor(i, a, b) for (i = a; i >= b; i--)
#define rep(i, N) For(i, 0, N)
#define rep1(i, N) For(i, 1, N)
#define brep(i, N) bFor(i, N - 1, 0)
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define pb push_back
#define output(v) \
do { \
bool f = 0; \
for (auto outi : v) { \
cout << (f ? " " : "") << outi; \
f = 1; \
} \
cout << endl; \
} while (0)
const ll mod = 1000000007;
const ll inf = 1LL << 60;
template <class T> inline bool chmax(T &a, T b) {
bool x = a < b;
if (x)
a = b;
return x;
}
template <class T> inline bool chmin(T &a, T b) {
bool x = a > b;
if (x)
a = b;
return x;
}
double distance(ddatas &x, ddatas &y) {
double a = x.first - y.first, b = x.second - y.second;
return sqrt(a * a + b * b);
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + mod) % mod;
}
ll moddevide(ll a, ll b) { return (a * modinv(b)) % mod; }
vec modncrlistp, modncrlistm;
ll modncr(ll n, ll r) {
ll i, size = modncrlistp.size();
if (size <= n) {
modncrlistp.resize(n + 1);
modncrlistm.resize(n + 1);
if (!size) {
modncrlistp[0] = modncrlistm[0] = 1;
size++;
}
For(i, size, n + 1) {
modncrlistp[i] = modncrlistp[i - 1] * i % mod;
modncrlistm[i] = modinv(modncrlistp[i]);
}
}
return modncrlistp[n] * modncrlistm[r] % mod * modncrlistm[n - r] % mod;
}
ll modpow(ll a, ll n) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {
if (!b)
return a;
return (a % b == 0) ? b : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll countdigits(ll n) {
ll ans = 0;
while (n) {
n /= 10;
ans++;
}
return ans;
}
ll sumdigits(ll n) {
ll ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
vec eratosthenes(ll N) {
ll i;
vec ch(N + 1, 1), p;
ch[0] = ch[1] = 0;
rep(i, N + 1) {
if (ch[i]) {
p.pb(i);
for (ll j = 2; i * j <= N; j++) {
ch[i * j] = 0;
}
}
}
return ch;
}
vec primefactorization(ll N) {
ll i = 2;
vec res;
while (i * i <= N) {
while (!(N % i)) {
res.pb(i);
N /= i;
}
i++;
}
if (N - 1)
res.pb(N);
return res;
}
vec diviserlist(ll N) {
ll i;
vec res;
for (i = 1; i * i < N; i++) {
if (N % i == 0) {
res.pb(i);
res.pb(N / i);
}
}
if (i * i == N)
res.pb(i);
vsort(res);
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M, ans = 1;
cin >> M >> N;
vec v = primefactorization(N);
map<ll, ll> mp;
for (auto i : v) {
mp[i]++;
if (mp[i] % M == 0)
ans *= i;
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 991,157 | 991,158 | u251847465 | cpp |
p03196 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
const int mod = 1e9 + 7;
const int inf = 1 << 20;
const long long INF = 1LL << 60;
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
using namespace std;
map<ll, ll> prime_factors(ll n) {
map<ll, ll> res;
if (n == 1) {
res[n] = 1;
return res;
}
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
++res[i];
n /= i;
}
}
if (n != 1) {
res[n] = 1;
}
return res;
}
int main() {
ll n, p;
ll ans = 1;
cin >> n >> p;
map<ll, ll> mp = prime_factors(p);
for (auto i : mp) {
if (i.second >= n) {
ll cnt = i.second / n;
for (ll j = 1; j < cnt; j++) {
ans *= i.first;
}
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
const int mod = 1e9 + 7;
const int inf = 1 << 20;
const long long INF = 1LL << 60;
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
using namespace std;
map<ll, ll> prime_factors(ll n) {
map<ll, ll> res;
if (n == 1) {
res[n] = 1;
return res;
}
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
++res[i];
n /= i;
}
}
if (n != 1) {
res[n] = 1;
}
return res;
}
int main() {
ll n, p;
ll ans = 1;
cin >> n >> p;
map<ll, ll> mp = prime_factors(p);
for (auto i : mp) {
if (i.second >= n) {
ll cnt = i.second / n;
for (ll j = 1; j <= cnt; j++) {
ans *= i.first;
}
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,171 | 991,172 | u883323885 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#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;
const int MOD = 1000000007;
typedef long long ll;
// typedef pair<ll, ll> p;
const int INF = (1 << 28);
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
ll m, p;
int a[10000];
set<ll> s;
//素因数分解o√n
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
++res[i];
if (res[i] == m)
s.insert(i);
n /= i;
}
}
if (n != 1) {
res[n] = 1;
if (res[n] == m)
s.insert(n);
}
// for(int i=2;i<=n;i++)cout<<res[i]<<"\n";
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> m >> p;
map<ll, ll> m = prime_factor(p);
if (s.size() == 0) {
cout << 1 << "\n";
return 0;
}
ll ans = 1;
for (auto i = s.begin(); i != s.end(); i++) {
ans *= *i;
}
cout << ans << "\n";
}
| #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#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;
const int MOD = 1000000007;
typedef long long ll;
// typedef pair<ll, ll> p;
const int INF = (1 << 28);
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
ll m, p;
int a[10000];
multiset<ll> s;
//素因数分解o√n
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
++res[i];
if (res[i] % m == 0)
s.insert(i);
n /= i;
}
}
if (n != 1) {
res[n] = 1;
if (res[n] == m)
s.insert(n);
}
// for(int i=2;i<=n;i++)cout<<res[i]<<"\n";
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> m >> p;
map<ll, ll> m = prime_factor(p);
if (s.size() == 0) {
cout << 1 << "\n";
return 0;
}
ll ans = 1;
for (auto i = s.begin(); i != s.end(); i++) {
ans *= *i;
}
cout << ans << "\n";
}
| [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 991,173 | 991,174 | u155416173 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
int main() {
lint n, p;
cin >> n >> p;
map<lint, lint> pf;
for (lint i = 2; i * i <= p; i++) {
while (p % i == 0)
pf[i]++, p /= i;
}
if (p != 1)
pf[p] = 1;
lint ans = 1;
for (auto e : pf) {
lint c = e.second / n;
if (c)
ans *= e.first * c;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
int main() {
lint n, p;
cin >> n >> p;
map<lint, lint> pf;
for (lint i = 2; i * i <= p; i++) {
while (p % i == 0)
pf[i]++, p /= i;
}
if (p != 1)
pf[p] = 1;
lint ans = 1;
for (auto e : pf) {
lint c = e.second / n;
if (c)
ans *= pow(e.first, c);
}
cout << ans << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 991,175 | 991,176 | u194268736 | cpp |
p03196 | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#define MOD 1000000007
#define INT long long int
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
const long long INF = numeric_limits<long long>::max();
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
int main() {
INT N, P;
cin >> N >> P;
INT limit = (pow(P, (double)1 / N));
// vector <int64_t> divide = divisor(int64_t (P));
// sort(divide.begin(),divide.end());
if (N == 1) {
cout << P << endl;
return 0;
}
INT tmp;
INT ans = 0;
for (int i = 1; i < limit + 1; i++) {
tmp = (pow(i, N));
if (P % tmp == 0)
ans = i;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#define MOD 1000000007
#define INT long long int
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
const long long INF = numeric_limits<long long>::max();
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
int main() {
INT N, P;
cin >> N >> P;
INT limit = (pow(P, (double)1 / N));
// vector <int64_t> divide = divisor(int64_t (P));
// sort(divide.begin(),divide.end());
if (N == 1) {
cout << P << endl;
return 0;
}
INT tmp;
INT ans = 0;
// cout << limit << endl;
for (int i = 1; i < limit + 10; i++) {
tmp = (pow(i, N));
// printf("%d:%lld,%lld\n",i,tmp,(P%tmp));
if (P % tmp == 0)
ans = i;
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 991,181 | 991,182 | u698176039 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
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;
}
map<long long, int> prime_factor(long long n) {
map<long long, int> res;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
int main() {
ll n, p;
cin >> n >> p;
auto mp = prime_factor(p);
ll ans = 1;
for (auto e : mp)
ans *= e.first * (e.second / n);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
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;
}
map<long long, int> prime_factor(long long n) {
map<long long, int> res;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
int main() {
ll n, p;
cin >> n >> p;
auto mp = prime_factor(p);
ll ans = 1;
for (auto e : mp)
ans *= pow(e.first, e.second / n);
cout << ans << endl;
return 0;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,185 | 991,186 | u608258653 | cpp |
p03196 | // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
ll n, p, ans = 1;
map<ll, ll> mp;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p;
for (ll i = 2; i * i <= p; i++)
while (p % i == 0)
p /= i, mp[i]++;
if (p > 1)
mp[p]++;
for (auto i : mp)
if (i.ss >= n)
for (int j = 0; j < i.ss; j++)
ans *= i.ff;
cout << ans << endl;
return 0;
}
| // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
ll n, p, ans = 1;
map<ll, ll> mp;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p;
for (ll i = 2; i * i <= p; i++)
while (p % i == 0)
p /= i, mp[i]++;
if (p > 1)
mp[p]++;
for (auto i : mp)
if (i.ss >= n)
for (int j = 0; j < i.ss / n; j++)
ans *= i.ff;
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 991,189 | 991,190 | u535425458 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
// xを二進数に変換
vector<ll> to2(ll x) {
vector<ll> ret;
while (x > 0) {
if (x % 2) {
ret.push_back(1);
} else {
ret.push_back(0);
}
x /= 2;
}
return ret;
}
ll myPow(ll x, ll n) {
vector<ll> r = to2(n);
vector<ll> v(r.size()); // v[0] = v^1 v[1] = v^2, v[2] = v^4, v[3] = v^8,
ll tmp = 1;
for (ll i = 0; i < r.size(); i++) {
if (i == 0)
v[i] = x;
else
v[i] = v[i - 1] * v[i - 1];
if (r[i] == 1) {
tmp *= v[i];
}
}
return tmp;
}
int main() {
ll N, P;
cin >> N >> P;
if (N == 1 || P == 1) {
cout << P << endl;
return 0;
}
ll logMax = log(P) / N;
ll left = 1;
ll right = P;
while (right - left >= 2) {
ll mid = (right + left) / 2;
if (log(mid) <= logMax) {
left = mid;
} else {
right = mid;
}
}
for (ll i = right; i >= 1; i--) {
if (myPow(i, N) <= 0)
continue;
if (P % myPow(i, N) == 0) {
cout << i << endl;
return 0;
}
}
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
// xを二進数に変換
vector<ll> to2(ll x) {
vector<ll> ret;
while (x > 0) {
if (x % 2) {
ret.push_back(1);
} else {
ret.push_back(0);
}
x /= 2;
}
return ret;
}
ll myPow(ll x, ll n) {
vector<ll> r = to2(n);
vector<ll> v(r.size()); // v[0] = v^1 v[1] = v^2, v[2] = v^4, v[3] = v^8,
ll tmp = 1;
for (ll i = 0; i < r.size(); i++) {
if (i == 0)
v[i] = x;
else
v[i] = v[i - 1] * v[i - 1];
if (r[i] == 1) {
tmp *= v[i];
}
}
return tmp;
}
int main() {
ll N, P;
cin >> N >> P;
if (N == 1 || P == 1) {
cout << P << endl;
return 0;
}
ll logMax = log(P) / N + 1;
ll left = 1;
ll right = P;
while (right - left >= 2) {
ll mid = (right + left) / 2;
if (log(mid) <= logMax) {
left = mid;
} else {
right = mid;
}
}
for (ll i = right; i >= 1; i--) {
if (myPow(i, N) <= 0)
continue;
if (P % myPow(i, N) == 0) {
cout << i << endl;
return 0;
}
}
} | [
"assignment.change"
] | 991,197 | 991,198 | u412550879 | cpp |
p03196 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
// xを二進数に変換
vector<ll> to2(ll x) {
vector<ll> ret;
while (x > 0) {
if (x % 2) {
ret.push_back(1);
} else {
ret.push_back(0);
}
x /= 2;
}
return ret;
}
ll myPow(ll x, ll n) {
vector<ll> r = to2(n);
vector<ll> v(r.size()); // v[0] = v^1 v[1] = v^2, v[2] = v^4, v[3] = v^8,
ll tmp = 1;
for (ll i = 0; i < r.size(); i++) {
if (i == 0)
v[i] = x;
else
v[i] = v[i - 1] * v[i - 1];
if (r[i] == 1) {
tmp *= v[i];
}
}
return tmp;
}
int main() {
ll N, P;
cin >> N >> P;
if (N == 1 || P == 1) {
cout << P << endl;
return 0;
}
ll logMax = log(P) / N;
ll left = 1;
ll right = P;
while (right - left >= 2) {
ll mid = (right + left) / 2;
if (log(mid) <= logMax) {
left = mid;
} else {
right = mid;
}
}
for (ll i = right; i >= 1; i--) {
if (myPow(i, N) < 0)
continue;
if (P % myPow(i, N) == 0) {
cout << i << endl;
return 0;
}
}
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const bool DEBAG = false;
// xを二進数に変換
vector<ll> to2(ll x) {
vector<ll> ret;
while (x > 0) {
if (x % 2) {
ret.push_back(1);
} else {
ret.push_back(0);
}
x /= 2;
}
return ret;
}
ll myPow(ll x, ll n) {
vector<ll> r = to2(n);
vector<ll> v(r.size()); // v[0] = v^1 v[1] = v^2, v[2] = v^4, v[3] = v^8,
ll tmp = 1;
for (ll i = 0; i < r.size(); i++) {
if (i == 0)
v[i] = x;
else
v[i] = v[i - 1] * v[i - 1];
if (r[i] == 1) {
tmp *= v[i];
}
}
return tmp;
}
int main() {
ll N, P;
cin >> N >> P;
if (N == 1 || P == 1) {
cout << P << endl;
return 0;
}
ll logMax = log(P) / N + 1;
ll left = 1;
ll right = P;
while (right - left >= 2) {
ll mid = (right + left) / 2;
if (log(mid) <= logMax) {
left = mid;
} else {
right = mid;
}
}
for (ll i = right; i >= 1; i--) {
if (myPow(i, N) <= 0)
continue;
if (P % myPow(i, N) == 0) {
cout << i << endl;
return 0;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,199 | 991,198 | u412550879 | cpp |
p03196 | #include <iostream>
using namespace std;
int main() {
long long n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
long long nw = 0;
long long ans = 1;
bool lock = false;
for (long long i = 2; p >= i * i; i++) {
if (p % i == 0) {
nw++;
if (i * i == p)
nw++;
if (!lock && nw >= n) {
lock = true;
ans *= i;
}
p /= i;
i--;
} else {
lock = false;
nw = 0;
}
}
cout << ans << endl;
}
| #include <iostream>
using namespace std;
int main() {
long long n, p;
cin >> n >> p;
if (n == 1) {
cout << p << endl;
return 0;
}
long long nw = 0;
long long ans = 1;
bool lock = false;
for (long long i = 2; p >= i * i; i++) {
if (p % i == 0) {
nw++;
if (i * i == p)
nw++;
if (!lock && nw >= n) {
nw = nw % n;
ans *= i;
}
p /= i;
i--;
} else {
lock = false;
nw = 0;
}
}
cout << ans << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"assignment.value.change",
"assignment.change"
] | 991,202 | 991,203 | u466161487 | cpp |
p03196 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
typedef pair<int, int> P;
typedef pair<Int, Int> Pl;
const int mod = 1e9 + 7;
#define END \
{ \
cout << ans << '\n'; \
return 0; \
}
#define ALL(v) v.begin(), v.end()
#define Pr(type) priority_queue<type>
#define gPr(type) priority_queue<type, vector<type>, greater<type>>
#define V(type) vector<type>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rer(i, st, en) for (int i = st; i < en; i++)
#define eb emplace_back
#define pri1(a) cout << a << '\n'
#define pri2(a, n) rep(i, n) cout << a[i] << '\n'
#define pri3(a, n) \
rep(i, n - 1) cout << a[i] << ' '; \
cout << a[n - 1] << '\n'
#define prip(p) cout << p.first << ' ' << p.second << '\n'
template <class T> inline bool cmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool cmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
Int n, m, _, x, y, q;
string s, sb;
bool ok;
map<Int, Int> p;
void dic(Int n) {
for (Int i = 2; i * i <= n; i++) {
if (!(n % i)) {
p[i]++;
dic(n / i);
return;
}
}
if (n != 1)
p[n]++;
return;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n >> q;
Int ans = 1;
if (n == 1) {
pri1(q);
return 0;
}
dic(q);
for (auto e : p)
if (e.second >= n)
ans *= (e.first * (e.second / n));
END
} | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
typedef pair<int, int> P;
typedef pair<Int, Int> Pl;
const int mod = 1e9 + 7;
#define END \
{ \
cout << ans << '\n'; \
return 0; \
}
#define ALL(v) v.begin(), v.end()
#define Pr(type) priority_queue<type>
#define gPr(type) priority_queue<type, vector<type>, greater<type>>
#define V(type) vector<type>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rer(i, st, en) for (int i = st; i < en; i++)
#define eb emplace_back
#define pri1(a) cout << a << '\n'
#define pri2(a, n) rep(i, n) cout << a[i] << '\n'
#define pri3(a, n) \
rep(i, n - 1) cout << a[i] << ' '; \
cout << a[n - 1] << '\n'
#define prip(p) cout << p.first << ' ' << p.second << '\n'
template <class T> inline bool cmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool cmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
Int n, m, _, x, y, q;
string s, sb;
bool ok;
map<Int, Int> p;
void dic(Int n) {
for (Int i = 2; i * i <= n; i++) {
if (!(n % i)) {
p[i]++;
dic(n / i);
return;
}
}
if (n != 1)
p[n]++;
return;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n >> q;
Int ans = 1;
if (n == 1) {
pri1(q);
return 0;
}
dic(q);
for (auto e : p)
if (e.second >= n)
ans *= pow(e.first, (e.second / n));
END
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change"
] | 991,206 | 991,207 | u735089337 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 1; i <= n; i++) {
if (v[i] % 2) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 0; i < n; i++) {
if (v[i] % 2) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
return 0;
} | [
"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"
] | 991,220 | 991,221 | u645322855 | cpp |
p03197 | /////////////////////////////////////////////////
///// Give me AC!!!! /////
/////////////////////////////////////////////////
//↑これじゃ気合いが足りない！
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////
///お願いしますACをくださいそうじゃないと僕泣きますお願いしますACをくださいJudge様....
////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define erep(i, N) for (int i = N - 1; i >= 0; i--)
const int MOD = 1000000007;
const int MAX = 100000;
const ld PI = (acos(-1));
using Graph = vector<vector<int>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef pair<int, int> P;
typedef pair<ll, ll> PLL;
ld rad(ld a) { return a * 180 / PI; }
const int dx[4] = {1, 0, -1, 0}; // 2次元グリッド上のx軸方向
const int dy[4] = {0, 1, 0, -1}; // 2次元グリッド上のy軸方向
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
map<ll, ll> factorize_list;
void prime_factorize(ll N) {
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
factorize_list[a] = ex;
}
// 最後に残った数について
if (N != 1)
factorize_list[N] = 1;
return;
}
// dpTable
vector<ll> dp(100, MAX);
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll mod(ll val, ll m) {
ll res = val % m;
if (res < 0)
res += m;
return res;
}
long long fac[MAX], finv[MAX], inv[MAX];
char upper(char c) {
if ('a' <= c && c <= 'z') {
c = c - ('a' - 'A');
}
return c;
}
char lower(char c) {
if ('A' <= c && c <= 'Z') {
c = c + ('a' - 'A');
}
return c;
}
const ll INF = 10000000000;
struct edge {
ll to, cost;
};
int main() {
int N;
cin >> N;
bool ans = false;
for (int i = 0; i < N; i++) {
ll a;
cin >> a;
if (a % 2 != 0)
ans = true;
}
cout << (ans ? "second" : "first") << endl;
return 0;
}
| /////////////////////////////////////////////////
///// Give me AC!!!! /////
/////////////////////////////////////////////////
//↑これじゃ気合いが足りない！
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////
///お願いしますACをくださいそうじゃないと僕泣きますお願いしますACをくださいJudge様....
////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define erep(i, N) for (int i = N - 1; i >= 0; i--)
const int MOD = 1000000007;
const int MAX = 100000;
const ld PI = (acos(-1));
using Graph = vector<vector<int>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef pair<int, int> P;
typedef pair<ll, ll> PLL;
ld rad(ld a) { return a * 180 / PI; }
const int dx[4] = {1, 0, -1, 0}; // 2次元グリッド上のx軸方向
const int dy[4] = {0, 1, 0, -1}; // 2次元グリッド上のy軸方向
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
map<ll, ll> factorize_list;
void prime_factorize(ll N) {
for (ll a = 2; a * a <= N; ++a) {
if (N % a != 0)
continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (N % a == 0) {
++ex;
N /= a;
}
// その結果を push
factorize_list[a] = ex;
}
// 最後に残った数について
if (N != 1)
factorize_list[N] = 1;
return;
}
// dpTable
vector<ll> dp(100, MAX);
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll mod(ll val, ll m) {
ll res = val % m;
if (res < 0)
res += m;
return res;
}
long long fac[MAX], finv[MAX], inv[MAX];
char upper(char c) {
if ('a' <= c && c <= 'z') {
c = c - ('a' - 'A');
}
return c;
}
char lower(char c) {
if ('A' <= c && c <= 'Z') {
c = c + ('a' - 'A');
}
return c;
}
const ll INF = 10000000000;
struct edge {
ll to, cost;
};
int main() {
int N;
cin >> N;
bool ans = false;
for (int i = 0; i < N; i++) {
ll a;
cin >> a;
if (a % 2 != 0)
ans = true;
}
cout << (ans ? "first" : "second") << endl;
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 991,222 | 991,223 | u620626180 | cpp |
p03197 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
int n = 0;
for (auto e : vec)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
int n = 0;
for (auto e : st)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
int n = 0;
for (auto e : mp)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
for (T &e : vec)
is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
int main() {
int N;
cin >> N;
vector<int64> a(N);
cin >> a;
for (int i = 0; i < N; i++) {
if (a[N] % 2 == 1) {
cout << "second" << endl;
return 0;
}
}
cout << "first" << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
int n = 0;
for (auto e : vec)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
int n = 0;
for (auto e : st)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
int n = 0;
for (auto e : mp)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
for (T &e : vec)
is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
int main() {
int N;
cin >> N;
vector<int64> a(N);
cin >> a;
for (int i = 0; i < N; i++) {
if (a[i] % 2 == 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 991,226 | 991,227 | u721166818 | cpp |
p03197 | #include <bits/stdc++.h>
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const ll MAX = 1000000000000000;
static const int NIL = -1;
using namespace std;
const long double EPS = 0.0000000001;
const long double PI = (acos(-1));
const ll MOD = 1e9 + 7;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int main() {
ll n, a;
cin >> n;
string ans = "first";
rep(i, n) {
cin >> a;
if (a % 2 == 1)
ans = "second";
}
cout << ans;
}
| #include <bits/stdc++.h>
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const ll MAX = 1000000000000000;
static const int NIL = -1;
using namespace std;
const long double EPS = 0.0000000001;
const long double PI = (acos(-1));
const ll MOD = 1e9 + 7;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int main() {
ll n, a;
cin >> n;
string ans = "second";
rep(i, n) {
cin >> a;
if (a % 2 == 1)
ans = "first";
}
cout << ans;
}
| [
"literal.string.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 991,230 | 991,231 | u236585484 | cpp |
p03197 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define repi(i, x) \
for (auto i = (x).begin(), i##_fin = (x).end(); i != i##_fin; i++)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a) ? "first" : "second")
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef pair<int, int> Pi;
typedef vector<Pi> VPi;
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long, long long> P;
typedef vector<P> VP;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const int INF = 1 << 30;
const double PI = acos(-1);
int main() {
int n;
bool ans = false;
cin >> n;
Vi a(n);
rep(i, n) {
cin >> a[i];
ans ^= ((a[i] % 2));
}
cout << solve(ans) << endl;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define repi(i, x) \
for (auto i = (x).begin(), i##_fin = (x).end(); i != i##_fin; i++)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a) ? "first" : "second")
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef pair<int, int> Pi;
typedef vector<Pi> VPi;
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long, long long> P;
typedef vector<P> VP;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const int INF = 1 << 30;
const double PI = acos(-1);
int main() {
int n;
bool ans = false;
cin >> n;
Vi a(n);
rep(i, n) {
cin >> a[i];
ans |= (a[i] % 2);
}
cout << solve(ans) << endl;
} | [
"expression.operator.change"
] | 991,245 | 991,246 | u179778090 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = (0); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define DEBUG(val) cout << #val << " : " << val << endl
#define MOD 1000000007
int main() {
int n;
cin >> n;
bool flag = true;
REP(i, n) {
int x;
cin >> x;
flag ^= (x % 2);
}
string s = flag ? "second" : "first";
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = (0); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define DEBUG(val) cout << #val << " : " << val << endl
#define MOD 1000000007
int main() {
int n;
cin >> n;
bool flag = true;
REP(i, n) {
int x;
cin >> x;
flag = flag && (x % 2 == 0);
}
string s = flag ? "second" : "first";
cout << s << endl;
} | [
"assignment.value.change",
"assignment.change"
] | 991,247 | 991,248 | u947517859 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for (int i = 0; i < (a); i++)
typedef long long ll;
#ifdef _DEBUG
inline void dump() { cerr << endl; }
template <typename Head> void dump(Head &&head) {
cerr << head;
dump();
}
template <typename Head, typename... Tail>
void dump(Head &&head, Tail &&...tail) {
cerr << head << ", ";
dump(forward<Tail>(tail)...);
}
#define debug(...) \
do { \
cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
dump(__VA_ARGS__); \
} while (false)
#else
#define dump(...)
#define debug(...)
#endif
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T> using Matrix = vector<vector<T>>;
/////////////////////////////////////////////////////////////////////
const ll inf = 1LL << 60;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
bool flg = true;
rep(i, n) if (a[i] % 2) flg = false;
if (flg)
cout << "first" << endl;
else
cout << "second" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for (int i = 0; i < (a); i++)
typedef long long ll;
#ifdef _DEBUG
inline void dump() { cerr << endl; }
template <typename Head> void dump(Head &&head) {
cerr << head;
dump();
}
template <typename Head, typename... Tail>
void dump(Head &&head, Tail &&...tail) {
cerr << head << ", ";
dump(forward<Tail>(tail)...);
}
#define debug(...) \
do { \
cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
dump(__VA_ARGS__); \
} while (false)
#else
#define dump(...)
#define debug(...)
#endif
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T> using Matrix = vector<vector<T>>;
/////////////////////////////////////////////////////////////////////
const ll inf = 1LL << 60;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
bool flg = true;
rep(i, n) if (a[i] % 2) flg = false;
if (flg)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
}
| [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 991,249 | 991,250 | u305824645 | cpp |
p03197 | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repr(i, n) for (ll i = n - 1; i >= 0; --i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
using namespace std;
void solve(void) {
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
ll cta = 0;
rep(i, n) if (a[i] % 2 == 1) cta++;
if (cta % 2 == 1)
cout << "first" << endl;
else
cout << "second" << endl;
}
int main(void) { solve(); } | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repr(i, n) for (ll i = n - 1; i >= 0; --i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
using namespace std;
void solve(void) {
ll n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
ll cta = 0;
rep(i, n) if (a[i] % 2 == 1) cta++;
if (cta > 0)
cout << "first" << endl;
else
cout << "second" << endl;
}
int main(void) { solve(); } | [
"expression.operation.binary.remove"
] | 991,251 | 991,252 | u110044127 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
if (a % 2 == 1) {
cout << "First" << endl;
return 0;
}
}
cout << "Second" << endl;
} | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
if (a % 2 == 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,253 | 991,254 | u239409893 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
ll s;
bool ans = false;
rep(i, n) {
int a;
cin >> a;
if (a % 2)
ans = true;
}
if (ans)
cout << "First" << endl;
else
cout << "Second" << endl;
} | #include <bits/stdc++.h>
#define rep(i, N) for (ll(i) = 0; (i) < (N); (i)++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
ll s;
bool ans = false;
rep(i, n) {
int a;
cin >> a;
if (a % 2)
ans = true;
}
if (ans)
cout << "first" << endl;
else
cout << "second" << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,255 | 991,256 | u239409893 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
bool K = false;
vector<long long> v(N);
for (int X = 0; X < N; X++) {
cin >> v[X];
if (v[X] % 2 == 1) {
K = true;
cout << "first" << endl;
break;
}
}
if (K == true) {
cout << "second" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
bool K = false;
vector<long long> v(N);
for (int X = 0; X < N; X++) {
cin >> v[X];
if (v[X] % 2 == 1) {
K = true;
cout << "first" << endl;
break;
}
}
if (K == false) {
cout << "second" << endl;
}
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 991,257 | 991,258 | u740002394 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool f = true;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
f &= f % 2 == 0;
}
cout << (f ? "second" : "first") << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
bool f = true;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
f &= x % 2 == 0;
}
cout << (f ? "second" : "first") << endl;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 991,267 | 991,268 | u691380397 | cpp |
p03197 | #include <iostream>
using namespace std;
int main() {
int n;
bool second = true;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (num % 2 != 0)
second = false;
}
if (second)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
bool second = true;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (num % 2 != 0)
second = false;
}
if (second)
cout << "second" << endl;
else
cout << "first" << endl;
return 0;
}
| [] | 991,269 | 991,270 | u509420256 | cpp |
p03197 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
if (a % 2 != 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
int n;
cin >> n;
rep(i, n) {
int a;
cin >> a;
if (a % 2 == 1) {
cout << "first" << endl;
return 0;
}
}
cout << "second" << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 991,273 | 991,274 | u233586402 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
int flag = 1;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (A[i] % 2 == 1) {
flag = 0;
}
}
if (flag == 1) {
cout << "second" << endl;
} else {
cout << "fitst" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N];
int flag = 1;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (A[i] % 2 == 1) {
flag = 0;
}
}
if (flag == 1) {
cout << "second" << endl;
} else {
cout << "first" << endl;
}
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 991,282 | 991,283 | u469315559 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using st = string;
using ch = char;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<P> vP;
typedef vector<ch> vc;
typedef vector<vc> vvc;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, n) FOR(i, 0, n)
#define ROF(i, a, b) for (ll i = a; i >= b; i--)
#define per(i, a) ROF(i, a, 0)
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
const ld PI = acos(-1);
const ll INF = 1e18;
st abc = "abcdefghijklmnopqrstuvwxyz";
st ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
struct edge {
ll to, cost;
};
int main() {
ll N;
cin >> N;
ll a;
bool B = false;
rep(i, N) {
cin >> a;
if (a % 2 == 1) {
B = true;
}
}
if (B) {
cout << "first" << endl;
} else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using st = string;
using ch = char;
typedef pair<ll, ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<P> vP;
typedef vector<ch> vc;
typedef vector<vc> vvc;
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, n) FOR(i, 0, n)
#define ROF(i, a, b) for (ll i = a; i >= b; i--)
#define per(i, a) ROF(i, a, 0)
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
const ld PI = acos(-1);
const ll INF = 1e18;
st abc = "abcdefghijklmnopqrstuvwxyz";
st ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
struct edge {
ll to, cost;
};
int main() {
ll N;
cin >> N;
ll a;
bool B = false;
rep(i, N) {
cin >> a;
if (a % 2 == 1) {
B = true;
}
}
if (B) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
}
| [
"literal.string.change",
"io.output.change"
] | 991,288 | 991,289 | u328811800 | cpp |
p03197 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define VI vector<int>
#define MOD 1000000007
using ll = long long int;
using P = pair<int, int>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll INF = (ll)1e19;
// const int INF=(1<<30);
// const int INF=(1<<29);
int main() {
int N;
cin >> N;
bool ok = true;
REP(i, N) {
int a;
cin >> a;
if (a % 2 == 1)
ok = false;
}
cout << (ok ? "Second" : "First") << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define VI vector<int>
#define MOD 1000000007
using ll = long long int;
using P = pair<int, int>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll INF = (ll)1e19;
// const int INF=(1<<30);
// const int INF=(1<<29);
int main() {
int N;
cin >> N;
bool ok = true;
REP(i, N) {
int a;
cin >> a;
if (a % 2 == 1)
ok = false;
}
cout << (ok ? "second" : "first") << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,299 | 991,300 | u868089307 | cpp |
p03197 | #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline T intceil(T a, T b) { return (a + (b - 1)) / b; }
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
const long long MOD = 1e9 + 7;
#define precout(val) cout << std::fixed << std::setprecision(20) << val;
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
const int dy[4] = {0, 1, 0, -1};
const int dx[4] = {1, 0, -1, 0};
static const double pi = 3.141592653589793;
// if(nextH >= 0 && nextH < H && nextW >= 0 && nextW < W)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
bool first = 0;
rep(i, n) {
int a;
cin >> a;
if (a % 2 == 1) {
bool first = 1;
}
}
if (first) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <numeric>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline T intceil(T a, T b) { return (a + (b - 1)) / b; }
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
const long long MOD = 1e9 + 7;
#define precout(val) cout << std::fixed << std::setprecision(20) << val;
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
const int dy[4] = {0, 1, 0, -1};
const int dx[4] = {1, 0, -1, 0};
static const double pi = 3.141592653589793;
// if(nextH >= 0 && nextH < H && nextW >= 0 && nextW < W)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
bool first = 0;
rep(i, n) {
int a;
cin >> a;
if (a % 2 == 1) {
first = 1;
}
}
if (first) {
cout << "first" << endl;
} else {
cout << "second" << endl;
}
return 0;
}
| [] | 991,305 | 991,306 | u223160139 | cpp |
p03197 | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(c) (c).rbegin(), (c).rend()
#define mp make_pair
#define endl '\n'
typedef long long ll;
typedef pair<ll, ll> pll;
typedef long double ld;
const ll inf = 1e9 + 7;
const ll mod = 1e9 + 7;
signed main() {
ll n;
cin >> n;
ll ans = 0;
rep(i, n) {
ll a;
cin >> a;
ans |= (a % 2);
}
cout << (ans ? "First" : "Second") << endl;
} | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long
#define REP(i, m, n) for (int i = (m); i < (n); i++)
#define rep(i, n) REP(i, 0, n)
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(c) (c).rbegin(), (c).rend()
#define mp make_pair
#define endl '\n'
typedef long long ll;
typedef pair<ll, ll> pll;
typedef long double ld;
const ll inf = 1e9 + 7;
const ll mod = 1e9 + 7;
signed main() {
ll n;
cin >> n;
ll ans = 0;
rep(i, n) {
ll a;
cin >> a;
ans |= (a % 2);
}
cout << (ans ? "first" : "second") << endl;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 991,309 | 991,310 | u339937125 | cpp |
p03197 |
/*
@・ω・@
*/
/*****/
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
//#define int long long
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<long long, long long>;
template <class T> using vec = vector<T>;
#define debug(x) std::cerr << x
#define debugln(x) std::cerr << x << "\n"
#define debuglntab(n, x) std::cerr << strMulti("\t", n) << x << "\n"
#define debug_cout(x) \
std::cerr << #x << " = "; \
_debug_cout(x)
#define debug_tabcout(n, x) \
std::cerr << strMulti("\t", n) << #x << " = "; \
_debug_cout(x)
#define debug_headcout(h, x) \
std::cerr << h << " = "; \
_debug_cout(x)
#define debug_tabheadcout(n, h, x) \
std::cerr << strMulti("\t", n) << h << " = "; \
_debug_cout(x)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rrep1(i, n) for (int i = (n); i > 0; --i)
#define step(i, a, n) for (int i = (a), i##_len = (a) + (n); i < i##_len; ++i)
#define rstep(i, a, n) \
for (int i = (a) + (n)-1, i##_len = (a); i >= i##_len; --i)
#define range(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rrange(i, a, b) for (int i = (b)-1, i##_len = (a); i >= i##_len; --i)
#define repll(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1ll(i, n) for (ll i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrepll(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrep1ll(i, n) for (ll i = (n); i > 0; --i)
#define stepll(i, a, n) for (ll i = (a), i##_len = (a) + (n); i < i##_len; ++i)
#define rstepll(i, a, n) \
for (ll i = (a) + (n)-1, i##_len = (a); i >= i##_len; --i)
#define rangell(i, a, b) for (ll i = (a), i##_len = (b); i < i##_len; ++i)
#define rrangell(i, a, b) for (ll i = (b)-1, i##_len = (a); i >= i##_len; --i)
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b)
template <class T> void _debug_cout(const T v, const string space = " ") {
debugln(v);
}
template <class T>
void _debug_cout(const vector<T> ar, const string space = " ") {
for (auto v : ar) {
debug(v << space);
}
debugln("");
}
template <class T1, class T2>
void _debug_cout(const vector<pair<T1, T2>> ar, const string space = " ") {
rep(i, ar.size()) { debug(ar[i].first << "," << ar[i].second << space); }
debugln("");
}
std::string strMulti(const std::string t, const int n) {
std::string out = "";
for (int i = 0; i < n; i++) {
out += t;
}
return out;
}
constexpr int INF = numeric_limits<int>::max();
constexpr ll INFL = numeric_limits<ll>::max();
template <class T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T divup(const T a, const T b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
template <class T> bool cmp_2nd(pair<T, T> a, pair<T, T> b) {
if (a.second != b.second) {
return a.second < b.second;
}
return a.first < b.first;
}
ll mod_pow(ll x, ll n, const ll &p) {
ll ret = 1;
while (n > 0) {
if (n & 1) {
(ret *= x) %= p;
}
(x *= x) %= p;
n >>= 1;
}
return ret;
}
template <class T> T modinv(T a, const T &p) {
T b = p, u = 1, v = 0;
while (b) {
T t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= p;
if (u < 0) {
u += p;
}
return u;
}
template <class T> T math_P(T m, T n) {
T ret = 1;
for (T i = m; i > m - n; i--) {
ret *= i;
}
return ret;
}
template <class T> T math_C(T m, T n) {
T ret = math_P(m, n);
for (T i = 2; i <= n; i++) {
ret /= i;
}
return ret;
}
ll extended_euclidean(ll u, ll v) {
ll r0 = u;
ll r1 = v;
ll s0 = 1;
ll s1 = 0;
ll t0 = 0;
ll t1 = 1;
while (r1 != 0) {
ll q = r0 / r1;
ll r = r0 - q * r1;
ll s = s0 - q * s1;
ll t = t0 - q * t1;
r0 = r1;
s0 = s1;
t0 = t1;
r1 = r;
s1 = s;
t1 = t;
}
if (t0 < 0) {
return t0 + u;
} else {
return t0;
}
}
ll math_C_mod(ll n, ll c, const ll &p) {
ll upe = 1;
ll dow = 1;
for (ll i = 1; i < c + 1; ++i) {
upe = upe * n % p;
dow = dow * i % p;
n -= 1;
}
return (upe * extended_euclidean(p, dow)) % p;
}
// ll math_P_mod(ll m, ll n, const ll& p) { ll ret = 1; for (ll i = m; i > m -
// n; i--) { ret = (ret * i) % p; }return ret; } ll math_C_mod(ll m, ll n, const
// ll& p) { ll ret = math_P_mod(m, n, p); ll div = 1; for (ll i = 2; i <= n; i++)
// { div = (div * i) % p; }ret = (ret * modinv(div, p)) % p; return ret; }
template <class T> T math_gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return math_gcd(b, a % b);
}
}
template <class T> T SumStep(T a, T n, T d) {
return n * (2 * a + (n - 1) * d) / 2;
}
template <class T> T SumRange(T a, T b, T d) {
return SumStep(a, (b - a) / d, d);
}
constexpr ll MOD = 1000000007; // 10^9+7
/*****/
void Main() {
int N;
cin >> N;
vec<ll> A(N);
rep(i, N) cin >> A[i];
bool allEven = true;
rep(i, N) allEven &= A[i] % 2 == 0;
cout << (allEven ? "first" : "second");
}
/*****/
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed << std::setprecision(10);
/**
while (true)
{
Main();
std::cerr << flush;
cout << endl;
}
/*/
Main();
std::cerr << flush;
cout << endl;
/**/
return 0;
}
|
/*
@・ω・@
*/
/*****/
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
//#define int long long
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<long long, long long>;
template <class T> using vec = vector<T>;
#define debug(x) std::cerr << x
#define debugln(x) std::cerr << x << "\n"
#define debuglntab(n, x) std::cerr << strMulti("\t", n) << x << "\n"
#define debug_cout(x) \
std::cerr << #x << " = "; \
_debug_cout(x)
#define debug_tabcout(n, x) \
std::cerr << strMulti("\t", n) << #x << " = "; \
_debug_cout(x)
#define debug_headcout(h, x) \
std::cerr << h << " = "; \
_debug_cout(x)
#define debug_tabheadcout(n, h, x) \
std::cerr << strMulti("\t", n) << h << " = "; \
_debug_cout(x)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rrep1(i, n) for (int i = (n); i > 0; --i)
#define step(i, a, n) for (int i = (a), i##_len = (a) + (n); i < i##_len; ++i)
#define rstep(i, a, n) \
for (int i = (a) + (n)-1, i##_len = (a); i >= i##_len; --i)
#define range(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rrange(i, a, b) for (int i = (b)-1, i##_len = (a); i >= i##_len; --i)
#define repll(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep1ll(i, n) for (ll i = 1, i##_len = (n); i <= i##_len; ++i)
#define rrepll(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrep1ll(i, n) for (ll i = (n); i > 0; --i)
#define stepll(i, a, n) for (ll i = (a), i##_len = (a) + (n); i < i##_len; ++i)
#define rstepll(i, a, n) \
for (ll i = (a) + (n)-1, i##_len = (a); i >= i##_len; --i)
#define rangell(i, a, b) for (ll i = (a), i##_len = (b); i < i##_len; ++i)
#define rrangell(i, a, b) for (ll i = (b)-1, i##_len = (a); i >= i##_len; --i)
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b)
template <class T> void _debug_cout(const T v, const string space = " ") {
debugln(v);
}
template <class T>
void _debug_cout(const vector<T> ar, const string space = " ") {
for (auto v : ar) {
debug(v << space);
}
debugln("");
}
template <class T1, class T2>
void _debug_cout(const vector<pair<T1, T2>> ar, const string space = " ") {
rep(i, ar.size()) { debug(ar[i].first << "," << ar[i].second << space); }
debugln("");
}
std::string strMulti(const std::string t, const int n) {
std::string out = "";
for (int i = 0; i < n; i++) {
out += t;
}
return out;
}
constexpr int INF = numeric_limits<int>::max();
constexpr ll INFL = numeric_limits<ll>::max();
template <class T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T divup(const T a, const T b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
template <class T> bool cmp_2nd(pair<T, T> a, pair<T, T> b) {
if (a.second != b.second) {
return a.second < b.second;
}
return a.first < b.first;
}
ll mod_pow(ll x, ll n, const ll &p) {
ll ret = 1;
while (n > 0) {
if (n & 1) {
(ret *= x) %= p;
}
(x *= x) %= p;
n >>= 1;
}
return ret;
}
template <class T> T modinv(T a, const T &p) {
T b = p, u = 1, v = 0;
while (b) {
T t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= p;
if (u < 0) {
u += p;
}
return u;
}
template <class T> T math_P(T m, T n) {
T ret = 1;
for (T i = m; i > m - n; i--) {
ret *= i;
}
return ret;
}
template <class T> T math_C(T m, T n) {
T ret = math_P(m, n);
for (T i = 2; i <= n; i++) {
ret /= i;
}
return ret;
}
ll extended_euclidean(ll u, ll v) {
ll r0 = u;
ll r1 = v;
ll s0 = 1;
ll s1 = 0;
ll t0 = 0;
ll t1 = 1;
while (r1 != 0) {
ll q = r0 / r1;
ll r = r0 - q * r1;
ll s = s0 - q * s1;
ll t = t0 - q * t1;
r0 = r1;
s0 = s1;
t0 = t1;
r1 = r;
s1 = s;
t1 = t;
}
if (t0 < 0) {
return t0 + u;
} else {
return t0;
}
}
ll math_C_mod(ll n, ll c, const ll &p) {
ll upe = 1;
ll dow = 1;
for (ll i = 1; i < c + 1; ++i) {
upe = upe * n % p;
dow = dow * i % p;
n -= 1;
}
return (upe * extended_euclidean(p, dow)) % p;
}
// ll math_P_mod(ll m, ll n, const ll& p) { ll ret = 1; for (ll i = m; i > m -
// n; i--) { ret = (ret * i) % p; }return ret; } ll math_C_mod(ll m, ll n, const
// ll& p) { ll ret = math_P_mod(m, n, p); ll div = 1; for (ll i = 2; i <= n; i++)
// { div = (div * i) % p; }ret = (ret * modinv(div, p)) % p; return ret; }
template <class T> T math_gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return math_gcd(b, a % b);
}
}
template <class T> T SumStep(T a, T n, T d) {
return n * (2 * a + (n - 1) * d) / 2;
}
template <class T> T SumRange(T a, T b, T d) {
return SumStep(a, (b - a) / d, d);
}
constexpr ll MOD = 1000000007; // 10^9+7
/*****/
void Main() {
int N;
cin >> N;
vec<ll> A(N);
rep(i, N) cin >> A[i];
bool allEven = true;
rep(i, N) allEven &= A[i] % 2 == 0;
cout << (allEven ? "second" : "first");
}
/*****/
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed << std::setprecision(10);
/**
while (true)
{
Main();
std::cerr << flush;
cout << endl;
}
/*/
Main();
std::cerr << flush;
cout << endl;
/**/
return 0;
}
| [
"literal.string.change",
"io.output.change"
] | 991,314 | 991,315 | u588369531 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.