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 |
|---|---|---|---|---|---|---|---|
p02949 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define sperase(v, n) (v).erase(remove(all(v), n), (v).end())
#define vdelete(v) (v).erase(unique(all(v)), (v).end())
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1000000007
#define INF LONG_LONG_MAX
int n, m, p, a, b, c, ans, memo[2500];
bool is_ok[2500], visited[2500], inf;
vector<pair<int, int>> v[2500];
vector<int> vv[2500];
void kr(int k) {
if (is_ok[k])
return;
is_ok[k] = true;
for (auto i : vv[k])
kr(i);
}
void masu(int k, int now) {
if (!is_ok[k] || inf)
return;
if (visited[k] && memo[k] < now) {
inf = true;
return;
}
if (visited[k] || memo[k] >= now)
return;
memo[k] = now;
if (k == n - 1)
ans = max(ans, memo[k]);
visited[k] = true;
for (auto i : v[k])
masu(i.fi, now + i.se);
visited[k] = false;
}
signed main() {
rep(i, 2500) memo[i] = -1;
cin >> n >> m >> p;
rep(i, m) {
cin >> a >> b >> c;
c -= p;
a--, b--;
v[a].pb(mp(b, c));
vv[b].pb(a);
}
kr(n - 1);
masu(0, 0);
if (inf)
cout << -1 << endl;
else
cout << max(0LL, ans) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define sperase(v, n) (v).erase(remove(all(v), n), (v).end())
#define vdelete(v) (v).erase(unique(all(v)), (v).end())
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1000000007
#define INF LONG_LONG_MAX
int n, m, p, a, b, c, ans, memo[2500];
bool is_ok[2500], visited[2500], inf;
vector<pair<int, int>> v[2500];
vector<int> vv[2500];
void kr(int k) {
if (is_ok[k])
return;
is_ok[k] = true;
for (auto i : vv[k])
kr(i);
}
void masu(int k, int now) {
if (!is_ok[k] || inf)
return;
if (visited[k] && memo[k] < now) {
inf = true;
return;
}
if (memo[k] >= now)
return;
memo[k] = now;
if (k == n - 1)
ans = max(ans, memo[k]);
visited[k] = true;
for (auto i : v[k])
masu(i.fi, now + i.se);
visited[k] = false;
}
signed main() {
rep(i, 2500) memo[i] = -INF;
cin >> n >> m >> p;
rep(i, m) {
cin >> a >> b >> c;
c -= p;
a--, b--;
v[a].pb(mp(b, c));
vv[b].pb(a);
}
kr(n - 1);
masu(0, 0);
if (inf)
cout << -1 << endl;
else
cout << max(0LL, ans) << endl;
}
| [
"expression.operation.binary.remove",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 751,205 | 751,206 | u721367699 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define N 5050
typedef pair<int, int> pii;
typedef long long ll;
const ll inf = 1e18;
int n, m, p, head[N], nxt[N], to[N], w[N];
ll d[N];
void add_edge(int x, int y, int z, int id) {
to[id] = y, w[id] = z;
nxt[id] = head[x], head[x] = id;
}
queue<int> Q;
bool inq[N];
bool spfa(int x) {
for (int i = 1; i <= n; i++)
d[i] = inf, inq[i] = 0;
while (!Q.empty())
Q.pop();
Q.push(x);
d[x] = 0, inq[x] = 1;
for (int runs = 0; runs <= n; runs++) {
int sz = Q.size();
if (!sz)
return 1;
while (sz--) {
x = Q.front(), Q.pop();
inq[x] = 0;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i], z = w[i];
if (d[y] <= d[x] + z)
continue;
if (runs == n && y == n)
return 0;
d[y] = d[x] + z;
if (!inq[y])
Q.push(y), inq[y] = 1;
}
}
}
return 1;
}
int main() {
cin >> n >> m >> p;
int tot = 0;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
add_edge(a, b, p - c, ++tot);
}
if (!spfa(1))
puts("-1");
else
printf("%lld\n", max(0ll, -d[n]));
}
| #include <bits/stdc++.h>
using namespace std;
#define N 5050
typedef pair<int, int> pii;
typedef long long ll;
const ll inf = 1e18;
int n, m, p, head[N], nxt[N], to[N], w[N];
ll d[N];
void add_edge(int x, int y, int z, int id) {
to[id] = y, w[id] = z;
nxt[id] = head[x], head[x] = id;
}
queue<int> Q;
bool inq[N];
bool spfa(int x) {
for (int i = 1; i <= n; i++)
d[i] = inf, inq[i] = 0;
while (!Q.empty())
Q.pop();
Q.push(x);
d[x] = 0, inq[x] = 1;
for (int runs = 0; runs <= 2 * n; runs++) {
int sz = Q.size();
if (!sz)
return 1;
while (sz--) {
x = Q.front(), Q.pop();
inq[x] = 0;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i], z = w[i];
if (d[y] <= d[x] + z)
continue;
if (runs >= n && y == n)
return 0;
d[y] = d[x] + z;
if (!inq[y])
Q.push(y), inq[y] = 1;
}
}
}
return 1;
}
int main() {
cin >> n >> m >> p;
int tot = 0;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
add_edge(a, b, p - c, ++tot);
}
if (!spfa(1))
puts("-1");
else
printf("%lld\n", max(0ll, -d[n]));
}
| [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,216 | 751,217 | u074493292 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pil pair<int, ll>
#define pli pair<ll, int>
#define ppi pair<pii, int>
#define pip pair<int, pii>
#define pdd pair<double, double>
#define f first
#define s second
#define MOD 1000000007
#define mkp make_pair
#define M_PI 3.14159265358979323846
#define FOR(i, l, r) for (int i = l; i <= r; i++)
#define LOR(i, l, r) for (ll i = l; i <= r; i++)
#define FORD(i, r, l) for (int i = r; i >= l; i--)
#define LORD(i, r, l) for (ll i = r; i >= l; i--)
#define INF 1000000000
#define CL(x) memset(x, 0, sizeof(x))
#define DEB(x) cout << #x << " : " << x << '\n'
#define ALL(x) x.begin(), x.end()
#define SZ(x) x.size()
#define UI(x) (int)(x - 'A')
#define LI(x) (int)(x - 'a')
typedef long long ll;
#define MXN 2505
int N, M;
ll T, P;
ll dis[MXN];
vector<pil> G[MXN];
typedef pair<pii, ll> ppl;
ppl E[MXN * 2];
ll inf = (1LL << 60);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M >> P;
int a, b;
ll c;
FOR(i, 1, M) {
cin >> a >> b >> c;
G[a].pb(mkp(b, -(c - P)));
E[i] = mkp(mkp(a, b), c);
}
dis[1] = 0;
FOR(i, 2, N) dis[i] = inf;
bool negc = false;
FOR(i, 1, 3 * N) {
FOR(j, 1, M) {
int u = E[j].f.f, v = E[j].f.s;
ll c = E[j].s;
if (dis[u] + c < dis[v]) {
dis[v] = dis[u] + c;
if (i > N && v == N)
negc = true;
}
}
}
if (negc) {
cout << -1 << '\n';
return 0;
}
cout << max(0LL, -dis[N]) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pil pair<int, ll>
#define pli pair<ll, int>
#define ppi pair<pii, int>
#define pip pair<int, pii>
#define pdd pair<double, double>
#define f first
#define s second
#define MOD 1000000007
#define mkp make_pair
#define M_PI 3.14159265358979323846
#define FOR(i, l, r) for (int i = l; i <= r; i++)
#define LOR(i, l, r) for (ll i = l; i <= r; i++)
#define FORD(i, r, l) for (int i = r; i >= l; i--)
#define LORD(i, r, l) for (ll i = r; i >= l; i--)
#define INF 1000000000
#define CL(x) memset(x, 0, sizeof(x))
#define DEB(x) cout << #x << " : " << x << '\n'
#define ALL(x) x.begin(), x.end()
#define SZ(x) x.size()
#define UI(x) (int)(x - 'A')
#define LI(x) (int)(x - 'a')
typedef long long ll;
#define MXN 2505
int N, M;
ll T, P;
ll dis[MXN];
vector<pil> G[MXN];
typedef pair<pii, ll> ppl;
ppl E[MXN * 2];
ll inf = (1LL << 60);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M >> P;
int a, b;
ll c;
FOR(i, 1, M) {
cin >> a >> b >> c;
G[a].pb(mkp(b, -(c - P)));
E[i] = mkp(mkp(a, b), -(c - P));
}
dis[1] = 0;
FOR(i, 2, N) dis[i] = inf;
bool negc = false;
FOR(i, 1, 3 * N) {
FOR(j, 1, M) {
int u = E[j].f.f, v = E[j].f.s;
ll c = E[j].s;
if (dis[u] + c < dis[v]) {
dis[v] = dis[u] + c;
if (i > N && v == N)
negc = true;
}
}
}
if (negc) {
cout << -1 << '\n';
return 0;
}
cout << max(0LL, -dis[N]) << '\n';
return 0;
}
| [] | 751,227 | 751,228 | u146724119 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
const int INF = -2e9;
int n, m, p;
int dist[N], cnt[N];
bool inqueue[N];
vector<pair<int, int>> g[N];
vector<int> rg[N];
bool vis[N];
void dfs(int u) {
if (vis[u])
return;
vis[u] = 1;
for (auto &it : rg[u])
dfs(it);
}
bool negativeCycle() // Returns true if there is a negative cycle
{
queue<int> q;
for (int i = 1; i <= 1; i++) {
dist[i] = cnt[i] = 0;
q.push(i), inqueue[i] = true;
}
for (int i = 2; i <= n; i++)
dist[i] = -INF;
while (!q.empty()) {
int v = q.front();
q.pop();
inqueue[v] = false;
for (auto &edge : g[v]) {
int to = edge.first;
int w = edge.second;
if (dist[v] + w < dist[to]) {
dist[to] = dist[v] + w;
dist[to] = max(dist[to], INF);
if (!inqueue[to]) {
q.push(to);
inqueue[to] = true;
cnt[to]++;
if (cnt[to] > n)
return true;
}
}
}
}
return false;
}
int32_t main() {
IOS;
cin >> n >> m >> p;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, p - w});
rg[v].push_back(u);
}
dfs(n);
for (int i = 1; i <= n; i++) {
vector<pair<int, int>> v;
for (auto &it : g[i])
if (vis[it.first])
v.push_back(it);
g[i].clear();
g[i] = v;
}
int check = negativeCycle();
if (check) {
cout << "-1";
return 0;
}
cout << -dist[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
const int INF = -2e9;
int n, m, p;
int dist[N], cnt[N];
bool inqueue[N];
vector<pair<int, int>> g[N];
vector<int> rg[N];
bool vis[N];
void dfs(int u) {
if (vis[u])
return;
vis[u] = 1;
for (auto &it : rg[u])
dfs(it);
}
bool negativeCycle() // Returns true if there is a negative cycle
{
queue<int> q;
for (int i = 1; i <= 1; i++) {
dist[i] = cnt[i] = 0;
q.push(i), inqueue[i] = true;
}
for (int i = 2; i <= n; i++)
dist[i] = -INF;
while (!q.empty()) {
int v = q.front();
q.pop();
inqueue[v] = false;
for (auto &edge : g[v]) {
int to = edge.first;
int w = edge.second;
if (dist[v] + w < dist[to]) {
dist[to] = dist[v] + w;
dist[to] = max(dist[to], INF);
if (!inqueue[to]) {
q.push(to);
inqueue[to] = true;
cnt[to]++;
if (cnt[to] > n)
return true;
}
}
}
}
return false;
}
int32_t main() {
IOS;
cin >> n >> m >> p;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, p - w});
rg[v].push_back(u);
}
dfs(n);
for (int i = 1; i <= n; i++) {
vector<pair<int, int>> v;
for (auto &it : g[i])
if (vis[it.first])
v.push_back(it);
g[i].clear();
g[i] = v;
}
int check = negativeCycle();
if (check) {
cout << "-1";
return 0;
}
cout << max(0LL, -dist[n]);
return 0;
} | [
"call.add",
"call.arguments.change"
] | 751,244 | 751,245 | u901862155 | cpp |
p02950 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ull = uint64_t;
using P = pair<int, int>;
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
int mod = 2;
// constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
// template<int mod>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt(t);
return (is);
}
};
// using modint = ModInt<mod>;
template <typename T> struct Combination {
int sz;
vector<T> fact_;
vector<T> ifact_;
vector<T> inv_;
Combination(int n = 1e+6) : sz(n) {
fact_.resize(sz + 1);
ifact_.resize(sz + 1);
inv_.resize(sz + 1);
fact_[0] = ifact_[sz] = inv_[0] = 1;
for (int i = 1; i <= sz; ++i)
fact_[i] = fact_[i - 1] * i;
ifact_[sz] /= fact_[sz];
for (int i = sz; i > 0; --i)
ifact_[i - 1] = ifact_[i] * i;
for (int i = 1; i <= sz; ++i)
inv_[i] = ifact_[i] * fact_[i - 1];
}
inline T fact(int k) const { return fact_[k]; }
inline T ifact(int k) const { return ifact_[k]; }
inline T inv(int k) const { return inv_[k]; }
T get_permutation(int n, int k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact(n) * ifact(n - k);
}
T get_combination(int n, int k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact(n) * ifact(k) * ifact(n - k);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int p;
cin >> p;
mod = p;
vector<ModInt> b(p);
Combination<ModInt> c(p - 1);
for (int i = 0; i < p; ++i) {
int a;
cin >> a;
if (a == 0)
continue;
b[0] += 1;
for (int j = 0; j < p; ++j) {
b[j] -= c.get_combination(p - 1, j) * ModInt(-j).pow(p - j - 1);
}
}
for (int i = 0; i < p; ++i) {
cout << b[i];
cout << ((i == p - 1) ? '\n' : ' ');
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ull = uint64_t;
using P = pair<int, int>;
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
int mod = 2;
// constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
// template<int mod>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt(t);
return (is);
}
};
// using modint = ModInt<mod>;
template <typename T> struct Combination {
int sz;
vector<T> fact_;
vector<T> ifact_;
vector<T> inv_;
Combination(int n = 1e+6) : sz(n) {
fact_.resize(sz + 1);
ifact_.resize(sz + 1);
inv_.resize(sz + 1);
fact_[0] = ifact_[sz] = inv_[0] = 1;
for (int i = 1; i <= sz; ++i)
fact_[i] = fact_[i - 1] * i;
ifact_[sz] /= fact_[sz];
for (int i = sz; i > 0; --i)
ifact_[i - 1] = ifact_[i] * i;
for (int i = 1; i <= sz; ++i)
inv_[i] = ifact_[i] * fact_[i - 1];
}
inline T fact(int k) const { return fact_[k]; }
inline T ifact(int k) const { return ifact_[k]; }
inline T inv(int k) const { return inv_[k]; }
T get_permutation(int n, int k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact(n) * ifact(n - k);
}
T get_combination(int n, int k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact(n) * ifact(k) * ifact(n - k);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int p;
cin >> p;
mod = p;
vector<ModInt> b(p);
Combination<ModInt> c(p - 1);
for (int i = 0; i < p; ++i) {
int a;
cin >> a;
if (a == 0)
continue;
b[0] += 1;
for (int j = 0; j < p; ++j) {
b[j] -= c.get_combination(p - 1, j) * ModInt(-i).pow(p - j - 1);
}
}
for (int i = 0; i < p; ++i) {
cout << b[i];
cout << ((i == p - 1) ? '\n' : ' ');
}
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 751,255 | 751,256 | u190018920 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define isSquare(x) (sqrt(x) * sqrt(x) == x)
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 (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
static const int MAX = 3005;
ll MOD;
ll fact[MAX], fact_inv[MAX];
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
} // mod mでの逆元aを計算
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
iosetup;
int p;
IN(p);
MOD = p;
vector<int> a(p);
rep(i, 0, p) cin >> a[i];
fact[0] = 1;
for (int i = 0; i < MOD - 1; i++)
fact[i + 1] = fact[i] * (i + 1) % MOD;
fact_inv[MOD - 1] = modpow(fact[MOD - 1], MOD - 2, MOD);
for (int i = MOD - 2; i >= 0; i--)
fact_inv[i] = fact_inv[i + 1] % MOD * (i + 1) % MOD;
cout << a[0];
rep(i, 1, p) {
ll ans = 0;
rep(j, 0, p) if (a[j] == 1) {
if ((p - 1 - i) & 1 == 0)
ans -= (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
else
ans += (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
}
ans %= p;
if (ans < 0)
ans += p;
cout << " ";
cout << ans;
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define isSquare(x) (sqrt(x) * sqrt(x) == x)
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 (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
static const int MAX = 3005;
ll MOD;
ll fact[MAX], fact_inv[MAX];
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
} // mod mでの逆元aを計算
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
iosetup;
int p;
IN(p);
MOD = p;
vector<int> a(p);
rep(i, 0, p) cin >> a[i];
fact[0] = 1;
for (int i = 0; i < MOD - 1; i++)
fact[i + 1] = fact[i] * (i + 1) % MOD;
fact_inv[MOD - 1] = modpow(fact[MOD - 1], MOD - 2, MOD);
for (int i = MOD - 2; i >= 0; i--)
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD;
cout << a[0];
rep(i, 1, p) {
ll ans = 0;
rep(j, 0, p) if (a[j] == 1) {
if (((p - 1 - i) & 1) == 0)
ans -= (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
else
ans += comb(p - 1, i) * modpow(j, p - 1 - i, p) % p;
}
// cerr << ans << endl;
ans %= p;
if (ans < 0)
ans += p;
cout << " ";
cout << ans;
}
cout << endl;
return 0;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 751,263 | 751,264 | u839397805 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define isSquare(x) (sqrt(x) * sqrt(x) == x)
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 (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
static const int MAX = 3005;
ll MOD;
ll fact[MAX], fact_inv[MAX];
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
} // mod mでの逆元aを計算
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
iosetup;
int p;
IN(p);
MOD = p;
vector<int> a(p);
rep(i, 0, p) cin >> a[i];
fact[0] = 1;
for (int i = 0; i < MOD - 1; i++)
fact[i + 1] = fact[i] * (i + 1) % MOD;
fact_inv[MOD - 1] = modpow(fact[MOD - 1], MOD - 2, MOD);
for (int i = MOD - 2; i >= 0; i--)
fact_inv[i] = fact_inv[i + 1] % MOD * (i + 1) % MOD;
cout << a[0];
rep(i, 1, p) {
ll ans = 0;
rep(j, 0, p) if (a[j] == 1) {
if ((p - 1 - i) & 1 == 0)
ans -= (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
else
ans += (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
}
ans %= p;
if (ans < 0)
ans += p;
cout << " ";
cout << ans;
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define isSquare(x) (sqrt(x) * sqrt(x) == x)
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 (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
static const int MAX = 3005;
ll MOD;
ll fact[MAX], fact_inv[MAX];
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
} // mod mでの逆元aを計算
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
iosetup;
int p;
IN(p);
MOD = p;
vector<int> a(p);
rep(i, 0, p) cin >> a[i];
fact[0] = 1;
for (int i = 0; i < MOD - 1; i++)
fact[i + 1] = fact[i] * (i + 1) % MOD;
fact_inv[MOD - 1] = modpow(fact[MOD - 1], MOD - 2, MOD);
for (int i = MOD - 2; i >= 0; i--)
fact_inv[i] = fact_inv[i + 1] % MOD * (i + 1) % MOD;
cout << a[0];
rep(i, 1, p) {
ll ans = 0;
rep(j, 0, p) if (a[j] == 1) {
if (((p - 1 - i) & 1) == 0)
ans -= (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
else
ans += (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
}
ans %= p;
if (ans < 0)
ans += p;
cout << " ";
cout << ans;
}
cout << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 751,263 | 751,265 | u839397805 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define isSquare(x) (sqrt(x) * sqrt(x) == x)
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 (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
static const int MAX = 3005;
ll MOD;
ll fact[MAX], fact_inv[MAX];
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
} // mod mでの逆元aを計算
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
iosetup;
int p;
IN(p);
MOD = p;
vector<int> a(p);
rep(i, 0, p) cin >> a[i];
fact[0] = 1;
for (int i = 0; i < MOD - 1; i++)
fact[i + 1] = fact[i] * (i + 1) % MOD;
fact_inv[MOD - 1] = modpow(fact[MOD - 1], MOD - 2, MOD);
for (int i = MOD - 2; i >= 0; i--)
fact_inv[i] = fact_inv[i + 1] % MOD * (i + 1) % MOD;
cout << a[0];
rep(i, 0, p) {
ll ans = 0;
rep(j, 0, p) if (a[j] == 1) {
if ((p - 1 - i) % 2 == 0)
ans -= (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
else
ans += (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
ans %= p;
if (ans < 0)
ans += p;
}
cout << " ";
cout << ans;
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define isSquare(x) (sqrt(x) * sqrt(x) == x)
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 (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
static const int MAX = 3005;
ll MOD;
ll fact[MAX], fact_inv[MAX];
ll comb(ll n, ll r) {
return (fact[n] * fact_inv[r]) % MOD * fact_inv[n - r] % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
} // mod mでの逆元aを計算
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
iosetup;
int p;
IN(p);
MOD = p;
vector<int> a(p);
rep(i, 0, p) cin >> a[i];
fact[0] = 1;
for (int i = 0; i < MOD - 1; i++)
fact[i + 1] = fact[i] * (i + 1) % MOD;
fact_inv[MOD - 1] = modpow(fact[MOD - 1], MOD - 2, MOD);
for (int i = MOD - 2; i >= 0; i--)
fact_inv[i] = fact_inv[i + 1] % MOD * (i + 1) % MOD;
cout << a[0];
rep(i, 1, p) {
ll ans = 0;
rep(j, 0, p) if (a[j] == 1) {
if ((p - 1 - i) % 2 == 0)
ans -= (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
else
ans += (comb(p - 1, i) * modpow(j, p - 1 - i, p)) % p;
}
ans %= p;
if (ans < 0)
ans += p;
cout << " ";
cout << ans;
}
cout << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 751,268 | 751,267 | u839397805 | cpp |
p02950 | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#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 REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define CASET \
int ___T; \
scanf("%d", &___T); \
for (int cs = 1; cs <= ___T; cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
template <class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U> void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U> void _W(const pair<T, U> &x) {
_W(x.F);
putchar(' ');
_W(x.S);
}
template <class T> void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin())
putchar(' ');
}
void W() {}
template <class T, class... U> void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
#ifdef HOME
#define DEBUG(...) \
{ \
printf("# "); \
printf(__VA_ARGS__); \
puts(""); \
}
#else
#define DEBUG(...)
#endif
int MOD = 1e9 + 7;
void ADD(LL &x, LL v) {
x = (x + v) % MOD;
if (x < 0)
x += MOD;
}
/*}}}*/
const int SIZE = 1e6 + 10;
LL d[SIZE], a[SIZE], an[SIZE], res[SIZE], tmp[SIZE], ker[SIZE];
LL mypow(LL x, LL y) {
x %= MOD;
LL re = 1 % MOD;
while (y) {
if (y & 1)
re = re * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return re;
}
int main() {
int p;
R(p);
MOD = p;
REP(i, p) R(a[i]);
d[1] = 1;
REPP(i, 1, p) {
for (int j = p; j > 0; j--) {
d[j] = (d[j - 1] - d[j] * i) % p;
}
}
REP(i, p) {
if (!a[i])
continue;
FOR(j, 0, p) tmp[j] = d[j];
for (int j = p; j > 0; j--) {
LL v = tmp[j];
ker[j - 1] = v;
ADD(tmp[j - 1], v * -i);
}
LL now = 1;
FOR(j, 0, p - 1) {
if (j != i)
now = now * (i - j) % MOD;
}
LL inv = mypow(now, MOD - 2);
FOR(j, 0, p - 1) ADD(res[j], inv * ker[j]);
}
W(VL(res, res + p));
return 0;
}
| /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#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 REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define CASET \
int ___T; \
scanf("%d", &___T); \
for (int cs = 1; cs <= ___T; cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
template <class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U> void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U> void _W(const pair<T, U> &x) {
_W(x.F);
putchar(' ');
_W(x.S);
}
template <class T> void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin())
putchar(' ');
}
void W() {}
template <class T, class... U> void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
#ifdef HOME
#define DEBUG(...) \
{ \
printf("# "); \
printf(__VA_ARGS__); \
puts(""); \
}
#else
#define DEBUG(...)
#endif
int MOD = 1e9 + 7;
void ADD(LL &x, LL v) {
x = (x + v) % MOD;
if (x < 0)
x += MOD;
}
/*}}}*/
const int SIZE = 1e6 + 10;
LL d[SIZE], a[SIZE], an[SIZE], res[SIZE], tmp[SIZE], ker[SIZE];
LL mypow(LL x, LL y) {
x %= MOD;
LL re = 1 % MOD;
while (y) {
if (y & 1)
re = re * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return re;
}
int main() {
int p;
R(p);
MOD = p;
REP(i, p) R(a[i]);
d[1] = 1;
REPP(i, 1, p) {
for (int j = p; j > 0; j--) {
d[j] = (d[j - 1] - d[j] * i) % p;
}
}
REP(i, p) {
if (!a[i])
continue;
FOR(j, 0, p) tmp[j] = d[j];
for (int j = p; j > 0; j--) {
LL v = tmp[j];
ker[j - 1] = v;
ADD(tmp[j - 1], v * i);
}
LL now = 1;
FOR(j, 0, p - 1) {
if (j != i)
now = now * (i - j) % MOD;
}
LL inv = mypow(now, MOD - 2);
FOR(j, 0, p - 1) ADD(res[j], inv * ker[j]);
}
W(VL(res, res + p));
return 0;
}
| [
"expression.operation.unary.arithmetic.remove",
"call.arguments.change"
] | 751,273 | 751,274 | u284124505 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll a, b, c;
cin >> a >> b >> c;
vector<ll> vec(3);
ll d = min(a + c, b);
cout << c - d + a << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll a, b, c;
cin >> a >> b >> c;
vector<ll> vec(3);
ll d = min(a, b + c);
cout << c - d + b << endl;
return 0;
} | [
"expression.operation.binary.remove",
"identifier.change",
"io.output.change"
] | 751,281 | 751,282 | u883297128 | cpp |
p02951 | #include <bits/stdc++.h>
#define int long long
#define fast_io() \
; \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define loop(i, a, b) for (int i = a; i < b; i++)
#define all(x) x.begin(), x.end()
#define pb push_back
#define ins insert
#define fi first
#define se second
#define _max max_element
#define _min min_element
#define tc(T) \
int T; \
cin >> T; \
while (T--)
#define q(q) \
int q; \
cin >> q; \
while (q--)
#define pi 3.1415926535897932384626433832
const int pinf = ((int)9e18);
const int ninf = ((int)-9e18);
const int mod = 1000000007;
using namespace std;
int32_t main() {
fast_io();
// FILE *fptr1=freopen("in.txt","r",stdin);
// FILE *fptr2=freopen("out.txt","w",stdout);
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b);
return 0;
}
| #include <bits/stdc++.h>
#define int long long
#define fast_io() \
; \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define loop(i, a, b) for (int i = a; i < b; i++)
#define all(x) x.begin(), x.end()
#define pb push_back
#define ins insert
#define fi first
#define se second
#define _max max_element
#define _min min_element
#define tc(T) \
int T; \
cin >> T; \
while (T--)
#define q(q) \
int q; \
cin >> q; \
while (q--)
#define pi 3.1415926535897932384626433832
const int pinf = ((int)9e18);
const int ninf = ((int)-9e18);
const int mod = 1000000007;
using namespace std;
int32_t main() {
fast_io();
// FILE *fptr1=freopen("in.txt","r",stdin);
// FILE *fptr2=freopen("out.txt","w",stdout);
int a, b, c;
cin >> a >> b >> c;
cout << max(c - (a - b), 0LL);
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 751,292 | 751,293 | u085634861 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define fr(i, a, b) for (int i = a; i <= b; ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define trav(a, x) for (auto &a : x)
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
#define fst first
#define snd second
using namespace __gnu_pbds;
using ordered_set = tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>;
// find_by_order(k):returns iterator to kth element starting from 0
// order_of_key(k):returns count of elements strictly smaller than k
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long double ld;
template <class T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
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 <class T> void re(T &x) { cin >> x; }
template <typename T> void remdup(vector<T> &v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
template <typename T> void re(vector<T> &v) { trav(i, v) cin >> i; }
template <class H, class... T> void re(H &h, T &...t) {
re(h);
re(t...);
}
void unsyncIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
#ifdef np
#include "/home/o_o/MyCodes/pr.h"
#else
#define trace(...)
#endif
#define MOD 1000000007
void solve() {
int a, b, c;
re(a, b, c);
cout << c - (a - b) << endl;
}
signed main() {
unsyncIO();
int tt = 1;
// cin >> tt;
rep(i, 0, tt) solve();
#ifdef np
cout << endl
<< endl
<< "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define fr(i, a, b) for (int i = a; i <= b; ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define trav(a, x) for (auto &a : x)
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
#define fst first
#define snd second
using namespace __gnu_pbds;
using ordered_set = tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>;
// find_by_order(k):returns iterator to kth element starting from 0
// order_of_key(k):returns count of elements strictly smaller than k
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long double ld;
template <class T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
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 <class T> void re(T &x) { cin >> x; }
template <typename T> void remdup(vector<T> &v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
template <typename T> void re(vector<T> &v) { trav(i, v) cin >> i; }
template <class H, class... T> void re(H &h, T &...t) {
re(h);
re(t...);
}
void unsyncIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
#ifdef np
#include "/home/o_o/MyCodes/pr.h"
#else
#define trace(...)
#endif
#define MOD 1000000007
void solve() {
int a, b, c;
re(a, b, c);
cout << max(0LL, c - (a - b)) << endl;
}
signed main() {
unsyncIO();
int tt = 1;
// cin >> tt;
rep(i, 0, tt) solve();
#ifdef np
cout << endl
<< endl
<< "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 751,294 | 751,295 | u128142444 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - (a - b)) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 751,302 | 751,303 | u596234104 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define endl "\n"
#define pb push_back
#define PI 3.1415926535897932384626433832795l
#define F first
#define S second
#define mp make_pair
#define f(i, n) for (int i = 0; i < n; i++)
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define gcd(a, b) __gcd((a), (b))
#define fill(a, value) memset(a, value, sizeof(a));
#define minn(v) *min_element(v.begin(), v.end());
#define maxx(v) *max_element(v.begin(), v.end());
#define print(x) cout << (x) << endl;
#define sum(v) +x accumulate(v.begin(), v.end(), x);
#define debug(x) cout << #x << '=' << (x) << endl;
typedef pair<int, int> pii;
typedef vector<int> vi;
signed main() {
fastio;
cout << fixed << setprecision(12);
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define endl "\n"
#define pb push_back
#define PI 3.1415926535897932384626433832795l
#define F first
#define S second
#define mp make_pair
#define f(i, n) for (int i = 0; i < n; i++)
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define gcd(a, b) __gcd((a), (b))
#define fill(a, value) memset(a, value, sizeof(a));
#define minn(v) *min_element(v.begin(), v.end());
#define maxx(v) *max_element(v.begin(), v.end());
#define print(x) cout << (x) << endl;
#define sum(v) +x accumulate(v.begin(), v.end(), x);
#define debug(x) cout << #x << '=' << (x) << endl;
typedef pair<int, int> pii;
typedef vector<int> vi;
signed main() {
fastio;
cout << fixed << setprecision(12);
int a, b, c;
cin >> a >> b >> c;
cout << max(0ll, c - (a - b)) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 751,304 | 751,305 | u858929490 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = a - b;
int e = min(d, c);
int ans = d - e;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = a - b;
int e = min(d, c);
int ans = c - e;
cout << ans << endl;
}
| [
"identifier.change",
"expression.operation.binary.change"
] | 751,310 | 751,311 | u856957535 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = a - b;
int use = min(d, c);
int ans = d - use;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = a - b;
int e = min(d, c);
int ans = c - e;
cout << ans << endl;
}
| [
"variable_declaration.name.change",
"identifier.change",
"expression.operation.binary.change"
] | 751,312 | 751,311 | u856957535 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
signed main() {
int A, B, C;
scanf("%d%d", &A, &B, &C);
printf("%d\n", max(0, C - A + B));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
signed main() {
int A, B, C;
scanf("%d%d%d", &A, &B, &C);
printf("%d\n", max(0, C - A + B));
return 0;
} | [
"literal.string.change",
"call.arguments.change"
] | 751,313 | 751,314 | u208608367 | cpp |
p02951 | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
// BDD,ZDD,kdtree, bdtree,bicalc, bolonoy,
// doloney,chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu,
// heirokenshutu, topologicalsort, kyourenketuseibun
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
int main() {
int a, b, c;
cin >> a >> b >> c;
PRI(c + b - a);
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
// BDD,ZDD,kdtree, bdtree,bicalc, bolonoy,
// doloney,chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu,
// heirokenshutu, topologicalsort, kyourenketuseibun
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
int main() {
int a, b, c;
cin >> a >> b >> c;
PRI(max(c + b - a, 0));
return 0;
}
| [
"call.arguments.add"
] | 751,319 | 751,320 | u539145601 | cpp |
p02951 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a - b >= c)
cout << a - b - c << endl;
else
cout << c - a + b << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a - b >= c)
cout << 0 << endl;
else
cout << c - a + b << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change",
"expression.operation.binary.remove"
] | 751,323 | 751,324 | u422506696 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll LINF = 1e18;
const int mod = 1e9 + 7;
#define pi pair<int, int>
#define pl pair<lld, lld>
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define SANKOU(n, a, b) cout << ((n) ? (#a) : (#b)) << endl
#define mem0(x) memset(x, 0, sizeof(x))
#define fillnum(x, n) fill(begin(x), end(x), n)
#define asort(x) sort(x.begin(), x.end())
#define dsort(x, t) sort(x.begin(), x.end(), greater<t>())
#define vuniq(x) x.erase(unique(x.begin(), x.end()), x.end())
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
int main() {
ll A, B, C;
cin >> A >> B >> C;
cout << C - (A - B) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll LINF = 1e18;
const int mod = 1e9 + 7;
#define pi pair<int, int>
#define pl pair<lld, lld>
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define SANKOU(n, a, b) cout << ((n) ? (#a) : (#b)) << endl
#define mem0(x) memset(x, 0, sizeof(x))
#define fillnum(x, n) fill(begin(x), end(x), n)
#define asort(x) sort(x.begin(), x.end())
#define dsort(x, t) sort(x.begin(), x.end(), greater<t>())
#define vuniq(x) x.erase(unique(x.begin(), x.end()), x.end())
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
int main() {
ll A, B, C;
cin >> A >> B >> C;
cout << max(0LL, C - (A - B)) << endl;
} | [
"call.add",
"call.arguments.change"
] | 751,327 | 751,328 | u118434175 | cpp |
p02951 | // Bismillahir Rahmanir Rahim
#include <bits/stdc++.h>
using namespace std;
#define ios \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ll long long
#define endl '\n'
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
bool sortbysec(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.second < b.second);
}
int main() {
ios;
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
}
// Alhamdulillah
| // Bismillahir Rahmanir Rahim
#include <bits/stdc++.h>
using namespace std;
#define ios \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ll long long
#define endl '\n'
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
bool sortbysec(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.second < b.second);
}
int main() {
ios;
int a, b, c;
cin >> a >> b >> c;
cout << c - min(c, (a - b)) << endl;
}
// Alhamdulillah
| [
"call.add",
"call.arguments.change"
] | 751,329 | 751,330 | u572033996 | cpp |
p02951 | #include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int a, b, c, dif;
cin >> a >> b >> c;
dif = a - b;
c -= dif;
if (c < 0) {
cout << 0;
} else {
cout << c - dif;
}
return 0;
}
| #include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
int a, b, c, dif;
cin >> a >> b >> c;
dif = a - b;
c -= dif;
if (c < 0) {
cout << 0;
} else {
cout << c;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 751,340 | 751,341 | u701212130 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << B + C - A << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(B + C - A, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 751,342 | 751,343 | u280966279 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, a, b) for (int i = a; i < (int)b; ++i)
typedef long long ll;
const int Inf = 1e9;
const double EPS = 1e-9;
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int bitCount(long bits) {
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
if (a - b > c) {
cout << 0 << '\n';
} else {
cout << c - (a + b) << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, a, b) for (int i = a; i < (int)b; ++i)
typedef long long ll;
const int Inf = 1e9;
const double EPS = 1e-9;
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int bitCount(long bits) {
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
if (a - b > c) {
cout << 0 << '\n';
} else {
cout << c - (a - b) << '\n';
}
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 751,354 | 751,355 | u940569542 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << b + c - a << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b + c - a, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 751,356 | 751,357 | u882098164 | cpp |
p02951 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
c = c + a - b;
if (c < 0)
cout << "0";
else
cout << c;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
c = c - a + b;
if (c < 0)
cout << "0";
else
cout << c;
return 0;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 751,365 | 751,366 | u086485448 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c = 0;
cin >> a >> b >> c;
if (c - (a - b) == 0) {
cout << c - (a - b) << endl;
} else {
cout << "0" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c = 0;
cin >> a >> b >> c;
if (c - (a - b) > 0) {
cout << c - (a - b) << endl;
} else {
cout << "0" << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,400 | 751,401 | u096025032 | cpp |
p02951 | #include <bits/stdc++.h>
#define lld long long int
#define vec vector<lld>
#define pll pair<lld, lld>
#define pb push_back
#define ss second
#define ff first
#define mp make_pair
#define mod 1000000007
#define answer cout << endl << "answer : ";
#define maxn 100005
#define messi \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
int main() {
messi lld t = 1; // cin>>t;
while (t--) {
lld n = 0, m = 0, k = 0, i = 0, j = 0, p = 0, q = 0, x = 0, y = 0, z = 0,
ans = 0, cnt = 0;
string s;
bool flag = false;
cin >> x >> y >> z;
ans = z - (y - x);
if (ans < 0)
ans = 0;
cout << ans << endl;
}
return 0;
}
/* CODED BY:-
________________________________________
| __ __ |
| /\ /\ |__) /\ | \ |__| \ / /\ |
| /~~\ /~~\ | \ /~~\ |__/ | | | /~~\ |
|________________________________________|
*/
| #include <bits/stdc++.h>
#define lld long long int
#define vec vector<lld>
#define pll pair<lld, lld>
#define pb push_back
#define ss second
#define ff first
#define mp make_pair
#define mod 1000000007
#define answer cout << endl << "answer : ";
#define maxn 100005
#define messi \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
int main() {
messi lld t = 1; // cin>>t;
while (t--) {
lld n = 0, m = 0, k = 0, i = 0, j = 0, p = 0, q = 0, x = 0, y = 0, z = 0,
ans = 0, cnt = 0;
string s;
bool flag = false;
cin >> x >> y >> z;
ans = z - (x - y);
if (ans < 0)
ans = 0;
cout << ans << endl;
}
return 0;
}
/* CODED BY:-
________________________________________
| __ __ |
| /\ /\ |__) /\ | \ |__| \ / /\ |
| /~~\ /~~\ | \ /~~\ |__/ | | | /~~\ |
|________________________________________|
*/
| [
"expression.operation.binary.remove",
"assignment.change"
] | 751,404 | 751,405 | u606883845 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(a + c - b, 0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b + c - a, 0) << endl;
}
| [
"identifier.change",
"io.output.change"
] | 751,406 | 751,407 | u252211543 | cpp |
p02951 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c - (a - b), 0) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 751,410 | 751,411 | u553321223 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int, int, int> tpl;
#define ALL(a) (a).begin(), (a).end()
#define SORT(c) sort((c).begin(), (c).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define EXIST(m, v) (m).find((v)) != (m).end()
#define LB(a, x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a, x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define RREP(i, n) RFOR(i, n, 0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.1415926535897932;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL << 60;
constexpr long long MOD = 1000000007; // 998244353;
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(0, C - (B - A)) << en;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int, int, int> tpl;
#define ALL(a) (a).begin(), (a).end()
#define SORT(c) sort((c).begin(), (c).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define EXIST(m, v) (m).find((v)) != (m).end()
#define LB(a, x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a, x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define RREP(i, n) RFOR(i, n, 0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.1415926535897932;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL << 60;
constexpr long long MOD = 1000000007; // 998244353;
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(0, C - (A - B)) << en;
return 0;
} | [
"expression.operation.binary.remove"
] | 751,424 | 751,425 | u934272719 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
int A, B, C;
cin >> A >> B >> C;
ans = C - (A - B);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
int A, B, C;
cin >> A >> B >> C;
ans = max(0, C - (A - B));
cout << ans << endl;
} | [
"call.add",
"call.arguments.change"
] | 751,426 | 751,427 | u446774692 | cpp |
p02951 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repd(i, n) for (ll i = (n)-1; i >= 0; --i)
#define INF 10e12
#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;
int main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repd(i, n) for (ll i = (n)-1; i >= 0; --i)
#define INF 10e12
#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;
int main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - (a - b)) << endl;
} | [
"call.add",
"call.arguments.change"
] | 751,439 | 751,440 | u110044127 | cpp |
p02951 | #include <iostream>
using namespace std;
int main(void) {
// 137
int A, B, C;
cin >> A >> B >> C;
if (A - B >= C) {
cout << "0" << endl;
} else if (A - B < C) {
cout << C - B << endl;
}
} | #include <iostream>
using namespace std;
int main(void) {
// 137
int A, B, C;
cin >> A >> B >> C;
if (A - B >= C) {
cout << "0" << endl;
} else if (A - B < C) {
cout << C - (A - B) << endl;
}
} | [] | 751,441 | 751,442 | u170558932 | cpp |
p02951 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int ans = c - (a - b);
if (ans < 0) {
cout << "0" << endl;
}
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int ans = c - (a - b);
if (ans < 0) {
cout << "0" << endl;
} else {
cout << ans << endl;
}
return 0;
}
| [
"control_flow.branch.else.add"
] | 751,443 | 751,444 | u025892939 | cpp |
p02951 | #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int x;
x = b + c;
if (a < x) {
int ans;
ans = a - x;
cout << ans << endl;
} else
cout << "0" << endl;
}
| #include <iostream>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int x;
x = b + c;
if (a < x) {
int ans;
ans = x - a;
cout << ans << endl;
} else
cout << "0" << endl;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 751,445 | 751,446 | u178938628 | cpp |
p02951 | #include <iostream>
#include <math.h>
using namespace std;
int main(void) {
int A;
int B;
int C;
cin >> A;
cin >> B;
cin >> C;
if (C < A - B) {
cout << A - C - B << endl;
}
if (C >= A - B) {
cout << 0 << endl;
return 0;
}
}
| #include <iostream>
#include <math.h>
using namespace std;
int main(void) {
int A;
int B;
int C;
cin >> A;
cin >> B;
cin >> C;
if (C > A - B) {
cout << C - A + B << endl;
}
if (C <= A - B) {
cout << 0 << endl;
return 0;
}
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 751,447 | 751,448 | u121251784 | cpp |
p02951 | #include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int T;
T = B + C;
if (A >= T) {
cout << A - T << endl;
} else {
cout << T - A << endl;
}
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
int T;
T = B + C;
if (A >= T) {
cout << 0 << endl;
} else {
cout << T - A << endl;
}
}
| [
"identifier.replace.remove",
"literal.replace.add",
"io.output.change",
"expression.operation.binary.remove"
] | 751,449 | 751,450 | u466018786 | cpp |
p02951 | /*
* cpp_filepath
*/
// C++ 14
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // memset
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for (int __x = __start; __x < __end; __x++)
template <class T> ostream &operator<<(ostream &out, vector<T> const &v) {
for (auto &&a : v)
out << a << " ";
out << endl;
return out;
}
template <class T> void dump(T &a) { cout << a << endl; }
void solve();
int main() {
solve();
return 0;
}
void solve() {
int a, b, c;
cin >> a >> b >> c;
int r = a - b;
cout << c - r << endl;
}
| /*
* cpp_filepath
*/
// C++ 14
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // memset
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for (int __x = __start; __x < __end; __x++)
template <class T> ostream &operator<<(ostream &out, vector<T> const &v) {
for (auto &&a : v)
out << a << " ";
out << endl;
return out;
}
template <class T> void dump(T &a) { cout << a << endl; }
void solve();
int main() {
solve();
return 0;
}
void solve() {
int a, b, c;
cin >> a >> b >> c;
int r = a - b;
cout << max(c - r, 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 751,455 | 751,456 | u823862638 | cpp |
p02951 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define be(v) v.begin(), v.end()
#define ll long long
ll INF = 1e9;
ll mod = 1e9 + 7;
ll dp[10001];
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define be(v) v.begin(), v.end()
#define ll long long
ll INF = 1e9;
ll mod = 1e9 + 7;
ll dp[10001];
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - min(c, a - b) << endl;
} | [
"call.add",
"call.arguments.add"
] | 751,463 | 751,464 | u769530239 | cpp |
p02951 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - a + b << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c - a + b, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 751,465 | 751,466 | u641900703 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
//最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
//出力系
#define print(x) cout << x << endl
#define prints(x) cout << fixed << setprecision(20) << x << endl
#define printc(x) cout << setw(2) << setfill('0') << x << endl;
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
// begin() end()
#define all(x) (x).begin(), (x).end()
// for
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, a, b) for (int i = (a); i > (b); i--)
#define rep(i, a, b) for (int i = (a); i < (b); i++)
//最大公約数
unsigned gcd(unsigned a, unsigned b) {
if (a < b)
return gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
// 最小公倍数
unsigned lcm(unsigned a, unsigned b) { return a / gcd(a, b) * b; }
// a = max(a, b), a = min(a, b)
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;
}
// 階乗(MODをとる)
ll pow_mod(ll num, ll pow, ll mod) {
ll prod = 1;
num %= mod;
while (pow > 0) {
if (pow & 1)
prod = prod * num % mod;
num = num * num % mod;
pow >>= 1;
}
return prod;
}
// 二項係数(MODとる、1 ≦ k ≦ n ≦ 10^7 程度)
// COMinit()
// COM(x, y)
// とコンビで使う
// テーブルを作る前処理
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// UnionFind
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<ll> Size;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n + 1);
rank.resize(n + 1);
Size.resize(n + 1);
for (int i = 0; i <= n; ++i)
par[i] = i, rank[i] = 0, Size[i] = 1;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(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 (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
Size[x] += Size[y];
return true;
}
ll size(int x) { return Size[root(x)]; }
};
// modint構造体
struct Mint {
int val;
Mint inv() const {
int tmp, a = val, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
return Mint(x);
}
public:
Mint() : val(0) {}
Mint(ll x) {
if ((val = x % mod) < 0)
val += mod;
}
Mint pow(ll t) {
Mint res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
Mint &operator+=(const Mint &x) {
if ((val += x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator-=(const Mint &x) {
if ((val += mod - x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator*=(const Mint &x) {
val = (ll)val * x.val % mod;
return *this;
}
Mint &operator/=(const Mint &x) { return *this *= x.inv(); }
bool operator==(const Mint &x) const { return val == x.val; }
bool operator!=(const Mint &x) const { return val != x.val; }
bool operator<(const Mint &x) const { return val < x.val; }
bool operator<=(const Mint &x) const { return val <= x.val; }
bool operator>(const Mint &x) const { return val > x.val; }
bool operator>=(const Mint &x) const { return val >= x.val; }
Mint operator+(const Mint &x) const { return Mint(*this) += x; }
Mint operator-(const Mint &x) const { return Mint(*this) -= x; }
Mint operator*(const Mint &x) const { return Mint(*this) *= x; }
Mint operator/(const Mint &x) const { return Mint(*this) /= x; }
};
struct factorial {
vector<Mint> Fact, Finv;
public:
// factorial fact(10000010);
// fact.nCr(a, b)
//「fact」の部分は自由に名前変更可能
factorial(int maxx) {
Fact.resize(maxx + 1), Finv.resize(maxx + 1);
Fact[0] = Mint(1);
rep(i, 0, maxx) Fact[i + 1] = Fact[i] * (i + 1);
Finv[maxx] = Mint(1) / Fact[maxx];
rrep(i, maxx, 0) Finv[i - 1] = Finv[i] * i;
}
Mint fact(int n, bool inv = 0) {
if (inv)
return Finv[n];
else
return Fact[n];
}
Mint nPr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[n - r];
}
Mint nCr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[r] * Finv[n - r];
}
};
// 1 * 2 * 3 .... * n (mod)
ll modfact(ll n) {
if (n <= 1)
return 1;
return (n * modfact(n - 1)) % MOD;
}
// kが角度だった場合:cos(k * (PI / 180));
const double PI = acos(-1);
// 多次元 vector 生成 例: auto dp = make_vec<long long>(N+1, 5, 5, 5);
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
// int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
int main() {
int a, b, c;
cin >> a >> b >> c;
int tmp = b - a;
int ans = max(0, c - tmp);
print(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
//最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
//出力系
#define print(x) cout << x << endl
#define prints(x) cout << fixed << setprecision(20) << x << endl
#define printc(x) cout << setw(2) << setfill('0') << x << endl;
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
// begin() end()
#define all(x) (x).begin(), (x).end()
// for
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, a, b) for (int i = (a); i > (b); i--)
#define rep(i, a, b) for (int i = (a); i < (b); i++)
//最大公約数
unsigned gcd(unsigned a, unsigned b) {
if (a < b)
return gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
// 最小公倍数
unsigned lcm(unsigned a, unsigned b) { return a / gcd(a, b) * b; }
// a = max(a, b), a = min(a, b)
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;
}
// 階乗(MODをとる)
ll pow_mod(ll num, ll pow, ll mod) {
ll prod = 1;
num %= mod;
while (pow > 0) {
if (pow & 1)
prod = prod * num % mod;
num = num * num % mod;
pow >>= 1;
}
return prod;
}
// 二項係数(MODとる、1 ≦ k ≦ n ≦ 10^7 程度)
// COMinit()
// COM(x, y)
// とコンビで使う
// テーブルを作る前処理
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// UnionFind
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<ll> Size;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n + 1);
rank.resize(n + 1);
Size.resize(n + 1);
for (int i = 0; i <= n; ++i)
par[i] = i, rank[i] = 0, Size[i] = 1;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(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 (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
Size[x] += Size[y];
return true;
}
ll size(int x) { return Size[root(x)]; }
};
// modint構造体
struct Mint {
int val;
Mint inv() const {
int tmp, a = val, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
return Mint(x);
}
public:
Mint() : val(0) {}
Mint(ll x) {
if ((val = x % mod) < 0)
val += mod;
}
Mint pow(ll t) {
Mint res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
Mint &operator+=(const Mint &x) {
if ((val += x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator-=(const Mint &x) {
if ((val += mod - x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator*=(const Mint &x) {
val = (ll)val * x.val % mod;
return *this;
}
Mint &operator/=(const Mint &x) { return *this *= x.inv(); }
bool operator==(const Mint &x) const { return val == x.val; }
bool operator!=(const Mint &x) const { return val != x.val; }
bool operator<(const Mint &x) const { return val < x.val; }
bool operator<=(const Mint &x) const { return val <= x.val; }
bool operator>(const Mint &x) const { return val > x.val; }
bool operator>=(const Mint &x) const { return val >= x.val; }
Mint operator+(const Mint &x) const { return Mint(*this) += x; }
Mint operator-(const Mint &x) const { return Mint(*this) -= x; }
Mint operator*(const Mint &x) const { return Mint(*this) *= x; }
Mint operator/(const Mint &x) const { return Mint(*this) /= x; }
};
struct factorial {
vector<Mint> Fact, Finv;
public:
// factorial fact(10000010);
// fact.nCr(a, b)
//「fact」の部分は自由に名前変更可能
factorial(int maxx) {
Fact.resize(maxx + 1), Finv.resize(maxx + 1);
Fact[0] = Mint(1);
rep(i, 0, maxx) Fact[i + 1] = Fact[i] * (i + 1);
Finv[maxx] = Mint(1) / Fact[maxx];
rrep(i, maxx, 0) Finv[i - 1] = Finv[i] * i;
}
Mint fact(int n, bool inv = 0) {
if (inv)
return Finv[n];
else
return Fact[n];
}
Mint nPr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[n - r];
}
Mint nCr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[r] * Finv[n - r];
}
};
// 1 * 2 * 3 .... * n (mod)
ll modfact(ll n) {
if (n <= 1)
return 1;
return (n * modfact(n - 1)) % MOD;
}
// kが角度だった場合:cos(k * (PI / 180));
const double PI = acos(-1);
// 多次元 vector 生成 例: auto dp = make_vec<long long>(N+1, 5, 5, 5);
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
// int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
int main() {
int a, b, c;
cin >> a >> b >> c;
int tmp = a - b;
int ans = max(0, c - tmp);
print(ans);
return 0;
}
| [
"expression.operation.binary.remove"
] | 751,469 | 751,470 | u832995587 | cpp |
p02951 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
#define debug(x) cout << (#x) << "=" << (x) << ", ";
#define debug1(x) debug(x) cout << '\n';
#define debug2(x1, x2) debug(x1) debug(x2) cout << '\n';
#define debug3(x1, x2, x3) debug(x1) debug(x2) debug(x3) cout << '\n';
#define debug4(x1, x2, x3, x4) \
debug(x1) debug(x2) debug(x3) debug(x4) cout << '\n';
#define debug5(x1, x2, x3, x4, x5) \
debug(x1) debug(x2) debug(x3) debug(x4) debug(x5) cout << '\n';
#define fcout cout << fixed << setprecision(15)
#define repp(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) repp(i, 0, j)
#define rrep(i, j, k) for (int i = j; i >= k; --i)
#define all(x) (x).begin(), (x).end()
#define sort(x) sort(x.begin(), x.end())
#define lb(x, val) lower_bound(x.begin(), x.end(), val)
#define ub(x, val) upper_bound(x.begin(), x.end(), val)
#define pb(x) emplace_back(x);
typedef long long int lli;
typedef pair<int, int> pii;
typedef pair<lli, lli> pll;
typedef vector<int> vi;
typedef vector<lli> vl;
typedef tuple<int, int, lli> tiil;
// const lli M=998244353ll;
const lli M = 1000000007ll;
const double D = 1.0;
int main() {
fast_io int a, b, c;
cin >> a >> b >> c;
int k = b - a;
int p = c - k;
if (p <= 0)
cout << 0;
else
cout << p;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
#define debug(x) cout << (#x) << "=" << (x) << ", ";
#define debug1(x) debug(x) cout << '\n';
#define debug2(x1, x2) debug(x1) debug(x2) cout << '\n';
#define debug3(x1, x2, x3) debug(x1) debug(x2) debug(x3) cout << '\n';
#define debug4(x1, x2, x3, x4) \
debug(x1) debug(x2) debug(x3) debug(x4) cout << '\n';
#define debug5(x1, x2, x3, x4, x5) \
debug(x1) debug(x2) debug(x3) debug(x4) debug(x5) cout << '\n';
#define fcout cout << fixed << setprecision(15)
#define repp(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) repp(i, 0, j)
#define rrep(i, j, k) for (int i = j; i >= k; --i)
#define all(x) (x).begin(), (x).end()
#define sort(x) sort(x.begin(), x.end())
#define lb(x, val) lower_bound(x.begin(), x.end(), val)
#define ub(x, val) upper_bound(x.begin(), x.end(), val)
#define pb(x) emplace_back(x);
typedef long long int lli;
typedef pair<int, int> pii;
typedef pair<lli, lli> pll;
typedef vector<int> vi;
typedef vector<lli> vl;
typedef tuple<int, int, lli> tiil;
// const lli M=998244353ll;
const lli M = 1000000007ll;
const double D = 1.0;
int main() {
fast_io int a, b, c;
cin >> a >> b >> c;
int k = a - b;
int p = c - k;
if (p <= 0)
cout << 0;
else
cout << p;
return 0;
} | [
"expression.operation.binary.remove"
] | 751,473 | 751,474 | u397886197 | cpp |
p02951 | #include <iostream>
int main() {
int A, B, C;
std::cin >> A >> B >> C;
if (C - A - B < 0)
std::cout << 0;
else
std::cout << C - A - B;
} | #include <iostream>
int main() {
int A, B, C;
std::cin >> A >> B >> C;
if (C - (A - B) < 0)
std::cout << 0;
else
std::cout << C - (A - B);
} | [
"control_flow.branch.if.condition.change"
] | 751,475 | 751,476 | u509384866 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int a, b, c;
cin >> a >> b >> c;
int leave = a - b;
cout << max(a - b, 0) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int a, b, c;
cin >> a >> b >> c;
int leave = a - b;
cout << max(c - leave, 0) << endl;
return 0;
} | [
"identifier.change",
"io.output.change"
] | 751,481 | 751,482 | u442855610 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D;
cin >> A >> B >> C;
D = min(B - A, C);
cout << C - D << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D;
cin >> A >> B >> C;
D = min(A - B, C);
cout << C - D << endl;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 751,489 | 751,490 | u033273089 | cpp |
p02951 | #include <iostream>
using namespace std;
int main() {
int a, b, c, N, ans = 0;
string S, T;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c, N, ans = 0;
string S, T;
cin >> a >> b >> c;
cout << max(c - (a - b), 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 751,495 | 751,496 | u503052349 | cpp |
p02951 | #include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
const double EPS = 1e-9;
#define INF (1LL << 60)
#define D double
#define fs first
#define sc second
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define RFOR(i, a, b) for (int i = (int)(b - 1); i >= (int)(a); --i)
#define REP(i, n) FOR(i, 0, (n))
#define RREP(i, n) RFOR(i, 0, (n))
#define ITR(itr, mp) for (auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr, mp) for (auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i, a, b) ((a) <= (i) && (i) < (b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define SP << " " <<
typedef pair<int, int> P;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
signed main() {
ios::sync_with_stdio(false);
cout.tie(0);
cout.precision(20);
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
const double EPS = 1e-9;
#define INF (1LL << 60)
#define D double
#define fs first
#define sc second
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define RFOR(i, a, b) for (int i = (int)(b - 1); i >= (int)(a); --i)
#define REP(i, n) FOR(i, 0, (n))
#define RREP(i, n) RFOR(i, 0, (n))
#define ITR(itr, mp) for (auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr, mp) for (auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i, a, b) ((a) <= (i) && (i) < (b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define SP << " " <<
typedef pair<int, int> P;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
signed main() {
ios::sync_with_stdio(false);
cout.tie(0);
cout.precision(20);
int a, b, c;
cin >> a >> b >> c;
cout << max(0ll, c - (a - b)) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 751,497 | 751,498 | u237054088 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C - A + B << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(0, C - A + B) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 751,499 | 751,500 | u798950829 | cpp |
p02951 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, m) for (int i = n; i < m; i++)
#define reps(i, n) for (int i = 1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
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;
}
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b);
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n, m) for (int i = n; i < m; i++)
#define reps(i, n) for (int i = 1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
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;
}
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - (a - b));
}
| [
"call.add",
"call.arguments.change"
] | 751,501 | 751,502 | u467480147 | cpp |
p02951 | /* ______
_______ /\ |``\ | | /
| / \ |__/ |____ |/
| / _ _\ | \ | |\
| / \ | \ |______ | \
Dept. of CSE
Comilla University
*/
#include <bits/stdc++.h>
#define pi 2 * acos(0.0)
#define ll long long
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define valid(nx, ny) nx >= 0 && nx < n &&ny >= 0 && ny < m
#define ee endl
#define pii pair<int, int>
#define infinity 10000000000000000
#define mod 1000000007
int fx[] = {0, 0, +1, -1};
int fy[] = {+1, -1, 0, 0};
using namespace std;
/// check n=1;
/// check corner case;
const int maX = 1e5 + 1;
vector<ll> Graph[maX], cost[maX];
ll visit[maX];
ll x[10];
ll y[10];
double dist(ll i, ll j) {
double dx = x[i] - x[j];
double dy = y[i] - y[j];
return pow(dx * dx + dy * dy, 0.5);
}
int main() {
ll a, b, c;
cin >> a >> b >> c;
ll x = a - b;
cout << max(0ll, x - c) << endl;
}
| /* ______
_______ /\ |``\ | | /
| / \ |__/ |____ |/
| / _ _\ | \ | |\
| / \ | \ |______ | \
Dept. of CSE
Comilla University
*/
#include <bits/stdc++.h>
#define pi 2 * acos(0.0)
#define ll long long
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define valid(nx, ny) nx >= 0 && nx < n &&ny >= 0 && ny < m
#define ee endl
#define pii pair<int, int>
#define infinity 10000000000000000
#define mod 1000000007
int fx[] = {0, 0, +1, -1};
int fy[] = {+1, -1, 0, 0};
using namespace std;
/// check n=1;
/// check corner case;
const int maX = 1e5 + 1;
vector<ll> Graph[maX], cost[maX];
ll visit[maX];
ll x[10];
ll y[10];
double dist(ll i, ll j) {
double dx = x[i] - x[j];
double dy = y[i] - y[j];
return pow(dx * dx + dy * dy, 0.5);
}
int main() {
ll a, b, c;
cin >> a >> b >> c;
ll x = a - b;
cout << max(0ll, c - x) << endl;
}
| [
"expression.operation.binary.remove"
] | 751,507 | 751,508 | u164081575 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - (a - b)) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 751,514 | 751,515 | u929156598 | cpp |
p02951 | #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c - a - b < 0)
cout << "0";
else
cout << c - (a - b);
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c - (a - b) < 0)
cout << "0";
else
cout << c - (a - b);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 751,516 | 751,517 | u613326499 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C - A + B << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(0, C - A + B) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 751,518 | 751,519 | u319965179 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c - a - b < 0) {
cout << 0 << endl;
} else {
cout << c - a + b << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c - a + b < 0) {
cout << 0 << endl;
} else {
cout << c - a + b << endl;
}
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 751,524 | 751,525 | u453095051 | cpp |
p02951 | #include <bits/stdc++.h>
#define PI 3.141592653589
#define ll long long
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = a - (b + c);
if (ans > 0) {
cout << 0;
return 0;
}
if (ans < 0) {
cout << -1 * ans;
return 0;
}
} | #include <bits/stdc++.h>
#define PI 3.141592653589
#define ll long long
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = a - (b + c);
if (ans >= 0) {
cout << 0;
return 0;
}
if (ans < 0) {
cout << -1 * ans;
return 0;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,526 | 751,527 | u145562832 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(0, c - a + b) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - a + b) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 751,549 | 751,550 | u247123590 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b + c)
cout << c - a + b << endl;
else
cout << 0 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b + c)
cout << c - a + b << endl;
else
cout << 0 << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,551 | 751,552 | u945761460 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
if (ans < 0)
ans = 0;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = c + b - a;
if (ans < 0)
ans = 0;
cout << ans << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove"
] | 751,567 | 751,568 | u782700818 | cpp |
p02950 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "{";
for (const T &v : vc)
o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T> using V = vector<T>;
template <class T> using VV = vector<vector<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
#ifdef LOCAL
#define show(x) \
cerr << "LINE" << __LINE__ << " : " << #x << " = " << (x) << endl
#define dump(x) \
cerr << "LINE" << __LINE__ << " : " << #x << " = {"; \
for (auto v : x) \
cerr << v << ","; \
cerr << "}" << endl;
#else
#define show(x) true
#define dump(x) true
#endif
unsigned int mod = 1;
struct ModInt {
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
uint v;
ModInt() : v(0) {}
ModInt(ll _v) : v(normS(_v % mod + mod)) {}
explicit operator bool() const { return v != 0; }
static uint normS(const uint &x) {
return (x < mod) ? x : x - mod;
} // [0 , 2*mod-1] -> [0 , mod-1]
static ModInt make(const uint &x) {
ModInt m;
m.v = x;
return m;
}
ModInt operator+(const ModInt &b) const { return make(normS(v + b.v)); }
ModInt operator-(const ModInt &b) const { return make(normS(v + mod - b.v)); }
ModInt operator-() const { return make(normS(mod - v)); }
ModInt operator*(const ModInt &b) const { return make((ull)v * b.v % mod); }
ModInt operator/(const ModInt &b) const { return *this * b.inv(); }
ModInt &operator+=(const ModInt &b) { return *this = *this + b; }
ModInt &operator-=(const ModInt &b) { return *this = *this - b; }
ModInt &operator*=(const ModInt &b) { return *this = *this * b; }
ModInt &operator/=(const ModInt &b) { return *this = *this / b; }
ModInt &operator++(int) { return *this = *this + 1; }
ModInt &operator--(int) { return *this = *this - 1; }
ll extgcd(ll a, ll b, ll &x, ll &y) const {
ll p[] = {a, 1, 0}, q[] = {b, 0, 1};
while (*q) {
ll t = *p / *q;
rep(i, 3) swap(p[i] -= t * q[i], q[i]);
}
if (p[0] < 0)
rep(i, 3) p[i] = -p[i];
x = p[1], y = p[2];
return p[0];
}
ModInt inv() const {
ll x, y;
extgcd(v, mod, x, y);
return make(normS(x + mod));
}
ModInt pow(ll p) const {
if (p < 0)
return inv().pow(-p);
ModInt a = 1;
ModInt x = *this;
while (p) {
if (p & 1)
a *= x;
x *= x;
p >>= 1;
}
return a;
}
bool operator==(const ModInt &b) const { return v == b.v; }
bool operator!=(const ModInt &b) const { return v != b.v; }
friend istream &operator>>(istream &o, ModInt &x) {
ll tmp;
o >> tmp;
x = ModInt(tmp);
return o;
}
friend ostream &operator<<(ostream &o, const ModInt &x) { return o << x.v; }
};
using mint = ModInt;
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // DON'T USE scanf/printf/puts !!
cout << fixed << setprecision(20);
cin >> mod;
int N = mod;
VV<mint> f(N);
{
V<mint> F(N + 1);
F[N] = 1, F[1] = -1;
rep(i, N) {
V<mint> g = F;
f[i] = V<mint>(N);
for (int j = N - 1; j >= 0; j--) {
f[i][j] = g[j + 1];
g[j] += f[i][j] * i;
}
assert(!g[0]);
rep(j, N) f[i][j] = -f[i][j];
}
}
V<mint> g(N);
rep(i, N) {
int a;
cin >> a;
rep(j, N) g[j] -= f[i][j] * a;
}
rep(i, N) cout << g[i] << " ";
cout << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "{";
for (const T &v : vc)
o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T> using V = vector<T>;
template <class T> using VV = vector<vector<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
#ifdef LOCAL
#define show(x) \
cerr << "LINE" << __LINE__ << " : " << #x << " = " << (x) << endl
#define dump(x) \
cerr << "LINE" << __LINE__ << " : " << #x << " = {"; \
for (auto v : x) \
cerr << v << ","; \
cerr << "}" << endl;
#else
#define show(x) true
#define dump(x) true
#endif
unsigned int mod = 1;
struct ModInt {
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
uint v;
ModInt() : v(0) {}
ModInt(ll _v) : v(normS(_v % mod + mod)) {}
explicit operator bool() const { return v != 0; }
static uint normS(const uint &x) {
return (x < mod) ? x : x - mod;
} // [0 , 2*mod-1] -> [0 , mod-1]
static ModInt make(const uint &x) {
ModInt m;
m.v = x;
return m;
}
ModInt operator+(const ModInt &b) const { return make(normS(v + b.v)); }
ModInt operator-(const ModInt &b) const { return make(normS(v + mod - b.v)); }
ModInt operator-() const { return make(normS(mod - v)); }
ModInt operator*(const ModInt &b) const { return make((ull)v * b.v % mod); }
ModInt operator/(const ModInt &b) const { return *this * b.inv(); }
ModInt &operator+=(const ModInt &b) { return *this = *this + b; }
ModInt &operator-=(const ModInt &b) { return *this = *this - b; }
ModInt &operator*=(const ModInt &b) { return *this = *this * b; }
ModInt &operator/=(const ModInt &b) { return *this = *this / b; }
ModInt &operator++(int) { return *this = *this + 1; }
ModInt &operator--(int) { return *this = *this - 1; }
ll extgcd(ll a, ll b, ll &x, ll &y) const {
ll p[] = {a, 1, 0}, q[] = {b, 0, 1};
while (*q) {
ll t = *p / *q;
rep(i, 3) swap(p[i] -= t * q[i], q[i]);
}
if (p[0] < 0)
rep(i, 3) p[i] = -p[i];
x = p[1], y = p[2];
return p[0];
}
ModInt inv() const {
ll x, y;
extgcd(v, mod, x, y);
return make(normS(x + mod));
}
ModInt pow(ll p) const {
if (p < 0)
return inv().pow(-p);
ModInt a = 1;
ModInt x = *this;
while (p) {
if (p & 1)
a *= x;
x *= x;
p >>= 1;
}
return a;
}
bool operator==(const ModInt &b) const { return v == b.v; }
bool operator!=(const ModInt &b) const { return v != b.v; }
friend istream &operator>>(istream &o, ModInt &x) {
ll tmp;
o >> tmp;
x = ModInt(tmp);
return o;
}
friend ostream &operator<<(ostream &o, const ModInt &x) { return o << x.v; }
};
using mint = ModInt;
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // DON'T USE scanf/printf/puts !!
cout << fixed << setprecision(20);
cin >> mod;
int N = mod;
VV<mint> f(N);
{
V<mint> F(N + 1);
F[N] = 1, F[1] = -1;
rep(i, N) {
V<mint> g = F;
f[i] = V<mint>(N);
for (int j = N - 1; j >= 0; j--) {
f[i][j] = g[j + 1];
g[j] += f[i][j] * i;
}
assert(!g[0]);
rep(j, N) f[i][j] = -f[i][j];
}
}
V<mint> g(N);
rep(i, N) {
int a;
cin >> a;
rep(j, N) g[j] += f[i][j] * a;
}
rep(i, N) cout << g[i] << " ";
cout << endl;
}
| [
"expression.operator.change"
] | 751,579 | 751,580 | u309470177 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int p;
cin >> p;
auto mod = [&](int x) { return (x % p + p) % p; };
// Let g(x) = (x - x^p)/(x-1)
// Clearly g(x) = 0 for all x != 1.
// We can also write g as:
// g(x) = - x - x^2 - ... - x^{p-1}
// Hence g(1) = -(p-1) = 1
// So we have g(x) = [x=1] in iversion notation.
// So now the algorithm is simple:
// Let I be the set of indices i for which a_i = 1.
// The answer is then p(x) = \sum_{i \in I} g(x/i).
// There is one small issue: What about i=0?
// Here we can simply choose 1 - x^(p-1) instead of g(x/0).
// Below we avoid the special case by instead of adding g(x/i) we would add:
// 1 - (i^(p-1) - i^(p-2) x - i^(p-3) x^2 - .... - i x^(p-2) - x^(p-1))
// Which is equal to g(x/i) for i != 0 and 1 - x^(p-1) for i = 0.
vector<int> cs(p, 0);
for (int i = 0; i < p; ++i) {
int a;
cin >> a;
int multiplier = 1;
for (int j = p - 1; j >= 0; --j) {
cs[j] = mod(cs[j] - multiplier * a);
multiplier = (multiplier * i) % p;
}
cs[0] = mod(cs[0] + 1) * a;
}
for (int c : cs) {
cout << c << " ";
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int p;
cin >> p;
auto mod = [&](int x) { return (x % p + p) % p; };
// Let g(x) = (x - x^p)/(x-1)
// Clearly g(x) = 0 for all x != 1.
// We can also write g as:
// g(x) = - x - x^2 - ... - x^{p-1}
// Hence g(1) = -(p-1) = 1
// So we have g(x) = [x=1] in iversion notation.
// So now the algorithm is simple:
// Let I be the set of indices i for which a_i = 1.
// The answer is then p(x) = \sum_{i \in I} g(x/i).
// There is one small issue: What about i=0?
// Here we can simply choose 1 - x^(p-1) instead of g(x/0).
// Below we avoid the special case by instead of adding g(x/i) we would add:
// 1 - (i^(p-1) - i^(p-2) x - i^(p-3) x^2 - .... - i x^(p-2) - x^(p-1))
// Which is equal to g(x/i) for i != 0 and 1 - x^(p-1) for i = 0.
vector<int> cs(p, 0);
for (int i = 0; i < p; ++i) {
int a;
cin >> a;
int multiplier = 1;
for (int j = p - 1; j >= 0; --j) {
cs[j] = mod(cs[j] - multiplier * a);
multiplier = (multiplier * i) % p;
}
cs[0] = mod(cs[0] + a);
}
for (int c : cs) {
cout << c << " ";
}
cout << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"call.arguments.change"
] | 751,585 | 751,586 | u813181182 | cpp |
p02950 | #include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for (LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for (LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL << (i))
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
LLI power(LLI n, LLI p, LLI m) {
LLI ret = 1;
while (p > 0) {
if (p & 1)
(ret *= n) %= m;
(n *= n) %= m;
p /= 2;
}
return ret;
}
LLI mod_inv(LLI n, LLI p) { return power(n, p - 2, p); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
LLI p;
while (cin >> p) {
vector<LLI> a(p);
cin >> a;
vector<LLI> fac(p), ifac(p);
fac[0] = 1;
FOR(i, 1, p) { fac[i] = fac[i - 1] * i % p; }
REP(i, p) ifac[i] = mod_inv(fac[i], p);
vector<vector<LLI>> power_table(p + 1, vector<LLI>(p + 1, 1));
FORE(i, 1, p) {
FORE(j, 1, p) { power_table[i][j] = power_table[i][j - 1] * i % p; }
}
vector<LLI> ans(p);
REP(i, p) {
if (a[i]) {
(ans[0] += 1) %= p;
REP(j, p) {
LLI c = fac[p - 1] * ifac[j] % p * ifac[p - 1 - j] % p;
LLI t = c * power_table[i][p - 1 - j] % p;
if ((p - 1 - j) % 2 == 0)
t = (-t + p) % p;
(ans[j] += t) %= p;
}
}
}
join(cout, ALL(ans));
}
return 0;
}
| #include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for (LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for (LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL << (i))
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
LLI power(LLI n, LLI p, LLI m) {
LLI ret = 1;
while (p > 0) {
if (p & 1)
(ret *= n) %= m;
(n *= n) %= m;
p /= 2;
}
return ret;
}
LLI mod_inv(LLI n, LLI p) { return power(n, p - 2, p); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
LLI p;
while (cin >> p) {
vector<LLI> a(p);
cin >> a;
vector<LLI> fac(p), ifac(p);
fac[0] = 1;
FOR(i, 1, p) { fac[i] = fac[i - 1] * i % p; }
REP(i, p) ifac[i] = mod_inv(fac[i], p);
vector<vector<LLI>> power_table(p + 1, vector<LLI>(p + 1, 1));
FORE(i, 0, p) {
FORE(j, 1, p) { power_table[i][j] = power_table[i][j - 1] * i % p; }
}
vector<LLI> ans(p);
REP(i, p) {
if (a[i]) {
(ans[0] += 1) %= p;
REP(j, p) {
LLI c = fac[p - 1] * ifac[j] % p * ifac[p - 1 - j] % p;
LLI t = c * power_table[i][p - 1 - j] % p;
if ((p - 1 - j) % 2 == 0)
t = (-t + p) % p;
(ans[j] += t) %= p;
}
}
}
join(cout, ALL(ans));
}
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 751,587 | 751,588 | u543167400 | cpp |
p02950 | #include <cstring>
#include <iostream>
using namespace std;
int main() {
int p;
cin >> p;
int b[p];
memset(b, 0, sizeof(b));
for (int i = 0; i < p; i++) {
int a;
cin >> a;
if (i == 0) {
b[0] += a;
continue;
}
int t = p - a;
for (int j = p - 1; j >= 1; j--) {
b[j] = (b[j] + t) % p;
t = t * i % p;
}
}
for (int i = 0; i < p; i++) {
cout << b[i] << (i == p - 1 ? '\n' : ' ');
}
return 0;
}
| #include <cstring>
#include <iostream>
using namespace std;
int main() {
int p;
cin >> p;
int b[p];
memset(b, 0, sizeof(b));
for (int i = 0; i < p; i++) {
int a;
cin >> a;
if (i == 0) {
b[0] += a;
}
int t = p - a;
for (int j = p - 1; j >= 1; j--) {
b[j] = (b[j] + t) % p;
t = t * i % p;
}
}
for (int i = 0; i < p; i++) {
cout << b[i] << (i == p - 1 ? '\n' : ' ');
}
return 0;
}
| [] | 751,589 | 751,590 | u587665681 | cpp |
p02950 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
ll MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
template <class C> void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c),
std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
// mod int struct
// original : https://github.com/beet-aizu/library/blob/master/mod/mint.cpp
struct mint {
ll v;
ll mod;
mint() : v(0) {}
mint(signed v, ll mod = MOD) : v(v), mod(mod) {}
mint(ll t, ll mod = MOD) : mod(mod) {
v = t % mod;
if (v < 0)
v += mod;
}
mint pow(ll k) {
mint res(1), tmp(v);
while (k) {
if (k & 1)
res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static mint add_identity() { return mint(0); }
static mint mul_identity() { return mint(1); }
mint inv() { return pow(mod - 2); }
mint &operator+=(mint a) {
v += a.v;
if (v >= mod)
v -= mod;
return *this;
}
mint &operator-=(mint a) {
v += mod - a.v;
if (v >= mod)
v -= mod;
return *this;
}
mint &operator*=(mint a) {
v = 1LL * v * a.v % mod;
return *this;
}
mint &operator/=(mint a) { return (*this) *= a.inv(); }
mint operator+(mint a) const { return mint(v) += a; };
mint operator-(mint a) const { return mint(v) -= a; };
mint operator*(mint a) const { return mint(v) *= a; };
mint operator/(mint a) const { return mint(v) /= a; };
mint operator-() const { return v ? mint(mod - v) : mint(v); }
bool operator==(const mint a) const { return v == a.v; }
bool operator!=(const mint a) const { return v != a.v; }
bool operator<(const mint a) const { return v < a.v; }
// find x s.t. a^x = b
ll log(ll a, ll b) {
const ll sq = 40000;
unordered_map<ll, ll> dp;
dp.reserve(sq);
mint res(1);
for (int r = 0; r < sq; r++) {
if (!dp.count(res.v))
dp[res.v] = r;
res *= a;
}
mint p = mint(a).inv().pow(sq);
res = b;
for (int q = 0; q <= mod / sq + 1; q++) {
if (dp.count(res.v)) {
ll idx = q * sq + dp[res.v];
if (idx > 0)
return idx;
}
res *= p;
}
assert(0);
return ll(-1);
}
static mint comb(long long n, int k) {
mint num(1), dom(1);
for (int i = 0; i < k; i++) {
num *= mint(n - i);
dom *= mint(i + 1);
}
return num / dom;
}
};
ostream &operator<<(ostream &os, mint m) {
os << m.v;
return os;
}
// x座標が相異なるn+1点(x_i,y_i)を通るn次以下の多項式f(x)を返す
// O(n^2)
vector<mint> lagrange_interpolation(vector<mint> x, vector<mint> y) {
const int n = x.size() - 1;
for (int i = 0; i < n + 1; ++i) {
mint t = 1;
for (int j = 0; j < n + 1; ++j) {
if (i != j)
t *= x[i] - x[j];
}
y[i] /= t;
}
ll cur = 0, nxt = 1;
vector<vector<mint>> dp(2, vector<mint>(n + 2));
dp[0][0] = -x[0], dp[0][1] = 1;
for (int i = 1; i < n + 1; ++i) {
for (int j = 0; j < n + 2; ++j) {
dp[nxt][j] = dp[cur][j] * -1 * x[i];
if (j >= 1)
dp[nxt][j] += dp[cur][j - 1];
}
swap(nxt, cur);
}
vector<mint> xinv(n + 1);
for (int i = 0; i < n + 1; ++i)
xinv[i] = x[i].inv();
vector<mint> ret(n + 1); // f(x)
for (int i = 0; i < n + 1; ++i) {
if (y[i] == 0)
continue;
// 0割り対策の場合分け
if (x[i] == 0) {
for (int j = 0; j < n + 1; ++j) {
ret[j] += dp[cur][j + 1] * y[i];
}
} else {
ret[0] -= dp[cur][0] * xinv[i] * y[i];
mint pre = -dp[cur][0] * xinv[i];
for (int j = 1; j < n + 1; ++j) {
ret[j] -= (dp[cur][j] - pre) * xinv[i] * y[i];
pre = -(dp[cur][j] - pre) * xinv[i];
}
}
}
return ret;
}
int main() {
int p;
cin >> p;
MOD = p;
vector<mint> a(p, 0);
for (int i = 0; i < p; ++i) {
int aa;
cin >> aa;
a[i] = aa;
}
vector<mint> x(p);
for (int i = 0; i < p; ++i) {
x[i] = i;
}
auto ret = lagrange_interpolation(x, a);
print(ret);
return 0;
} | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
ll MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
template <class C> void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c),
std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
// mod int struct
// original : https://github.com/beet-aizu/library/blob/master/mod/mint.cpp
struct mint {
ll v;
ll mod;
mint() : v(0) {}
mint(signed v, ll mod = MOD) : v(v), mod(mod) {}
mint(ll t, ll mod = MOD) : mod(mod) {
v = t % mod;
if (v < 0)
v += mod;
}
mint pow(ll k) {
mint res(1), tmp(v);
while (k) {
if (k & 1)
res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static mint add_identity() { return mint(0); }
static mint mul_identity() { return mint(1); }
mint inv() { return pow(mod - 2); }
mint &operator+=(mint a) {
v += a.v;
if (v >= mod)
v -= mod;
return *this;
}
mint &operator-=(mint a) {
v += mod - a.v;
if (v >= mod)
v -= mod;
return *this;
}
mint &operator*=(mint a) {
v = 1LL * v * a.v % mod;
return *this;
}
mint &operator/=(mint a) { return (*this) *= a.inv(); }
mint operator+(mint a) const { return mint(v) += a; };
mint operator-(mint a) const { return mint(v) -= a; };
mint operator*(mint a) const { return mint(v) *= a; };
mint operator/(mint a) const { return mint(v) /= a; };
mint operator-() const { return v ? mint(mod - v) : mint(v); }
bool operator==(const mint a) const { return v == a.v; }
bool operator!=(const mint a) const { return v != a.v; }
bool operator<(const mint a) const { return v < a.v; }
// find x s.t. a^x = b
ll log(ll a, ll b) {
const ll sq = 40000;
unordered_map<ll, ll> dp;
dp.reserve(sq);
mint res(1);
for (int r = 0; r < sq; r++) {
if (!dp.count(res.v))
dp[res.v] = r;
res *= a;
}
mint p = mint(a).inv().pow(sq);
res = b;
for (int q = 0; q <= mod / sq + 1; q++) {
if (dp.count(res.v)) {
ll idx = q * sq + dp[res.v];
if (idx > 0)
return idx;
}
res *= p;
}
assert(0);
return ll(-1);
}
static mint comb(long long n, int k) {
mint num(1), dom(1);
for (int i = 0; i < k; i++) {
num *= mint(n - i);
dom *= mint(i + 1);
}
return num / dom;
}
};
ostream &operator<<(ostream &os, mint m) {
os << m.v;
return os;
}
// x座標が相異なるn+1点(x_i,y_i)を通るn次以下の多項式f(x)を返す
// O(n^2)
vector<mint> lagrange_interpolation(vector<mint> x, vector<mint> y) {
const int n = x.size() - 1;
for (int i = 0; i < n + 1; ++i) {
mint t = 1;
for (int j = 0; j < n + 1; ++j) {
if (i != j)
t *= x[i] - x[j];
}
y[i] /= t;
}
ll cur = 0, nxt = 1;
vector<vector<mint>> dp(2, vector<mint>(n + 2));
dp[0][0] = -x[0], dp[0][1] = 1;
for (int i = 1; i < n + 1; ++i) {
for (int j = 0; j < n + 2; ++j) {
dp[nxt][j] = dp[cur][j] * -1 * x[i];
if (j >= 1)
dp[nxt][j] += dp[cur][j - 1];
}
swap(nxt, cur);
}
vector<mint> xinv(n + 1);
for (int i = 0; i < n + 1; ++i)
xinv[i] = x[i].inv();
vector<mint> ret(n + 1, 0); // f(x)
for (int i = 0; i < n + 1; ++i) {
if (y[i] == 0)
continue;
// 0割り対策の場合分け
if (x[i] == 0) {
for (int j = 0; j < n + 1; ++j) {
ret[j] += dp[cur][j + 1] * y[i];
}
} else {
ret[0] -= dp[cur][0] * xinv[i] * y[i];
mint pre = -dp[cur][0] * xinv[i];
for (int j = 1; j < n + 1; ++j) {
ret[j] -= (dp[cur][j] - pre) * xinv[i] * y[i];
pre = -(dp[cur][j] - pre) * xinv[i];
}
}
}
return ret;
}
int main() {
int p;
cin >> p;
MOD = p;
vector<mint> a(p, 0);
for (int i = 0; i < p; ++i) {
int aa;
cin >> aa;
a[i] = aa;
}
vector<mint> x(p);
for (int i = 0; i < p; ++i) {
x[i] = i;
}
auto ret = lagrange_interpolation(x, a);
print(ret);
return 0;
} | [
"call.arguments.add"
] | 751,608 | 751,609 | u756088996 | cpp |
p02950 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const int MAX = 510000;
int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int p;
cin >> p;
MOD = p;
COMinit();
ll a[p];
rep(i, p) cin >> a[i];
ll b[p] = {};
for (int i = 0; i < p; i++) {
if (i == 0) {
b[p - 1]++;
b[0] = p - 1;
b[p - 1] *= (finv[p - 1] * a[p - 1]);
b[p - 1] %= p;
b[0] *= finv[p - 1] * a[0];
b[0] %= p;
} else {
ll temp = 1;
ll add[p] = {};
for (int j = 0; j < p - 1; j++) {
add[p - 1 - j] = temp * a[i];
add[p - 1 - j] *= finv[p - 1];
add[p - 1 - j] %= p;
b[p - 1 - j] += add[p - 1 - j];
b[p - 1 - j] %= p;
temp *= i;
temp %= p;
}
}
}
for (int i = 0; i < p; i++)
cout << b[i] % p << ' ';
cout << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const int MAX = 510000;
int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int p;
cin >> p;
MOD = p;
COMinit();
ll a[p];
rep(i, p) cin >> a[i];
ll b[p] = {};
for (int i = 0; i < p; i++) {
if (i == 0) {
b[p - 1]++;
b[0] = p - 1;
b[p - 1] *= (finv[p - 1] * a[0]);
b[p - 1] %= p;
b[0] *= finv[p - 1] * a[0];
b[0] %= p;
} else {
ll temp = 1;
ll add[p] = {};
for (int j = 0; j < p - 1; j++) {
add[p - 1 - j] = temp * a[i];
add[p - 1 - j] *= finv[p - 1];
add[p - 1 - j] %= p;
b[p - 1 - j] += add[p - 1 - j];
b[p - 1 - j] %= p;
temp *= i;
temp %= p;
}
}
}
for (int i = 0; i < p; i++)
cout << b[i] % p << ' ';
cout << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 751,610 | 751,611 | u906208439 | cpp |
p02950 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const int MAX = 510000;
int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int p;
cin >> p;
MOD = p;
COMinit();
ll a[p];
rep(i, p) cin >> a[i];
ll b[p] = {};
for (int i = 0; i < p; i++) {
if (i == 0) {
b[p - 1]++;
b[0] = p - 1;
b[p - 1] *= (finv[p - 1] * a[p - 1]);
b[p - 1] %= p;
b[0] *= finv[p - 1] * a[0];
b[0] %= p;
} else {
ll temp = 1;
ll add[p] = {};
for (int j = 0; j < p - 1; j++) {
add[p - 1 - j] = temp * a[i];
add[p - 1 - j] *= finv[p - 1];
add[p - 1 - j] %= p;
b[p - 1 - j] += add[p - 1 - j];
b[p - 1 - j] %= p;
temp *= i;
temp %= p;
}
}
}
for (int i = 0; i < p; i++)
cout << b[i] << ' ';
cout << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef pair<int, int> pint;
typedef pair<ll, int> pli;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const int MAX = 510000;
int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main() {
int p;
cin >> p;
MOD = p;
COMinit();
ll a[p];
rep(i, p) cin >> a[i];
ll b[p] = {};
for (int i = 0; i < p; i++) {
if (i == 0) {
b[p - 1]++;
b[0] = p - 1;
b[p - 1] *= (finv[p - 1] * a[0]);
b[p - 1] %= p;
b[0] *= finv[p - 1] * a[0];
b[0] %= p;
} else {
ll temp = 1;
ll add[p] = {};
for (int j = 0; j < p - 1; j++) {
add[p - 1 - j] = temp * a[i];
add[p - 1 - j] *= finv[p - 1];
add[p - 1 - j] %= p;
b[p - 1 - j] += add[p - 1 - j];
b[p - 1 - j] %= p;
temp *= i;
temp %= p;
}
}
}
for (int i = 0; i < p; i++)
cout << b[i] % p << ' ';
cout << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 751,612 | 751,611 | u906208439 | cpp |
p02950 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, a, b) for (ll i = (a); i < (b); i++)
typedef uint64_t ull;
typedef int64_t ll;
typedef std::pair<ll, ll> PLL;
using namespace std;
std::vector<ll> fac(510000, 1), finv(510000, 1), inv(510000, 1);
void c4_init(ll m) {
for (ll i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % m;
inv[i] = m - inv[m % i] * (m / i) % m;
finv[i] = finv[i - 1] * inv[i] % m;
}
}
ll c4(ll n, ll k, ll m) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % m) % m;
}
signed main() {
ll p;
cin >> p;
vector<ll> a(p - 1);
rep(i, p) cin >> a[i];
c4_init(p);
vector<ll> b(p - 1, 0);
rep(i, p) {
if (a[i] == 0)
continue;
(b[0] += 1) %= p;
ll pw = 1;
for (ll j = p - 1; j >= 0; j--) {
(b[j] += pw * c4(p - 1, j, p)) %= p;
(pw *= p - i) %= p;
}
}
rep(i, p) { cout << b[i] << (i != p - 1 ? " " : ""); }
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, a, b) for (ll i = (a); i < (b); i++)
typedef uint64_t ull;
typedef int64_t ll;
typedef std::pair<ll, ll> PLL;
using namespace std;
std::vector<ll> fac(510000, 1), finv(510000, 1), inv(510000, 1);
void c4_init(ll m) {
for (ll i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % m;
inv[i] = m - inv[m % i] * (m / i) % m;
finv[i] = finv[i - 1] * inv[i] % m;
}
}
ll c4(ll n, ll k, ll m) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % m) % m;
}
signed main() {
ll p;
cin >> p;
vector<ll> a(p - 1);
rep(i, p) cin >> a[i];
c4_init(p);
vector<ll> b(p - 1, 0);
rep(i, p) {
if (a[i] == 0)
continue;
(b[0] += 1) %= p;
ll pw = 1;
for (ll j = p - 1; j >= 0; j--) {
(b[j] += p * p - pw * c4(p - 1, j, p)) %= p;
(pw *= p - i) %= p;
}
}
rep(i, p) { cout << b[i] << (i != p - 1 ? " " : ""); }
cout << endl;
return 0;
}
| [
"assignment.change"
] | 751,613 | 751,614 | u702996070 | cpp |
p02950 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
int mod = 2;
struct mint {
unsigned x;
mint() : x(0) {}
mint(signed sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
mint(signed long long sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
int get() const { return (int)x; }
mint &operator+=(mint that) {
if ((x += that.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(mint that) {
if ((x += mod - that.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(mint that) {
x = (unsigned long long)x * that.x % mod;
return *this;
}
mint &operator/=(mint that) { return *this *= that.inverse(); }
mint operator+(mint that) const { return mint(*this) += that; }
mint operator-(mint that) const { return mint(*this) -= that; }
mint operator*(mint that) const { return mint(*this) *= that; }
mint operator/(mint that) const { return mint(*this) /= that; }
mint inverse() const {
long long a = x, b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mint(u);
}
bool operator==(mint that) const { return x == that.x; }
bool operator!=(mint that) const { return x != that.x; }
mint operator-() const {
mint t;
t.x = x == 0 ? 0 : mod - x;
return t;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inverse();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
class FPolynomialConstruction {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
void solve(std::istream &cin, std::ostream &cout) {
int p;
cin >> p;
mod = p;
vector<int> a(p);
vector<mint> b(p);
REP(i, p - 1) { cin >> a[i]; }
combination c(p - 1);
REP(i, a.size()) {
if (a[i] == 0)
continue;
mint ni = 1;
b[0] += 1;
REV(j, b.size() - 1, 0) {
b[j] -= ni * c(p - 1, j);
ni *= -i;
}
}
REP(i, b.size()) cout << b[i].get() << " ";
cout << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
FPolynomialConstruction solver;
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
int mod = 2;
struct mint {
unsigned x;
mint() : x(0) {}
mint(signed sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
mint(signed long long sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
int get() const { return (int)x; }
mint &operator+=(mint that) {
if ((x += that.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(mint that) {
if ((x += mod - that.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(mint that) {
x = (unsigned long long)x * that.x % mod;
return *this;
}
mint &operator/=(mint that) { return *this *= that.inverse(); }
mint operator+(mint that) const { return mint(*this) += that; }
mint operator-(mint that) const { return mint(*this) -= that; }
mint operator*(mint that) const { return mint(*this) *= that; }
mint operator/(mint that) const { return mint(*this) /= that; }
mint inverse() const {
long long a = x, b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mint(u);
}
bool operator==(mint that) const { return x == that.x; }
bool operator!=(mint that) const { return x != that.x; }
mint operator-() const {
mint t;
t.x = x == 0 ? 0 : mod - x;
return t;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inverse();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
class FPolynomialConstruction {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
void solve(std::istream &cin, std::ostream &cout) {
int p;
cin >> p;
mod = p;
vector<int> a(p);
vector<mint> b(p);
REP(i, p) { cin >> a[i]; }
combination c(p - 1);
REP(i, a.size()) {
if (a[i] == 0)
continue;
mint ni = 1;
b[0] += 1;
REV(j, b.size() - 1, 0) {
b[j] -= ni * c(p - 1, j);
ni *= -i;
}
}
REP(i, b.size()) cout << b[i].get() << " ";
cout << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
FPolynomialConstruction solver;
solver.solve(in, out);
return 0;
}
| [
"expression.operation.binary.remove"
] | 751,615 | 751,616 | u516353059 | cpp |
p02950 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
int mod = 2;
struct mint {
unsigned x;
mint() : x(0) {}
mint(signed sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
mint(signed long long sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
int get() const { return (int)x; }
mint &operator+=(mint that) {
if ((x += that.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(mint that) {
if ((x += mod - that.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(mint that) {
x = (unsigned long long)x * that.x % mod;
return *this;
}
mint &operator/=(mint that) { return *this *= that.inverse(); }
mint operator+(mint that) const { return mint(*this) += that; }
mint operator-(mint that) const { return mint(*this) -= that; }
mint operator*(mint that) const { return mint(*this) *= that; }
mint operator/(mint that) const { return mint(*this) /= that; }
mint inverse() const {
long long a = x, b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mint(u);
}
bool operator==(mint that) const { return x == that.x; }
bool operator!=(mint that) const { return x != that.x; }
mint operator-() const {
mint t;
t.x = x == 0 ? 0 : mod - x;
return t;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inverse();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
class FPolynomialConstruction {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
void solve(std::istream &cin, std::ostream &cout) {
int p;
cin >> p;
mod = p;
vector<int> a(p);
vector<mint> b(p);
REP(i, p - 1) { cin >> a[i]; }
combination c(p - 1);
REP(i, a.size()) {
if (a[i] == 0)
continue;
mint ni = 1;
b[0] += 1;
REV(j, b.size() - 1, 0) {
b[j] += ni * c(p - 1, j);
ni *= -i;
}
}
REP(i, b.size()) cout << b[i].get() << " ";
cout << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
FPolynomialConstruction solver;
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
int mod = 2;
struct mint {
unsigned x;
mint() : x(0) {}
mint(signed sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
mint(signed long long sig) { x = sig < 0 ? sig % mod + mod : sig % mod; }
int get() const { return (int)x; }
mint &operator+=(mint that) {
if ((x += that.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(mint that) {
if ((x += mod - that.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(mint that) {
x = (unsigned long long)x * that.x % mod;
return *this;
}
mint &operator/=(mint that) { return *this *= that.inverse(); }
mint operator+(mint that) const { return mint(*this) += that; }
mint operator-(mint that) const { return mint(*this) -= that; }
mint operator*(mint that) const { return mint(*this) *= that; }
mint operator/(mint that) const { return mint(*this) /= that; }
mint inverse() const {
long long a = x, b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mint(u);
}
bool operator==(mint that) const { return x == that.x; }
bool operator!=(mint that) const { return x != that.x; }
mint operator-() const {
mint t;
t.x = x == 0 ? 0 : mod - x;
return t;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inverse();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
class FPolynomialConstruction {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
void solve(std::istream &cin, std::ostream &cout) {
int p;
cin >> p;
mod = p;
vector<int> a(p);
vector<mint> b(p);
REP(i, p) { cin >> a[i]; }
combination c(p - 1);
REP(i, a.size()) {
if (a[i] == 0)
continue;
mint ni = 1;
b[0] += 1;
REV(j, b.size() - 1, 0) {
b[j] -= ni * c(p - 1, j);
ni *= -i;
}
}
REP(i, b.size()) cout << b[i].get() << " ";
cout << endl;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
FPolynomialConstruction solver;
solver.solve(in, out);
return 0;
}
| [
"expression.operation.binary.remove",
"expression.operator.change"
] | 751,617 | 751,616 | u516353059 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
int n, ans[10010];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (i == 0)
ans[0] += x;
x = n - x;
for (int j = 1; j < n; j++) {
ans[n - j] = (ans[n - j] + x) % n;
x = (x * i) % n;
}
}
for (int i = 0; i < n; i++)
cout << ans[i];
}
| #include <bits/stdc++.h>
using namespace std;
int n, ans[10010];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (i == 0)
ans[0] += x;
x = n - x;
for (int j = 1; j < n; j++) {
ans[n - j] = (ans[n - j] + x) % n;
x = (x * i) % n;
}
}
for (int i = 0; i < n; i++)
cout << ans[i] << ' ';
}
| [
"io.output.change"
] | 751,618 | 751,619 | u110464018 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
#define endl "\n"
#define MP make_pair
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORR(x, arr) for (auto &x : arr)
#define PII pair<int, int>
#define FI first
#define SE second
#define ALL(x) (x).begin(), (x).end()
const int INF = 1 << 30;
const ll LINF = 1LL << 60; // const ll mod=1e9+7; const int NIL = -1;
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;
}
//-------------------
ll p;
ll b[3005];
ll x[3005];
ll mod;
ll power(ll x, ll n, ll MOD = mod) {
if (n == 0)
return 1;
ll res = power(x, n / 2, MOD);
res = res * res % MOD;
if (n & 1)
res *= res * x % MOD;
return res;
}
ll inv(ll x, ll MOD = mod) { return power(x, MOD - 2, MOD); }
int main() {
cin >> p;
mod = p;
// interpolation
// Ay = b, A:Vandermonde's matrix
for (int i = 0; i <= p; i++)
x[i] = i; // x is A's element.
for (int i = 0; i < p; i++)
cin >> b[i];
int n = p - 1;
for (int k = 0; k <= n - 1; k++) {
for (int i = n; i >= k + 1; i--) {
b[i] = (b[i] - b[i - 1] + mod) * inv(x[i] - x[i - k - 1] + mod, mod);
b[i] %= mod;
}
}
for (int k = n - 1; k >= 0; k--) {
for (int i = k; i <= n - 1; i++) {
b[i] = b[i] - b[i + 1] * x[k];
b[i] += mod * mod;
b[i] %= mod;
}
}
for (int i = 0; i <= n; i++) {
cout << b[i] << " ";
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
#define endl "\n"
#define MP make_pair
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORR(x, arr) for (auto &x : arr)
#define PII pair<int, int>
#define FI first
#define SE second
#define ALL(x) (x).begin(), (x).end()
const int INF = 1 << 30;
const ll LINF = 1LL << 60; // const ll mod=1e9+7; const int NIL = -1;
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;
}
//-------------------
ll p;
ll b[3005];
ll x[3005];
ll mod;
ll power(ll x, ll n, ll MOD = mod) {
if (n == 0)
return 1;
ll res = power(x, n / 2, MOD);
res = res * res % MOD;
if (n & 1)
res = res * x % MOD;
return res;
}
ll inv(ll x, ll MOD = mod) { return power(x, MOD - 2, MOD); }
int main() {
cin >> p;
mod = p;
// interpolation O(n^{2})
// Ay = b, A:Vandermonde's matrix
for (int i = 0; i <= p; i++)
x[i] = i; // x is A's element.
for (int i = 0; i < p; i++)
cin >> b[i];
int n = p - 1;
for (int k = 0; k <= n - 1; k++) {
for (int i = n; i >= k + 1; i--) {
b[i] = (b[i] - b[i - 1] + mod) * inv(x[i] - x[i - k - 1] + mod);
b[i] %= mod;
}
}
for (int k = n - 1; k >= 0; k--) {
for (int i = k; i <= n - 1; i++) {
b[i] = b[i] - b[i + 1] * x[k];
b[i] += mod * mod;
b[i] %= mod;
}
}
for (int i = 0; i <= n; i++) {
cout << b[i] << " ";
}
cout << endl;
return 0;
}
| [
"assignment.value.change",
"call.arguments.change"
] | 751,622 | 751,623 | u297590902 | cpp |
p02950 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
// #include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
// const ll RANDOM =
// chrono::high_resolution_clock::now().time_since_epoch().count();
// gp_hash_table<int, int> table;
#define ll long long int
#define vii vector<ll>
#define pb push_back
#define pii pair<ll, ll>
#define ppi pair<pii, ll>
#define all(x) x.begin(), x.end()
#define S second
#define F first
#define ins insert
#define ld long double
#define lp(l, r) for (i = l; i <= r; ++i)
#define lpj(l, r) for (j = l; j <= r; ++j)
#define lpr(l, r) for (i = r; i >= l; --i)
#define lprj(l, r) for (j = r; j >= l; --j)
#define swap(a, b) \
{ \
auto _t = a; \
a = b, b = _t; \
}
#define flush() cout.flush()
#define popcount __builtin_popcount
#define die() return 0;
// #define size()
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define MD 1000000007
#define M 100011
#define LN 14
#define fftmod 998244353
#define EPS (double)1e-10
ll md = MD;
ll inf = 1e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll exp(ll a, ll b) {
if (a == 0 && b == 0)
return 1ll;
if (a == 0)
return 0ll;
ll r = 1LL;
while (b > 0) {
if (b & 1) {
r = (r % md) * (a % md);
r = (r + md) % md;
}
b /= 2;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
if (a == 0)
return b;
return gcd(b, a % b);
}
inline ll poww(ll a, ll b) {
ll r = 1LL;
while (b > 0) {
if (b & 1)
r = r * a;
b /= 2;
a = a * a;
}
return (ll)r;
}
using cd = complex<double>;
const double PI = acos(-1);
inline ll rand(ll l, ll r) { return l + rng() % (r - l + 1); }
vii mul(vii a, vii b) {
// trace(a.size(),b.size());
vii r(a.size() + b.size());
ll i, j;
for (i = 0; i < a.size(); ++i) {
for (j = 0; j < b.size(); ++j) {
r[i + j] += a[i] * b[j] % md;
// r[i+j]%=md;
r[i + j] = (r[i + j] + md) % md;
}
}
return r;
}
ll iv[5000];
int main() {
// ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
// ifstream fin("input.txt");ofstream fout("outut.txt");
ll t, i, j, m, n, s, z, k, p;
string s1, s2;
ll q;
ll x, y;
ll h;
iv[0] = 1;
cin >> n;
md = n;
lp(1, 4999) iv[i] = iv[i - 1] * exp(i, md - 2) % md, iv[i] %= md;
vii v;
lp(1, n - 1) {
cin >> x;
v.pb(x);
}
vii a;
a.pb(v[0]);
for (i = 1; i < n; ++i) {
ll aux = v[i];
ll p = i;
ll r = 1;
for (j = 0; j < i; ++j) {
// trace(a[j],j,r);
aux = aux - (a[j] % md) * r % md;
aux = (aux + md) % md;
r *= p % md;
r %= md;
p--;
}
// trace(aux,i);
aux = (aux + md) % md;
// trace(aux,i);
r = 1;
r = iv[i] % md;
// trace(aux);
aux = aux * r % md;
aux = (aux + md) % md;
a.pb(aux);
}
// vii po(n);
// for(auto x:a)cout<<x<<" ";cout<<"\n";
vii po(1);
po[0] = 1;
vii ans(n);
for (ll id = 0; id < n; ++id) {
vii v(2);
v[0] = -id;
v[1] = 1;
// trace(id);
// for(auto x:po)cout<<x<<" ";cout<<"\n";
for (i = 0; i < po.size(); ++i) {
if (i < n) {
ans[i] += po[i] * a[id] % md;
ans[i] = (ans[i] + md) % md;
}
}
po = mul(po, v);
}
for (auto x : ans)
cout << x << " ";
cout << "\n";
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
// #include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
// const ll RANDOM =
// chrono::high_resolution_clock::now().time_since_epoch().count();
// gp_hash_table<int, int> table;
#define ll long long int
#define vii vector<ll>
#define pb push_back
#define pii pair<ll, ll>
#define ppi pair<pii, ll>
#define all(x) x.begin(), x.end()
#define S second
#define F first
#define ins insert
#define ld long double
#define lp(l, r) for (i = l; i <= r; ++i)
#define lpj(l, r) for (j = l; j <= r; ++j)
#define lpr(l, r) for (i = r; i >= l; --i)
#define lprj(l, r) for (j = r; j >= l; --j)
#define swap(a, b) \
{ \
auto _t = a; \
a = b, b = _t; \
}
#define flush() cout.flush()
#define popcount __builtin_popcount
#define die() return 0;
// #define size()
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define MD 1000000007
#define M 100011
#define LN 14
#define fftmod 998244353
#define EPS (double)1e-10
ll md = MD;
ll inf = 1e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll exp(ll a, ll b) {
if (a == 0 && b == 0)
return 1ll;
if (a == 0)
return 0ll;
ll r = 1LL;
while (b > 0) {
if (b & 1) {
r = (r % md) * (a % md);
r = (r + md) % md;
}
b /= 2;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
if (a == 0)
return b;
return gcd(b, a % b);
}
inline ll poww(ll a, ll b) {
ll r = 1LL;
while (b > 0) {
if (b & 1)
r = r * a;
b /= 2;
a = a * a;
}
return (ll)r;
}
using cd = complex<double>;
const double PI = acos(-1);
inline ll rand(ll l, ll r) { return l + rng() % (r - l + 1); }
vii mul(vii a, vii b) {
// trace(a.size(),b.size());
vii r(a.size() + b.size());
ll i, j;
for (i = 0; i < a.size(); ++i) {
for (j = 0; j < b.size(); ++j) {
r[i + j] += a[i] * b[j] % md;
// r[i+j]%=md;
r[i + j] = (r[i + j] + md) % md;
}
}
return r;
}
ll iv[5000];
int main() {
// ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
// ifstream fin("input.txt");ofstream fout("outut.txt");
ll t, i, j, m, n, s, z, k, p;
string s1, s2;
ll q;
ll x, y;
ll h;
iv[0] = 1;
cin >> n;
md = n;
lp(1, 4999) iv[i] = iv[i - 1] * exp(i, md - 2) % md, iv[i] %= md;
vii v;
lp(1, n) {
cin >> x;
v.pb(x);
}
vii a;
a.pb(v[0]);
for (i = 1; i < n; ++i) {
ll aux = v[i];
ll p = i;
ll r = 1;
for (j = 0; j < i; ++j) {
// trace(a[j],j,r);
aux = aux - (a[j] % md) * r % md;
aux = (aux + md) % md;
r *= p % md;
r %= md;
p--;
}
// trace(aux,i);
aux = (aux + md) % md;
// trace(aux,i);
r = 1;
r = iv[i] % md;
// trace(aux);
aux = aux * r % md;
aux = (aux + md) % md;
a.pb(aux);
}
// vii po(n);
// for(auto x:a)cout<<x<<" ";cout<<"\n";
vii po(1);
po[0] = 1;
vii ans(n);
for (ll id = 0; id < n; ++id) {
vii v(2);
v[0] = -id;
v[1] = 1;
// trace(id);
// for(auto x:po)cout<<x<<" ";cout<<"\n";
for (i = 0; i < po.size(); ++i) {
if (i < n) {
ans[i] += po[i] * a[id] % md;
ans[i] = (ans[i] + md) % md;
}
}
po = mul(po, v);
}
for (auto x : ans)
cout << x << " ";
cout << "\n";
}
| [
"expression.operation.binary.remove"
] | 751,626 | 751,627 | u653136790 | cpp |
p02950 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string &s, int k) {
if (k == 0)
return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1)
p += s;
return p;
}
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
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;
}
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
//二分グラフの最大マッチングを求めたりも出来る また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph &G, ll s, ll t) // O(V(V+E))
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
bool z_algorithm(string &str, vector<int> &z,
ll s) { // s&tを渡してtにsが含まれるかを返す
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
if (z[i] == s)
return true;
}
return false;
}
bool z_algorithm(string &str,
vector<int> &z) { // z[i]==|s|のときstr[i]からsが含まれる
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
}
return true;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll p;
cin >> p;
Array a(p);
REP(i, p) cin >> a[i];
Array ans(p, 0);
Combination comb(p, p);
REP(i, p - 1) {
if (a[i] == 1) {
(ans[0] += 1) %= p;
if (i == 0) {
(ans[p - 1] += p - 1) %= p;
continue;
}
ll now = comb.mod_inv(i);
for (int j = p - 1; j >= 0; j--) {
(now *= i) %= p;
if (j % 2 == 1) {
(ans[j] += now * comb.nCr(p - 1, j) % p) %= p;
} else {
(ans[j] += p - now * comb.nCr(p - 1, j) % p) %= p;
}
}
}
}
REP(i, p) cout << ans[i] << ' ';
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define rep(i, m, n) for (int(i) = (int)(m); i < (int)(n); i++)
#define REP(i, n) rep(i, 0, n)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
string operator*(const string &s, int k) {
if (k == 0)
return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1)
p += s;
return p;
}
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
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;
}
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
//二分グラフの最大マッチングを求めたりも出来る また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph &G, ll s, ll t) // O(V(V+E))
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
bool tsort(Graph &graph, vector<int> &order) { //トポロジカルソートO(E+V)
int n = graph.size(), k = 0;
Array in(n);
for (auto &es : graph)
for (auto &e : es)
in[e.to]++;
priority_queue<ll, Array, greater<ll>> que;
REP(i, n)
if (in[i] == 0)
que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto &e : graph[v])
if (--in[e.to] == 0)
que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const Graph &g, int root)
: n(g.size()), log2_n(log2(n) + 1), parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const Graph &g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto &e : g[v]) {
if (e.to != p)
dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { //集合の数を返す
return num;
}
};
class SumSegTree {
private:
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
//約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
vector<ll> lis_fast(const vector<ll> &a) { //最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
bool z_algorithm(string &str, vector<int> &z,
ll s) { // s&tを渡してtにsが含まれるかを返す
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
if (z[i] == s)
return true;
}
return false;
}
bool z_algorithm(string &str,
vector<int> &z) { // z[i]==|s|のときstr[i]からsが含まれる
const int L = str.size();
z.resize(str.size());
for (int i = 1, left = 0, right = 0; i < L; i++) {
if (i > right) {
left = right = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
} else {
int k = i - left;
if (z[k] < right - i + 1) {
z[i] = z[k];
} else {
left = i;
for (; right < L && str[right - left] == str[right]; right++)
;
z[i] = right - left;
right--;
}
}
}
return true;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
template <class T> class RectangleSum {
public:
vector<vector<T>> sum;
T GetSum(int left, int right, int top,
int bottom) { //[left, right], [top, bottom]
T res = sum[bottom][right];
if (left > 0)
res -= sum[bottom][left - 1];
if (top > 0)
res -= sum[top - 1][right];
if (left > 0 && top > 0)
res += sum[top - 1][left - 1];
return res;
}
RectangleSum(const vector<vector<T>> &s, int h, int w) {
sum.resize(h);
for (int i = 0; i < h; i++)
sum[i].resize(w, 0);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
sum[y][x] = s[y][x];
if (y > 0)
sum[y][x] += sum[y - 1][x];
if (x > 0)
sum[y][x] += sum[y][x - 1];
if (y > 0 && x > 0)
sum[y][x] -= sum[y - 1][x - 1];
}
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll p;
cin >> p;
Array a(p);
REP(i, p) cin >> a[i];
Array ans(p, 0);
Combination comb(p, p);
REP(i, p) {
if (a[i] == 1) {
(ans[0] += 1) %= p;
if (i == 0) {
(ans[p - 1] += p - 1) %= p;
continue;
}
ll now = comb.mod_inv(i);
for (int j = p - 1; j >= 0; j--) {
(now *= i) %= p;
if (j % 2 == 1) {
(ans[j] += now * comb.nCr(p - 1, j) % p) %= p;
} else {
(ans[j] += p - now * comb.nCr(p - 1, j) % p) %= p;
}
}
}
}
REP(i, p) cout << ans[i] << ' ';
return 0;
} | [
"expression.operation.binary.remove"
] | 751,628 | 751,629 | u051493691 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
int n, A[10100], cnt[10010], ans[10100], C[3000][3000];
void init() {
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % n;
}
}
}
int main() {
scanf("%d", &n);
init();
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
for (int i = 0; i < n; i++) {
if (A[i] == 1)
cnt[i]++, ans[i]++;
}
for (int i = 0; i < n; i++) {
if (cnt[i] == 0)
continue;
for (int j = 0, po = 1; j < n; j++) {
int res = C[n - 1][j] * po;
res %= n;
if (res < 0) {
int tmp = abs(res);
res = (n - tmp % n) % n;
} else
res = res % n;
ans[n - 1 - j] = (ans[n - 1 - j] + n - res) % n;
po = po * (-i);
if (po < 0) {
int tmp = abs(po);
po = (n - tmp % n) % n;
} else
po = po % n;
}
}
for (int i = 0; i < n; i++)
printf("%d ", ans[i]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, A[10100], cnt[10010], ans[10100], C[3000][3000];
void init() {
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % n;
}
}
}
int main() {
scanf("%d", &n);
init();
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
for (int i = 0; i < n; i++) {
if (A[i] == 1)
cnt[i]++, ans[0]++;
}
for (int i = 0; i < n; i++) {
if (cnt[i] == 0)
continue;
for (int j = 0, po = 1; j < n; j++) {
int res = C[n - 1][j] * po;
res %= n;
if (res < 0) {
int tmp = abs(res);
res = (n - tmp % n) % n;
} else
res = res % n;
ans[n - 1 - j] = (ans[n - 1 - j] + n - res) % n;
po = po * (-i);
if (po < 0) {
int tmp = abs(po);
po = (n - tmp % n) % n;
} else
po = po % n;
}
}
for (int i = 0; i < n; i++)
printf("%d ", ans[i]);
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 751,630 | 751,631 | u047371023 | cpp |
p02950 | #include <bits/stdc++.h>
#define Ms(a, b) memset(a, b, sizeof a)
#define db(x) cout << #x << "=" << x << endl;
#define db2(x, y) cout << #x << "=" << x << " " << #y << "=" << y << endl;
#define db3(x, y, z) \
cout << #x << "=" << x << " " << #y << "=" << y << " " << #z << "=" << z \
<< endl;
using namespace std;
int n, a, c[3005][3005], r[3005];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
if (!i || !j)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % n;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (!a)
continue;
int now = 1;
for (int j = n - 1; j >= 0; j--) {
r[j] -= c[n - 1][j] * now % n, r[j] %= n;
now *= -i, now %= n;
}
r[0]++;
}
for (int i = 0; i < n; i++)
printf("%d ", r[i]);
return 0;
}
| #include <bits/stdc++.h>
#define Ms(a, b) memset(a, b, sizeof a)
#define db(x) cout << #x << "=" << x << endl;
#define db2(x, y) cout << #x << "=" << x << " " << #y << "=" << y << endl;
#define db3(x, y, z) \
cout << #x << "=" << x << " " << #y << "=" << y << " " << #z << "=" << z \
<< endl;
using namespace std;
int n, a, c[3005][3005], r[3005];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
if (!i || !j)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % n;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (!a)
continue;
int now = 1;
for (int j = n - 1; j >= 0; j--) {
r[j] -= c[n - 1][j] * now % n, r[j] %= n;
now *= -i, now %= n;
}
r[0]++;
}
for (int i = 0; i < n; i++)
printf("%d ", (r[i] + n) % n);
return 0;
}
| [
"call.arguments.change"
] | 751,632 | 751,633 | u928673524 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (const T &i : a)
out << i << ',';
out << ']';
return out;
}
template <class T> ostream &operator<<(ostream &out, const set<T> &a) {
out << '{';
for (const T &i : a)
out << i << ',';
out << '}';
return out;
}
template <class T, class S>
ostream &operator<<(ostream &out, const map<T, S> &a) {
out << '{';
for (auto &i : a)
out << i << ',';
out << '}';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
// const ll MOD = 1000000007;
ll MOD;
ll binpow(ll x, ll e) {
ll ret = 1, p = x;
while (e > 0) {
if (e & 1) {
(ret *= p) %= MOD;
e--;
} else {
(p *= p) %= MOD;
e /= 2;
}
}
return ret;
}
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll p;
cin >> p;
vector<ll> a(p);
REP(i, p) cin >> a[i];
MOD = p;
vector<ll> inv(p + 2);
REP(i, p + 2) inv[i] = binpow(i, p - 2);
vector<ll> ans(p);
REP(j, p) {
if (a[j] == 0)
continue;
ll c = 1, po = 1;
REP(k, p) {
(ans[p - 1 - k] += p - (c * po % p)) %= p;
(po *= p - j) %= p;
(c *= p - 1 - j) %= p;
(c *= inv[j + 1]) %= p;
}
ans[0]++;
}
ans[0] %= p;
REP(i, p) cout << ans[i] << (i == p - 1 ? '\n' : ' ');
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// #define int ll
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (const T &i : a)
out << i << ',';
out << ']';
return out;
}
template <class T> ostream &operator<<(ostream &out, const set<T> &a) {
out << '{';
for (const T &i : a)
out << i << ',';
out << '}';
return out;
}
template <class T, class S>
ostream &operator<<(ostream &out, const map<T, S> &a) {
out << '{';
for (auto &i : a)
out << i << ',';
out << '}';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0}; // DRUL
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
// const ll MOD = 1000000007;
ll MOD;
ll binpow(ll x, ll e) {
ll ret = 1, p = x;
while (e > 0) {
if (e & 1) {
(ret *= p) %= MOD;
e--;
} else {
(p *= p) %= MOD;
e /= 2;
}
}
return ret;
}
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll p;
cin >> p;
vector<ll> a(p);
REP(i, p) cin >> a[i];
MOD = p;
vector<ll> inv(p + 2);
REP(i, p + 2) inv[i] = binpow(i, p - 2);
vector<ll> ans(p);
REP(j, p) {
if (a[j] == 0)
continue;
ll c = 1, po = 1;
REP(k, p) {
(ans[p - 1 - k] += p - (c * po % p)) %= p;
(po *= p - j) %= p;
(c *= p - 1 - k) %= p;
(c *= inv[k + 1]) %= p;
}
ans[0]++;
}
ans[0] %= p;
REP(i, p) cout << ans[i] << (i == p - 1 ? '\n' : ' ');
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"variable_access.subscript.index.change"
] | 751,636 | 751,637 | u333917945 | cpp |
p02950 | #include <bits/stdc++.h>
#define MAX 3010
using namespace std;
int P;
int arr[MAX];
int poly[MAX];
inline int add(int a, int b) { return (a + b) % P; }
inline int prod(int a, int b) { return a * b % P; }
int main(void) {
cin >> P;
for (int i = 0; i < P; i++) {
int val;
cin >> val;
if (!val)
continue;
arr[P] = 1;
for (int j = P; j > 0; j--) {
poly[j - 1] = add(poly[j - 1], arr[j]);
arr[j - 1] = prod(arr[j], i);
if (j == 2)
arr[1] = add(arr[1], P - 1);
arr[j] = 0;
}
}
for (int i = 0; i < P; i++)
cout << poly[i] << " ";
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
#define MAX 3010
using namespace std;
int P;
int arr[MAX];
int poly[MAX];
inline int add(int a, int b) { return (a + b) % P; }
inline int prod(int a, int b) { return a * b % P; }
int main(void) {
cin >> P;
for (int i = 0; i < P; i++) {
int val;
cin >> val;
if (!val)
continue;
arr[P] = 1;
for (int j = P; j > 0; j--) {
poly[j - 1] = add(poly[j - 1], P - arr[j]);
arr[j - 1] = prod(arr[j], i);
if (j == 2)
arr[1] = add(arr[1], P - 1);
arr[j] = 0;
}
}
for (int i = 0; i < P; i++)
cout << poly[i] << " ";
cout << endl;
return 0;
}
| [
"assignment.change"
] | 751,638 | 751,639 | u305757380 | cpp |
p02950 | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define MOD (long long int)(1e9 + 7)
#define ll long long int
#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 REP(i, n) for (int i = n - 1; i >= 0; i--)
#define REPS(i, n) for (int i = n; i > 0; i--)
#define INF (int)(1123456789)
#define LINF (long long int)(112345678901234567)
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define all(v) v.begin(), v.end()
ll p;
ll mpow(ll a, ll b) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
ll memo = mpow(a, b / 2);
return memo * memo % p;
} else
return mpow(a, b - 1) * a % p;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
vector<ll> kaijo_memo;
ll kaijo(ll n) {
if (kaijo_memo.size() > n)
return kaijo_memo[n];
if (kaijo_memo.size() == 0)
kaijo_memo.push_back(1);
while (kaijo_memo.size() <= n)
kaijo_memo.push_back(kaijo_memo[kaijo_memo.size() - 1] * kaijo_memo.size() %
p);
return kaijo_memo[n];
}
ll nCr(ll n, ll r) {
if (n < r || r < 0)
return 0;
ll ret = 1;
ret *= kaijo(n);
ret %= MOD;
ret *= mpow(kaijo(r), MOD - 2);
ret %= MOD;
ret *= mpow(kaijo(n - r), MOD - 2);
ret %= MOD;
return ret;
}
int main(void) {
cin >> p;
vector<ll> A;
rep(i, p) {
ll a;
cin >> a;
A.push_back(a);
}
vector<vector<ll>> dp;
rep(i, p) {
dp.push_back(vector<ll>());
rep(j, i + 1) { dp[i].push_back(0); }
}
dp[0][0] = 1;
reps(i, p - 1) {
rep(j, i + 1) {
if (j != i) {
dp[i][j] += dp[i - 1][j] * (-i + 1);
}
if (j - 1 >= 0) {
dp[i][j] += dp[i - 1][j - 1];
}
dp[i][j] %= p;
}
}
// cout<<"hoge"<<dp[0][0]<<endl;
vector<ll> B, C;
rep(i, p) {
B.push_back(0);
C.push_back(0);
}
rep(ai, p) { // a_aiに対処
ll sum = 0;
rep(j, ai) {
sum += C[j] * kaijo(ai) % p * mpow(kaijo(ai - j), p - 2) % p;
sum %= p;
}
sum += (p - A[ai]) % p; //ほんと?
rep(j, p) {
if ((j * kaijo(ai) + sum) % p == 0) {
C[ai] = j;
break;
}
}
rep(j, ai + 1) { // x^jの項を求める
if (j == 0) {
// cout<<ai<<" "<<dp[ai][j]<<" "<<C[ai]<<endl;
}
B[j] += dp[ai][j] * C[ai];
B[j] %= p;
}
// cout<<B[0]<<endl;
}
/*rep(i, dp.size()){
rep(j, dp[i].size()){
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
// cout<<dp[1][0]<<endl;
rep(i, B.size()) {
cout << B[i];
if (i != B.size() - 1) {
cout << " ";
}
}
cout << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define MOD (long long int)(1e9 + 7)
#define ll long long int
#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 REP(i, n) for (int i = n - 1; i >= 0; i--)
#define REPS(i, n) for (int i = n; i > 0; i--)
#define INF (int)(1123456789)
#define LINF (long long int)(112345678901234567)
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define all(v) v.begin(), v.end()
ll p;
ll mpow(ll a, ll b) {
if (b == 0)
return 1;
else if (b % 2 == 0) {
ll memo = mpow(a, b / 2);
return memo * memo % p;
} else
return mpow(a, b - 1) * a % p;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
vector<ll> kaijo_memo;
ll kaijo(ll n) {
if (kaijo_memo.size() > n)
return kaijo_memo[n];
if (kaijo_memo.size() == 0)
kaijo_memo.push_back(1);
while (kaijo_memo.size() <= n)
kaijo_memo.push_back(kaijo_memo[kaijo_memo.size() - 1] * kaijo_memo.size() %
p);
return kaijo_memo[n];
}
ll nCr(ll n, ll r) {
if (n < r || r < 0)
return 0;
ll ret = 1;
ret *= kaijo(n);
ret %= MOD;
ret *= mpow(kaijo(r), MOD - 2);
ret %= MOD;
ret *= mpow(kaijo(n - r), MOD - 2);
ret %= MOD;
return ret;
}
int main(void) {
cin >> p;
vector<ll> A;
rep(i, p) {
ll a;
cin >> a;
A.push_back(a);
}
vector<vector<ll>> dp;
rep(i, p) {
dp.push_back(vector<ll>());
rep(j, i + 1) { dp[i].push_back(0); }
}
dp[0][0] = 1;
reps(i, p - 1) {
rep(j, i + 1) {
if (j != i) {
dp[i][j] += dp[i - 1][j] * (p - i + 1);
}
if (j - 1 >= 0) {
dp[i][j] += dp[i - 1][j - 1];
}
dp[i][j] %= p;
}
}
// cout<<"hoge"<<dp[0][0]<<endl;
vector<ll> B, C;
rep(i, p) {
B.push_back(0);
C.push_back(0);
}
rep(ai, p) { // a_aiに対処
ll sum = 0;
rep(j, ai) {
sum += C[j] * kaijo(ai) % p * mpow(kaijo(ai - j), p - 2) % p;
sum %= p;
}
sum += (p - A[ai]) % p; //ほんと?
rep(j, p) {
if ((j * kaijo(ai) + sum) % p == 0) {
C[ai] = j;
break;
}
}
rep(j, ai + 1) { // x^jの項を求める
if (j == 0) {
// cout<<ai<<" "<<dp[ai][j]<<" "<<C[ai]<<endl;
}
B[j] += dp[ai][j] * C[ai];
B[j] %= p;
}
// cout<<B[0]<<endl;
}
/*rep(i, dp.size()){
rep(j, dp[i].size()){
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
// cout<<dp[1][0]<<endl;
rep(i, B.size()) {
cout << B[i];
if (i != B.size() - 1) {
cout << " ";
}
}
cout << endl;
return 0;
}
| [] | 751,642 | 751,643 | u838742270 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fi first
#define se second
typedef pair<ll, ll> P;
using VP = vector<P>;
using VVP = vector<VP>;
using VI = vector<ll>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
#define INF 1ll << 59
ll Mod;
ll modinv(ll a) {
ll m = Mod;
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int main() {
ll i, j;
ll p;
cin >> p;
Mod = p;
ll pow[3030];
pow[1] = 1;
for (i = 2; i < 3030; i++) {
pow[i] = (pow[i - 1] * i) % p;
}
ll c[p];
ll a[p];
for (i = 0; i < p; i++)
cin >> a[i];
c[0] = a[0];
for (i = 1; i < p; i++) {
ll x = a[i];
for (j = 0; j < i; j++) {
x = (x + p - c[j]) % p;
x *= modinv(i - j);
x %= p;
}
c[i] = x;
}
ll b[p];
for (i = 0; i < p; i++)
b[i] = 0;
vector<ll> v(p, 0);
v[0] = 1;
b[0] = c[0];
for (i = 1; i < p; i++) {
vector<ll> v2(p, 0);
for (j = 0; j < p; j++) {
v2[(j + 1) % p] += v[j];
v2[(j + 1) % p] %= p;
v2[j] += (p + 1 - i) * v[j];
v2[j] %= p;
}
for (j = 0; j < p; j++)
v[j] = v2[j];
for (j = 0; j < p; j++) {
b[j] += c[j] * v[j];
b[j] %= p;
}
}
for (i = 0; i < p; i++) {
if (i == 0)
cout << b[0];
else
cout << " " << b[i];
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fi first
#define se second
typedef pair<ll, ll> P;
using VP = vector<P>;
using VVP = vector<VP>;
using VI = vector<ll>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
#define INF 1ll << 59
ll Mod;
ll modinv(ll a) {
ll m = Mod;
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int main() {
ll i, j;
ll p;
cin >> p;
Mod = p;
ll pow[3030];
pow[1] = 1;
for (i = 2; i < 3030; i++) {
pow[i] = (pow[i - 1] * i) % p;
}
ll c[p];
ll a[p];
for (i = 0; i < p; i++)
cin >> a[i];
c[0] = a[0];
for (i = 1; i < p; i++) {
ll x = a[i];
for (j = 0; j < i; j++) {
x = (x + p - c[j]) % p;
x *= modinv(i - j);
x %= p;
}
c[i] = x;
}
ll b[p];
for (i = 0; i < p; i++)
b[i] = 0;
vector<ll> v(p, 0);
v[0] = 1;
b[0] = c[0];
for (i = 1; i < p; i++) {
vector<ll> v2(p, 0);
for (j = 0; j < p; j++) {
v2[(j + 1) % p] += v[j];
v2[(j + 1) % p] %= p;
v2[j] += (p + 1 - i) * v[j];
v2[j] %= p;
}
for (j = 0; j < p; j++)
v[j] = v2[j];
for (j = 0; j < p; j++) {
b[j] += c[i] * v[j];
b[j] %= p;
}
}
for (i = 0; i < p; i++) {
if (i == 0)
cout << b[0];
else
cout << " " << b[i];
}
cout << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 751,646 | 751,647 | u586567203 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
template <i64 p> class fp {
public:
i64 x;
fp() : x(0) {}
fp(i64 x_) : x((x_ % p + p) % p) {}
fp operator+() const { return fp(x); }
fp operator-() const { return fp(-x); }
fp &operator+=(const fp &y) {
x += y.x;
if (x >= p)
x -= p;
return *this;
}
fp &operator-=(const fp &y) { return *this += -y; }
fp &operator*=(const fp &y) {
x = x * y.x % p;
return *this;
}
fp &operator/=(const fp &y) { return *this *= fp(inverse(y.x)); }
fp operator+(const fp &y) const { return fp(x) += y; }
fp operator-(const fp &y) const { return fp(x) -= y; }
fp operator*(const fp &y) const { return fp(x) *= y; }
fp operator/(const fp &y) const { return fp(x) /= y; }
bool operator==(const fp &y) const { return x == y.x; }
bool operator!=(const fp &y) const { return !(*this == y); }
i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
i64 d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
i64 inverse(i64 a) {
i64 x, y;
extgcd(a, p, x, y);
return (x % p + p) % p;
}
};
template <i64 p> i64 abs(const fp<p> &x) { return x.x; }
template <i64 p> ostream &operator<<(ostream &os, const fp<p> &x) {
os << x.x;
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename A, typename T, size_t size>
void fill(A (&ary)[size], const T &val) {
fill((T *)ary, (T *)(ary + size), val);
}
// x未満の要素の個数を返す
template <typename T> i64 count_less(const vector<T> &v, T x) {
return lower_bound(begin(v), end(v), x) - begin(v);
}
// x以下の要素の個数を返す
template <typename T> i64 count_less_or_equal(const vector<T> &v, T x) {
return upper_bound(begin(v), end(v), x) - begin(v);
}
// xより大きい要素の個数を返す
template <typename T> i64 count_greater(const vector<T> &v, T x) {
return end(v) - upper_bound(begin(v), end(v), x);
}
// x以上の要素の個数を返す
template <typename T> i64 count_greater_or_equal(const vector<T> &v, T x) {
return end(v) - lower_bound(begin(v), end(v), x);
}
// x未満の要素のうち最大のものを返す
template <typename T> T max_less(const vector<T> &v, T x) {
return *(lower_bound(begin(v), end(v), x) - 1);
}
// x以下の要素のうち最大のものを返す
template <typename T> T max_less_or_equal(const vector<T> &v, T x) {
return *(upper_bound(begin(v), end(v), x) - 1);
}
// xより大きい要素のうち最小のものを返す
template <typename T> T min_greater(const vector<T> &v, T x) {
return *upper_bound(begin(v), end(v), x);
}
// x以上の要素のうち最小のものを返す
template <typename T> T min_greater_or_equal(const vector<T> &v, T x) {
return *lower_bound(begin(v), end(v), x);
}
constexpr int inf = 1.01e9;
constexpr i64 inf64 = 4.01e18;
constexpr double eps = 1e-9;
class mint {
public:
i64 x, m;
mint() = default;
mint(i64 m_, i64 x_) : m(m_), x((x_ % m_ + m_) % m_) {}
mint operator+() const { return mint(m, x); }
mint operator-() const { return mint(m, -x); }
mint &operator+=(const mint &y) {
if (m == 0) {
assert(y.m != 0);
m = y.m;
}
assert(m == y.m);
x = ((x + y.x) % m + m) % m;
return *this;
}
mint &operator-=(const mint &y) { return *this += -y; }
mint &operator*=(const mint &y) {
if (m == 0) {
assert(y.m != 0);
m = y.m;
}
assert(m == y.m);
x = x * y.x % m;
return *this;
}
mint &operator/=(const mint &y) { return *this *= mint(m, inverse(y.x)); }
mint operator+(const mint &y) const { return mint(m, x) += y; }
mint operator-(const mint &y) const { return mint(m, x) -= y; }
mint operator*(const mint &y) const { return mint(m, x) *= y; }
mint operator/(const mint &y) const { return mint(m, x) /= y; }
bool operator==(const mint &y) const { return x == y.x; }
bool operator!=(const mint &y) const { return !(*this == y); }
i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
i64 d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
i64 inverse(i64 a) {
i64 x, y;
extgcd(a, m, x, y);
return (x % m + m) % m;
}
};
ostream &operator<<(ostream &os, const mint &x) {
os << x.x;
return os;
}
void solve() {
// constexpr i64 mod = 1'000'000'007;
i64 p;
cin >> p;
vector<mint> a(p);
rep(i, 0, p) {
i64 x;
cin >> x;
a[i] = mint(p, x);
}
vector<mint> fact(p);
fact[0] = mint(p, 1);
rep(i, 1, p) fact[i] = fact[i - 1] * mint(p, i);
vector<mint> q(p + 1, mint(p, 0));
q[0] = mint(p, 0);
q[1] = mint(p, 1);
rep(i, 1, p) {
// X-i
vector<mint> r(p + 1);
rep(j, 0, p + 1) r[j] = mint(p, 0);
rep(j, 0, p + 1) r[j] += q[j] * mint(p, -i);
rep(j, 0, p) r[j + 1] += q[j];
rep(j, 0, p + 1) q[j] = r[j];
}
print(q);
vector<mint> ans(p);
rep(i, 0, p) ans[i] = mint(p, 0);
rep(i, 0, p) {
if (a[i].x == 0)
continue;
// 分母
mint x = mint(p, 1) / (fact[i] * fact[p - i - 1]) *
((p - i - 1) % 2 == 1 ? mint(p, -1) : mint(p, 1));
// 分子
// q/(X-i)
vector<mint> r(p, mint(p, 0));
mint c(p, 0);
for (i64 j = p; j >= 1; --j) {
mint k = q[j] + c;
r[j - 1] = k;
c = r[j - 1] * mint(p, -i);
}
print(x);
print(r);
rep(j, 0, p) ans[j] += x * r[j];
}
rep(i, 0, p) {
cout << ans[i].x;
if (i == p - 1)
cout << endl;
else
cout << " ";
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
template <i64 p> class fp {
public:
i64 x;
fp() : x(0) {}
fp(i64 x_) : x((x_ % p + p) % p) {}
fp operator+() const { return fp(x); }
fp operator-() const { return fp(-x); }
fp &operator+=(const fp &y) {
x += y.x;
if (x >= p)
x -= p;
return *this;
}
fp &operator-=(const fp &y) { return *this += -y; }
fp &operator*=(const fp &y) {
x = x * y.x % p;
return *this;
}
fp &operator/=(const fp &y) { return *this *= fp(inverse(y.x)); }
fp operator+(const fp &y) const { return fp(x) += y; }
fp operator-(const fp &y) const { return fp(x) -= y; }
fp operator*(const fp &y) const { return fp(x) *= y; }
fp operator/(const fp &y) const { return fp(x) /= y; }
bool operator==(const fp &y) const { return x == y.x; }
bool operator!=(const fp &y) const { return !(*this == y); }
i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
i64 d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
i64 inverse(i64 a) {
i64 x, y;
extgcd(a, p, x, y);
return (x % p + p) % p;
}
};
template <i64 p> i64 abs(const fp<p> &x) { return x.x; }
template <i64 p> ostream &operator<<(ostream &os, const fp<p> &x) {
os << x.x;
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename A, typename T, size_t size>
void fill(A (&ary)[size], const T &val) {
fill((T *)ary, (T *)(ary + size), val);
}
// x未満の要素の個数を返す
template <typename T> i64 count_less(const vector<T> &v, T x) {
return lower_bound(begin(v), end(v), x) - begin(v);
}
// x以下の要素の個数を返す
template <typename T> i64 count_less_or_equal(const vector<T> &v, T x) {
return upper_bound(begin(v), end(v), x) - begin(v);
}
// xより大きい要素の個数を返す
template <typename T> i64 count_greater(const vector<T> &v, T x) {
return end(v) - upper_bound(begin(v), end(v), x);
}
// x以上の要素の個数を返す
template <typename T> i64 count_greater_or_equal(const vector<T> &v, T x) {
return end(v) - lower_bound(begin(v), end(v), x);
}
// x未満の要素のうち最大のものを返す
template <typename T> T max_less(const vector<T> &v, T x) {
return *(lower_bound(begin(v), end(v), x) - 1);
}
// x以下の要素のうち最大のものを返す
template <typename T> T max_less_or_equal(const vector<T> &v, T x) {
return *(upper_bound(begin(v), end(v), x) - 1);
}
// xより大きい要素のうち最小のものを返す
template <typename T> T min_greater(const vector<T> &v, T x) {
return *upper_bound(begin(v), end(v), x);
}
// x以上の要素のうち最小のものを返す
template <typename T> T min_greater_or_equal(const vector<T> &v, T x) {
return *lower_bound(begin(v), end(v), x);
}
constexpr int inf = 1.01e9;
constexpr i64 inf64 = 4.01e18;
constexpr double eps = 1e-9;
class mint {
public:
i64 x, m;
mint() = default;
mint(i64 m_, i64 x_) : m(m_), x((x_ % m_ + m_) % m_) {}
mint operator+() const { return mint(m, x); }
mint operator-() const { return mint(m, -x); }
mint &operator+=(const mint &y) {
if (m == 0) {
assert(y.m != 0);
m = y.m;
}
assert(m == y.m);
x = ((x + y.x) % m + m) % m;
return *this;
}
mint &operator-=(const mint &y) { return *this += -y; }
mint &operator*=(const mint &y) {
if (m == 0) {
assert(y.m != 0);
m = y.m;
}
assert(m == y.m);
x = x * y.x % m;
return *this;
}
mint &operator/=(const mint &y) { return *this *= mint(m, inverse(y.x)); }
mint operator+(const mint &y) const { return mint(m, x) += y; }
mint operator-(const mint &y) const { return mint(m, x) -= y; }
mint operator*(const mint &y) const { return mint(m, x) *= y; }
mint operator/(const mint &y) const { return mint(m, x) /= y; }
bool operator==(const mint &y) const { return x == y.x; }
bool operator!=(const mint &y) const { return !(*this == y); }
i64 extgcd(i64 a, i64 b, i64 &x, i64 &y) {
i64 d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
i64 inverse(i64 a) {
i64 x, y;
extgcd(a, m, x, y);
return (x % m + m) % m;
}
};
ostream &operator<<(ostream &os, const mint &x) {
os << x.x;
return os;
}
void solve() {
// constexpr i64 mod = 1'000'000'007;
i64 p;
cin >> p;
vector<mint> a(p);
rep(i, 0, p) {
i64 x;
cin >> x;
a[i] = mint(p, x);
}
vector<mint> fact(p);
fact[0] = mint(p, 1);
rep(i, 1, p) fact[i] = fact[i - 1] * mint(p, i);
vector<mint> q(p + 1, mint(p, 0));
q[0] = mint(p, 0);
q[1] = mint(p, 1);
rep(i, 1, p) {
// X-i
vector<mint> r(p + 1);
rep(j, 0, p + 1) r[j] = mint(p, 0);
rep(j, 0, p + 1) r[j] += q[j] * mint(p, -i);
rep(j, 0, p) r[j + 1] += q[j];
rep(j, 0, p + 1) q[j] = r[j];
}
print(q);
vector<mint> ans(p);
rep(i, 0, p) ans[i] = mint(p, 0);
rep(i, 0, p) {
if (a[i].x == 0)
continue;
// 分母
mint x = mint(p, 1) / (fact[i] * fact[p - i - 1]) *
((p - i - 1) % 2 == 1 ? mint(p, -1) : mint(p, 1));
// 分子
// q/(X-i)
vector<mint> r(p, mint(p, 0));
mint c(p, 0);
for (i64 j = p; j >= 1; --j) {
mint k = q[j] + c;
r[j - 1] = k;
c = r[j - 1] * mint(p, i);
}
print(x);
print(r);
rep(j, 0, p) ans[j] += x * r[j];
}
rep(i, 0, p) {
cout << ans[i].x;
if (i == p - 1)
cout << endl;
else
cout << " ";
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
return 0;
}
| [
"expression.operation.unary.arithmetic.remove",
"call.arguments.change"
] | 751,648 | 751,649 | u759266806 | cpp |
p02950 | #include <bits/stdc++.h>
using namespace std;
// Define
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
const ll mod = 998244353;
const ll inf = 1 << 30;
const ll LINF = LONG_MAX;
const ll INF = 1LL << 60;
const ull MAX = ULONG_MAX;
#define mp make_pair
#define pb push_back
#define elif else if
#define endl '\n'
#define space ' '
#define def inline auto
#define func inline constexpr ll
#define run(a) __attribute__((constructor)) def _##a()
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define input(a) scanf("%lld", &(a))
#define print(a) printf("%lld\n", (a))
#define fi first
#define se second
#define ok(a, b) (0 <= (a) && (a) < (b))
template <class T> using vvector = vector<vector<T>>;
template <class T> using pvector = vector<pair<T, T>>;
template <class T>
using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
// Debug
#define debug(...) \
{ \
cerr << __LINE__ << ": " << #__VA_ARGS__ << " = "; \
for (auto &&X : {__VA_ARGS__}) \
cerr << "[" << X << "] "; \
cerr << endl; \
}
#define dump(a, h, w) \
{ \
cerr << __LINE__ << ": " << #a << " = [" << endl; \
rep(__i, h) { \
rep(__j, w) cerr << a[__i][__j] << space; \
cerr << endl; \
} \
cerr << "]" << endl; \
}
#define vdump(a, n) \
{ \
cerr << __LINE__ << ": " << #a << " = ["; \
rep(__i, n) if (__i) cerr << space << a[__i]; \
else cerr << a[__i]; \
cerr << "]" << endl; \
}
// Loop
#define inc(i, a, n) for (ll i = (a), _##i = (n); i <= _##i; ++i)
#define dec(i, a, n) for (ll i = (a), _##i = (n); i >= _##i; --i)
#define rep(i, n) for (ll i = 0, _##i = (n); i < _##i; ++i)
#define each(i, a) for (auto &&i : a)
#define loop() for (;;)
// Stream
#define fout(n) cout << fixed << setprecision(n)
#define fasten cin.tie(0), ios::sync_with_stdio(0)
run(0) { fasten, fout(10); }
// Speed
#pragma GCC optimize("O3")
#pragma GCC target("avx")
// Math
func gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
func lcm(ll a, ll b) { return a * b / gcd(a, b); }
func sign(ll a) { return a ? abs(a) / a : 0; }
inline constexpr ll modulo(const ll n, const ll m = MOD) {
if (n < 0) {
return n % m + m;
} else if (n >= m) {
return n % m;
} else {
return n;
}
}
inline constexpr ll chmod(ll &n, const ll m = MOD) { return n = modulo(n, m); }
inline constexpr ll mpow(ll a, ll n, const ll m = MOD) {
ll r = 1;
while (n) {
if (n & 1)
r *= a;
chmod(r, m);
a *= a;
chmod(a, m);
n >>= 1;
}
return r;
}
struct Factor {
inline vector<ll> factors(ll N) {
vector<ll> A;
ll i = 2;
while (i * i <= N) {
if (N % i == 0) {
A.push_back(i);
N /= i;
} else {
i++;
}
}
if (N != 1)
A.push_back(N);
sort(all(A));
return A;
}
inline vector<ll> divisor(ll N) {
vector<ll> A = factors(N), B;
ll a = A.size();
rep(i, 1 << a) {
ll d = 1;
rep(j, a) if (i & (1 << j)) d *= A[j];
B.push_back(d);
}
sort(all(B)), B.erase(unique(all(B)), B.end());
return B;
}
};
struct csum {
ll N;
vector<ll> A, S;
csum(vector<ll> v) : A(v), S(1) { each(k, v) S.push_back(k + S.back()); }
ll sum(ll l, ll r) { return S[r] - S[l]; }
ll lsum(ll r) { return S[r]; }
ll rsum(ll l) { return S.back() - S[l]; }
};
ll p;
ll inv(ll n) {
ll a = n, b = p, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return x % p;
}
vector<ll> exp(vector<ll> A, ll N) {
vector<ll> B;
rep(i, A.size()) {
if (i == 0)
B.pb(A[i] * (p - N) % p);
else
B.back() += A[i] * (p - N), B.back() %= p;
B.pb(A[i] % p);
}
return B;
}
vector<ll> div(vector<ll> A, ll N) {
vector<ll> B;
reverse(all(A));
rep(i, A.size()) {
if (i == 0)
B.pb(A[i] % p);
else if (i != A.size() - 1)
B.pb((B[i - 1] * N + A[i]) % p);
}
reverse(all(B));
return B;
}
signed main() {
cin >> p;
ll A, B[p];
vector<ll> v = {0, 1};
rep(i, p - 1) v = exp(v, i + 1);
rep(i, p) B[i] = 0;
rep(i, p) {
cin >> A;
rep(j, p) if (i != j) A *= inv(i - j), A = modulo(A, p);
vector<ll> k = div(v, i);
rep(j, p) B[j] += k[j] * A, B[j] %= p;
}
rep(i, p) cout << B[i] << (i == p - 1 ? endl : space);
}
| #include <bits/stdc++.h>
using namespace std;
// Define
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
const ll mod = 998244353;
const ll inf = 1 << 30;
const ll LINF = LONG_MAX;
const ll INF = 1LL << 60;
const ull MAX = ULONG_MAX;
#define mp make_pair
#define pb push_back
#define elif else if
#define endl '\n'
#define space ' '
#define def inline auto
#define func inline constexpr ll
#define run(a) __attribute__((constructor)) def _##a()
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define input(a) scanf("%lld", &(a))
#define print(a) printf("%lld\n", (a))
#define fi first
#define se second
#define ok(a, b) (0 <= (a) && (a) < (b))
template <class T> using vvector = vector<vector<T>>;
template <class T> using pvector = vector<pair<T, T>>;
template <class T>
using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
// Debug
#define debug(...) \
{ \
cerr << __LINE__ << ": " << #__VA_ARGS__ << " = "; \
for (auto &&X : {__VA_ARGS__}) \
cerr << "[" << X << "] "; \
cerr << endl; \
}
#define dump(a, h, w) \
{ \
cerr << __LINE__ << ": " << #a << " = [" << endl; \
rep(__i, h) { \
rep(__j, w) cerr << a[__i][__j] << space; \
cerr << endl; \
} \
cerr << "]" << endl; \
}
#define vdump(a, n) \
{ \
cerr << __LINE__ << ": " << #a << " = ["; \
rep(__i, n) if (__i) cerr << space << a[__i]; \
else cerr << a[__i]; \
cerr << "]" << endl; \
}
// Loop
#define inc(i, a, n) for (ll i = (a), _##i = (n); i <= _##i; ++i)
#define dec(i, a, n) for (ll i = (a), _##i = (n); i >= _##i; --i)
#define rep(i, n) for (ll i = 0, _##i = (n); i < _##i; ++i)
#define each(i, a) for (auto &&i : a)
#define loop() for (;;)
// Stream
#define fout(n) cout << fixed << setprecision(n)
#define fasten cin.tie(0), ios::sync_with_stdio(0)
run(0) { fasten, fout(10); }
// Speed
#pragma GCC optimize("O3")
#pragma GCC target("avx")
// Math
func gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
func lcm(ll a, ll b) { return a * b / gcd(a, b); }
func sign(ll a) { return a ? abs(a) / a : 0; }
inline constexpr ll modulo(const ll n, const ll m = MOD) {
if (n < 0) {
return n % m + m;
} else if (n >= m) {
return n % m;
} else {
return n;
}
}
inline constexpr ll chmod(ll &n, const ll m = MOD) { return n = modulo(n, m); }
inline constexpr ll mpow(ll a, ll n, const ll m = MOD) {
ll r = 1;
while (n) {
if (n & 1)
r *= a;
chmod(r, m);
a *= a;
chmod(a, m);
n >>= 1;
}
return r;
}
struct Factor {
inline vector<ll> factors(ll N) {
vector<ll> A;
ll i = 2;
while (i * i <= N) {
if (N % i == 0) {
A.push_back(i);
N /= i;
} else {
i++;
}
}
if (N != 1)
A.push_back(N);
sort(all(A));
return A;
}
inline vector<ll> divisor(ll N) {
vector<ll> A = factors(N), B;
ll a = A.size();
rep(i, 1 << a) {
ll d = 1;
rep(j, a) if (i & (1 << j)) d *= A[j];
B.push_back(d);
}
sort(all(B)), B.erase(unique(all(B)), B.end());
return B;
}
};
struct csum {
ll N;
vector<ll> A, S;
csum(vector<ll> v) : A(v), S(1) { each(k, v) S.push_back(k + S.back()); }
ll sum(ll l, ll r) { return S[r] - S[l]; }
ll lsum(ll r) { return S[r]; }
ll rsum(ll l) { return S.back() - S[l]; }
};
ll p;
ll inv(ll n) {
ll a = n, b = p, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return x % p;
}
vector<ll> exp(vector<ll> A, ll N) {
vector<ll> B;
rep(i, A.size()) {
if (i == 0)
B.pb(A[i] * (p - N) % p);
else
B.back() += A[i] * (p - N), B.back() %= p;
B.pb(A[i] % p);
}
return B;
}
vector<ll> div(vector<ll> A, ll N) {
vector<ll> B;
reverse(all(A));
rep(i, A.size()) {
if (i == 0)
B.pb(A[i] % p);
else if (i != A.size() - 1)
B.pb((B[i - 1] * N + A[i]) % p);
}
reverse(all(B));
return B;
}
signed main() {
cin >> p;
ll A, B[p];
vector<ll> v = {0, 1};
rep(i, p - 1) v = exp(v, i + 1);
rep(i, p) B[i] = 0;
rep(i, p) {
cin >> A;
rep(j, p) if (i != j) A *= inv(p + i - j), A = modulo(A, p);
vector<ll> k = div(v, i);
rep(j, p) B[j] += k[j] * A, B[j] %= p;
}
rep(i, p) cout << B[i] << (i == p - 1 ? endl : space);
}
| [
"assignment.change"
] | 751,652 | 751,653 | u398942100 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
// #define stop char nyaa;cin>>nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
#define all(v) (v).begin(), (v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
// typedef vector<vector<ll>> mat;
typedef vector<int> vec;
//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() : n(0) { ; }
modint(ll m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((ll)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)
return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
//逆元(Eucledean algorithm)
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void solve() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(10);
// init_f();
// init();
// int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
// #define stop char nyaa;cin>>nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
#define all(v) (v).begin(), (v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
// typedef vector<vector<ll>> mat;
typedef vector<int> vec;
//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() : n(0) { ; }
modint(ll m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((ll)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)
return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
//逆元(Eucledean algorithm)
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void solve() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c - (a - b), 0) << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(10);
// init_f();
// init();
// int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 751,662 | 751,663 | u132371041 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
//#define int long long
using ll = long long;
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define reps(i, n) for (ll i = 0; i <= n; i++)
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647; // 2^31-1
const double PI = acos(-1);
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int main() {
ios_base::sync_with_stdio(false);
ll a, b, c;
cin >> a >> b >> c;
if (c - a - b >= 0) {
cout << c - a + b << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#define int long long
using ll = long long;
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define reps(i, n) for (ll i = 0; i <= n; i++)
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647; // 2^31-1
const double PI = acos(-1);
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int main() {
ios_base::sync_with_stdio(false);
ll a, b, c;
cin >> a >> b >> c;
if (c - (a - b) >= 0) {
cout << c - (a - b) << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 751,664 | 751,665 | u575664976 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) int(x.size())
#define pb push_back
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y)
const ll MOD = 1000000007, MOD2 = 998244353, INF = 1e18;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << b + c - a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) int(x.size())
#define pb push_back
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y)
const ll MOD = 1000000007, MOD2 = 998244353, INF = 1e18;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(b + c - a, 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 751,666 | 751,667 | u387221709 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (C <= A + B) {
cout << "0" << endl;
} else {
cout << C - (A + B) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (C <= A - B) {
cout << "0" << endl;
} else {
cout << C - (A - B) << endl;
}
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 751,684 | 751,685 | u516876944 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C - (A - B) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(C - (A - B), 0) << endl;
}
| [
"call.add",
"call.arguments.add"
] | 751,688 | 751,689 | u222625974 | cpp |
p02951 | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C - (A - B) << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(C - (A - B), 0) << "\n";
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 751,690 | 751,691 | u762158020 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C - A + B << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(0, C - A + B) << endl;
} | [
"call.add",
"call.arguments.change"
] | 751,692 | 751,693 | u125669112 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c - a - b <= 0) {
cout << 0;
} else {
cout << c - a - b;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (c - (a - b) <= 0) {
cout << 0;
} else {
cout << c - (a - b);
}
}
| [
"control_flow.branch.if.condition.change"
] | 751,719 | 751,720 | u459025138 | cpp |
p02951 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = c - a - b;
if (ans < 0)
ans = 0;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = c - (a - b);
if (ans < 0)
ans = 0;
cout << ans << endl;
return 0;
}
| [] | 751,725 | 751,726 | u904995051 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << C - (A - B) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << max(0, C - (A - B)) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 751,727 | 751,728 | u729703601 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c - (a - b), 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 751,729 | 751,730 | u455067221 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a > b + c) {
cout << c - a + b << endl;
} else {
cout << 0 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a < b + c) {
cout << b + c - a << endl;
} else {
cout << 0 << endl;
}
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 751,731 | 751,732 | u492660436 | cpp |
p02951 | // Template //
#include <bits/stdc++.h>
using namespace std;
// マクロ //
#define rep(i, N) for (int i = 0; i < N; i++)
#define all(x) x.begin(), x.end()
#define sort(x) sort(all(x))
#define uniq(x) x.erase(unique(all(x)), x.end())
#define vsum(x) accumulate(all(x), 0)
#define cou(x) cout << x << endl
#define y() cout << "Yes" << endl
#define n() cout << "No" << endl
#define Y() cout << "YES" << endl
#define N() cout << "NO" << endl
#define x2(x) (x) * (x)
// 型エイリアス //
using lint = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vli = vector<lint>;
using vc = vector<char>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvc = vector<vc>;
using vpii = vector<pii>;
using msi = map<string, int>;
// 関数 //
template <class T> lint gcd(T a, T b) {
int t;
while (b != 0) {
t = a % b;
a = b;
b = t;
}
return a;
}
template <class T> lint lcm(T a, T b) { return a * b / gcd(a, b); }
double distance(pii a, pii b) {
double dist;
dist = sqrt(x2(a.first - b.first) + x2(a.second - b.second));
return dist;
}
lint perm(int a) {
lint perm = 1;
for (int i = a; i >= 1; i--) {
perm *= i;
}
return perm;
}
lint combination(int n, int m) {
long double c = 1;
for (int i = n, k = 1; i > m; i--, k++) {
c *= i;
c /= k;
}
return (lint)c;
}
template <class T, class Q> inline bool chmin(T &a, Q b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class Q> inline bool chmax(T &a, Q b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 定数 //
#define pi acos(-1)
#define mod 1000000007
#define MOD 998244353
#define inf ((1LL << 62) - 1 + (1LL << 62))
// キーワード //
#define elif else if
// End of Template //
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int A, B, C;
cin >> A >> B >> C;
cou(C - (A - B));
} | // Template //
#include <bits/stdc++.h>
using namespace std;
// マクロ //
#define rep(i, N) for (int i = 0; i < N; i++)
#define all(x) x.begin(), x.end()
#define sort(x) sort(all(x))
#define uniq(x) x.erase(unique(all(x)), x.end())
#define vsum(x) accumulate(all(x), 0)
#define cou(x) cout << x << endl
#define y() cout << "Yes" << endl
#define n() cout << "No" << endl
#define Y() cout << "YES" << endl
#define N() cout << "NO" << endl
#define x2(x) (x) * (x)
// 型エイリアス //
using lint = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vli = vector<lint>;
using vc = vector<char>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvc = vector<vc>;
using vpii = vector<pii>;
using msi = map<string, int>;
// 関数 //
template <class T> lint gcd(T a, T b) {
int t;
while (b != 0) {
t = a % b;
a = b;
b = t;
}
return a;
}
template <class T> lint lcm(T a, T b) { return a * b / gcd(a, b); }
double distance(pii a, pii b) {
double dist;
dist = sqrt(x2(a.first - b.first) + x2(a.second - b.second));
return dist;
}
lint perm(int a) {
lint perm = 1;
for (int i = a; i >= 1; i--) {
perm *= i;
}
return perm;
}
lint combination(int n, int m) {
long double c = 1;
for (int i = n, k = 1; i > m; i--, k++) {
c *= i;
c /= k;
}
return (lint)c;
}
template <class T, class Q> inline bool chmin(T &a, Q b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class Q> inline bool chmax(T &a, Q b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 定数 //
#define pi acos(-1)
#define mod 1000000007
#define MOD 998244353
#define inf ((1LL << 62) - 1 + (1LL << 62))
// キーワード //
#define elif else if
// End of Template //
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int A, B, C;
cin >> A >> B >> C;
cou(max(C - (A - B), 0));
}
| [
"call.arguments.add"
] | 751,741 | 751,742 | u073983440 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c + b - a << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(c + b - a, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 751,750 | 751,751 | u941313907 | cpp |
p02951 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(0, c - (a - b)) << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - (a - b)) << endl;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 751,752 | 751,753 | u924451152 | cpp |
p02951 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c - (a - b) << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << max(0, c - (a - b)) << endl;
} | [
"call.add",
"call.arguments.change"
] | 751,754 | 751,753 | u924451152 | cpp |
p02951 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = b - a;
if (d >= c)
cout << 0 << endl;
else
cout << c - d << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int d = a - b;
if (d >= c)
cout << 0 << endl;
else
cout << c - d << endl;
} | [
"expression.operation.binary.remove"
] | 751,757 | 751,758 | u481657940 | cpp |
p02951 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define repe1(i, n) for (int i = 0; i <= (n); ++i)
#define all(x) (x).begin(), (x).end()
#define pb(x) push_back(x)
#define eb(k, v) emplace_back(k, v)
#define ct(res) cout << res << "\n";
#define vi vector<int>
#define vl vector<ll>
using namespace std;
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 int INF = 1e9;
const ll MOD = 1000000007;
using Graph = vector<vector<int>>;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
ans = c - (a - b);
ct(ans);
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define repe1(i, n) for (int i = 0; i <= (n); ++i)
#define all(x) (x).begin(), (x).end()
#define pb(x) push_back(x)
#define eb(k, v) emplace_back(k, v)
#define ct(res) cout << res << "\n";
#define vi vector<int>
#define vl vector<ll>
using namespace std;
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 int INF = 1e9;
const ll MOD = 1000000007;
using Graph = vector<vector<int>>;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
ans = max(0, c - (a - b));
ct(ans);
}
| [
"call.add",
"call.arguments.change"
] | 751,759 | 751,760 | u673981655 | cpp |
p02951 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ll mod = 1e9 + 7;
// const ll mod = 998244353;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<vector<T>> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
string num2bit(ll num, ll len) {
string bit = "";
REP(i, len) { bit += char('0' + (num >> i & 1)); }
return bit;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll A, B, C;
cin >> A >> B >> C;
cout << C - (A - B) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ll mod = 1e9 + 7;
// const ll mod = 998244353;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<vector<T>> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
string num2bit(ll num, ll len) {
string bit = "";
REP(i, len) { bit += char('0' + (num >> i & 1)); }
return bit;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll A, B, C;
cin >> A >> B >> C;
cout << max(C - (A - B), 0ll) << endl;
return 0;
} | [
"call.add",
"call.arguments.add"
] | 751,761 | 751,762 | u895971408 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.