solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a,x) for (auto& a : x)
#define uid(a, b) uniform_int_distribution<int>(a, b)(rng)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 998244353;
const char nl = '\n';
const int MX = 300001; //check the limits, dummy
ll modExp(ll base, ll power) {
if (power == 0) {
return 1;
} else {
ll cur = modExp(base, power / 2); cur = cur * cur; cur = cur % MOD;
if (power % 2 == 1) cur = cur * base;
cur = cur % MOD;
return cur;
}
}
ll inv(ll base) {
int g = MOD, r = base, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r; swap(g, r);
x -= q * y; swap(x, y);
}
return x < 0 ? x+MOD : x;
}
ll mul(ll A, ll B) {
return (A*B)%MOD;
}
ll add(ll A, ll B) {
return (A+B)%MOD;
}
ll dvd(ll A, ll B) {
return mul(A, inv(B));
}
ll sub(ll A, ll B) {
return (A-B+MOD)%MOD;
}
namespace NTT { //Source: Codeforces user neal
vector<ll> roots = {0, 1};
vector<int> bit_reverse;
int max_size = -1;
ll root;
bool is_power_of_two(int n) {
return (n & (n - 1)) == 0;
}
int round_up_power_two(int n) {
while (n & (n - 1))
n = (n | (n - 1)) + 1;
return max(n, 1);
}
// Given n (a power of two), finds k such that n == 1 << k.
int get_length(int n) {
assert(is_power_of_two(n));
return __builtin_ctz(n);
}
// Rearranges the indices to be sorted by lowest bit first, then second lowest, etc., rather than highest bit first.
// This makes even-odd div-conquer much easier.
void bit_reorder(int n, vector<ll> &values) {
if ((int) bit_reverse.size() != n) {
bit_reverse.assign(n, 0);
int length = get_length(n);
for (int i = 0; i < n; i++)
bit_reverse[i] = (bit_reverse[i >> 1] >> 1) + ((i & 1) << (length - 1));
}
for (int i = 0; i < n; i++)
if (i < bit_reverse[i])
swap(values[i], values[bit_reverse[i]]);
}
void find_root() {
max_size = 1 << __builtin_ctz(MOD - 1);
root = 2;
// Find a max_size-th primitive root of MOD.
while (!(modExp(root, max_size) == 1 && modExp(root, max_size/2) != 1))
root++;
}
void prepare_roots(int n) {
if (max_size < 0)
find_root();
assert(n <= max_size);
if ((int) roots.size() >= n)
return;
int length = get_length(roots.size());
roots.resize(n);
// The roots array is set up such that for a given power of two n >= 2, roots[n / 2] through roots[n - 1] are
// the first half of the n-th primitive roots of MOD.
while (1 << length < n) {
// z is a 2^(length + 1)-th primitive root of MOD.
ll z = modExp(root, max_size >> (length+1));
for (int i = 1 << (length - 1); i < 1 << length; i++) {
roots[2 * i] = roots[i];
roots[2 * i + 1] = (roots[i] * z)%MOD;
}
length++;
}
}
void fft_iterative(int N, vector<ll> &values) {
assert(is_power_of_two(N));
prepare_roots(N);
bit_reorder(N, values);
for (int n = 1; n < N; n *= 2)
for (int start = 0; start < N; start += 2 * n)
for (int i = 0; i < n; i++) {
ll even = values[start + i];
ll odd = values[start + n + i] * roots[n + i];
odd %= MOD;
values[start + n + i] = even - odd + MOD;
values[start + i] = even + odd;
values[start + n + i] %= MOD;
values[start + i] %= MOD;
}
}
const int FFT_CUTOFF = 150;
vector<ll> mod_multiply(vector<ll> left, vector<ll> right) {
int n = left.size();
int m = right.size();
// Brute force when either n or m is small enough.
if (min(n, m) < FFT_CUTOFF) {
const uint64_t ULL_BOUND = numeric_limits<uint64_t>::max() - (uint64_t) MOD * MOD;
vector<uint64_t> result(n + m - 1, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
result[i + j] += (uint64_t) ((int) left[i]) * ((int) right[j]);
if (result[i + j] > ULL_BOUND)
result[i + j] %= MOD;
}
for (uint64_t &x : result)
if (x >= MOD)
x %= MOD;
return vector<ll>(result.begin(), result.end());
}
int N = round_up_power_two(n + m - 1);
left.resize(N);
right.resize(N);
bool equal = left == right;
fft_iterative(N, left);
if (equal)
right = left;
else
fft_iterative(N, right);
ll inv_N = inv(N);
for (int i = 0; i < N; i++) {
left[i] *= (right[i] * inv_N)%MOD;
left[i] %= MOD;
}
reverse(left.begin() + 1, left.end());
fft_iterative(N, left);
left.resize(n + m - 1);
return left;
}
vector<ll> mod_power(const vector<ll> &v, int exponent) {
assert(exponent >= 0);
vector<ll> result = {1};
if (exponent == 0)
return result;
for (int k = 31 - __builtin_clz(exponent); k >= 0; k--) {
result = mod_multiply(result, result);
if (exponent >> k & 1)
result = mod_multiply(result, v);
}
return result;
}
vector<ll> mod_multiply_all(const vector<vector<ll>> &polynomials) {
if (polynomials.empty())
return {1};
struct compare_size {
bool operator()(const vector<ll> &x, const vector<ll> &y) {
return x.size() > y.size();
}
};
priority_queue<vector<ll>, vector<vector<ll>>, compare_size> pq(polynomials.begin(), polynomials.end());
while (pq.size() > 1) {
vector<ll> a = pq.top(); pq.pop();
vector<ll> b = pq.top(); pq.pop();
pq.push(mod_multiply(a, b));
}
return pq.top();
}
}
struct mi {
ll v; explicit operator ll() const { return v; }
mi() { v = 0; }
mi(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mi& a, const mi& b) {
return a.v == b.v; }
friend bool operator!=(const mi& a, const mi& b) {
return !(a == b); }
friend bool operator<(const mi& a, const mi& b) {
return a.v < b.v; }
mi& operator+=(const mi& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this; }
mi& operator-=(const mi& m) {
if ((v -= m.v) < 0) v += MOD;
return *this; }
mi& operator*=(const mi& m) {
v = v*m.v%MOD; return *this; }
mi& operator/=(const mi& m) { return (*this) *= inv(m); }
friend mi pow(mi a, ll p) {
mi ans = 1; assert(p >= 0);
for (; p; p /= 2, a *= a) if (p&1) ans *= a;
return ans;
}
friend mi inv(const mi& a) { assert(a.v != 0);
return pow(a,MOD-2); }
mi operator-() const { return mi(-v); }
mi& operator++() { return *this += 1; }
mi& operator--() { return *this -= 1; }
mi operator++(int) { mi temp; temp.v = v++; return temp; }
mi operator--(int) { mi temp; temp.v = v--; return temp; }
friend mi operator+(mi a, const mi& b) { return a += b; }
friend mi operator-(mi a, const mi& b) { return a -= b; }
friend mi operator*(mi a, const mi& b) { return a *= b; }
friend mi operator/(mi a, const mi& b) { return a /= b; }
friend ostream& operator<<(ostream& os, const mi& m) {
os << m.v; return os;
}
friend istream& operator>>(istream& is, mi& m) {
ll x; is >> x;
m.v = x;
return is;
}
};
typedef vector<mi> vmi;
typedef pair<mi,mi> pmi;
typedef vector<pmi> vpmi;
mi facs[MX];
mi facInvs[MX];
mi choose(mi _a, mi _b) {
ll a = (ll) _a, b = (ll) _b;
if (b > a) return 0;
if (a < 0) return 0;
if (b < 0) return 0;
mi cur = facs[a];
cur = cur * facInvs[b];
cur = cur * facInvs[a-b];
return cur;
}
void initFacs() {
facs[0] = 1;
FOR(i, 1, MX) {
facs[i] = (facs[i-1] * i);
}
facInvs[MX - 1] = inv(facs[MX-1]);
F0Rd(i, MX-1) {
facInvs[i] = facInvs[i+1] * (i+1);
}
}
void solve() {
initFacs();
int N; cin >> N;
vl dp{1};
F0R(i, N) {
int A, B; cin >> A >> B;
int X = sz(dp);
int lo = max(B-X-1, 0);
int hi = X+A-1;
vl vals;
FOR(i, lo, hi+1) {
vals.pb(choose(A+B, i).v);
}
vl res = NTT::mod_multiply(dp, vals);
while (sz(dp) < X+A-B) dp.pb(0);
while (sz(dp) > X+A-B) dp.pop_back();
F0R(i, sz(res)) {
if (i + lo >= B && i + lo < X+A) {
dp[i+lo-B] = res[i];
}
}
}
mi ans = 0; F0R(i, sz(dp)) ans += dp[i];
cout << ans << nl;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int T = 1;
// cin >> T;
while(T--) {
solve();
}
return 0;
}
// read the question correctly (ll vs int)
// template by bqi343
| 13 | CPP |
#pragma GCC target("avx2")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
//#include <bits/stdc++.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <string>
#include <numeric>
#include <cmath>
#include <bitset>
#include <tuple>
#include <memory>
#include <random>
#include <chrono>
#include <sstream>
#include <iterator>
#define ull unsigned long long
#define ll long long
#define all(vec) vec.begin(), vec.end()
#define pb push_back
#define FOR(i,a,b) for(int i = a; i < b; ++i)
#define printvec(vec) for(auto el: vec) {cout << el << " ";}
constexpr long long INF = 200000000000000001LL;
constexpr int INF32 = 2100000001;
size_t seed42 = std::chrono::system_clock::now().time_since_epoch().count();
std::mt19937 rng(seed42);
std::uniform_int_distribution<int> unidistrib;
int randint() {return unidistrib(rng);}
using namespace std;
ull modulo = 998244353 ; // 1+7*17*2^23.
//ull modulo = 1000000007 ;
int modulo32 = 998244353;
/*ull poww(ull x, ull n) {
if (n == 0)
return 1;
ull answ = poww(x, n/2);
answ = (answ * answ) % modulo;
if (n%2)
answ = (answ * x) % modulo;
return answ;
}*/
int poww(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % modulo32)
if (b & 1)
res = 1ll * res * a % modulo32;
return res;
}
pair<int, int> operator+ (const pair<int, int>& lhs, pair<int, int>& rhs) {
return {lhs.first +rhs.first, lhs.second + rhs.second};
}
template <class T>
ostream& operator << (ostream& lhs, pair<T, T>& rhs) {
return (lhs << rhs.first<<":" << rhs.second);
}
vector<int> r;
vector<int> fft(vector<int>& a, bool inv = false) {
size_t n = a.size();
//vector<int> r(n);
r.resize(n);
for (size_t k = 0; k < n; k++) {
size_t b = 0;
for (size_t z = 1; z < n; z *= 2) {
b *= 2;
if (k&z) ++b;
}
r[b] = a[k];
}
ull wm;
for (int m = 2; m <= n; m *= 2) {
if (!inv)
wm = poww(5ULL, (119ULL<<23)/m);
else
wm = poww(5ULL, (((119ULL<<23)/m) * (modulo-2))%(modulo-1));
for (int k = 0; k < n; k += m) {
ull w = 1;
for (int j = 0; j < m/2; j++) {
int u = r[k+j];
int t = (w*r[k+j+m/2])%modulo;
r[k+j] = (u+t)%modulo32;
r[k+j+m/2] = (u + modulo32 - t) % modulo32;
w = (w*wm)%modulo;
}
}
}
if (inv) {
ull ninv = poww(n, modulo-2);
for (int i = 0; i < n; i++)
r[i] = (ninv*r[i])%modulo;
}
return r;
}
int main() {
#ifdef DARTH
std::ifstream filestream("input.txt");
std::cin.rdbuf(filestream.rdbuf());
#else
ios::sync_with_stdio(false);
std::cin.tie(0);
#endif //DARTH
vector<ull> facc(200002,1), invfac(200002,1);
for(ull i = 2; i <= 200001; ++i) {
facc[i] = (i * facc[i-1]) % modulo;
invfac[i] = poww(facc[i], modulo-2);
}
auto Cnk = [&](int n, int k) {
if (k<0 || k> n)
return 0ULL;
return (((facc[n] * invfac[k]) % modulo) * invfac[n-k])%modulo;
};
int n;
cin >> n;
vector<int> a(n), b(n);
FOR(i,0,n) {
cin >> a[i] >> b[i];
}
int maxsz = 1 << 14;
vector<int> answ (1, 1);
vector<int> cnk;
answ.reserve(1<<14);
cnk.reserve(1<<14);
r.reserve(1<<14);
//vector<ull> tmp(1<<14);
answ[0] = 1;
ull m = 1;
for(int i = 0; i < n; ++i) {
int maxj = 2 * m + a[i] - b[i];
//int maxjj = 2 *m + max(a[i] - b[i], 0);
int maxjpow2 = 1;
while (maxjpow2 < maxj)
maxjpow2<<=1;
answ.resize(maxjpow2, 0ULL);
cnk.resize(maxjpow2, 0ULL);
for (int jplusm = 0; jplusm < maxj; ++jplusm) {
cnk[jplusm] = Cnk(a[i] + b[i], b[i] + jplusm - m);
//cout << a[i] + b[i] - j << " a[i] + b[i] - j" << k << "=" << cnk[k] << " ";
}
fill(cnk.begin()+maxj, cnk.end(), 0);
answ = fft(answ);
cnk = fft(cnk);
for (int j = 0; j < answ.size(); ++j) {
answ[j] = (answ[j]*1ULL*cnk[j]) % modulo;
}
answ = fft(answ, true);
copy(answ.begin() + m, answ.begin() + maxj, answ.begin());
m = m + a[i] - b[i];
fill(answ.begin() + m, answ.end(), 0);
}
cout << (accumulate(answ.begin(), answ.begin()+m, 0ULL)) % modulo;
//cout << answ[3];
//printvec(answ);
return 0;
}
| 13 | CPP |
#include <algorithm>
#include <cassert>
#include <chrono>
#include <iostream>
#include <limits>
#include <queue>
#include <random>
#include <vector>
using namespace std;
template<typename T> ostream& operator<<(ostream &os, const vector<T> &v) { os << '{'; string sep; for (const auto &x : v) os << sep << x, sep = ", "; return os << '}'; }
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#ifdef NEAL_DEBUG
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif
template<const int &MOD>
struct _m_int {
int val;
_m_int(int64_t v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static int mod_inv(int a, int m = MOD) {
// https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Example
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r; swap(g, r);
x -= q * y; swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
explicit operator int64_t() const { return val; }
_m_int& operator+=(const _m_int &other) {
val -= MOD - other.val;
if (val < 0) val += MOD;
return *this;
}
_m_int& operator-=(const _m_int &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
#if !defined(_WIN32) || defined(_WIN64)
return x % m;
#endif
// Optimized mod for Codeforces 32-bit machines.
// x must be less than 2^32 * m for this to work, so that x / m fits in a 32-bit integer.
unsigned x_high = x >> 32, x_low = (unsigned) x;
unsigned quot, rem;
asm("divl %4\n"
: "=a" (quot), "=d" (rem)
: "d" (x_high), "a" (x_low), "r" (m));
return rem;
}
_m_int& operator*=(const _m_int &other) {
val = fast_mod((uint64_t) val * other.val);
return *this;
}
_m_int& operator/=(const _m_int &other) {
return *this *= other.inv();
}
friend _m_int operator+(const _m_int &a, const _m_int &b) { return _m_int(a) += b; }
friend _m_int operator-(const _m_int &a, const _m_int &b) { return _m_int(a) -= b; }
friend _m_int operator*(const _m_int &a, const _m_int &b) { return _m_int(a) *= b; }
friend _m_int operator/(const _m_int &a, const _m_int &b) { return _m_int(a) /= b; }
_m_int& operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
_m_int& operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
_m_int operator++(int) { _m_int before = *this; ++*this; return before; }
_m_int operator--(int) { _m_int before = *this; --*this; return before; }
_m_int operator-() const {
return val == 0 ? 0 : MOD - val;
}
bool operator==(const _m_int &other) const { return val == other.val; }
bool operator!=(const _m_int &other) const { return val != other.val; }
_m_int inv() const {
return mod_inv(val);
}
_m_int pow(int64_t p) const {
if (p < 0)
return inv().pow(-p);
_m_int a = *this, result = 1;
while (p > 0) {
if (p & 1)
result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream& operator<<(ostream &os, const _m_int &m) {
return os << m.val;
}
};
extern const int MOD = 998244353;
using mod_int = _m_int<MOD>;
template<const int &MOD>
struct NTT {
using ntt_int = _m_int<MOD>;
vector<ntt_int> roots = {0, 1};
vector<int> bit_reverse;
int max_size = -1;
ntt_int root;
void reset() {
roots = {0, 1};
max_size = -1;
}
static bool is_power_of_two(int n) {
return (n & (n - 1)) == 0;
}
static int round_up_power_two(int n) {
while (n & (n - 1))
n = (n | (n - 1)) + 1;
return max(n, 1);
}
// Given n (a power of two), finds k such that n == 1 << k.
static int get_length(int n) {
assert(is_power_of_two(n));
return __builtin_ctz(n);
}
// Rearranges the indices to be sorted by lowest bit first, then second lowest, etc., rather than highest bit first.
// This makes even-odd div-conquer much easier.
void bit_reorder(int n, vector<ntt_int> &values) {
if ((int) bit_reverse.size() != n) {
bit_reverse.assign(n, 0);
int length = get_length(n);
for (int i = 1; i < n; i++)
bit_reverse[i] = (bit_reverse[i >> 1] >> 1) | ((i & 1) << (length - 1));
}
for (int i = 0; i < n; i++)
if (i < bit_reverse[i])
swap(values[i], values[bit_reverse[i]]);
}
void find_root() {
max_size = 1 << __builtin_ctz(MOD - 1);
root = 2;
// Find a max_size-th primitive root of MOD.
while (!(root.pow(max_size) == 1 && root.pow(max_size / 2) != 1))
root++;
}
void prepare_roots(int n) {
if (max_size < 0)
find_root();
assert(n <= max_size);
if ((int) roots.size() >= n)
return;
int length = get_length(roots.size());
roots.resize(n);
// The roots array is set up such that for a given power of two n >= 2, roots[n / 2] through roots[n - 1] are
// the first half of the n-th primitive roots of MOD.
while (1 << length < n) {
// z is a 2^(length + 1)-th primitive root of MOD.
ntt_int z = root.pow(max_size >> (length + 1));
for (int i = 1 << (length - 1); i < 1 << length; i++) {
roots[2 * i] = roots[i];
roots[2 * i + 1] = roots[i] * z;
}
length++;
}
}
void fft_iterative(int N, vector<ntt_int> &values) {
assert(is_power_of_two(N));
prepare_roots(N);
bit_reorder(N, values);
for (int n = 1; n < N; n *= 2)
for (int start = 0; start < N; start += 2 * n)
for (int i = 0; i < n; i++) {
ntt_int even = values[start + i];
ntt_int odd = values[start + n + i] * roots[n + i];
values[start + n + i] = even - odd;
values[start + i] = even + odd;
}
}
void invert_fft(int N, vector<ntt_int> &values) {
ntt_int inv_N = ntt_int(N).inv();
for (int i = 0; i < N; i++)
values[i] *= inv_N;
reverse(values.begin() + 1, values.end());
fft_iterative(N, values);
}
const int FFT_CUTOFF = 150;
// Note: `circular = true` can be used for a 2x speedup when only the `max(n, m) - min(n, m) + 1` fully overlapping
// ranges are needed. It computes results using indices modulo the power-of-two FFT size; see the brute force below.
template<typename T>
vector<T> mod_multiply(const vector<T> &_left, const vector<T> &_right, bool circular = false) {
if (_left.empty() || _right.empty())
return {};
vector<ntt_int> left(_left.begin(), _left.end());
vector<ntt_int> right(_right.begin(), _right.end());
int n = left.size();
int m = right.size();
int output_size = circular ? round_up_power_two(max(n, m)) : n + m - 1;
// Brute force when either n or m is small enough.
if (min(n, m) < FFT_CUTOFF) {
auto &&mod_output_size = [&](int x) {
return x < output_size ? x : x - output_size;
};
static const uint64_t U64_BOUND = numeric_limits<uint64_t>::max() - (uint64_t) MOD * MOD;
vector<uint64_t> result(output_size, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int index = mod_output_size(i + j);
result[index] += (uint64_t) (int64_t) left[i] * (int64_t) right[j];
if (result[index] > U64_BOUND)
result[index] %= MOD;
}
for (uint64_t &x : result)
if (x >= MOD)
x %= MOD;
return vector<T>(result.begin(), result.end());
}
int N = round_up_power_two(output_size);
left.resize(N, 0);
right.resize(N, 0);
if (left == right) {
fft_iterative(N, left);
right = left;
} else {
fft_iterative(N, left);
fft_iterative(N, right);
}
for (int i = 0; i < N; i++)
left[i] *= right[i];
invert_fft(N, left);
return vector<T>(left.begin(), left.begin() + output_size);
}
template<typename T>
vector<T> mod_power(const vector<T> &v, int exponent) {
assert(exponent >= 0);
vector<T> result = {1};
if (exponent == 0)
return result;
for (int k = 31 - __builtin_clz(exponent); k >= 0; k--) {
result = mod_multiply(result, result);
if (exponent >> k & 1)
result = mod_multiply(result, v);
}
return result;
}
template<typename T>
vector<T> mod_multiply_all(const vector<vector<T>> &polynomials) {
if (polynomials.empty())
return {1};
struct compare_size {
bool operator()(const vector<T> &x, const vector<T> &y) {
return x.size() > y.size();
}
};
priority_queue<vector<T>, vector<vector<T>>, compare_size> pq(polynomials.begin(), polynomials.end());
while (pq.size() > 1) {
vector<T> a = pq.top(); pq.pop();
vector<T> b = pq.top(); pq.pop();
pq.push(mod_multiply(a, b));
}
return pq.top();
}
};
NTT<MOD> ntt;
auto random_address = [] { char *p = new char; delete p; return (uint64_t) p; };
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() * (random_address() | 1));
const int N = 3e5 + 10;
mod_int fact[N],ifact[N];
void init()
{
fact[0] = 1;
for(int i=1;i<N;i++) fact[i] = (fact[i-1]*i);
ifact[N-1] = fact[N-1].inv();;
for(int i=N-2;i>=0;i--) ifact[i] = ifact[i+1]*(i+1);
}
mod_int ncr(int n,int r)
{
if(r>n || r < 0) return (mod_int)0;
return fact[n]*ifact[r]*ifact[n-r];
}
int main() {
init();
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n,a,b;
cin >> n;
vector<mod_int> cur = {1};
while(n--)
{
cin >> a >> b;
int sz = cur.size();
int mn = b - sz + 1;
int mx = a + sz - 1;
vector<mod_int> mult(mx - mn + 1);
for(int i=0;i<mx-mn+1;i++) mult[i] = ncr(a + b , mn + i);
auto res = ntt.mod_multiply(cur,mult);
cur.clear();
for(int i=b;i<=sz+a-1;i++)
cur.push_back(res[i - mn]);
}
mod_int res = 0;
for(auto x : cur) res += x;
cout << res;
} | 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define MOD 998244353
#define MAXN 200500
#define R1 3
#define R2 332748118
inline int add(int a, int b){return (a+b>=MOD)?a+b-MOD:a+b;}
inline void inc(int& a, int b){a = add(a, b);}
inline int sub(int a, int b){return (a-b<0)?a-b+MOD:a-b;}
inline void dec(int &a, int b){a = sub(a, b);}
inline int mul(int a, int b){return 1ll*a*b%MOD;}
inline void grow(int &a, int b){a = mul(a, b);}
int euclid(int a, int b, int &x, int &y){
if(b == 0){
x = 1, y = 0;
return a;
}
int x1, y1;
int d = euclid(b, a%b, x1, y1);
x = y1, y = x1-y1*(a/b);
return d;
}
int inv(int a){
int x, y;
euclid(a, MOD, x, y);
return (x%MOD+MOD)%MOD;
}
int binpow(int a, int pw){
int res = 1;
while(pw>0){
if(pw&1) grow(res, a);
grow(a, a);
pw >>= 1;
}
return res;
}
void ntt(vector<int> &a, bool invert){
int n = a.size();
for(int i = 1, j = 0; i<n; i++){
int bit = n>>1;
for(; j&bit; bit>>=1) j^=bit;
j ^= bit;
if(i < j) swap(a[i], a[j]);
}
for(int len = 2; len<=n; len <<= 1){
int wlen = binpow((invert)?R2:R1, (MOD-1)/len);
for(int i = 0; i<n; i += len){
int w = 1;
for(int j = 0; j<len/2; j++){
int u = a[i+j], v = mul(a[i+j+len/2], w);
a[i+j] = add(u, v);
a[i+j+len/2] = sub(u, v);
grow(w, wlen);
}
}
}
if(invert){
int n1 = inv(n);
for(int &x : a) grow(x, n1);
}
}
vector<int> multiply(vector<int> &a, vector<int> &b){
vector<int> na(a.begin(), a.end()), nb(b.begin(), b.end());
int n = 1;
while(n < a.size()+b.size()) n <<= 1;
na.resize(n), nb.resize(n);
ntt(na, 0); ntt(nb, 0);
for(int i = 0; i<n; i++) grow(na[i], nb[i]);
ntt(na, 1);
return na;
}
int n;
int fac[MAXN], invfac[MAXN];
vector<pair<int, int>> arr;
void init(){
fac[0] = 1;
for(int i = 1; i<MAXN; i++) fac[i] = mul(fac[i-1], i);
for(int i = 0; i<MAXN; i++) invfac[i] = inv(fac[i]);
}
int comb(int a, int b){
if(b < 0 || a < 0 || b > a) return 0;
return mul(fac[a], mul(invfac[b], invfac[a-b]));
}
void test(){
vector<int> p1 = {1, 1}; vector<int> p2 = {1, 1};
vector<int> res = multiply(p1, p2);
for(auto x : res) cout << x << " ";
cout << endl;
}
int main(){
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0); init();
cin >> n; arr.resize(n);
for(int i = 0; i<n; i++) cin >> arr[i].first >> arr[i].second;
// test();
vector<int> ans; ans.push_back(1);
int cur = 1;
for(int i = 0; i<n; i++){
int a = arr[i].first, b = arr[i].second;
int nxt = cur+a-b;
int l = b-cur+1, r = a+b-l;
// cout << l << " " << r << endl;
vector<int> poly;
for(int j = l; j<=r; j++) poly.push_back(comb(a+b, j));
ans = multiply(ans, poly);
ans = vector<int>(ans.begin()+cur-1, ans.begin()+cur-1+nxt);
cur = nxt;
}
int res = 0;
for(auto x : ans) inc(res, x);
cout << res << endl;
} | 13 | CPP |
#include<bits/stdc++.h>
#define L(i, j, k) for(int i = j, i##E = k; i <= i##E; i++)
#define R(i, j, k) for(int i = j, i##E = k; i >= i##E; i--)
#define ll long long
#define db double
#define pii pair<int, int>
#define mkp make_pair
using namespace std;
const int N = 2e5 + 7;
const int mod = 998244353;
const int G = 3;
const int iG = (mod + 1) / G;
int qpow(int x, int y = mod - 2) {
int res = 1;
for(; y; x = (ll) x * x % mod, y >>= 1) if(y & 1) res = (ll) res * x % mod;
return res;
}
int pp[N];
void polyinit(int len) {
L(i, 0, len - 1) pp[i] = ((pp[i >> 1] >> 1) | ((i & 1) * (len >> 1)));
}
void NTT(int *f, int len, int flag) {
L(i, 0, len - 1) if(pp[i] < i) swap(f[pp[i]], f[i]);
for(int i = 2; i <= len; i <<= 1)
for(int j = 0, l = (i >> 1), ch = qpow(flag == 1 ? G : iG, (mod - 1) / i); j < len; j += i)
for(int k = j, now = 1; k < j + l; k ++) {
int pa = f[k], pb = (ll) f[k + l] * now % mod;
f[k] = (pa + pb) % mod, f[k + l] = (pa + mod - pb) % mod;
now = (ll) now * ch % mod;
}
if(flag == -1) {
int nylen = qpow(len);
L(i, 0, len - 1) f[i] = (ll) f[i] * nylen % mod;
}
}
int up(int x) {
int lim = 1;
for(; lim <= x; lim <<= 1);
return lim;
}
int fac[N], ifac[N];
int C(int x, int y) {
if(y < 0 || y > x) return 0;
return (ll) fac[x] * ifac[y] % mod * ifac[x - y] % mod;
}
void math_init(int x) {
fac[0] = 1;
L(i, 1, x) fac[i] = (ll) fac[i - 1] * i % mod;
ifac[x] = qpow(fac[x]);
R(i, x, 1) ifac[i - 1] = (ll) ifac[i] * i % mod;
}
int n, dp[2][N], a[N], b[N];
int A[N], B[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
math_init(200000);
int bf = 0, now = 0;
dp[0][0] = 1;
L(i, 1, n) {
bf ^= 1;
memset(dp[bf], 0, sizeof(dp[bf]));
cin >> a[i] >> b[i];
int las = now;
now += a[i] - b[i];
int mx = max(now, las), lim = up(now + las + mx);
L(j, 0, lim - 1) A[j] = B[j] = 0;
L(j, 0, las) A[j] = dp[bf ^ 1][j];
L(j, -mx, mx) B[j + mx] = C(a[i] + b[i], b[i] + j);
polyinit(lim);
NTT(A, lim, 1), NTT(B, lim, 1);
L(j, 0, lim - 1) A[j] = (ll) A[j] * B[j] % mod;
NTT(A, lim, -1);
L(j, 0, now) dp[bf][j] = A[j + mx];
}
int sum = 0;
L(i, 0, now) (sum += dp[bf][i]) %= mod;
cout << sum << endl;
return 0;
} | 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
template<typename T> inline void chkmin(T &a, const T &b) { a = a < b ? a : b; }
template<typename T> inline void chkmax(T &a, const T &b) { a = a > b ? a : b; }
namespace NTT {
const int BIT = 16, MAXN = 1 << BIT;
const int MOD = 998244353, G = 3;
int w[2][MAXN], inv[MAXN], hasinit;//power table
int modpow(int a, int b) {
int res = 1;
for (; b; b >>= 1) {
if (b & 1) res = (LL)res * a % MOD;
a = (LL)a * a % MOD;
}
return res;
}
void init() {
hasinit = 1;
int mul = modpow(G, (MOD - 1) >> BIT);
for (int i = w[0][0] = 1; i < MAXN; i++) w[0][i] = (LL)w[0][i - 1] * mul % MOD;
mul = modpow(G, MOD - 1 - ((MOD - 1) >> BIT));
for (int i = w[1][0] = 1; i < MAXN; i++) w[1][i] = (LL)w[1][i - 1] * mul % MOD;
inv[1] = 1;
for (int i = 2; i < MAXN; i++) inv[i] = MOD - (LL)MOD / i * inv[MOD % i] % MOD;
}
int get_tpow(int n) {//return min{2^k|2^k>=n}
int k = 1;
while (k < n) k <<= 1;
return k;
}
void ntt(int *b, int n, int rev) {
if (!hasinit) init();
typedef unsigned long long ull;
static ull a[MAXN]; static int ww[MAXN];
const ull mmod = (ull)MOD * MOD; const int *W = w[rev];
for (int i = 0, j = 0; i < n; i++) {
a[i] = b[j];
for (int k = n >> 1; (j ^= k) < k; k >>= 1);
}
int n0 = __builtin_ctz(n);
if (n0 & 1) {
for (int i = 0; i < n; i += 2) {
const ull x = a[i], y = a[i + 1];
a[i] = x + y, a[i + 1] = x + MOD - y;
}
}
for (int h = n0 & 1 ? 4 : 2; h <= n; h <<= 2) {
int hh = h >> 1, t = (1 << BIT) / h >> 1;
for (int i = 0; i < h; i++) ww[i] = W[i * t];
for (int i = 0; i < n; i += h << 1) {
ull *ax = a + i, *ay = a + i + hh, *au = a + i + h, *av = a + i + h + hh;
register int *aw = ww, *bw = ww, *cw = ww + hh;
for (register int j = i; j < i + hh; ++j, ++ax, ++ay, ++au, ++av, aw += 2, ++bw, ++cw) {
const ull x = *ax, y = *ay % MOD * *aw, u = *au, v = *av % MOD * *aw;
const ull p = x + y, q = x + mmod - y, o = (u + v) % MOD * *bw, r = (u + mmod - v) % MOD * *cw;
*ax = p + o, *ay = q + r, *au = p + mmod - o, *av = q + mmod - r;
}
}
if (h == 65536 || h == 32768) for (int j = 0; j < n; j++) a[j] %= MOD;
}
for (int i = 0; i < n; i++) b[i] = a[i] % MOD;
if (rev) {
int inv = modpow(n, MOD - 2);
for (int i = 0; i < n; i++) b[i] = (LL)b[i] * inv % MOD;
}
}
//reset a polynomial to zero
void reset(int *a, int n) { memset(a, 0, sizeof(int) * n); }
//copy polynomial a to b
void copy(int *a, int *b, int n) { memcpy(b, a, sizeof(int) * n); }
//get multiplication of two polynomial in O(nlogn)
void get_mul(int *a, int *b, int *c, int n, int m, int p) {
if ((LL)n * m <= 4096) {
typedef unsigned long long ull;
static ull res[MAXN];
for (int i = 0; i < p; i++) res[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m && i + j < p; j++) res[i + j] += (ull)a[i] * b[j];
if (!(i & 15)) for (int j = 0; j < p; j++) res[j] %= MOD;
}
for (int i = 0; i < p; i++) c[i] = res[i] % MOD;
} else {
static int A[MAXN], B[MAXN];
int len = get_tpow(n + m - 1);
reset(A, len), reset(B, len);
copy(a, A, n), copy(b, B, m);
ntt(A, len, 0), ntt(B, len, 0);
for (int i = 0; i < len; i++) A[i] = (LL)A[i] * B[i] % MOD;
ntt(A, len, 1);
copy(A, c, p);
}
}
}
const int MAXN = 5005, MAXM = 200005, MOD = 998244353;
LL fac[MAXM], inv[MAXM], f[MAXN], g[MAXN];
int n, a[MAXN], b[MAXN], A[MAXN << 1], B[MAXN << 1];
LL modpow(LL a, int b) {
LL res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void init() {
int n = 2e5;
for (int i = fac[0] = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
inv[n] = modpow(fac[n], MOD - 2);
for (int i = n; i > 0; i--) inv[i - 1] = inv[i] * i % MOD;
}
LL C(int a, int b) {
return a < b ? 0 : fac[a] * inv[b] % MOD * inv[a - b] % MOD;
}
int main() {
init();
scanf("%d", &n);
int m = 1;
f[1] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d%d", a + i, b + i);
if (a[i] >= b[i]) {
for (int j = b[i] + 1; j <= a[i]; j++) {
memset(g, 0, sizeof(g));
for (int k = 1; k <= m; k++) {
(g[k] += f[k]) %= MOD;
(g[k + 1] += f[k]) %= MOD;
}
memcpy(f, g, sizeof(g));
++m;
}
a[i] = b[i];
}
memset(g, 0, sizeof(g));
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int j = 1; j <= m; j++) A[j] = f[j];
for (int j = 0; j <= m; j++) B[j] = C(2 * a[i], a[i] + j);
NTT::get_mul(A, B, A, m + 1, m + 1, m + 1);
for (int j = 1; j <= m; j++) g[j] = A[j];
memset(A, 0, sizeof(A));
for (int j = 1; j <= m; j++) A[j] = f[j];
reverse(A, A + m + 1);
NTT::get_mul(A, B, A, m + 1, m + 1, m * 2 + 1);
for (int j = 1; j <= m; j++) g[j] = (g[j] + A[m - j]) % MOD;
for (int j = 1; j <= m; j++)
g[j] = (g[j] + C(2 * a[i], a[i]) * (MOD - f[j])) % MOD;
memcpy(f, g, sizeof(g));
for (int j = a[i] + 1; j <= b[i]; j++) {
memset(g, 0, sizeof(g));
for (int k = 1; k < m; k++)
g[k] = (f[k] + f[k + 1]) % MOD;
memcpy(f, g, sizeof(g));
--m;
}
}
LL ans = 0;
for (int i = 1; i <= m; i++) ans = (ans + f[i]) % MOD;
printf("%lld\n", ans);
return 0;
} | 13 | CPP |
#include <bits/stdc++.h>
const int lim = 3e5;
const int maxn = 32768 + 177;
const int mod = 998244353;
using ll = long long;
int fac[lim + 17],ifac[lim + 17],n,a[maxn],b[maxn],ans,f[maxn],g[maxn],h[maxn];
int rev[maxn<<2];
int qpow(int a,int b) {
if (b == 0) return 1;
ll d = qpow(a,b>>1); d = d * d % mod;
if (b&1) d = d * a % mod;
return d;
}
void NTT( int *a, int lim, int flag ) {
for (int i = 1; i < lim; ++ i) rev[i] = (rev[i>>1]>>1) | (i&1) * (lim>>1);
for (int i = 0; i < lim; ++ i) if (i < rev[i]) std::swap(a[i], a[rev[i]]);
for (int i = 1; i < lim; i <<= 1) {
int wn = qpow(3,(mod-1)/(i<<1));
if (flag == -1) wn = qpow(wn, mod - 2);
for (int j = 0; j < lim; j += (i<<1)) {
for (int k = 0, w = 1; k < i; w=(ll)w*wn%mod,++k) {
int a1 = a[j+k], a2 = (ll) w * a[j+k+i] % mod;
a[j+k] = (a1 + a2) % mod; a[j+k+i] = (a1 - a2 + mod) % mod;
}
}
} if (flag == -1)
for (int i = 0,inv=qpow(lim,mod-2); i < lim; ++i) a[i] = (ll) a[i] * inv % mod;
}
int main() {
scanf("%d",&n);
int curL = 1;
f[1] = 1;
fac[0] = ifac[0] = ifac[1] = 1;
for (int i = 1; i <= lim; ++ i) fac[i] = (ll) fac[i-1] * i % mod;
for (int i = 2; i <= lim; ++ i) ifac[i] = (ll) (mod - mod / i ) * ifac[mod % i] % mod;
for (int i = 1; i <= lim; ++ i) ifac[i] = (ll) ifac[i - 1] * ifac[i] % mod;
auto binom = [&](int n,int m) {
if (n < m || n < 0 || m < 0) return 0ll;
return (ll) fac[n] * ifac[m] % mod * ifac[n - m] % mod;
};
for (int i = 1; i <= n; ++ i) {
scanf("%d%d",&a[i],&b[i]);
int nxtL = curL + a[i] - b[i];
int N = curL + a[i];
std::memset(g,0,sizeof(g));
int L = 2 * N - curL - nxtL;
std::memset(h,0,sizeof(h));
for (int i = 1; i <= curL + nxtL; ++ i)
if (N - i + 1 >= 0 && (L - (N - i + 1)) >= 0)
h[i] = (ll) ifac[N - i + 1] * ifac[L - (N - i + 1)] % mod;
std::reverse(f + 1, f + curL + 1);
int lm = 1; while (lm <= nxtL + curL + curL) lm <<= 1;
NTT(f,lm,1); NTT(h,lm,1);
for (int i = 0; i < lm; ++ i) g[i] = (ll) f[i] * h[i] % mod;
NTT(g,lm,-1);
std::memset(f,0,sizeof(f));
for (int i = 1; i <= nxtL; ++ i) f[i] = (ll) g[curL + 1 + i] * fac[L] % mod;
curL = nxtL;
}
for (int i = 1; i <= curL; ++ i) ans = (ans + f[i]) % mod;
printf("%d",ans);
return 0;
} | 13 | CPP |
#include<bits/stdc++.h>
#define go(i,a,b) for(int i=a;i< b;i++)
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
typedef long long ll;
const int X=2e5,N=33e3,mo=998244353;
int fac[X+9],ivf[X+9],n,a,b,m=1,m1,n1,f[2][N],g[N],ans;
void P(int&x,ll y) {x=(x+y)%mo;}
void T(int&x,ll y) {x=x*y%mo;}
int ksm(int x,int y=mo-2) {int a=1; for(;y;y/=2,T(x,x)) if(y&1)T(a,x); return a;}
int C(int n,int m) {return m>=0&&m<=n?1ll*fac[n]*ivf[m]%mo*ivf[n-m]%mo:0;}
namespace NTT
{
int tf[N],w[N],o;
void build(int n)
{
o=__builtin_ctz(n);
go(i,1,n) tf[i]=tf[i/2]+n*(i&1)>>1;
for(int i=1;i<n;i*=2)
{
int v=ksm(3,(mo-1)/2/i); w[i]=1;
go(j,1,i) w[i+j]=1ll*w[i+j-1]*v%mo;
}
}
void DFT(int a[N],int n,bool f)
{
static unsigned long long b[N];
int u=o-__builtin_ctz(n),v;
go(i,0,n) b[i]=a[tf[i]>>u];
for(int i=1;i<n;i*=2) for(int j=0;j<n;j+=2*i) go(k,0,i)
v=b[i+j+k]*w[i+k]%mo, b[i+j+k]=b[j+k]-v+mo, b[j+k]+=v;
go(i,0,n) a[i]=b[i]%mo;
if(f)
{
reverse(a+1,a+n);
v=mo-(mo-1)/n;
go(i,0,n) T(a[i],v);
}
}
void mtp(int a[N],int b[N],int n)
{
DFT(a,n,0); DFT(b,n,0);
go(i,0,n) T(a[i],b[i]);
DFT(a,n,1);
}
}
int main()
{
fac[0]=1;
fo(i,1,X) fac[i]=1ll*fac[i-1]*i%mo;
ivf[X]=ksm(fac[X]);
fd(i,X,1) ivf[i-1]=1ll*ivf[i]*i%mo;
NTT::build(32768);
scanf("%d",&n); f[0][1]=1;
fo(i,1,n)
{
scanf("%d%d",&a,&b); m1=m+a-b;
int I=i&1;
for(n1=1;n1/2<=m+m1+1;n1*=2);
memset(g,0,4*n1);
fo(j,0,m+m1) g[j]=C(a+b,b+j-m);
NTT::mtp(g,f[!I],n1);
memset(f[!I],0,4*n1);
fo(j,1,m+a-b) f[I][j]=g[j+m];
m=m1;
}
fo(i,1,m) P(ans,f[n&1][i]);
printf("%d",ans);
}
| 13 | CPP |
/**
* created: 14/01/2021, 18:07:05
**/
#include <bits/stdc++.h>
using namespace std;
template<typename T>
ostream& operator << (ostream &os, const vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
if (i) {
os << " ";
}
os << v[i];
}
os << "]";
return os;
}
const int max_lev = 20, mod = 998244353;
template<int mod, int max_lev>
struct NTT {
static const int max_n = 1 << max_lev;
int roots[2][max_lev];
int rev[max_n], buf1[max_n], buf2[max_n], bufpw[max_n];
NTT() {
int root = find_root();
int rroot = power(root, mod - 2);
roots[0][0] = root;
roots[1][0] = rroot;
for (int i = 1; i < max_lev; ++i) {
roots[0][i] = mul(roots[0][i - 1], roots[0][i - 1]);
roots[1][i] = mul(roots[1][i - 1], roots[1][i - 1]);
}
for (int i = 1; i < max_n; ++i) {
rev[i] = (rev[i / 2] / 2) + ((i & 1) << (max_lev - 1));
}
}
static inline void inc(int &x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
}
static inline int mul(int x, int y) {
return (1LL * x * y) % mod;
}
static int power(int x, int y) {
if (y == 0) {
return 1;
}
if (y % 2 == 0) {
return power(mul(x, x), y / 2);
}
return mul(x, power(x, y - 1));
}
static int find_root() {
for (int root = 2; ; ++root) {
if (power(root, max_n) == 1) {
int cur = 1;
bool ok = true;
for (int i = 1; i < max_n; ++i) {
cur = mul(cur, root);
if (cur == 1) {
ok = false;
break;
}
}
if (ok) {
return root;
}
}
}
}
void fft(int *a, const int *roots, int lg) {
const int n = 1 << lg;
for (int i = 0; i < n; ++i) {
int r = (rev[i] >> (max_lev - lg)) & (n - 1);
if (i < r) {
swap(a[i], a[r]);
}
}
int pos = max_lev - 1;
for (int st = 1; st < n; st *= 2) {
int cur = 1;
for (int i = 0; i < st; ++i) {
bufpw[i] = cur;
cur = mul(cur, roots[pos]);
}
--pos;
for (int i = 0; i < n; i += 2 * st) {
int *curpw = bufpw;
for (int j = i; j < i + st; ++j) {
int y = mul(*curpw++, a[j + st]);
a[j + st] = a[j];
inc(a[j + st], mod - y);
inc(a[j], y);
}
}
}
}
vector<int> product(const vector<int> &a, const vector<int> &b) {
int sz = a.size() + b.size() - 1;
int n = 1, rn = 1, lg = 0;
while (n < sz) {
n *= 2;
rn = mul(rn, (mod + 1) / 2);
++lg;
}
memcpy(buf1, a.data(), 4 * a.size());
memset(buf1 + a.size(), 0, 4 * (n - a.size()));
memcpy(buf2, b.data(), 4 * b.size());
memset(buf2 + b.size(), 0, 4 * (n - b.size()));
fft(buf1, roots[0], lg);
fft(buf2, roots[0], lg);
for (int i = 0; i < n; ++i) {
buf1[i] = mul(buf1[i], buf2[i]);
}
fft(buf1, roots[1], lg);
vector<int> ans(sz);
for (int i = 0; i < sz; ++i) {
ans[i] = mul(buf1[i], rn);
}
return ans;
}
vector<int> square(const vector<int> &a) {
int sz = a.size() + a.size() - 1;
int n = 1, rn = 1, lg = 0;
while (n < sz) {
n *= 2;
rn = mul(rn, (mod + 1) / 2);
++lg;
}
memcpy(buf1, a.data(), 4 * a.size());
memset(buf1 + a.size(), 0, 4 * (n - a.size()));
fft(buf1, roots[0], lg);
for (int i = 0; i < n; ++i) {
buf1[i] = mul(buf1[i], buf1[i]);
}
fft(buf1, roots[1], lg);
vector<int> ans(sz);
for (int i = 0; i < sz; ++i) {
ans[i] = mul(buf1[i], rn);
}
return ans;
}
};
NTT<mod, max_lev> ntt;
inline void inc(int &x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
}
inline void dec(int &x, int y) {
x -= y;
if (x < 0) {
x += mod;
}
}
inline int mul(int x, int y) {
return (1LL * x * y) % mod;
}
int power(int a, int b) {
int res = 1 % mod;
while (b) {
if (b % 2) {
res = mul(res, a);
}
b /= 2;
a = mul(a, a);
}
return res;
}
int inv(int x) {
return power(x, mod - 2);
}
string str_fraq(int x, int n = 20) {
stringstream res;
pair<int, int> best(x, 1);
for (int j = 1; j < n; ++j) {
best = min(best, {mul(x, j), j});
}
res << best.first << "/" << best.second;
return res.str();
}
const int max_f = 200111;
int f[max_f], rf[max_f];
void get_all_f() {
f[0] = rf[0] = 1;
for (int i = 1; i < max_f; ++i) {
f[i] = mul(i, f[i - 1]);
}
rf[max_f - 1] = inv(f[max_f - 1]);
for (int i = max_f - 2; i > 0; --i) {
rf[i] = mul(i + 1, rf[i + 1]);
}
}
int get_c(int n, int k) {
if (n < k || k < 0) {
return 0;
}
return mul(f[n], mul(rf[k], rf[n - k]));
}
int n;
const bool debug = 0;
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
get_all_f();
if (debug) {
n = 1000;
} else {
cin >> n;
}
vector<int> dp{1};
while (n--) {
int a = 100000, b = 100000 - 5;
if (!debug) {
cin >> a >> b;
}
vector<int> ndp(dp.size() + a - b);
vector<int> d(dp.size() + ndp.size() - 1);
const int shift = dp.size() - 1;
for (int pos = 0; pos < d.size(); ++pos) {
const int k = pos - shift;
d[pos] = get_c(a + b, b + k);
continue;
for (int j = 0; j <= b; ++j) {
const int i = k + j;
if (0 <= i && i <= a) {
inc(d[pos], mul(get_c(a, i), get_c(b, j)));
}
}
}
/*for (int i = 0; i <= a; ++i) {
for (int j = 0; j <= b; ++j) {
const int pos = shift + i - j;
if (0 <= pos && pos < d.size()) {
inc(d[pos], mul(get_c(a, i), get_c(b, j)));
}
}
}*/
vector<int> C = ntt.product(dp, d);
for (int i = 0; i < C.size(); ++i) {
int pos = i - shift;
if (0 <= pos && pos < ndp.size()) {
inc(ndp[pos], C[i]);
}
}
dp.swap(ndp);
//cout << dp << ", d = " << d << endl;
}
int ans = accumulate(dp.begin(), dp.end(), 0LL) % mod;
printf("%d\n", ans);
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
#include"map"
#include"string"
#include"cmath"
#include"cstdio"
#include"iostream"
#include"cstring"
#include"algorithm"
#include"vector"
//#pragma GCC optimize(3, "Ofast")
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, ll> pii;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch>'9') { if (ch == '-')w = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
#ifdef local
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
#define f(i, l, r) for (int i = l; i <= r; ++i)
#define rf(i, r, l) for (int i = r; i >= l; --i)
#define all(x) (x).begin(), (x).end()
#define l l
#define r r
#define lch (o << 1)
#define rch (o << 1 | 1)
#define mid ((l + r) >> 1)
#define mem(x, y) memset(x, y, sizeof(x))
#define mod1(x) ((x >= mod) && (x -= mod))
#define mod2(x) ((x < 0) && (x += mod))
const int inf = 2e9 + 7;
//const ll INF = INT64_MAX;
double eps = 1e-6;
const int mod = 998244353;
const int N = 2e5 + 10;
const double pi = acos(-1.0);
ll power(ll a, ll b) { ll res = 1; while (b) { if (b & 1)res = res * a % mod; a = a * a % mod; b >>= 1; }return res; }
ll gcd(ll a, ll b) { return !b ? a : gcd(b, a % b); }
ll exgcd(ll a, ll b, ll& x, ll& y) { ll c; return !b ? (x = 1, y = 0, a) : (c = exgcd(b, a % b, y, x), y -= (a / b) * x, c); }
ll INV(ll a) { ll x, y; exgcd(a, mod, x, y); x %= mod; if (x < 0)x += mod; return x; }
/*int len, C[N], clen;
int id(int v) { return lower_bound(C + 1, C + len, v) - C; }
void initC() { sort(C + 1, C + clen+1); len = unique(C + 1, C + 1 + clen) - C - 1; }*/
typedef unsigned int uint;
namespace Poly {
typedef vector<uint> poly;
constexpr uint Max_size = 1 << 21 | 5;
constexpr int gn = 3;
inline uint mf(uint x)
{
return (static_cast<ll>(x) << 32) / mod;
}
int sz;
uint w[Max_size], w_mf[Max_size];
inline void init(int n)
{
for (sz = 2; sz < n; sz <<= 1);
uint pr = power(gn, (mod - 1) / sz);
w[sz / 2] = 1, w_mf[sz / 2] = mf(w[sz / 2]);
for (int i = 1; i < sz / 2; ++i)
w[sz / 2 + i] = (ll)w[sz / 2 + i - 1] * pr % mod, w_mf[sz / 2 + i] = mf(w[sz / 2 + i]);
for (int i = sz / 2 - 1; i; --i)
w[i] = w[i << 1], w_mf[i] = w_mf[i << 1];
}
inline void NTT(poly& A, const int L)
{
for (int d = L >> 1; d; d >>= 1)
for (int i = 0; i != L; i += d << 1)
for (int j = 0; j != d; ++j)
{
uint x = A[i + j] + A[i + d + j];
if (x >= mod * 2)
x -= mod * 2;
ll t = A[i + j] + mod * 2 - A[i + d + j];
ll q = t * w_mf[d + j] >> 32;
uint y = t * w[d + j] - q * mod;
A[i + j] = x, A[i + d + j] = y;
}
}
inline void INTT(poly& A, const int L)
{
for (int d = 1; d != L; d <<= 1)
for (int i = 0; i != L; i += d << 1)
for (int j = 0; j != d; ++j)
{
uint x = A[i + j];
if (x >= mod * 2)
x -= mod * 2;
ll y = A[i + d + j];
ll q = y * w_mf[d + j] >> 32;
ll t = y * w[d + j] - q * mod;
A[i + j] = x + t, A[i + d + j] = x + mod * 2 - t;
}
reverse(A.begin() + 1, A.end());
int k = __builtin_ctz(L);
for (int i = 0; i != L; ++i)
{
ll m = -A[i] & (L - 1);
A[i] = (A[i] + m * mod) >> k;
}
}
poly operator*(poly a, poly b) {
int n = a.size() + b.size() - 1, R = 2;
for (; R <= n; R <<= 1); init(R);
a.resize(R), b.resize(R);
NTT(a, R); NTT(b, R);
f(i, 0, R - 1)a[i] = 1ll * b[i] * a[i] % mod;
INTT(a, R); a.resize(n);
f(i, 0, n - 1)if (a[i] >= mod)a[i] -= mod;
return a;
}
}; using namespace Poly;
int main() {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#ifdef local
freopen("in.txt", "r", stdin);
int start = clock();
#endif
int n; cin >> n;
const int N2 = 4e5;
vector<ll> fac(N2+1), ifac(fac);
fac[0] = 1; f(i, 1, N2)fac[i] = fac[i - 1] * i % mod;
ifac[N2] = power(fac[N2], mod - 2);
rf(i, N2-1, 0)ifac[i] = ifac[i + 1] * (i + 1) % mod;
poly res; res.push_back(1);
f(i, 1, n) {
int a, b; cin >> a >> b;
int m = res.size();
int m2 = m + a - b;
poly F;
f(j, max(0, b - (m-1)), min(a+(m-1), a + b)) {
F.push_back(fac[a + b] * ifac[j] % mod * ifac[a + b - j] % mod);
}
res = res * F;
int yu = (res.size() - m2) / 2;
res.erase(res.end() - yu, res.end());
res.erase(res.begin(), res.begin() + yu);
}
ll ans = 0;
for (auto I : res)ans += I;
cout << ans % mod;
#ifdef local
int end = clock();
//cout << '\n' << end - start << "ms";
#endif* /
} | 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i,a,b) for(int i=a;i<b;i++)
#define REPI(i,a,b) for(ll i=b-1;i>=a;i--)
#define PB push_back
#define DB pop_back
#define V(a) vector<a>
static const int N=(1<<20)+5, M=998244353, G=3;
static int fc[N],fci[N],inv[N],rev[N],rt[N];
int powM(int x,int y)
{
int ans=1;
while(y)
{
if(y&1)
ans=1LL*ans*x%M;
x=1LL*x*x%M;
y>>=1;
}
return ans;
}
void fft(V(ll) &a,ll n,bool invert)
{
for(int i=1; i<n; i++)
{
if(rev[n+i]>i)
{
swap(a[i],a[rev[n+i]]);
}
}
for(int s=1; s<n; s<<=1)
{
ll y=powM(G, (M-1)/(s<<1) );
for(int j=0; j<n; j+=(s<<1))
{
ll r=1;
for(int i=0; i<s; i++)
{
ll u=a[i+j];
ll v=(r*a[i+j+s])%M;
a[i+j]=u+v;
if(a[i+j]>M) a[i+j]-=M;
a[i+j+s]=u-v;
if(a[i+j+s]<0) a[i+j+s]+=M;
r*=y;
r%=M;
}
}
}
if(invert)
{
int invn=inv[n];
REP(i,0,n)
{
a[i]=(a[i]*invn)%M;
}
reverse(a.begin()+1,a.end());
}
return;
}
void PolyMult(V(ll) &a,V(ll) &b,V(ll) &v)
{
ll n=1;
while(n<((ll)a.size())+((ll)b.size()))
{
n<<=1;
}
V(ll) fa(a.begin(),a.end());
fa.resize(n,0);
V(ll) fb(b.begin(),b.end());
fb.resize(n,0);
// cout<<"fa"<<endl;
// for(auto it:fa) cout<<it<<' ';cout<<endl;
// cout<<"fb"<<endl;
// for(auto it:fb) cout<<it<<' ';cout<<endl;
fft(fa,n,false);
fft(fb,n,false);
// cout<<"fa"<<endl;
// for(auto it:fa) cout<<it<<' ';cout<<endl;
// cout<<"fb"<<endl;
// for(auto it:fb) cout<<it<<' ';cout<<endl;
v.resize(n,0);
REP(i,0,n)
{
v[i]=((fa[i]*fb[i])%M);
}
// cout<<"v"<<endl;
// for(auto it:v) cout<<it<<' ';cout<<endl;
fft(v,n,true);
// cout<<"v"<<endl;
// for(auto it:v) cout<<it<<' ';cout<<endl;
v.resize(((ll)a.size())+((ll)b.size())-1,0LL);
// cout<<"v"<<endl;
// for(auto it:v) cout<<it<<' ';cout<<endl;
return;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fc[0]=1;
REP(i,1,N) fc[i] = 1LL*fc[i-1]*i % M;
fci[N-1]=powM(fc[N-1], M-2);
REPI(i,0,N-1) fci[i] = 1LL*fci[i+1]*(i+1) % M;
REP(i,1,N) inv[i] = 1LL*fci[i]*fc[i-1]%M;
rev[1]=0;
for(int s=2; (s<<1)<=N; s<<=1)
{
for(int i=0; i<(s>>1); i++)
{
rev[s+i]=(rev[(s>>1)+i]<<1);
rev[s+(s>>1)+i]=((rev[(s>>1)+i]<<1)|1);
}
}
ll n;
cin>>n;
V(ll) v={1};
while(n--)
{
ll a,b;
cin>>a>>b;
ll nv=v.size();
// cout<<a<<' '<<b<<endl;
// for(auto it:v) cout<<it<<' ';cout<<endl;
V(ll) tmp(2*nv+a-b,0LL);
REP(i,b-nv,a+nv)
{
if(i>=0&&i<=a+b)
{
tmp[i-(b-nv)]=1LL*fc[a+b]*fci[i]%M*fci[a+b-i]%M;
}
}
// cout<<a<<' '<<b<<endl;
// for(auto it:tmp) cout<<it<<' ';cout<<endl;
V(ll) ans;
PolyMult(v,tmp,ans);
// cout<<a<<' '<<b<<endl;
// for(auto it:ans) cout<<it<<' ';cout<<endl;
V(ll) newv(nv+a-b,0LL);
REP(i,0,nv+a-b)
{
newv[i]=ans[i+nv];
}
// cout<<a<<' '<<b<<endl;
// for(auto it:newv) cout<<it<<' ';cout<<endl;
v=newv;
}
ll ans=0;
for(auto it:v) ans = (ans+it)%M;
cout<<ans;
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < int(n); ++i)
#define fore(i, l, r) for (int i = int(l); i < int(r); ++i)
#define sz(a) int((a).size())
template<const int &MOD>
struct _m_int {
int val;
_m_int(int64_t v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = int(v);
}
_m_int(uint64_t v) {
if (v >= MOD) v %= MOD;
val = int(v);
}
_m_int(int v) : _m_int(int64_t(v)) {}
_m_int(unsigned v) : _m_int(uint64_t(v)) {}
static int inv_mod(int a, int m = MOD) {
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r; swap(g, r);
x -= q * y; swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
explicit operator unsigned() const { return val; }
explicit operator int64_t() const { return val; }
explicit operator uint64_t() const { return val; }
explicit operator double() const { return val; }
explicit operator long double() const { return val; }
_m_int& operator+=(const _m_int &other) {
val -= MOD - other.val;
if (val < 0) val += MOD;
return *this;
}
_m_int& operator-=(const _m_int &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
#if !defined(_WIN32) || defined(_WIN64)
return unsigned(x % m);
#endif
// Optimized mod for Codeforces 32-bit machines.
// x must be less than 2^32 * m for this to work, so that x / m fits in an unsigned 32-bit int.
unsigned x_high = unsigned(x >> 32), x_low = unsigned(x);
unsigned quot, rem;
asm("divl %4\n"
: "=a" (quot), "=d" (rem)
: "d" (x_high), "a" (x_low), "r" (m));
return rem;
}
_m_int& operator*=(const _m_int &other) {
val = fast_mod(uint64_t(val) * other.val);
return *this;
}
_m_int& operator/=(const _m_int &other) {
return *this *= other.inv();
}
friend _m_int operator+(const _m_int &a, const _m_int &b) { return _m_int(a) += b; }
friend _m_int operator-(const _m_int &a, const _m_int &b) { return _m_int(a) -= b; }
friend _m_int operator*(const _m_int &a, const _m_int &b) { return _m_int(a) *= b; }
friend _m_int operator/(const _m_int &a, const _m_int &b) { return _m_int(a) /= b; }
_m_int& operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
_m_int& operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
_m_int operator++(int) { _m_int before = *this; ++*this; return before; }
_m_int operator--(int) { _m_int before = *this; --*this; return before; }
_m_int operator-() const {
return val == 0 ? 0 : MOD - val;
}
friend bool operator==(const _m_int &a, const _m_int &b) { return a.val == b.val; }
friend bool operator!=(const _m_int &a, const _m_int &b) { return a.val != b.val; }
friend bool operator<(const _m_int &a, const _m_int &b) { return a.val < b.val; }
friend bool operator>(const _m_int &a, const _m_int &b) { return a.val > b.val; }
friend bool operator<=(const _m_int &a, const _m_int &b) { return a.val <= b.val; }
friend bool operator>=(const _m_int &a, const _m_int &b) { return a.val >= b.val; }
_m_int inv() const {
return inv_mod(val);
}
_m_int pow(int64_t p) const {
if (p < 0)
return inv().pow(-p);
_m_int a = *this, result = 1;
while (p > 0) {
if (p & 1)
result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend string to_string(_m_int<MOD> x) {
return to_string(x.val);
}
friend ostream& operator<<(ostream &os, const _m_int &m) {
return os << m.val;
}
};
extern const int MOD = 998244353;
using Mint = _m_int<MOD>;
const int g = 3;
const int LOGN = 15;
vector<Mint> w[LOGN];
vector<int> rv[LOGN];
void prepare() {
Mint wb = Mint(g).pow((MOD - 1) / (1 << LOGN));
forn(st, LOGN - 1) {
w[st].assign(1 << st, 1);
Mint bw = wb.pow(1 << (LOGN - st - 1));
Mint cw = 1;
forn(k, 1 << st) {
w[st][k] = cw;
cw *= bw;
}
}
forn(st, LOGN) {
rv[st].assign(1 << st, 0);
if (st == 0) {
rv[st][0] = 0;
continue;
}
int h = (1 << (st - 1));
forn(k, 1 << st)
rv[st][k] = (rv[st - 1][k & (h - 1)] << 1) | (k >= h);
}
}
void ntt(vector<Mint> &a, bool inv) {
int n = sz(a);
int ln = __builtin_ctz(n);
forn(i, n) {
int ni = rv[ln][i];
if (i < ni) swap(a[i], a[ni]);
}
forn(st, ln) {
int len = 1 << st;
for (int k = 0; k < n; k += (len << 1)) {
fore(pos, k, k + len){
Mint l = a[pos];
Mint r = a[pos + len] * w[st][pos - k];
a[pos] = l + r;
a[pos + len] = l - r;
}
}
}
if (inv) {
Mint rn = Mint(n).inv();
forn(i, n) a[i] *= rn;
reverse(a.begin() + 1, a.end());
}
}
vector<Mint> mul(vector<Mint> a, vector<Mint> b) {
int cnt = 1 << (32 - __builtin_clz(sz(a) + sz(b) - 1));
a.resize(cnt);
b.resize(cnt);
ntt(a, false);
ntt(b, false);
vector<Mint> c(cnt);
forn(i, cnt) c[i] = a[i] * b[i];
ntt(c, true);
return c;
}
#define ll long long
const int M = 202020;
int pwr(int a, int b){
int ret = 1;
for(int c=1; c<=b; c*=2){
if(c&b) ret = ((ll)ret*a)%MOD;
a = ((ll)a*a)%MOD;
}
return ret;
}
int main(){
prepare();
int n;
cin >> n;
vector<int> a(n), b(n);
for(int i=0; i<n; i++) cin >> a[i] >> b[i];
vector<ll> f(M), inv(M);
f[0] = 1;
for(ll i=1; i<M; i++) f[i] = (f[i-1]*i)%MOD;
for(int i=0; i<M; i++) inv[i] = pwr(f[i], MOD-2);
vector<Mint> ans(1, 1);
forn(i, n){
vector<Mint> Cs;
int sum = a[i]+b[i];
for(int j = b[i] - sz(ans) + 1; j < sz(ans) + a[i]; ++j){
int tmp = 0;
if(j >= 0 && j <= sum) tmp = (((f[sum]*inv[j])%MOD)*inv[sum-j])%MOD;
Mint tmp2 = tmp;
Cs.push_back(tmp2);
}
auto res = mul(ans, Cs);
int cnt = sz(ans);
ans.resize(cnt + a[i] - b[i]);
forn(j, sz(ans)) ans[j] = res[cnt + j - 1];
}
cout << accumulate(ans.begin(), ans.end(), Mint(0)) << endl;
return 0;
}
| 13 | CPP |
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <string>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <complex>
using namespace std;
typedef long long ll;
#define MAXN 600000
const int G = 3, MOD = 998244353;
int L;
int R[MAXN + 10];
int n;
int fac[MAXN + 10], inv[MAXN + 10];
int qpow(int a,int b){
int ans = 1;
for (; b; b >>= 1,a = 1ll * a * a % MOD)
if (b & 1) ans = 1ll * ans * a % MOD;
return ans;
}
void ntt(int a[], int len, int f){
for (int i = 0; i < len; i++) if (i < R[i]) swap(a[i],a[R[i]]);
for (int i = 1; i < len; i <<= 1){
int gn = qpow(G, (MOD - 1) / (i << 1));
for (int j = 0; j < len; j += (i << 1)){
int g = 1;
for (int k = 0; k < i; k++, g = 1ll * g * gn % MOD){
int x = a[j + k],y = 1ll * g * a[j + k + i] % MOD;
a[j + k] = (x + y) % MOD; a[j + k + i] = (x - y + MOD) % MOD;
}
}
}
if(f == 1) return;
int nv = qpow(len, MOD - 2); reverse(a + 1, a + len);
for(int i = 0; i < len; i++) a[i] = 1ll * a[i] * nv % MOD;
}
void NTT(int len, int A[], int B[], int C[]) {
ntt(A, len, 1);
ntt(B, len, 1);
for(int i = 0;i < len; i++) C[i] = 1ll * A[i] * B[i] % MOD;
ntt(C, len, -1);
}
void init(int up) {
fac[0] = inv[0] = 1;
for(int i = 1;i <= up; i++) fac[i] = (1ll * fac[i - 1] * i) % MOD;
inv[up] = qpow(fac[up], MOD - 2);
for(int i = up - 1;i >= 1; i--) inv[i] = (1ll * inv[i + 1] * (i + 1)) % MOD;
}
int get_C(int a, int b) {
if(a < 0 || b < 0 || a > b) return 0;
return ((1ll * fac[b] * inv[a]) % MOD * inv[b - a]) % MOD;
}
int A[MAXN], B[MAXN],C[MAXN];
int main(){
scanf("%d", &n);
A[0] = 1;
int tot = 0;
init(600000);
for(int i = 0;i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
int ntot = tot + a - b;
int p = 2 * tot + ntot;
int len;
L = 0;
for(len = 1;len <= p; len <<= 1) L++;
for(int i = 0;i < len; i++) R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
for(int i = 0;i < len; i++) B[i] = 0;
for(int i = -tot;i <= ntot; i++) B[tot + i] = get_C(b + i, a + b);
// for(int i = 0;i < len; i++) printf("%d ", A[i]);
// puts("");
// for(int i = 0;i < len; i++) printf("%d ", B[i]);
// puts("");
ntt(A, len, 1); ntt(B, len, 1);
for(int i = 0;i < len; i++) A[i] = 1ll * A[i] * B[i] % MOD;
ntt(A, len, -1);
// for(int i = 0;i < len; i++) printf("%d ", A[i]);
// puts("");
for(int i = 0;i <= ntot; i++) A[i] = A[i + tot];
for(int i = ntot + 1;i < len; i++) A[i] = 0;
tot = ntot;
}
int ans = 0;
for (int i = 0; i <= tot; i++) ans = (ans + A[i]) % MOD;
printf("%d\n", ans);
return 0;
} | 13 | CPP |
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
const int G = 3;
const int mod = 998244353;
int fac[N],rev[N];
int qpow(int a,int b){
int r=1;
while(b){
if(b&1)r=1ll*r*a%mod;
b>>=1;a=1ll*a*a%mod;
}
return r;
}
struct NTT{
int n,m,rev[N<<1];
int a[N<<1],b[N<<1];
void init(int len){
for(n=1,m=0;n<=len;n<<=1,m++);
for(int i=0;i<n;++i){
rev[i]=rev[i>>1]>>1|(1&i)<<(m-1);
a[i]=b[i]=0;
}
}
void FFT(int *a,int f){
for(int i=0;i<n;++i)if(i<rev[i])swap(a[i],a[rev[i]]);
for(int i=1;i<n;i<<=1){
int wn=qpow(G,(mod-1)/(i<<1));
if(f==-1)wn=qpow(wn,mod-2);
for(int j=0;j<n;j+=i<<1){
int w=1;
for(int k=0;k<i;++k,w=1ll*w*wn%mod){
int x=a[j+k],y=1ll*a[j+k+i]*w%mod;
a[j+k]=(x+y)%mod;a[j+k+i]=(x-y+mod)%mod;
}
}
}
if(f==-1){
int rn=qpow(n,mod-2);
for(int i=0;i<n;++i)a[i]=1ll*a[i]*rn%mod;
}
}
void work(){
FFT(a,1);FFT(b,1);
for(int i=0;i<n;++i)a[i]=1ll*a[i]*b[i]%mod;
FFT(a,-1);
}
}B;
void init(){
fac[0]=1;
for(int i=1;i<N;++i)fac[i]=1ll*fac[i-1]*i%mod;
rev[N-1]=qpow(fac[N-1],mod-2);
for(int i=N-2;~i;--i)rev[i]=1ll*rev[i+1]*(i+1)%mod;
}
int C(int n,int m){
if(n<m||m<0)return 0;
return 1ll*fac[n]*rev[m]%mod*rev[n-m]%mod;
}
int n,ans[N];
int main(){
init();
cin>>n;
int len=0;
ans[0]=1;
for(int i=1,a,b;i<=n;++i){
cin>>a>>b;
B.init(2*len+a-b);
for(int k=-len;k<=len+a-b;++k)B.a[k+len]=C(a+b,b+k);
for(int j=0;j<=len;++j)B.b[j]=ans[j];
B.work();
for(int k=0;k<=len+a-b;++k){
ans[k]=B.a[k+len];
}
len+=a-b;
}
int res=0;
for(int i=0;i<=len;++i)(res+=ans[i])%=mod;
cout<<res<<endl;
}
| 13 | CPP |
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef pair <int, int> P;
const int inf = 0x3f3f3f3f, N = 5005, mod = 998244353, M = 6e5 + 10;
template <typename T>
void rd_(T &x) {
x = 0; int f = 1;
char ch = getchar();
for (; ch > '9' || ch < '0'; ch = getchar()) if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x*10 + ch - '0';
x *= f;
}
LL fpow_(LL a, LL b, LL res = 1) {
for (; b; b >>= 1, a = a*a%mod)
if (b&1) res = res*a%mod;
return res;
}
int n, a, b, f[M], g[M], len, tr[M], tot, tk, R = 3, iR = fpow_(3, mod - 2);
LL fac[M], inv[M], ans;
void init_(int n) {
fac[0] = inv[0] = 1;
rep (i, 1, n) fac[i] = fac[i - 1]*i%mod;
inv[n] = fpow_(fac[n], mod - 2);
per (i, n - 1, 1) inv[i] = inv[i + 1]*(i + 1)%mod;
}
void ntt_(int *a, int f = 1) {
rep (i, 0, len - 1)
if (i < tr[i]) swap(a[i], a[tr[i]]);
for (int l = 2; l <= len; l <<= 1) {
int wn = fpow_(f == 1 ? R : iR, (mod - 1)/l);
for (int j = 0; j < len; j += l) {
int w = 1;
for (int k = 0; k < l/2; k++) {
int u = a[j + k], v = 1ll*a[j + k + l/2]*w%mod;
a[j + k] = (u + v)%mod, a[j + k + l/2] = (u - v + mod)%mod;
w = 1ll*w*wn%mod;
}
}
}
if (f == -1) {
int iL = fpow_(len, mod - 2);
rep (i, 0, len - 1)
a[i] = 1ll*a[i]*iL%mod;
}
}
int main() {
rd_(n), init_(600000);
f[0] = 1, tot = 0;
rep (T, 1, n) {
rd_(a), rd_(b);
for (len = 1, tk = 0; len <= 3*tot + a - b; len <<= 1) tk++;
rep (i, 0, len - 1) {
tr[i] = (tr[i>>1]>>1) | ((i&1)<<tk - 1);
g[i] = 0;
}
rep (i, 0, tot + tot + a - b)
if (b + (i - tot) >= 0 && a - (i - tot) >= 0)
g[i] = inv[b + (i - tot)]*inv[a - (i - tot)]%mod;
rep (i, tot + 1, len - 1) f[i] = 0;
ntt_(f), ntt_(g);
rep (i, 0, len - 1) f[i] = 1ll*f[i]*g[i]%mod;
ntt_(f, -1);
rep (i, 0, tot + a - b)
f[i] = f[i + tot]*fac[a + b]%mod;
tot += a - b;
}
rep (i, 0, tot)
ans = (ans + f[i])%mod;
printf("%lld\n", ans);
} | 13 | CPP |
#pragma GCC optimize("Ofast")
//#pragma GCC target ("sse4")
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<cassert>
#include<complex>
#include<numeric>
#include<array>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
constexpr ll mod =998244353;
const ll INF = mod * mod;
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 double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acosl(-1.0);
ll mod_pow(ll x, ll n, ll m = mod) {
if (n < 0) {
ll res = mod_pow(x, -n, m);
return mod_pow(res, m - 2, m);
}
if (abs(x) >= m)x %= m;
if (x < 0)x += m;
ll res = 1;
while (n) {
if (n & 1)res = res * x % m;
x = x * x % 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, ll n) {
if (n == 0)return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
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)); }
modint operator/=(modint& a, modint b) { a = a / b; return a; }
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];
}
modint combP(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[a - b];
}
int gcd(int a, int b) {
if (a < b)swap(a, b);
while (b) {
int r = a % b; a = b; b = r;
}
return a;
}
int get_premitive_root() {
int primitive_root = 0;
if (!primitive_root) {
primitive_root = [&]() {
set<int> fac;
int v = mod - 1;
for (ll i = 2; i * i <= v; i++) while (v % i == 0) fac.insert(i), v /= i;
if (v > 1) fac.insert(v);
for (int g = 1; g < mod; g++) {
bool ok = true;
for (auto i : fac) if (mod_pow(g, (mod - 1) / i) == 1) { ok = false; break; }
if (ok) return g;
}
return -1;
}();
}
return primitive_root;
}
const int proot = get_premitive_root();
typedef vector <modint> poly;
void dft(poly& f, bool inverse = false) {
int n = f.size(); if (n == 1)return;
static poly w{ 1 }, iw{ 1 };
for (int m = w.size(); m < n / 2; m *= 2) {
modint dw = mod_pow(proot, (mod - 1) / (4 * m)), dwinv = (modint)1 / dw;
w.resize(m * 2); iw.resize(m * 2);
for (int i = 0; i < m; i++)w[m + i] = w[i] * dw, iw[m + i] = iw[i] * dwinv;
}
if (!inverse) {
for (int m = n; m >>= 1;) {
for (int s = 0, k = 0; s < n; s += 2 * m, k++) {
for (int i = s; i < s + m; i++) {
modint x = f[i], y = f[i + m] * w[k];
f[i] = x + y, f[i + m] = x - y;
}
}
}
}
else {
for (int m = 1; m < n; m *= 2) {
for (int s = 0, k = 0; s < n; s += 2 * m, k++) {
for (int i = s; i < s + m; i++) {
modint x = f[i], y = f[i + m];
f[i] = x + y, f[i + m] = (x - y) * iw[k];
}
}
}
modint n_inv = (modint)1 / (modint)n;
for (modint& v : f)v *= n_inv;
}
}
poly multiply(poly g, poly h) {
int n = 1;
int pi = 0, qi = 0;
rep(i, g.size())if (g[i])pi = i;
rep(i, h.size())if (h[i])qi = i;
int sz = pi + qi + 2;
while (n < sz)n *= 2;
g.resize(n); h.resize(n);
dft(g); dft(h);
rep(i, n) {
g[i] *= h[i];
}
dft(g, true);
return g;
}
void solve() {
int n; cin >> n;
vector<int> a(n), b(n);
rep(i, n)cin >> a[i] >> b[i];
vector<modint> dp = { 1 };
int cur = 1;
rep(i, n) {
int nex = cur + a[i] - b[i];
int ri = min(a[i], nex / 2);
int le = max(-b[i], -(cur - 1));
le = abs(le);
//cout << "? " << le << " " << ri << "\n";
//le,ri
poly p(ri + le + 1);
rep(k, ri + le + 1) {
p[k] = fact[a[i]+b[i]]*factinv[b[i] + (k - le)] * factinv[a[i] - (k - le)];
}
poly q(cur);
rep(i, cur)q[i] = dp[i];
poly r = multiply(p, q);
vector<modint> ndp(nex);
for (int j = 0; j < (nex + 1) / 2; j++) {
if (j + le < r.size())ndp[j] = r[j + le];
}
for (int j = (nex + 1) / 2; j < nex;j++) {
ndp[j] = ndp[nex - 1 - j];
}
swap(dp, ndp);
cur = nex;
//cout << dp[0] << "\n";
}
modint ans = 0;
rep(i, dp.size())ans += dp[i];
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(15);
init_f();
//init();
//expr();
//int t; cin >> t; rep(i,t)
solve();
return 0;
} | 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using base = ll;//complex<double>;
const ll mod = 998244353;
ll mexp(ll x, ll y) {
ll r = 1;
for(;y;x=x*x%mod, y>>=1) if(y & 1) r = r * x % mod;
return r;
}
ll modd(ll x) {
if(x >= mod) x -= mod;
if(x < 0) x += mod;
return x;
}
void fft(vector<base>& a, bool inv) {
int n = a.size(), j = 0;
vector<base> roots(n/2);
for(int i=1;i<n;i++) {
int bit = (n >> 1);
while(j >= bit) {
j -= bit;
bit >>= 1;
}
j += bit;
if(i < j) swap(a[i], a[j]);
}
// In NTT, let prr = primitive root. Then,
int prr = 3;
ll ang = mexp(prr, (mod - 1) / n);
if(inv) ang = mexp(ang, mod - 2);
for(int i=0; i<n/2; i++){
roots[i] = (i ? (1ll * roots[i-1] * ang % mod) : 1);
}
//also, make sure to apply modulus under here
for(int i=2;i<=n;i<<=1) {
int step = n / i;
for(int j=0;j<n;j+=i) {
for(int k=0;k<i/2;k++) {
base u = a[j+k], v = a[j+k+i/2] * roots[step * k] % mod;
a[j+k] = modd(u+v);
a[j+k+i/2] = modd(u-v+mod);
}
}
}
if(inv) for(int i=0;i<n;i++) a[i] = a[i] * mexp(n, mod-2) % mod;
}
void conv(vector<base>& x, vector<base>& y) {
int n = 2; while(n < x.size()+y.size()) n <<= 1;
x.resize(n), y.resize(n);
fft(x, false); fft(y, false);
for(int i=0;i<n;i++) x[i] = x[i] * y[i] % mod;
fft(x, true);
}
const int lim = 222222;
ll f[lim], fi[lim];
vector<base> ans, mul, nans;
int n;
ll binom(int a, int b) {
if(b < 0 || b > a) return 0;
return f[a] * fi[b] % mod * fi[a-b] % mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
ans.reserve(1<<16);
mul.reserve(1<<16);
f[0] = 1;
for(int i=1;i<lim;i++)
f[i] = i * f[i-1] % mod;
fi[lim-1] = mexp(f[lim-1], mod-2);
for(int i=lim-2;i>=0;i--)
fi[i] = (i+1) * fi[i+1] % mod;
ans.push_back(1);
for(int i=0;i<n;i++) {
int a, b;
cin >> a >> b;
int m = ans.size();
int m1 = 2 * m + a - b - 1;
for(int j=0;j<m1;j++)
mul.emplace_back(binom(a+b, b+j-(m-1)));
conv(ans, mul);
nans.clear(); nans.resize(m+a-b);
for(int i=0;i<m+a-b;i++) nans[i] = ans[m-1+i];
ans = nans;
mul.clear();
}
cout << accumulate(ans.begin(), ans.end(), 0LL) % mod;
} | 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
const int N = 4e5 + 9;
const int P = 998244353;
const int g = 3;
inline int add(int a, int b) { int r = a + b; return r < P ? r : r - P; }
inline int sub(int a, int b) { int r = a - b; return r < 0 ? r + P : r; }
inline int mul(ll a, ll b) { ll r = a * b; return r % P; }
inline int inv(int a) { return a == 1 ? a : mul(inv(P % a), P - P / a); }
inline int qpm(int a, int b) {
int r = 1;
do if (b & 1) r = mul(r, a);
while (a = mul(a, a), b >>= 1);
return r;
}
ll invs[N], f[N], fi[N];
ll binom(ll n, ll k) { if (n < k || k < 0) return 0; return mul(f[n], mul(fi[n - k], fi[k])); }
void ginv() {
invs[1] = 1; f[0] = fi[0] = 1;
for (int i = 2; i != N; ++i) invs[i] = mul(invs[P % i], (P - P / i));
for (int i = 1; i != N; ++i) f[i] = mul(f[i - 1], i);
for (int i = 1; i != N; ++i) fi[i] = mul(fi[i - 1], invs[i]);
}
const int W = 19, S = 1 << W;
int w[S + 1], rev[S << 1], *r[W + 1];
void init() {
for (int s = 0; s <= W&&(r[s]=rev+(1<<s),1); ++s)
for (int i = 0; i != (1 << s); ++i)
r[s][i] = (r[s][i >> 1] >> 1) | ((i & 1) << (s - 1));
w[0] = 1; w[1] = qpm(g, (P - 1) / S);
for (int i = 2; i <= S; ++i) w[i] = mul(w[i - 1], w[1]);
}
int m, s, im;
int init(int n) {
for (s = 0, m = 1; m < n; m <<= 1, ++s);
im = inv(m); return m;
}
void ntt(int* p, int t) {
for (int i = 0; i != m; ++i) if (i < r[s][i]) swap(p[i], p[r[s][i]]);
for (int i = 1, z = 0; i != m; i <<= 1, z++)
for (int j = 0; j != m; j += (i << 1))
for (int k = 0, u, v; k != i; k++)
u = p[j+k], v = mul(w[(t?(i<<1)-k:k)<<W-z-1], p[i+j+k]),
p[j + k] = add(u, v), p[i + j + k] = sub(u, v);
if (t) for (int i = 0; i != m; ++i) p[i] = mul(p[i], im);
}
int px[N], py[N];
vi mul(const vi& p1, const vi& p2, int n = 0) {
int n1 = p1.size(), n2 = p2.size(), n3 = n1 + n2 - 1;
init(n3);
copy_n(p1.begin(), n1, px); fill(px + n1, px + m, 0);
copy_n(p2.begin(), n2, py); fill(py + n2, py + m, 0);
ntt(px, 0); ntt(py, 0);
for (int i = 0; i != m; ++i) px[i] = mul(px[i], py[i]);
ntt(px, 1); vi p3(n3); copy_n(px, n3, p3.begin());
if (n && n3 > n) p3.resize(n); return p3;
}
int n;
int a[N], b[N];
vector<int> vc[N];
int main()
{
//freopen("C:/Users/MACHENIKE/Desktop/data.in","r",stdin);
ginv(); init();
scanf ("%d", &n);
for (int i = 1; i <= n; i++) scanf ("%d %d", a + i, b + i);
vc[0].push_back (1);
int u = 0;
for (int i = 1; i <= n; i++)
{
vc[i].resize(2 * u + a[i] - b[i] + 1);
for (int j = -u; j <= u + a[i] - b[i]; j++) vc[i][j + u] = binom (a[i] + b[i], b[i] + j);
vector<int> temp = mul (vc[i - 1], vc[i]);
int v = u + a[i] - b[i];
vc[i].resize (v + 1);
for (int j = 0; j <= v; j++) vc[i][j] = temp[j + u];
u = v;
}
int ans = 0;
for (auto it : vc[n]) ans = add (it, ans);
printf ("%d\n", ans);
return 0;
}
| 13 | CPP |
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define pb push_back
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define mem(a) memset(a, 0, sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef __int128_t int128;
const int maxn = 4 * 1e5 + 10, P = 998244353, G = 3, Gi = 332748118;
const ll mod = P;
//Gi是原根的逆元
int limit = 1, L, rev[maxn];
vector<ll> a, b;
ll fac[maxn], inv[maxn];
int n;
ll in[maxn], de[maxn];
vector<ll> tmp;
inline ll qp(ll a, ll k, ll mod = P)
{
ll base = 1;
while (k)
{
if (k & 1)
base = (base * a) % mod;
a = (a * a) % mod;
k >>= 1;
}
return base % mod;
}
int cnt = 0;
inline void NTT(vector<ll> &A, int type)
{
//cout << "SSSSS" << cnt++ << endl;
for (int i = 0; i < limit; i++)
if (i < rev[i])
swap(A[i], A[rev[i]]);
for (int mid = 1; mid < limit; mid <<= 1)
{
ll Wn = qp(type == 1 ? G : Gi, (P - 1) / (mid << 1));
for (int j = 0; j < limit; j += (mid << 1))
{
ll w = 1;
for (int k = 0; k < mid; k++, w = (w * Wn) % P)
{
//cout << mid << " " << j << " " << k << endl;
int x = A[j + k], y = w * A[j + k + mid] % P;
A[j + k] = (x + y) % P, A[j + k + mid] = (x - y + P) % P;
}
}
}
if (type == -1)
{
ll inv = qp(limit, P - 2);
for (int i = 0; i < limit; i++)
A[i] = A[i] * inv % P;
}
}
void init(int N, int M)
{
limit = 1;
L = 0;
while (limit <= N + M)
limit <<= 1, L++;
for (int i = 0; i < limit; i++)
{
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
}
}
void I()
{
fac[0] = 1, inv[0] = 1;
for (int i = 1; i < maxn; i++)
fac[i] = fac[i - 1] * i % P, inv[i] = qp(fac[i], mod - 2);
}
ll C(int n, int k)
{
if (k < 0 || k > n)
return 0;
return 1ll * fac[n] * inv[k] % mod * inv[n - k] % mod;
}
void mul(vector<ll> &a, vector<ll> &b)
{
int n = a.size(), m = b.size();
init(n, m);
a.resize(limit), b.resize(limit);
//cout << limit << endl;
NTT(a, 1), NTT(b, 1);
for (int i = 0; i < limit; i++)
a[i] = a[i] * b[i] % mod;
NTT(a, -1);
}
int main()
{
I();
//cout << C(6, 3) << " " << C(6, 2) << endl;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> in[i] >> de[i];
a.pb(1);
int len = 1;
for (int i = 1; i <= n; i++)
{
//cout << "I= " << i << endl;
len += in[i] - de[i];
tmp.clear();
int prev = a.size();
for (int j = de[i] - prev + 1; j <= prev + in[i] - 1; j++)
{
tmp.pb(C(in[i] + de[i], j));
}
mul(tmp, a);
vector<ll> tmp2(len,0);
for (int i = 0; i < len; i++)
tmp2[i]=(tmp[i + prev - 1]);
a.clear();
a = tmp2;
}
ll ans = 0;
for (auto c : a)
{
//cout << c << endl;
ans = (ans + c) % mod;
}
cout << ans << endl;
return 0;
} | 13 | CPP |
#include <bits/stdc++.h>
#ifdef NON_SUBMIT
#define TEST(n) (n)
#define tout cerr
#else
#define TEST(n) ((void)0)
#define tout cin
#endif
using namespace std;
const int MOD=998244353, PR=3;
vector<int> X, Y;
int F[300001], Finv[300001];
int mul(int a, int b) {return 1LL*a*b%MOD;}
int fast_pow(int a, int b)
{
int ret=1;
for(;b;b>>=1) {
if(b&1) ret=mul(ret,a);
a=mul(a,a);
}
return ret;
}
void FFT(vector<int> &A,bool inv)
{
int N=A.size();
stack<int> S;
for(int i=0;i<N;i++) {
int j=0;
for(int b=1;b<N;b<<=1) {
j<<=1;
if(b&i) j|=1;
}
if(i<j) swap(A[i],A[j]);
}
S.push(fast_pow(inv ? fast_pow(PR,MOD-2):PR,MOD/N));
for(int i=2;i<N;i<<=1) S.push(mul(S.top(),S.top()));
for(int i=1;i<N;i<<=1) {
int w=S.top();
S.pop();
for(int j=0;j<N;j+=i<<1) {
int th=1;
for(int k=0;k<i;k++) {
int temp=mul(A[i+j+k],th);
A[i+j+k]=A[j+k]-temp;
if(A[i+j+k]<0) A[i+j+k]+=MOD;
A[j+k]+=temp;
if(A[j+k]>=MOD) A[j+k]-=MOD;
th=mul(th,w);
}
}
}
if(inv) {
int v=fast_pow(N,MOD-2);
for(int i=0;i<N;i++) A[i]=mul(A[i],v);
}
}
void conv(vector<int> &A, vector<int> &B)
{
int N=1;
for(;N<A.size()+B.size();N<<=1);
A.resize(N); B.resize(N);
FFT(A,false); FFT(B,false);
for(int i=0;i<N;i++) A[i]=mul(A[i],B[i]);
FFT(A,true);
}
int nCr(int n, int r)
{
return mul(F[n],mul(Finv[r],Finv[n-r]));
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
TEST(freopen("input.txt","r",stdin));
TEST(freopen("output.txt","w",stdout));
TEST(freopen("debug.txt","w",stderr));
int N=1, M, ans=0;
F[0]=Finv[0]=1;
for(int i=1;i<=300000;i++) F[i]=mul(i,F[i-1]);
Finv[300000]=fast_pow(F[300000],MOD-2);
for(int i=300000;--i;) Finv[i]=mul(Finv[i+1],i+1);
X.resize(1,1);
for(cin>>M;M--;) {
int a, b, sz=X.size()+10;
cin>>a>>b;
Y.clear();
for(int i=-sz;i<=sz;i++) {
if(b+i<0 || i>a) Y.push_back(0);
else Y.push_back(nCr(a+b,b+i));
}
conv(X,Y);
N+=a-b;
for(int i=0;i<N;i++) X[i]=X[sz+i];
X.resize(N);
}
for(int i=0;i<N;i++) {
ans+=X[i];
if(ans>=MOD) ans-=MOD;
}
cout<<ans<<'\n';
return 0;
} | 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b, v;
string s;
bool ok(int p) {
bool f = true;
for (int i = 0; i < a.size(); i++) {
f &= a[i] < p;
}
for (int i = 0; i < b.size(); i++) {
f &= b[i] < p;
}
long long h, m;
h = m = 0;
for (int i = 0; i < a.size(); i++) {
h *= p;
h += a[i];
}
for (int i = 0; i < b.size(); i++) {
m *= p;
m += b[i];
}
return f && (m < 60) && (h < 24);
}
int main() {
cin >> s;
int i = 0;
while (s[i] != ':') {
if (s[i] >= '0' && s[i] <= '9') {
a.push_back(s[i] - '0');
} else {
a.push_back(s[i] - 'A' + 10);
}
i++;
}
s.erase(s.begin(), s.begin() + s.find(':') + 1);
for (int i = 0; i < s.size(); i++) {
if (s[i] >= '0' && s[i] <= '9') {
b.push_back(s[i] - '0');
} else {
b.push_back(s[i] - 'A' + 10);
}
}
if (ok(60)) {
cout << -1 << endl;
return 0;
}
for (int i = 2; i < 60; i++) {
if (ok(i)) {
v.push_back(i);
}
}
if (v.size() == 0) {
cout << 0 << endl;
return 0;
}
cout << v[0];
for (int i = 1; i < v.size(); i++) {
cout << ' ' << v[i];
}
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char str[100010], h[100010], m[100010];
long long int mh, mm, lh, lm;
long long int priority(char c) {
if (c >= '0' && c <= '9') return c - '0';
return ((c - 'A') + 10);
}
void find_time(long long int r) {
long long int i, p = 1;
for (i = (lh - 1); i >= 0; i--) {
mh += p * priority(h[i]);
p *= r;
}
p = 1;
for (i = (lm - 1); i >= 0; i--) {
mm += p * priority(m[i]);
p *= r;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scanf("%s", str);
long long int i, j, mymax;
for (i = 0; str[i] != '\0'; i++) {
if (str[i] == ':') {
h[i] = '\0';
break;
}
h[i] = str[i];
}
j = 0;
i++;
for (;; i++) {
if (str[i] == '\0') {
m[j] = '\0';
break;
} else
m[j++] = str[i];
}
lh = strlen(h);
lm = strlen(m);
bool um = 0, uh = 0, all = 1;
for (i = (lh - 1); i >= 0; i--) {
if (i < (lh - 1) && h[i] != '0') uh = 1;
if (h[i] != '0') all = 0;
}
for (i = (lm - 1); i >= 0; i--) {
if (i < (lm - 1) && m[i] != '0') um = 1;
if (m[i] != '0') all = 0;
}
if (all) {
cout << -1 << endl;
} else if (uh == 0 && um == 0) {
mh = 0;
mm = 0;
find_time(1);
if (mh <= 23 & mm < 60) {
cout << -1 << endl;
} else if (mh == 24 && mm == 0) {
cout << -1 << endl;
} else {
cout << 0 << endl;
}
} else {
mymax = 0;
vector<long long int> r;
for (i = 0; i < lh; i++) {
mymax = max(mymax, priority(h[i]));
}
for (i = 0; i < lm; i++) {
mymax = max(mymax, priority(m[i]));
}
for (i = mymax + 1;; i++) {
mh = 0;
mm = 0;
find_time(i);
if (mh <= 23 && mm < 60)
r.push_back(i);
else
break;
}
if (r.size() != 0) {
for (i = 0; i < r.size(); i++) cout << r[i] << " ";
cout << endl;
} else
cout << 0 << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c2i(char c) {
if (c <= '9') return c - '0';
return c - 'A' + 10;
}
long long conv(string s, int b) {
for (register int i = (0); i < (int)(((int)(s).size())); ++i)
if (c2i(s[i]) >= b) return -1U / 2;
long long res = 0;
for (register int i = (0); i < (int)(((int)(s).size())); ++i)
res = res * b + c2i(s[i]);
return res;
}
int main() {
string tmp;
cin >> tmp;
for (register int i = (0); i < (int)(((int)(tmp).size())); ++i)
if (tmp[i] == ':') tmp[i] = ' ';
istringstream sin(tmp);
string a, b;
sin >> a >> b;
vector<bool> base(1000, true);
base[0] = base[1] = false;
for (register int i = (2); i < (int)(1000); ++i)
if (conv(a, i) >= 24 || conv(b, i) >= 60) base[i] = false;
bool has = false;
if (base[999]) {
cout << -1 << "\n";
return 0;
}
for (register int i = (0); i < (int)(1000); ++i)
if (base[i]) {
cout << i << " ";
has = true;
}
if (!has) cout << "0";
cout << "\n";
return 0;
}
| 8 | CPP |
s = input()
a = s[:s.index(":")]
b = s[s.index(":")+1:]
a2 = ''
b2 = ''
found = False
for i in a:
if i!='0':
found = True
if found:
a2+=i
found = False
for i in b:
if i!='0':
found = True
if found:
b2+=i
a = a2
b = b2
apos = []
bpos = []
values = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
for i in a:
apos.append(values.index(i))
for i in b:
bpos.append(values.index(i))
if len(apos)==0:
apos.append(0)
if len(bpos)==0:
bpos.append(0)
minradix = max(max(apos), max(bpos))
#print(minradix)
results = []
for i in range(minradix+1, 60):
aresult = 0
bresult = 0
for j in range(len(apos)):
aresult+=apos[j]*(i**(len(apos)-j-1))
for j in range(len(bpos)):
bresult+=bpos[j]*(i**(len(bpos)-j-1))
if aresult<=23 and bresult<=59:
results.append(i)
#print(a, b)
if len(a)==1 and len(b)==1 and values.index(a)<=23 and values.index(b)<=59:
print(-1)
elif len(results)==0:
print(0)
elif apos==[0] and bpos==[0]:
print(-1)
elif len(a)==0 and len(b)==1 and values.index(b)<=59:
print(-1)
elif len(b)==0 and len(a)==1 and values.index(a)<=23:
print(-1)
else:
print(' '.join(list(map(str, results)))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int to(string s, int k) {
int res = 0;
int n = (int)s.length();
int p = 1;
for (int i = n - 1; i >= 0; i--) {
if (s[i] >= 'A' && s[i] <= 'Z' && s[i] - 'A' + 10 > k - 1)
return -1;
else if (s[i] - '0' > k - 1 && s[i] >= '0' && s[i] <= '9')
return -1;
if (s[i] >= 'A' && s[i] <= 'Z')
res += (s[i] - 'A' + 10) * p;
else
res += (s[i] - '0') * p;
p *= k;
}
return res;
}
string go(string a) {
for (int i = 0; i < (int)a.length(); i++)
if (a[i] != '0') return a.substr(i, (int)a.length() - i + 1);
return "0";
};
int main() {
string a = "";
string b = "";
char c;
while (c != ':') {
scanf("%c", &c);
if (c != ':') a += c;
}
cin >> b;
a = go(a);
b = go(b);
if ((int)a.length() == 1) {
if (a[0] >= '0' && a[0] <= '9' && a[0] - '0' >= 24) {
cout << "0";
return 0;
}
if (a[0] >= 'A' && a[0] <= 'Z' && a[0] - 'A' + 10 >= 24) {
cout << "0";
return 0;
}
}
if ((int)a.length() <= 1 && (int)b.length() <= 1) {
cout << "-1";
return 0;
}
bool was = false;
for (int i = 2;; i++) {
int ta = to(a, i);
int tb = to(b, i);
if (ta >= 0 && ta < 24 && tb >= 0 && tb < 60) {
cout << i << " ";
was = true;
}
if (ta >= 24 || tb >= 60) break;
}
if (!was) cout << "0";
return 0;
}
| 8 | CPP |
def val(c):
if 'A' <= c <='Z':
return ord(c) - 65 + 10
else:
return int(c)
def calc(h, b):
ans = 0
i = 0
for c in h[::-1]:
v = val(c)
ans += int(v) * (b**i)
i += 1
return ans
h, m = [x for x in input().split(":")]
min_base = -1
for c in h:
min_base = max(min_base, val(c)+1)
for c in m:
min_base = max(min_base, val(c)+1)
# print(min_base)
answers = []
while True:
hour = calc(h, min_base)
min = calc(m, min_base)
if hour > 23 or min > 59 or min_base > 60:
break
else:
answers.append(min_base)
min_base+= 1
if len(answers) == 0:
print(0)
elif min_base > 60:
print(-1)
else:
print(*answers) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 0.000000001;
const int INF = 1E9;
const int MAXN = 100000;
int ans, a[2], mn;
string s[2];
char c;
bool f[2];
int getn(char c) { return ('0' <= c && c <= '9') ? (c - '0') : (c - 'A' + 10); }
int main() {
c = getchar();
while (c != ':') {
s[0] += c;
c = getchar();
}
cin >> s[1];
for (int k = 0; k < (int)(2); k++)
for (int i = 0; i < (int)(s[k].size() - 1); i++)
if (s[k][i] != '0') f[k] = 1;
if (f[0] || f[1]) {
f[0] = 1;
for (int i = (int)(2); i <= (int)(60); i++) {
f[1] = 1;
for (int j = 0; j < (int)(2); j++) {
mn = 1;
a[j] = 0;
for (int k = (int)(s[j].size()) - 1; k >= 0; k--) {
if (getn(s[j][k]) >= i) f[1] = 0;
a[j] += mn * getn(s[j][k]);
mn *= i;
}
}
if (f[1] && a[0] <= 23 && a[1] <= 59) {
cout << i << ' ';
f[0] = 0;
}
}
if (f[0]) cout << 0 << endl;
} else {
if (getn(s[0][s[0].size() - 1]) <= 23)
cout << -1;
else
cout << 0;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool isprime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string st;
cin >> st;
long long int l = st.length();
long long int p = st.find(':');
long long int x, q = 0, Min = 0;
for (long long int i = 0; i < l; i++) {
if (st[i] == ':') continue;
x = st[i] - 48;
if (x > 9) x -= 7;
q = max(q, x);
}
q += 1;
long long int b[2];
long long int k = 0;
b[0] = 0;
b[1] = 0;
long long int c = 0;
for (long long int i = q; i <= 60; i++) {
k = 0;
b[0] = 0;
b[1] = 0;
for (long long int j = 0; j < l; j++) {
if (st[j] == ':') {
k += 1;
continue;
}
x = st[j] - 48;
if (x > 9) x -= 7;
q = max(q, x);
b[k] = b[k] * i + x;
}
if (b[0] <= 23 && b[1] < 60)
c++;
else
break;
}
if (c == 0) {
cout << 0 << endl;
return 0;
}
long long int s[2] = {0};
k = 0;
for (long long int i = 0; i < l; i++) {
if (st[i] == ':') {
k++;
continue;
}
x = st[i] - 48;
if (x > 9) x -= 7;
q = max(q, x);
s[k] = s[k] * 100 + x;
}
if (s[0] < 24 && s[1] < 60) {
cout << -1 << endl;
return 0;
}
for (long long int i = 0; i < c; i++) cout << q + i << " ";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1000;
long long ans[MAXN], ansN;
inline long long getval(string s, long long b) {
long long v = 1, outp = 0;
for (long long i = 0; i < s.size(); i++) {
long long t;
if (isdigit(s[i]))
t = (s[i] - '0');
else
t = (s[i] - 'A' + 10);
if (t >= b) return -1;
outp += t * v;
v *= b;
}
return outp;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
string s;
cin >> s;
bool flag = false;
string a, b;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == ':')
flag = true;
else if (!flag)
a += s[i];
else
b += s[i];
}
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
for (long long i = 1; i < 1000; i++) {
long long x = getval(a, i), y = getval(b, i);
if (x >= 0 && x < 24 && y >= 0 && y < 60) ans[ansN++] = i;
}
if (ansN > 100)
cout << -1;
else if (ansN == 0)
cout << 0;
else {
for (long long i = 0; i < ansN; i++) cout << ans[i] << " ";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int changeBase(string &see, int base) {
int ans{0};
for (auto va : see) {
ans *= base;
int add = 0;
if (va >= 'A')
add += 10 + (va - 'A');
else
add += va - '0';
if (add >= base) return 70;
ans += add;
}
return ans;
}
int main() {
string see;
cin >> see;
string part1 = "";
int i = 0;
while (see[i] != ':') {
part1 += see[i++];
if (part1.back() == '0' && part1.size() == 1) part1.pop_back();
}
++i;
string part2 = "";
while (i < see.size()) {
part2 += see[i++];
if (part2.back() == '0' && part2.size() == 1) part2.pop_back();
}
vector<int> ans;
for (int i = 1; i < 62; ++i) {
int see1 = changeBase(part1, i);
int see2 = changeBase(part2, i);
if (see1 < 24 && see2 < 60) ans.push_back(i);
}
if (!ans.size())
printf("0");
else if (ans.back() == 61)
printf("-1");
else
for (auto va : ans) printf("%d ", va);
puts("");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int biexp(long long int m, long long int n) {
long long int res = 1;
while (n > 0) {
if (n % 2) res = res * m;
m = m * m;
n = n / 2;
}
return res;
}
int main() {
int t = 1;
while (t--) {
string s;
cin >> s;
string a, b;
long long int i = 0, mi = 0;
while (s[i] != ':') {
if (s[i] == '0' and a.size() != 0)
a.push_back(s[i]);
else if (s[i] != '0')
a.push_back(s[i]);
i++;
}
i++;
while (i < s.length()) {
if (s[i] == '0' and b.size() != 0)
b.push_back(s[i]);
else if (s[i] != '0')
b.push_back(s[i]);
i++;
}
for (long long int i = 0; i < a.size(); i++) {
if (a[i] >= '0' and a[i] <= '9')
mi = max(mi, (long long int)a[i] - '0');
else
mi = max(mi, (long long int)(a[i] - 'A' + 10));
}
for (long long int i = 0; i < b.size(); i++) {
if (b[i] >= '0' and b[i] <= '9')
mi = max(mi, (long long int)b[i] - '0');
else
mi = max(mi, (long long int)(b[i] - 'A' + 10));
}
vector<long long int> v;
for (long long int i = mi + 1;; i++) {
long long int x = a.size(), h = 0, min = 0, j = 0;
while (x > 0) {
if (a[a.size() - x] >= '0' and a[a.size() - x] <= '9')
h = h + biexp(i, x - 1) * (a[a.size() - x] - '0');
else
h = h + biexp(i, x - 1) * (a[a.size() - x] - 'A' + 10);
x--;
}
x = b.size();
while (x > 0) {
if (b[b.size() - x] >= '0' and b[b.size() - x] <= '9')
min = min + biexp(i, x - 1) * (b[b.size() - x] - '0');
else
min = min + biexp(i, x - 1) * (b[b.size() - x] - 'A' + 10);
x--;
}
if (h > 23 or min > 59)
break;
else
v.push_back(i);
if (v.size() > 100) break;
}
if (v.size() > 100)
cout << -1;
else if (v.size() == 0) {
cout << 0;
} else {
for (long long int i = 0; i < v.size(); i++) cout << v[i] << " ";
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
string hours;
string minutes;
bool flag = false;
bool containsAlpha = false;
int maxVal = INT_MIN;
for (int i = 0; i < a.length(); i++) {
if ((a[i] != ':') && (flag == false)) {
hours += a[i];
} else if (a[i] == ':') {
flag = true;
continue;
} else {
minutes += a[i];
}
if (a[i] <= '9') {
maxVal = max(maxVal, a[i] - '0');
} else {
maxVal = max(maxVal, 10 + (a[i] - 'A'));
}
}
while (hours[0] == '0') {
hours = hours.substr(1);
}
while (minutes[0] == '0') {
minutes = minutes.substr(1);
}
vector<int> ans;
if ((hours.length() <= 1) && (minutes.length() <= 1)) {
if ((hours.length() == 0) || ((hours[0] >= '0') && (hours[0] <= '9')) ||
((hours[0] >= 'A') && (hours[0] <= 'N'))) {
cout << "-1";
return 0;
}
}
int i = maxVal + 1;
bool flag2 = false;
for (;; i++) {
int hour = 0;
int minute = 0;
for (int j = hours.size() - 1; j >= 0; j--) {
int val = 0;
if ((hours[j] >= '0') && (hours[j] <= '9')) {
val = hours[j] - '0';
} else {
val = 10 + (hours[j] - 'A');
}
hour += val * (pow(i, (hours.size() - 1) - j));
}
for (int j = minutes.size() - 1; j >= 0; j--) {
int val = 0;
if ((minutes[j] >= '0') && (minutes[j] <= '9')) {
val = minutes[j] - '0';
} else {
val = 10 + (minutes[j] - 'A');
}
minute += val * (pow(i, (minutes.size() - 1) - j));
}
if ((minute > 59) || (hour > 23)) {
break;
}
cout << i << " ";
flag2 = true;
}
if (!flag2) {
cout << "0";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long linf = 1 << 60;
vector<int> ans;
bool check(string& a, string& b, int& d) {
long long h = 0;
for (int i = 0; i < ((int)(a).size()); ++i) {
h *= d;
if ('0' <= a[i] && a[i] <= '9') {
h += a[i] - '0';
} else {
h += a[i] - 'A' + 10;
}
if (h > 23 || (a[i] >= 'A' && a[i] - 'A' + 10 >= d) ||
(a[i] < 'A' && a[i] - '0' >= d)) {
return 0;
}
}
long long m = 0;
for (int i = 0; i < ((int)(b).size()); ++i) {
m *= d;
if ('0' <= b[i] && b[i] <= '9') {
m += b[i] - '0';
} else {
m += b[i] - 'A' + 10;
}
if (m > 59 || (b[i] >= 'A' && b[i] - 'A' + 10 >= d) ||
(b[i] < 'A' && b[i] - '0' >= d)) {
return 0;
}
}
return 1;
}
int main() {
string s;
cin >> s;
string a, b;
bool fl = 0;
for (int i = 0; i < ((int)(s).size()); ++i) {
if (s[i] == ':') {
fl = 1;
} else if (!fl) {
a += s[i];
} else {
b += s[i];
}
}
for (int d = 2; d < 1000; ++d) {
if (check(a, b, d)) {
ans.push_back(d);
}
}
if (((int)(ans).size()) > 500) {
cout << "-1\n";
return 0;
}
if (((int)(ans).size()) == 0) {
cout << "0";
}
for (int i = 0; i < ((int)(ans).size()); ++i) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int toDec(string s, int base) {
int n = s.length();
int res = 0;
for (int i = 0; i < n; i++) {
res *= base;
int k = 0;
if (s[i] >= '0' && s[i] <= '9')
k = s[i] - '0';
else
k = s[i] - 'A' + 10;
if (res > 60) return 999;
if (k >= base)
return 999;
else
res += k;
}
return res;
}
vector<int> v;
int main() {
char c1[64];
char c2[64];
cin.getline(c1, 64, ':');
cin.getline(c2, 64);
string s1(c1), s2(c2);
for (int i = 2; i < 500; i++) {
int k1 = toDec(s1, i);
int k2 = toDec(s2, i);
if (k1 < 24 && k2 < 60) v.push_back(i);
}
if (v.size() == 0)
cout << 0;
else if (v[v.size() - 1] == 499)
cout << -1;
else {
for (int i = 0; i < v.size(); i++) cout << v[i] << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-9;
int bit_count(int first) {
return first == 0 ? 0 : 1 + bit_count(first & (first - 1));
}
inline int low_bit(int first) { return first & -first; }
inline int sign(double first) {
return first < -EPS ? -1 : first > EPS ? 1 : 0;
}
inline int sign(int first) { return (first > 0) - (first < 0); }
int nextComb(int first) {
if (!first) {
fprintf(stderr, "nextComb(0) called\n");
return ((1 << 30) - 1 + (1 << 30));
}
int smallest = first & -first;
int ripple = first + smallest;
int ones = first ^ ripple;
ones = (ones >> 2) / smallest;
return ripple | ones;
}
template <class T>
inline T gcd(T a, T b) {
a = abs(a);
b = abs(b);
while (b) {
int r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
inline int getInt() {
int a;
return scanf("%d", &a) ? a : (fprintf(stderr, "trying to read\n"), -1);
}
inline double getDouble() {
double a;
return scanf("%lf", &a) ? a : (fprintf(stderr, "trying to read\n"), -1.0);
}
inline double myRand() {
return ((double)rand() / RAND_MAX) + ((double)rand() / RAND_MAX / RAND_MAX);
}
inline string getLine() {
string ret;
getline(cin, ret, ':');
return ret;
}
long long process(string s, int base) {
long long ret = 0;
for (int i = (int)0; i < (int)((int)(s).size()); ++i) {
ret *= base;
if (isdigit(s[i]))
ret += s[i] - '0';
else
ret += s[i] - 'A' + 10;
}
return ret;
}
bool isValid(string s, int base) {
for (int i = (int)0; i < (int)((int)(s).size()); ++i) {
if (isdigit(s[i]) && s[i] - '0' >= base)
return false;
else if (s[i] - 'A' + 10 >= base)
return false;
}
return true;
}
void myCode() {
string hrs, mins;
getline(cin, hrs, ':');
getline(cin, mins);
vector<int> ret;
if (((int)(hrs).size()) < 6 && ((int)(mins).size()) < 7) {
for (int i = (int)2; i < (int)100; ++i) {
if (isValid(hrs, i) == true && isValid(mins, i) == true) {
if (process(hrs, i) < 24 && process(mins, i) < 60) {
ret.push_back(i);
}
}
}
}
if (ret.empty())
printf("0\n");
else if (ret[((int)(ret).size()) - 1] == 99)
printf("-1\n");
else
for (int i = (int)0; i < (int)((int)(ret).size()); ++i)
printf("%d%c", ret[i], i == ((int)(ret).size()) - 1 ? '\n' : ' ');
}
int main() {
srand(time(NULL));
myCode();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
string s;
string st1 = "", st2 = "";
cin >> s;
vector<int> ans;
int n = s.size();
int cnt1 = 0, nz1 = 0, cnt2 = 0, nz2 = 0;
int i = 0;
while (s[i] != ':') {
cnt1++;
if (s[i] == '0') nz1++;
st1 += s[i];
i++;
}
i++;
while (i < n) {
cnt2++;
st2 += s[i];
if (s[i] == '0') nz2++;
i++;
}
if (nz1 == cnt1 && nz2 == cnt2)
cout << -1 << "\n";
else if ((nz1 == (cnt1 - 1) && nz2 == cnt2) &&
((st1[st1.size() - 1] <= 'N' && st1[st1.size() - 1] != '0'))) {
cout << -1 << "\n";
} else if ((nz1 == (cnt1) && nz2 == (cnt2 - 1)) &&
((st2[st2.size() - 1] != '0'))) {
cout << -1 << "\n";
} else if ((nz1 == (cnt1 - 1) && nz2 == (cnt2 - 1)) &&
((st1[st1.size() - 1] != '0' && st2[st2.size() - 1] != '0' &&
st1[st1.size() - 1] <= 'N'))) {
cout << -1 << "\n";
} else {
int str = 3;
int cmp = -1;
for (int i = 0; i < s.size(); i++)
if (s[i] > cmp && s[i] != ':') cmp = s[i];
cmp -= 48;
if (cmp <= 9)
str = cmp + 1;
else
str = cmp + 48 - 65 + 10 + 1;
while (true) {
int calc1 = 0, calc2 = 0;
int nm = 1;
for (int j = st1.size() - 1; j >= 0; j--) {
if (st1[j] <= '9') {
int md = st1[j] - 48;
calc1 += md * nm;
} else {
int md = st1[j] - 65 + 10;
calc1 += md * nm;
}
nm = nm * str;
}
nm = 1;
for (int j = st2.size() - 1; j >= 0; j--) {
if (st2[j] <= '9') {
int md = st2[j] - 48;
calc2 += md * nm;
} else {
int md = st2[j] - 65 + 10;
calc2 += md * nm;
}
nm = nm * str;
}
if (calc1 < 24 && calc2 < 60)
ans.push_back(str);
else
break;
str++;
}
if (ans.size() == 0)
cout << 0 << "\n";
else {
for (int j = 0; j < ans.size(); j++) cout << ans[j] << " ";
cout << "\n";
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string aa;
cin >> aa;
int y = aa.find(':');
string a = aa.substr(0, y);
string b = aa.substr(y + 1);
vector<int> c;
for (int t = 1; t < 65; t++) {
int hr = 0, mi = 0;
int meow = 0;
for (int i = 0; i < max(a.size(), b.size()); i++) {
if (i < a.size()) {
int x = a[i] - 48;
if (x > 9) {
x = x - 7;
}
if (x >= t) {
meow++;
}
int z = a.size();
int y = pow(t, z - 1 - i);
hr = hr + y * x;
}
if (i < b.size()) {
int x = b[i] - 48;
if (x > 9) {
x = x - 7;
}
if (x >= t) {
meow++;
}
int z = b.size();
int y = pow(t, z - 1 - i);
mi = mi + y * x;
}
}
if (hr >= 0 && hr < 24 && mi >= 0 && mi < 60 && meow == 0) {
c.push_back(t);
}
}
if (c.size() == 0) {
cout << 0;
exit(0);
}
if (c[c.size() - 1] == 64) {
cout << -1;
exit(0);
}
for (auto x : c) {
cout << x << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ans[100];
char tp[300];
string ch;
int cal(string a, int base) {
int ans = 0;
for (int i = 0; i < a.size(); i++) {
if (tp[a[i]] >= base)
return -1;
else {
ans *= base;
ans += tp[a[i]];
}
}
return ans;
}
int main() {
for (int i = 0; i < 10; i++) tp['0' + i] = i;
for (int i = 0; i < 26; i++) tp['A' + i] = 10 + i;
while (cin >> ch) {
int flag;
for (int i = 0; i < ch.size(); i++)
if (ch[i] == ':') {
flag = i;
break;
}
string a = ch.substr(0, flag), b = ch.substr(flag + 1);
int n = 0;
for (int i = 1; i <= 101; i++) {
int H = cal(a, i), M = cal(b, i);
if (H < 0 || M < 0 || H > 23 || M > 59)
continue;
else {
ans[n++] = i;
if (i == 101) {
cout << -1 << endl;
return 0;
}
}
}
if (n == 0)
cout << 0 << endl;
else {
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
int n, col[5005];
int cnt[5005], ans[5005];
int main() {
string line;
cin >> line;
string left, right;
bool wasDw = false;
for (int i = 0; i < line.size(); i++) {
if (line[i] == ':') wasDw = true;
if (wasDw)
right += line[i];
else
left += line[i];
}
map<char, int> dig;
for (char i = '0'; i <= '9'; i++) {
dig[i] = i - '0';
}
for (int i = 'A'; i <= 'Z'; i++) {
dig[i] = i - 'A' + 10;
}
vector<int> goodBases;
for (int base = 1; base <= 65; base++) {
int hour = 0;
bool bad = false;
for (char c : left) {
(c, dig[c]);
hour = base * hour + dig[c];
if (dig[c] >= base || hour >= 24) {
bad = true;
}
}
(hour);
int minute = 0;
for (char c : right) {
minute = base * minute + dig[c];
if (dig[c] >= base || minute >= 60) {
bad = true;
}
}
if (bad) continue;
goodBases.push_back(base);
}
if (!goodBases.empty() && goodBases.back() == 65) {
printf("-1\n");
} else {
if (goodBases.empty()) {
printf("0\n");
return 0;
}
for (auto c : goodBases) {
printf("%d ", c);
}
printf("\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, a, b, c;
cin >> s;
map<char, int> A;
int p = 0;
for (char i = '0'; i <= '9'; i++) {
A[i] = p;
p++;
}
for (char i = 'A'; i <= 'Z'; i++) {
A[i] = p;
p++;
}
a = s.substr(0, s.find(':'));
b = s.substr(s.find(':') + 1, s.length() - s.find(':'));
while (a.length() > 1 && a[0] == '0') a.erase(0, 1);
while (b.length() > 1 && b[0] == '0') b.erase(0, 1);
c = a + b;
char w = c[0];
for (int i = 1; i < c.length(); i++)
if (c[i] > w) w = c[i];
int pos = A[w] + 1;
int size = 0;
if (a.length() == 1 && b.length() == 1 && A[a[0]] < 24 && A[b[0]] < 60)
cout << -1;
else {
for (int i = pos; i <= 60; i++) {
int h = 0, m = 0;
for (int j = 0; j < a.length(); j++) {
h = h * i + A[a[j]];
}
for (int j = 0; j < b.length(); j++) {
m = m * i + A[b[j]];
}
if (h < 24 && m < 60) size++, cout << i << ' ';
}
if (!size) cout << 0;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
char s[N], a[N], b[N];
map<pair<long, long>, bool> f;
vector<int> ans;
long long get(char s[], int base) {
long long res = 0;
for (int i = 0; s[i]; i++) {
int t;
if (s[i] >= '0' && s[i] <= '9')
t = s[i] - '0';
else
t = s[i] - 'A' + 10;
if (t >= base) return 61;
res = res * base + t;
}
return res;
}
int main() {
scanf("%s", s);
for (int i = 0; s[i]; i++) {
if (s[i] == ':') break;
a[i] = s[i];
}
for (int i = 0, j = 0, p = 0; s[i]; i++) {
if (j) b[p++] = s[i];
if (s[i] == ':') j = 1;
}
for (int i = (2); i < (101); i++) {
long long x = get(a, i), y = get(b, i);
if (x < 24 && y < 60) {
if (f.count(make_pair(x, y))) return 0 * puts("-1");
f[make_pair(x, y)] = 1;
ans.push_back(i);
}
}
for (int i = (0); i < ((int)ans.size()); i++) printf("%d ", ans[i]);
if ((int)ans.size() == 0) puts("0");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool check(int base, string s, int limit) {
int val, res = 0;
for (typeof(0) i = (0); i < (((int)(s).size())); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z')
val = s[i] - 'A' + 10;
else
val = s[i] - '0';
res = res * base + val;
}
return res <= limit;
}
int main() {
string s, min, sec;
while (cin >> s) {
int x = s.find(':');
min = s.substr(0, x);
sec = s.substr(x + 1);
int i = 0;
while (min[i] == '0') ++i;
min = min.substr(i);
i = 0;
while (sec[i] == '0') ++i;
sec = sec.substr(i);
int base, ma = 0, val, ma2 = 0;
if (((int)(min).size()) <= 1 && ((int)(sec).size()) <= 1) {
bool ok = true;
for (typeof(0) i = (0); i < (((int)(min).size())); ++i)
if (min[i] - 'A' > 13) {
puts("0");
ok = false;
}
if (ok) puts("-1");
continue;
}
ma = *max_element((min).begin(), (min).end());
if (ma >= '0' && ma <= '9')
ma -= '0';
else if (ma >= 'A' && ma <= 'Z')
ma = ma - 'A' + 10;
ma2 = *max_element((sec).begin(), (sec).end());
if (ma2 >= '0' && ma2 <= '9')
ma2 -= '0';
else if (ma2 >= 'A' && ma2 <= 'Z')
ma2 = ma2 - 'A' + 10;
base = max(ma, ma2) + 1;
if (!check(base, min, 23) || !check(base, sec, 59)) {
puts("0");
continue;
} else {
for (int b = base; b < 60; ++b) {
if (check(b, min, 23) && check(b, sec, 59))
printf("%d ", b);
else
break;
}
printf("\n");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int sti(string x, int b) {
int r = 0;
int p = 1;
int d;
for (int i = 0; i < x.size(); i++) {
if (x[i] >= 'A' && x[i] <= 'Z')
d = x[i] - 'A' + 10;
else
d = x[i] - '0';
r += d * p;
p *= b;
}
return r;
}
int main() {
string s;
cin >> s;
int p = s.find(":");
string h = s.substr(0, p);
string m = s.substr(p + 1);
reverse(h.begin(), h.end());
reverse(m.begin(), m.end());
int bg = 1;
int d;
for (int i = 0; i < h.size(); i++) {
if (h[i] >= 'A' && h[i] <= 'Z')
d = h[i] - 'A' + 10;
else
d = h[i] - '0';
bg = max(d + 1, bg);
}
for (int i = 0; i < m.size(); i++) {
if (m[i] >= 'A' && m[i] <= 'Z')
d = m[i] - 'A' + 10;
else
d = m[i] - '0';
bg = max(d + 1, bg);
}
vector<int> anw;
for (int i = bg; i < 70; i++) {
int hh = sti(h, i);
int mm = sti(m, i);
if (hh <= 23 && mm <= 59) {
anw.push_back(i);
if (i > 60) {
cout << -1 << endl;
return 0;
}
}
}
if (anw.size() == 0)
cout << 0 << endl;
else {
for (int i = 0; i < anw.size(); i++) {
if (i != 0) cout << ' ';
cout << anw[i];
}
cout << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Tnum {
int a[1000];
int l;
};
int getnum(char *te, Tnum &b) {
int l = strlen(te);
b.l = 0;
int minn = 0;
for (int i = l - 1; i >= 0; --i) {
if (isalpha(te[i]))
b.a[b.l++] = te[i] - 'A' + 10;
else
b.a[b.l++] = te[i] - '0';
if (b.a[b.l - 1] > minn) minn = b.a[b.l - 1];
}
while (b.l > 1 && b.a[b.l - 1] == 0) b.l--;
return minn;
}
int getvalue(const Tnum &a, int base) {
int summ = 0;
int pe = 1;
for (int i = 0; i < a.l; ++i) {
summ += a.a[i] * pe;
pe *= base;
if (summ > 60) return summ;
}
return summ;
}
char temp[200];
char t1[200], t2[200];
int l, r = 0;
Tnum nidong, nidong2;
int main() {
scanf("%s", temp);
int i;
for (i = 0; temp[i] != ':'; ++i) t1[i] = temp[i];
t1[i] = 0;
int ni = i;
for (i++; temp[i]; ++i) t2[i - ni - 1] = temp[i];
t2[i] = 0;
l = getnum(t1, nidong) + 1;
int te = getnum(t2, nidong2) + 1;
if (te > l) l = te;
if (nidong.l <= 1 && nidong2.l <= 1 && nidong.a[0] < 24 && nidong2.a[0] < 60)
puts("-1");
else {
r = 0;
if (nidong.l > 1) {
for (int i = l;; ++i) {
if (getvalue(nidong, i) > 23) {
r = i - 1;
break;
}
}
}
if (nidong2.l > 1) {
for (int i = l;; ++i) {
if (getvalue(nidong2, i) > 59) {
if (i - 1 < r || r == 0) r = i - 1;
break;
}
}
}
if (r < l)
puts("0");
else {
printf("%d", l);
for (int i = l + 1; i <= r; ++i) printf(" %d", i);
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char str[20];
char a[20], b[20];
int la, lb;
void get(char *ss, int s, int t) {
int i;
for (i = s; i < t; i++)
if (str[i] != '0') break;
int k = 0;
for (; i < t; i++) ss[k++] = str[i];
if (k == 0) ss[k++] = '0';
ss[k] = '\0';
}
int Pow(int a, int n) {
int ans = 1;
while (n) {
if (n & 1) ans = ans * a;
a = a * a;
n >>= 1;
}
return ans;
}
int Count(int bit, int len, char *s) {
int sum = 0;
for (int i = len - 1, k = 0; i >= 0; i--, k++) {
int num;
if (s[i] >= 'A' && s[i] <= 'Z')
num = s[i] - 'A' + 10;
else
num = s[i] - '0';
if (bit <= num) return 0x3f3f3f3f;
sum = sum + num * Pow(bit, k);
}
return sum;
}
int main() {
scanf("%s", str);
int len = strlen(str);
int pos = -1;
for (int i = 0; i < len; i++) {
if (str[i] == ':') {
pos = i;
break;
}
}
get(a, 0, pos);
get(b, pos + 1, len);
la = strlen(a);
lb = strlen(b);
int cnt = 0;
if (((la == 1 || la == 2) && Count(100, la, a) <= 23) &&
((lb == 1 || lb == 2) && Count(100, lb, b) <= 59))
printf("%d\n", (-1)), cnt = 1;
else {
for (int i = 2;; i++) {
int c1 = Count(i, la, a);
int c2 = Count(i, lb, b);
if (c1 == 0x3f3f3f3f || c2 == 0x3f3f3f3f)
continue;
else if (c1 > 23 || c2 > 59)
break;
else if (c1 <= 23 && c2 <= 59) {
if (cnt) printf(" ");
printf("%d", i);
cnt++;
}
}
}
if (cnt == 0) printf("%d\n", (0));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int SOD(long long int n) {
long long int sum = 0;
while (n > 0) {
sum = sum + n % 10;
n /= 10;
}
return sum;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int pow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b % 2 == 1) res *= a;
a *= a;
b /= 2;
}
return res;
}
long long int powmod(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y % 2 == 1) res = (res * x) % p;
y /= 2;
x = (x * x) % p;
}
return res;
}
string dectobin(long long int x) {
string s = "";
while (x > 0) {
long long int t = x % 2;
s.push_back(t + '0');
x /= 2;
}
reverse(s.begin(), s.end());
return s;
}
long long int bintodec(string s) {
long long int ans = 0;
long long int n = s.size();
for (long long int i = n - 1; i >= 0; i--) {
if (s[i] == '1') ans += pow(2, n - i - 1);
}
return ans;
}
long long int solve(string a, long long int base) {
long long int ans = 0;
long long int n = a.size();
for (long long int i = n - 1; i >= 0; i--) {
long long int x;
char y = a[i];
if (y - '0' <= 9)
x = y - '0';
else
x = y - 'A' + 10;
ans += (x * pow(base, n - i - 1));
}
return ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
string a, b;
long long int i = 0;
while (s[i] != ':') {
a.push_back(s[i]);
i++;
}
b = s.substr(i + 1);
bool flag = 1;
if (a.size() > 1) {
for (long long int i = 0; i <= a.size() - 1 - 1; i++) {
if (a[i] != '0') flag = 0;
}
}
if (flag) {
if (b.size() > 1) {
for (long long int i = 0; i <= b.size() - 1 - 1; i++) {
if (b[i] != '0') flag = 0;
}
}
if (flag) {
if ((long long int)a[a.size() - 1] <= 78) {
cout << -1 << "\n";
return 0;
}
}
}
char maxi = '0';
for (long long int j = 0; j <= a.size() - 1; j++) {
maxi = max(maxi, a[j]);
}
for (long long int j = 0; j <= b.size() - 1; j++) {
maxi = max(maxi, b[j]);
}
long long int base;
if (maxi == '9')
base = 10;
else if ((long long int)maxi >= 65)
base = maxi - 'A' + 11;
else
base = maxi - '0' + 1;
vector<long long int> ans;
long long int hr = solve(a, base);
long long int min = solve(b, base);
while (0 <= hr and hr < 24 and 0 <= min and min < 60) {
ans.push_back(base);
base++;
hr = solve(a, base);
min = solve(b, base);
}
if (ans.size() == 0)
cout << 0;
else {
for (auto i : ans) cout << i << " ";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
map<char, int> m;
int con(string s, int x) {
reverse(s.begin(), s.end());
int p = 1;
for (int i = 0; i < s.length(); i++)
if (m[s[i]] >= x) return 100;
int y;
int ans = 0;
for (int i = 0; i < s.length(); i++) {
if (ans >= 60) return 100;
ans += m[s[i]] * p;
p *= x;
}
return ans;
}
int main() {
string s;
cin >> s;
for (int i = 0; i < 10; i++) m[char(i + '0')] = i;
for (int i = 'A'; i <= 'Z'; i++) m[char(i)] = i - 'A' + 10;
string a, b;
bool dn = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ':') {
dn = true;
continue;
}
if (dn == false)
a += s[i];
else
b += s[i];
}
for (int i = 2; i <= 100; i++) {
if (con(a, i) < 24 && con(b, i) < 60) ans.push_back(i);
}
if (ans.size() == 0)
cout << 0 << endl;
else if (ans[ans.size() - 1] == 100)
cout << -1 << endl;
else
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag1 = 0, flag2 = 0, j = 0, k = 0, ma = 0, end = 0;
int a[5], b[5], i;
vector<int> ans;
string s;
cin >> s;
int lenth = s.size();
for (i = 0; s[i] != ':'; i++) {
if (flag1 == 0) {
if (s[i] != '0') {
flag1 = 1;
if (s[i] <= '9' && s[i] >= '0')
a[j++] = s[i] - '0';
else
a[j++] = s[i] - 'A' + 10;
if (a[j - 1] != 0) ma = max(a[j - 1], ma);
}
} else {
if (s[i] <= '9' && s[i] >= '0')
a[j++] = s[i] - '0';
else
a[j++] = s[i] - 'A' + 10;
if (a[j - 1] != 0) ma = max(a[j - 1], ma);
}
}
i++;
for (; i < lenth; i++) {
if (flag2 == 0) {
if (s[i] != '0') {
flag2 = 1;
if (s[i] <= '9' && s[i] >= '0')
b[k++] = s[i] - '0';
else
b[k++] = s[i] - 'A' + 10;
if (b[k - 1] != 0) ma = max(b[k - 1], ma);
}
} else {
if (s[i] <= '9' && s[i] >= '0')
b[k++] = s[i] - '0';
else
b[k++] = s[i] - 'A' + 10;
if (b[k - 1] != 0) ma = max(b[k - 1], ma);
}
}
if (j <= 1 && k <= 1) {
if (a[0] <= 23 || j == 0) {
cout << "-1" << endl;
return 0;
}
}
for (i = ma + 1;; i++) {
double temp = 0;
for (int l = 0; l < j; l++) {
temp += a[l] * pow((double)i, j - l - 1);
}
if (temp > 23) break;
temp = 0;
for (int l = 0; l < k; l++) {
temp += b[l] * pow((double)i, k - l - 1);
}
if (temp > 59) break;
end = i;
}
if (end == 0)
cout << "0" << endl;
else {
for (i = ma + 1; i <= end; i++) cout << i << " ";
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int xx[] = {1, 1, 1, 0, -1, -1, -1, 0};
int yy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
long long int gcd(long long int a, long long int b) {
return ((a % b == 0) ? b : gcd(b, a % b));
}
int cal(int mal, int times) {
int h = 1, i;
for (i = 0; i < times; i++) h = h * mal;
return h;
}
int main() {
int i, j, len, tmp;
map<char, int> my;
vector<int> res;
for (i = 0; i < 10; i++) {
my[(char)(i + 48)] = i;
}
for (i = 0; i < 26; i++) {
my[(char)(i + 65)] = i + 10;
}
bool f = true;
string str, s1, s2;
cin >> str;
len = str.size();
for (i = 0; i < len; i++) {
if (str[i] == ':') {
f = false;
continue;
}
if (f)
s1 += str[i];
else
s2 += str[i];
}
len = s1.size();
for (i = 0; i < len; i++) {
if (s1[i] == '0') {
s1.erase(s1.begin());
i--;
} else
break;
}
len = s2.size();
for (i = 0; i < len; i++) {
if (s2[i] == '0') {
s2.erase(s2.begin());
i--;
} else
break;
}
tmp = 0;
reverse(s1.begin(), s1.end());
reverse(s2.begin(), s2.end());
for (i = 0; i < s1.size(); i++) {
tmp = max(my[s1[i]], tmp);
}
for (i = 0; i < s2.size(); i++) {
tmp = max(my[s2[i]], tmp);
}
int m, n, l1, l2;
l1 = s1.size();
l2 = s2.size();
for (i = tmp + 1; i <= 70; i++) {
m = n = 0;
for (j = 0; j < l1; j++) {
m += (cal(i, j) * my[s1[j]]);
}
for (j = 0; j < l2; j++) {
n += (cal(i, j) * my[s2[j]]);
}
if (m < 24 && n < 60) {
res.push_back(i);
}
}
if (res.size() == 0) {
printf("0\n");
return 0;
}
if (res[res.size() - 1] == 70) {
printf("-1\n");
return 0;
}
l1 = res.size();
for (i = 0; i < l1; i++) {
cout << res[i] << " ";
}
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
char s[50], c[10], *pch;
long long a[500], hlen, mlen, h[500], m[500];
int mo, ho;
int ldig(char *x) {
int i;
int mx = 0;
for (i = 0; x[i]; i++) {
if (isdigit(x[i])) {
if (x[i] - '0' > mx) mx = x[i] - '0';
} else if (isalpha(x[i])) {
if ((x[i] - 'A') + 10 > mx) mx = (x[i] - 'A') + 10;
}
}
return mx;
}
int hour(int n) {
int i;
long long tot = 0, po = 1;
for (i = hlen - 1; i >= 0; i--) {
if (isdigit(c[i])) {
tot += (c[i] - '0') * po;
} else if (isalpha(c[i])) {
tot += ((c[i] - 'A') + 10) * po;
}
po *= n;
}
if (tot < 24) {
h[ho++] = tot;
return 1;
} else
return 0;
}
int minute(int n) {
int i;
long long tot = 0, po = 1;
for (i = mlen - 1; i >= 0; i--) {
if (isdigit(pch[i])) {
tot += (pch[i] - '0') * po;
} else if (isalpha(pch[i])) {
tot += ((pch[i] - 'A') + 10) * po;
}
po *= n;
}
if (tot < 60) {
m[mo++] = tot;
return 1;
} else
return 0;
}
int main() {
int i, n, fou = 0;
scanf("%s", &s);
pch = strtok(s, ":");
strcpy(c, pch);
pch = strtok(NULL, ":");
n = ldig(c);
fou = ldig(pch);
hlen = strlen(c);
mlen = strlen(pch);
if (fou > n) n = fou;
n++;
i = 0;
mo = 0;
ho = 0;
for (; n < 60; n++) {
if (hour(n) && minute(n))
a[i++] = n;
else
break;
}
if (n == 60) {
n = ho;
for (i = 0; i < n - 1; i++) {
if (h[i] != h[i + 1]) break;
if (m[i] != m[i + 1]) break;
}
if (i == n - 1)
puts("-1");
else {
i = 0;
while (i < n) {
if (i) printf(" ");
printf("%d", a[i]);
i++;
}
}
} else if (i == 0)
puts("0");
else {
n = i;
for (i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", a[i]);
}
puts("");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s;
int B, b[300], p[200], n, k, i, h, hs, a[1000100], l, sum, sumh, m, mx;
int main() {
cin >> s;
k = s.find(':');
mx = 0;
for (i = 0; i < k; i++) {
if (isdigit(s[i]))
a[i] = s[i] - '0';
else
a[i] = 10 + s[i] - 'A';
if (a[i] > mx) mx = a[i];
}
for (i = k + 1; i < s.size(); i++) {
if (isdigit(s[i]))
b[i] = s[i] - '0';
else
b[i] = 10 + s[i] - 'A';
if (b[i] > mx) mx = b[i];
}
for (B = mx + 1; B < 62; B++) {
m = 1;
sumh = 0;
for (i = k - 1; i >= 0; i--) {
sumh += a[i] * m;
m *= B;
}
m = 1;
sum = 0;
for (i = s.size() - 1; i > k; i--) {
sum += b[i] * m;
m *= B;
}
if (sumh < 24 && sum < 60) {
p[l] = B;
l++;
}
}
if (l == 0)
cout << 0 << endl;
else if (p[l - 1] == 61)
cout << -1 << endl;
else {
for (i = 0; i < l; i++) cout << p[i] << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
char t[10000];
int l;
bool isOk(int n) {
int s = 0, m = 0, q = 0;
for (int i = 0; i < l; i++) {
if (t[i] == 50) {
q = 1;
continue;
}
if (t[i] >= n) return false;
if (q)
m = m * n + t[i];
else
s = s * n + t[i];
if (s > 23 || m > 59) return false;
}
return true;
}
int main() {
gets(t);
l = strlen(t);
for (int i = 0; i < l; i++)
t[i] = '0' <= t[i] && t[i] <= '9' ? (t[i] - '0')
: ('A' <= t[i] && t[i] <= 'Z') ? (t[i] - 'A' + 10)
: 50;
if (isOk(100)) {
printf("%d\n", -1);
return 0;
}
int c = 0;
for (int i = 1; i <= 61; i++)
if (isOk(i)) printf("%d ", i), c++;
if (!c) puts("0");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mabna(string a, int m) {
int ans = 0;
int d = 1;
for (int i = a.size() - 1; i > -1; i--) {
if (a.at(i) < 58) {
ans += (a.at(i) - 48) * d;
} else {
ans += (a.at(i) - 55) * d;
}
if (ans >= 60) {
return 61;
}
d *= m;
}
return ans;
}
int main() {
string s;
cin >> s;
string a, b;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) == ':') {
a = s.substr(0, i);
b = s.substr(i + 1, s.size() - i);
}
}
bool isans = false;
int start = 1;
for (int i = 0; i < s.size(); i++) {
if (s.at(i) != ':') {
if (s.at(i) < 58 and s.at(i) - 48 > start)
start = s.at(i) - 48;
else if (s.at(i) - 55 > start)
start = s.at(i) - 55;
}
}
if (mabna(a, 60) < 24 and mabna(b, 60) < 60)
cout << -1;
else {
for (int i = start + 1; i <= 60; i++) {
if (mabna(a, i) < 24 and mabna(b, i) < 60) {
cout << i << " ";
isans = true;
} else {
break;
}
}
if (!isans) cout << 0;
}
cout << endl;
return 0;
}
| 8 | CPP |
import string
import re
values={str(d): d for d in range(10) }
for ch in string.ascii_uppercase:
values[ch] = ord(ch) - 55
def convert(s, i):
x=0
for ch in s:
d = values[ch]
if d>=i:
return None
x = i*x+d
return x
match=re.match('0*(\w+):0*(\w+)',input().strip())
a,b=match.groups([1, 2])
ans = []
for i in range(2, 60):
h = convert(a, i)
m = convert(b, i)
if h == None or m == None:
continue
if h < 24 and m < 60:
ans.append(i)
if len(ans) == 0:
print(0)
elif len(a) + len(b) == 2:
print(-1)
else:
print(*ans) | 8 | PYTHON3 |
import string
import re
values = { str(d): d for d in range(10) }
for ch in string.ascii_uppercase:
values[ch] = ord(ch) - 55
def convert(s, base):
x = 0
for ch in s:
d = values[ch]
if d >= base:
return None
x = base * x + d
return x
match = re.match('0*(\w+):0*(\w+)', input().strip())
a, b = match.groups([1, 2])
feasible = []
for base in range(2, 60):
h = convert(a, base)
m = convert(b, base)
if h == None or m == None:
continue
if h < 24 and m < 60:
feasible.append(base)
if len(feasible) == 0:
print(0)
elif len(a) + len(b) == 2:
print(-1)
else:
print(' '.join(map(str, feasible)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int convert(string s, int base) {
int p = 1, res = 0;
for (int i = s.size() - 1; i >= 0; i--) {
int cur;
if (s[i] >= 'A') {
cur = s[i] - 'A' + 10;
} else {
cur = s[i] - '0';
}
res += cur * p;
p = p * base;
}
return res;
}
int main() {
string s, s1 = "", s2 = "";
cin >> s;
int i = 0;
while (s[i] != ':') {
s1 = s1 + s[i];
i++;
}
i++;
while (i < s.size()) {
s2 = s2 + s[i];
i++;
}
int max = 0;
for (int i = 0; i < s1.size(); i++) {
if (s1[i] > max) {
max = s1[i];
}
}
for (int i = 0; i < s2.size(); i++) {
if (s2[i] > max) {
max = s2[i];
}
}
if (max >= 'A') {
max = max - 'A' + 10;
} else {
max = max - '0';
}
if (convert(s1, max + 1) > 23) {
cout << "0\n";
return 0;
}
if (convert(s2, max + 1) > 59) {
cout << "0\n";
return 0;
}
while (s1.size() > 1) {
if (s1[0] == '0') {
s1.erase(s1.begin());
} else {
break;
}
}
while (s2.size() > 1) {
if (s2[0] == '0') {
s2.erase(s2.begin());
} else {
break;
}
}
if (s1.size() == 1 && s2.size() == 1) {
cout << "-1\n";
return 0;
}
int res1 = 0, res2 = 0;
int cbase = max + 1;
if (s1.size() > 1) {
while (convert(s1, cbase) < 24) {
cbase++;
res1++;
}
} else {
res1 = 1000000000;
}
cbase = max + 1;
if (s2.size() > 1) {
while (convert(s2, cbase) < 60) {
cbase++;
res2++;
}
} else {
res2 = 1000000000;
}
if (res1 < res2) {
for (int i = 0; i < res1; i++) {
cout << (max + 1 + i) << " ";
}
} else {
for (int i = 0; i < res2; i++) {
cout << (max + 1 + i) << " ";
}
}
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int mx = 0;
bool m = 0, g = 0;
int first;
for (int i = 0; i < str.size(); i++) {
if (str[i] == ':') {
first = i;
int x;
if (str[i - 1] >= 'A' && str[i - 1] <= 'Z') {
x = str[i - 1] - 55;
mx = max(mx, x);
if (x >= 24) {
m = 1;
break;
}
} else {
x = str[i - 1] - '0';
mx = max(mx, x);
if (x >= 24) {
m = 1;
break;
}
}
for (int j = i - 2; j >= 0; j--) {
if (str[j] != '0') g = 1;
if (str[j] >= 'A' && str[j] <= 'Z') {
mx = max(mx, (str[j] - 55));
} else {
mx = max(mx, (str[j] - '0'));
}
}
for (int j = i + 1; j < (str.size() - 1); j++) {
if (str[j] != '0') g = 1;
if (str[j] >= 'A' && str[j] <= 'Z') {
mx = max(mx, (str[j] - 55));
} else {
mx = max(mx, (str[j] - '0'));
}
}
if (str[str.size() - 1] >= 'A' && str[str.size() - 1] <= 'Z') {
x = str[str.size() - 1] - 55;
mx = max(mx, x);
} else {
x = str[str.size() - 1] - '0';
mx = max(mx, x);
}
break;
}
}
if (m == 1) {
cout << 0 << endl;
} else if (m == 0 && g == 0)
cout << -1 << endl;
else {
mx++;
int i;
for (i = mx;; i++) {
long long x = 0;
int k = 0;
for (int j = first - 1; j >= 0; j--, k++) {
int y;
if (str[j] >= 'A' && str[j] <= 'Z')
y = str[j] - 55;
else
y = str[j] - '0';
x += y * pow(i, k);
}
if (x >= 24) {
break;
}
x = 0;
k = 0;
for (int j = str.size() - 1; j > first; j--, k++) {
int y;
if (str[j] >= 'A' && str[j] <= 'Z')
y = str[j] - 55;
else
y = str[j] - '0';
x += y * pow(i, k);
}
if (x >= 60) break;
cout << i << " ";
}
if (i == mx)
cout << 0 << endl;
else
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int char2int(char ch) {
if (ch >= '0' && ch <= '9') return ch - '0';
return ch - 'A' + 10;
}
char buf[20], *a = NULL, *b = NULL, *ptr = NULL;
int hour, minute;
void GetHM(int radix) {
hour = minute = 0;
ptr = a;
while ((*ptr) != 0) {
hour = hour * radix + char2int(*ptr);
++ptr;
}
ptr = b;
while ((*ptr) != 0) {
minute = minute * radix + char2int(*ptr);
++ptr;
}
}
int main() {
scanf("%s", buf);
a = strtok(buf, ":");
b = strtok(NULL, ":");
int min_r = 2;
ptr = a;
while ((*ptr) != 0) {
min_r = max(min_r, char2int(*ptr) + 1);
++ptr;
}
ptr = b;
while ((*ptr) != 0) {
min_r = max(min_r, char2int(*ptr) + 1);
++ptr;
}
GetHM(min_r);
if (hour >= 24 || minute >= 60) {
printf("0\n");
return 0;
}
GetHM(60);
if (hour < 24 && minute < 60) {
printf("-1\n");
return 0;
}
bool first = true;
for (int i = min_r; i < 60; ++i) {
GetHM(i);
if (hour >= 24 || minute >= 60) continue;
if (!first)
printf(" ");
else
first = false;
printf("%d", i);
}
printf("\n");
return 0;
}
| 8 | CPP |
a={}
for x in range(10): a[str(x)]=x
for x in range(26): a[chr(ord('A')+x)]=10+x
def to10(s,n):
y=0
for c in s:
if a[c]>=n: return None
y=y*n+a[c]
return y
h,m=input().split(':')
ans=[]
for i in range(2,60):
h1,m1=to10(h,i),to10(m,i)
if h1==None or m1==None: continue
if h1<24 and m1<60: ans.append(i)
if len(ans)==0:
print(0)
else:
h2,m2=to10(h,100),to10(m,100)
if h2<24 and m2<60:
print(-1)
else:
print(*ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int f(char c) {
if (c >= 'A' && c <= 'Z')
return 10 + c - 'A';
else
return c - '0';
}
int Pow(int i, int k) {
int sum = 1;
for (int j = 0; j < k; j++) sum *= i;
return sum;
}
char a[10], b[10], c[20];
int x[10], y[10], total, mn, lx, ly, res[210];
int solve() {
int i;
for (i = mn + 1; i < 62; i++) {
int flag = 0;
int sum = 0;
for (int j = lx - 1, k = 0; j >= 0; j--, k++) {
sum += x[j] * Pow(i, k);
}
if (sum > 23) flag = 1;
sum = 0;
for (int j = ly - 1, k = 0; j >= 0; j--, k++) {
sum += y[j] * Pow(i, k);
}
if (sum > 59) flag = 1;
if (!flag) {
res[total++] = i;
if (i >= 60) return 2;
}
}
if (total == 0)
return 0;
else
return 1;
}
int main() {
scanf("%s", c);
int i, j;
for (i = 0, j = 0; i < strlen(c); i++) {
if (c[i] == ':') break;
a[j++] = c[i];
}
a[j] = '\0';
i++;
for (j = 0; i < strlen(c); i++) {
if (c[i] == ':') break;
b[j++] = c[i];
}
b[j] = '\0';
for (i = 0; i < strlen(a); i++)
if (a[i] != '0') break;
lx = 0, ly = 0;
for (; i < strlen(a); i++) x[lx++] = f(a[i]);
for (i = 0; i < strlen(b); i++)
if (b[i] != '0') break;
for (; i < strlen(b); i++) y[ly++] = f(b[i]);
mn = 0;
if (!lx) lx = 1;
if (!ly) ly = 1;
for (int i = 0; i < lx; i++)
if (mn < x[i]) mn = x[i];
for (int i = 0; i < ly; i++)
if (mn < y[i]) mn = y[i];
total = 0;
if (mn == 0) mn = 1;
int nnn = solve();
if (nnn > 1)
printf("-1\n");
else if (nnn == 0)
printf("0\n");
else {
for (i = 0; i < total; i++)
printf("%d%c", res[i], i == total - 1 ? '\n' : ' ');
}
}
| 8 | CPP |
#include <bits/stdc++.h>
char str[12];
char a[6], b[6];
int radix[59];
int convert(char a[], int len, int radix) {
int i;
int dec = 0;
for (i = 0; i < len; i++) {
int temp = ('0' <= a[i] && a[i] <= '9') ? (a[i] - '0') : (a[i] - 'A' + 10);
dec = dec * radix + temp;
}
return dec;
}
int find_max(char a[], int len) {
int i;
int max = 0;
for (i = 0; i < len; i++) {
int temp = ('0' <= a[i] && a[i] <= '9') ? (a[i] - '0') : (a[i] - 'A' + 10);
if (temp > max) max = temp;
}
return max;
}
int main() {
scanf("%s", str);
int i = 0, j = 0;
while (str[i] != ':') {
a[j++] = str[i];
i++;
}
a[j] = '\0';
j = 0;
i++;
while (str[i] != '\0') {
b[j++] = str[i];
i++;
}
b[j] = '\0';
int a_len = strlen(a);
int b_len = strlen(b);
int a_max = find_max(a, a_len);
int b_max = find_max(b, b_len);
int min = ((a_max > b_max) ? a_max : b_max) + 1;
if (min < 2) {
min = 2;
}
int a_dec = 0, b_dec = 0;
j = 0;
for (i = min; i <= 60; i++) {
a_dec = convert(a, a_len, i);
b_dec = convert(b, b_len, i);
if (a_dec < 24 && b_dec < 60) {
radix[j++] = i;
}
}
if (radix[j - 1] == 60)
printf("-1\n");
else if (j == 0)
printf("0\n");
else {
for (i = 0; i < j; i++) {
printf("%d ", radix[i]);
}
printf("\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long convert(string s, int base, map<char, int>& m) {
long long val = 0;
for (int i = 0; i < s.size(); i++) val = val * base + m[s[i]];
return val;
}
int main() {
ios::sync_with_stdio(0);
string s, a, b;
map<char, int> m;
for (int i = 0; i < 10; i++) m['0' + i] = i;
for (char i = 'A'; i <= 'Z'; i++) m[i] = 10 + i - 'A';
cin >> s;
bool f = 1;
for (int i = 0; i < s.size(); i++)
if (s[i] == ':')
f = 0;
else if (f)
a += s[i];
else
b += s[i];
int min_base = 0;
for (int i = 0; i < s.size(); i++) min_base = max(min_base, m[s[i]] + 1);
while (a[0] == '0' && a.size() > 1) a.erase(a.begin());
while (b[0] == '0' && b.size() > 1) b.erase(b.begin());
if (a.size() == 1 && b.size() == 1 && convert(a, min_base, m) <= 23 &&
convert(b, min_base, m) <= 59)
return cout << -1, 0;
vector<int> ats;
for (int base = min_base; base < 100; base++)
if (convert(a, base, m) <= 23 && convert(b, base, m) <= 59)
ats.push_back(base);
if (ats.empty()) cout << 0;
for (auto x : ats) cout << x << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int power(int a, int b) {
int z = 1;
for (int i = 0; i < b; i++) {
z *= a;
}
return z;
}
int toRadix10(string s1, int r1) {
int sum = 0;
int o = 0;
for (int i = s1.size() - 1; i >= 0; i--, o++) {
int a = (s1.at(i) >= 'A' && s1.at(i) <= 'Z') ? (int)(s1.at(i) - 'A' + 10)
: (int)(s1.at(i) - '0');
if (a >= r1) return -1;
sum += a * (power(r1, o));
}
return sum;
}
int main() {
string str;
cin >> str;
string hour = "", min = "";
bool dono = false;
bool startH = false;
bool startM = false;
for (int i = 0; i < str.size(); i++) {
if (str.at(i) == ':') {
dono = true;
continue;
}
if (!dono) {
if (str.at(i) == '0' && !startH)
continue;
else {
startH = true;
hour += str.at(i);
}
} else {
if (str.at(i) == '0' && !startM)
continue;
else {
startM = true;
min += str.at(i);
}
}
}
if (hour.size() == 0) hour = "0";
if (min.size() == 0) min = "0";
if (hour.size() == 1 && min.size() == 1) {
int hh = (hour.at(0) >= 'A' && hour.at(0) <= 'Z')
? (int)(hour.at(0) - 'A' + 10)
: (int)(hour.at(0) - '0');
int mm = (min.at(0) >= 'A' && min.at(0) <= 'Z')
? (int)(min.at(0) - 'A' + 10)
: (int)(min.at(0) - '0');
if (hh <= 23 && hh >= 0 && mm <= 59 && mm >= 0)
cout << "-1" << endl;
else
cout << "0" << endl;
return 0;
}
vector<int> R;
for (int radix = 2; true; radix++) {
int hour10 = toRadix10(hour, radix);
int min10 = toRadix10(min, radix);
if (hour10 == -1 || min10 == -1) {
continue;
}
if (!(hour10 <= 23 && hour10 >= 0)) {
break;
}
if (!(min10 <= 59 && min10 >= 0)) {
break;
}
R.push_back(radix);
}
if (R.size() == 0)
cout << "0" << endl;
else {
for (int i = 0; i < R.size(); i++) {
cout << R.at(i) << " ";
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[10], b[10];
int main() {
long l1, l2, p, i, j, k, sum, l, flag, max;
char s[100];
while (cin >> s) {
l1 = 0;
l2 = 0;
flag = 1;
max = 0;
while (s[l1] != ':') {
if (s[l1] >= '0' && s[l1] <= '9')
a[l1] = s[l1] - '0';
else
a[l1] = s[l1] - 'A' + 10;
if (max < a[l1]) max = a[l1];
l1++;
}
while (s[l1 + l2 + 1] != '\0') {
if (s[l1 + l2 + 1] >= '0' && s[l1 + l2 + 1] <= '9')
b[l2] = s[l1 + l2 + 1] - '0';
else
b[l2] = s[l1 + l2 + 1] - 'A' + 10;
if (max < b[l2]) max = b[l2];
l2++;
}
for (p = max + 1; p < 70; p++) {
sum = 0;
k = 1;
for (l = l1 - 1; l >= 0; l--) {
sum = sum + k * a[l];
k = k * p;
}
if (sum >= 24) goto F1;
sum = 0;
k = 1;
for (l = l2 - 1; l >= 0; l--) {
sum += k * b[l];
k *= p;
}
if (sum >= 60) goto F1;
}
F1:
if (p == max + 1)
cout << 0;
else if (p >= 69)
cout << -1;
else {
for (i = max + 1; i < p; i++)
if (i == max + 1)
cout << i;
else
cout << " " << i;
}
cout << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[20], a[20], b[20];
gets(s);
int i, j, k, l, m;
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == ':') {
break;
} else {
a[i] = s[i];
}
}
a[i] = '\0';
for (j = i + 1; j < l; j++) {
b[j - i - 1] = s[j];
}
b[j - i - 1] = '\0';
char max = '0';
for (k = 0; k < l; k++) {
if (s[k] != ':') {
if (max <= s[k]) {
max = s[k];
}
}
}
int start;
if (max >= '0' && max <= '9') {
start = max - '0';
} else {
start = max - 'A' + 10;
}
int flag = 0;
for (k = 0; k < (i - 1); k++) {
if (s[k] != '0') {
flag = 1;
break;
}
}
for (k = i + 1; k < (l - 1); k++) {
if (s[k] != '0') {
flag = 1;
break;
}
}
int sum, flag2;
if (flag) {
for (k = start + 1;; k++) {
sum = 0;
for (j = 0; j < i; j++) {
flag2 = 1;
if (s[j] >= '0' && s[j] <= '9') {
sum = k * sum + (s[j] - '0');
if (sum > 23) {
flag2 = 0;
break;
}
} else {
sum = k * sum + (s[j] - 'A' + 10);
if (sum > 23) {
flag2 = 0;
break;
}
}
}
if (!flag2) {
break;
}
sum = 0;
for (j = i + 1; j < l; j++) {
flag2 = 1;
if (s[j] >= '0' && s[j] <= '9') {
sum = k * sum + (s[j] - '0');
if (sum > 59) {
flag2 = 0;
break;
}
} else {
sum = k * sum + (s[j] - 'A' + 10);
if (sum > 59) {
flag2 = 0;
break;
}
}
}
if (!flag2) {
break;
} else {
printf("%d ", k);
}
}
if (k == start + 1) {
printf("0");
}
} else {
if ((s[i - 1] - 'A' + 10) >= 24 || (s[l - 1] - 'A' + 10) >= 59) {
printf("0");
} else {
printf("-1");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int parse(int base, string s) {
int i, ans = 0;
for (int i = 0; i < s.size(); i++) {
int x = ((s[i] >= 'A' && s[i] <= 'Z') ? (s[i] - 'A' + 10) : (s[i] - '0'));
if (x >= base) return -1;
ans = ans * base + x;
}
return ans;
}
int main(void) {
int i;
string s;
cin >> s;
for (i = 0;; i++)
if (s[i] == ':') break;
string H = s.substr(0, i);
string M = s.substr(i + 1);
vector<int> ans;
for (i = 2; i < 70; i++) {
int h = parse(i, H);
int m = parse(i, M);
if (h >= 0 && h < 24 && m >= 0 && m < 60) ans.push_back(i);
}
if (ans.empty()) ans.push_back(0);
int sz = ans.size();
if (ans[sz - 1] == 69) {
ans.clear();
ans.push_back(-1);
}
sz = ans.size();
for (int i = 0; i < sz; i++) {
cout << ans[i];
if (i == sz - 1)
cout << endl;
else
cout << ' ';
}
return 0;
}
| 8 | CPP |
numbers = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'A':10,'B':11,'C':12,'D':13,'E':14,'F':15,'G':16,'H':17,'I':18,'J':19,'K':20,'L':21,'M':22,'N':23,'O':24,'P':25,'Q':26,'R':27,'S':28,'T':29,'U':30,'V':31,'W':32,'X':33,'Y':34,'Z':35}
def ConvertToDecimal(number, base):
newnumber = 0
for digit in range(-1,(0-len(number))-1,-1):
if(numbers[number[digit]] >= int(base)):
return -1
newnumber += numbers[number[digit]]*(int(base)**(0-digit-1))
return newnumber
a,b = [x for x in input().split(':')]
didmake = False
if(0<=ConvertToDecimal(a,60)<=23 and 0<=ConvertToDecimal(b,60)<=59):
print(-1)
didmake = True
else:
for base in range(2,60):
if(0<=ConvertToDecimal(a,base)<=23 and 0<=ConvertToDecimal(b,base)<=59):
print(base, end = " ")
didmake = True
if not didmake:
print(0) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char str[30];
char a[10], b[10];
bool chk(int r) {
int rr = 1;
int i = strlen(a);
int j = strlen(b);
i--;
j--;
int s = 0, t = 0;
while (i >= 0) {
int tmp;
if (isdigit(a[i]))
tmp = a[i] - '0';
else
tmp = a[i] - 'A' + 10;
s += rr * tmp;
rr *= r;
if (s > 23) return false;
i--;
}
rr = 1;
while (j >= 0) {
int tmp;
if (isdigit(b[j]))
tmp = b[j] - '0';
else
tmp = b[j] - 'A' + 10;
t += rr * tmp;
rr *= r;
if (t > 59) return false;
j--;
}
return true;
}
int main() {
while (scanf("%s", str) != -1) {
int i, j;
int len = strlen(str);
j = 0;
int ma = 0, mb = 0;
int maxm = 0;
for (i = 0; i < len; i++) {
if (isdigit(str[i])) ma = max(ma, str[i] - '0');
if (isalpha(str[i])) ma = max(ma, str[i] - 'A' + 10);
if (str[i] == ':') break;
a[j++] = str[i];
}
a[j] = '\0';
for (i += 1, j = 0; i < len; i++) {
if (isdigit(str[i])) mb = max(mb, str[i] - '0');
if (isalpha(str[i])) mb = max(mb, str[i] - 'A' + 10);
b[j++] = str[i];
}
b[j] = '\0';
bool ok = 0;
int cnt = 0;
int ll = strlen(a);
bool g1 = 0, g2 = 0;
for (i = 0; i < ll; i++) {
if (a[i] != '0' && cnt == ll - 1 && i == ll - 1) {
g1 = 1;
break;
} else if (a[i] == '0')
cnt++;
}
if (cnt == ll) g1 = 1;
ll = strlen(b);
cnt = 0;
for (i = 0; i < ll; i++) {
if (b[i] != '0' && cnt == ll - 1 && i == ll - 1) {
g2 = 1;
break;
} else if (b[i] == '0')
cnt++;
}
if (cnt == ll) g2 = 1;
if (g1 && g2 && ma <= 23 && mb <= 59) {
cout << -1 << endl;
continue;
} else if (g1 && g2 && (ma > 23 || mb > 59)) {
cout << 0 << endl;
continue;
}
maxm = max(ma, mb);
for (i = maxm + 1;; i++) {
if (chk(i)) {
cout << i << " ";
ok = 1;
} else
break;
}
if (!ok) cout << 0;
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int dec(string s, int n) {
long long int r = 0, p = 0, l = s.size() - 1, tmp;
while (l >= 0) {
if (isalpha(s[l]))
tmp = s[l] - 55;
else
tmp = s[l] - 48;
int prod = 1;
for (int k = 0; k < p; k++) prod *= n;
r += prod * tmp;
p++;
l--;
}
return r;
}
int main() {
string s, a, b;
int mx = 0;
cin >> s;
int i = 0;
while (s[i] != ':') {
a.push_back(s[i]);
if (mx < s[i]) mx = s[i];
i++;
}
i++;
while (s[i] != '\0') {
b.push_back(s[i]);
if (mx < s[i]) mx = s[i];
i++;
}
int bg;
bg = mx < 65 ? mx - 48 : mx - 55;
int beg = max(2, bg + 1);
if (dec(a, beg) >= 24 || dec(b, beg) >= 60) {
cout << 0 << endl;
return 0;
}
if (dec(a, 100) < 24 && dec(b, 100) < 60) {
cout << -1 << endl;
return 0;
}
for (i = beg;; i++) {
if (dec(a, i) < 24 && dec(b, i) < 60) {
cout << i << " ";
} else
break;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-7;
template <class TT>
TT sqr(TT a) {
return a * a;
}
template <class TT>
TT abs(TT a) {
if (a < 0) return -a;
return a;
}
template <class ZZ>
ZZ max(ZZ a, ZZ b, ZZ c) {
return max(a, max(b, c));
}
template <class ZZ>
ZZ min(ZZ a, ZZ b, ZZ c) {
return min(a, min(b, c));
}
long long f(char c) {
if (isdigit(c)) return c - '0';
return c - 'A' + 10;
}
long long val(string a, long long bs) {
reverse((a).begin(), (a).end());
long long x = 1, re = 0, i;
for (i = 0; i < ((int)a.size()); i++) {
re += x * f(a[i]);
x *= bs;
}
return re;
}
bool ch(string a, string b, long long bs) {
long long va = val(a, bs), vb = val(b, bs);
return (va <= 23 && vb <= 59);
}
int main() {
vector<int> v;
long long i, j, k, tks, ks = 1, n, m;
string s, a, b;
while (cin >> s) {
m = 0;
v.clear();
for (i = 0; i < ((int)s.size()); i++)
if (s[i] == ':')
s[i] = ' ';
else {
m = max(m, f(s[i]));
}
m++;
stringstream ss(s);
ss >> a >> b;
for (i = m; i < 100; i++)
if (ch(a, b, i)) {
v.push_back(i);
} else
break;
if (i == 100)
printf("-1\n");
else if (((int)v.size()) == 0)
printf("0\n");
else {
for (i = 0; i < ((int)v.size()); i++) {
if (i) cout << " ";
cout << v[i];
}
cout << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int num(char ch) {
if (isdigit(ch)) return ch - '0';
return 10 + ch - 'A';
}
int cnvt(string s, int base) {
int ans = 0;
int po = 0;
for (int i = s.length() - 1; i >= 0; i--) {
ans += num(s[i]) * pow(base, po++);
}
return ans;
}
int main() {
string s;
cin >> s;
int mid = 0;
while (s[mid] != ':') mid++;
string hr = s.substr(0, mid);
string mi = s.substr(mid + 1);
int zeros = 0;
while (hr[zeros] == '0') zeros++;
hr = hr.substr(zeros);
zeros = 0;
while (mi[zeros] == '0') zeros++;
mi = mi.substr(zeros);
int prevmi = -1;
int prevhr = -1;
int minBase = 1;
for (char ch : mi) minBase = std::max(minBase, num(ch));
for (char ch : hr) minBase = std::max(minBase, num(ch));
minBase++;
vector<int> ans;
while (true) {
int curhr = cnvt(hr, minBase);
int curmi = cnvt(mi, minBase);
if (curhr >= 0 && curhr < 24 && curmi >= 0 && curmi < 60) {
if (curhr == prevhr && curmi == prevmi) {
cout << -1;
return 0;
} else {
prevhr = curhr;
prevmi = curmi;
ans.push_back(minBase);
minBase++;
}
} else {
break;
}
}
if (ans.size() == 0)
cout << 0;
else
for (int t : ans) cout << t << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
int convert(string &s, int ps) {
long long res(0ll);
for (int i(0); i <= ((int)(s.length()) - 1); ++i) {
int x;
if (isdigit(s[i]))
x = s[i] - '0';
else
x = s[i] - 'A' + 10;
if (x >= ps) return -1;
res *= (long long)ps;
res += (long long)x;
}
return res;
}
int main() {
string a, b;
getline(cin, a);
b = a.substr(0, a.find(':'));
a.erase(a.begin(), a.begin() + a.find(':') + 1);
swap(a, b);
while (a.length() > 1 && a[0] == '0') a.erase(a.begin());
while (b.length() > 1 && b[0] == '0') b.erase(b.begin());
vector<int> res;
for (int i(2); i <= (140); ++i) {
if (convert(a, i) >= 0ll && convert(a, i) <= 23ll && convert(b, i) >= 0ll &&
convert(b, i) <= 59ll)
res.push_back(i);
}
if (((int)res.size()) == 0)
printf("0\n");
else if (((int)res.size()) > 66)
printf("-1\n");
else {
printf("%d", res[0]);
for (int i(0); i <= ((int)(((int)res.size()) - 1) - 1); ++i)
printf(" %d", res[i + 1]);
printf("\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c2i(char c) { return c <= '9' ? c - '0' : c - 'A' + 10; }
int conv(string s, int r) {
int ret = 0;
for (int i = 0, _n = (int)((int((s).size()))); i < _n; i++)
if (c2i(s[i]) >= r) return -1;
for (int i = 0, _n = (int)((int((s).size()))); i < _n; i++) {
ret = ret * r + c2i(s[i]);
if (ret > 1000) return -1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
string str;
cin >> str;
string a, b;
for (int i = 0, _n = (int)((int((str).size()))); i < _n; i++)
if (str[i] != ':')
a += str[i];
else
break;
for (int i = (int)((int((str).size()))), _x = (int)(0); i-- > _x;)
if (str[i] != ':')
b = str[i] + b;
else
break;
vector<int> ans;
for (int r = (int)(2), _n = (int)(1000); r < _n; r++) {
int x = conv(a, r);
int y = conv(b, r);
if (0 <= x && x < 24 && 0 <= y && y < 60) ans.push_back(r);
}
if ((int((ans).size())) == 0)
cout << 0 << endl;
else if ((int((ans).size())) > 100)
cout << -1 << endl;
else {
for (int i = 0, _n = (int)((int((ans).size()))); i < _n; i++)
cout << ans[i] << ' ';
cout << endl;
}
{
int _;
cin >> _;
return 0;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s;
char a[1005];
char b[1005];
int getv(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
return -1;
}
vector<int> ans;
int main() {
cin >> s;
int len = s.length();
int p = s.find(':');
int la = 0, lb = 0, i;
for (i = 0; i < p; i++) {
a[la++] = s[i];
}
a[la] = 0;
for (i = p + 1; i < len; i++) {
b[lb++] = s[i];
}
b[lb] = 0;
int hh = 0, ss = 0;
int nFlag;
for (int bt = 2; bt <= 200; bt++) {
hh = 0, ss = 0;
nFlag = 1;
for (i = 0; i < la; i++) {
int num = getv(a[i]);
if (num >= bt) {
nFlag = 0;
break;
}
hh = hh * bt + num;
}
if (!nFlag) continue;
for (i = 0; i < lb; i++) {
int num = getv(b[i]);
if (num >= bt) {
nFlag = false;
break;
}
ss = ss * bt + num;
}
if (!nFlag) continue;
if (hh >= 0 && hh < 24 && ss >= 0 && ss < 60) ans.push_back(bt);
}
if (ans.size() == 0)
puts("0");
else if (ans.size() > 100)
puts("-1");
else {
for (i = 0; i < (int)ans.size(); i++) {
printf("%d ", ans[i]);
}
puts("");
}
return 0;
}
| 8 | CPP |
def getValue(c):
res = ord(c) - ord('0')
if (res > 16):
res -= 7
return res
def getNumber(base, a, b):
hours, minutes = 0, 0
ii = 0
for i in range(len(a)-1, -1, -1):
hours += getValue(a[i]) * pow(base, ii)
ii += 1
if (hours > 23):
return -1, -1
ii = 0
for i in range(len(b) - 1, -1, -1):
minutes += getValue(b[i]) * pow(base, ii)
ii += 1
if (minutes > 59):
return -1, -1
return hours, minutes
def getBase(a,b):
base = 0
for i in range(len(a)):
base = max(base, getValue(a[i]))
for i in range(len(b)):
base = max(base, getValue(b[i]))
return base+1
if __name__ == '__main__':
a, b = input().split(':')
res = []
inf = 0
lastHours, lastMinutes = -1, -1
base = getBase(a, b)
while True:
hours, minutes = getNumber(base,a,b)
if (hours == -1 and minutes == -1):
break
if (hours == lastHours and minutes == lastMinutes):
inf = 1
break
res.append(base)
lastHours, lastMinutes = hours , minutes
base += 1
if (inf == 1):
print(-1)
elif (len(res) == 0):
print(0)
else:
print(' '.join(str(x) for x in res)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dx8[8] = {1, -1, 0, 0, 1, 1, -1, -1};
int dy8[8] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long chartoint(char ch) {
if ('0' <= ch && ch <= '9') return (ch - '0');
return (ch - 'A' + 10);
}
long long toint(string x, int base) {
long long ans = 0;
long long m = 1;
for (int i = x.size() - 1; i >= 0; i--) ans += chartoint(x[i]) * m, m *= base;
return ans;
}
int main() {
string x;
cin >> x;
string h, m;
bool hh = 1, fh = 0, fm = 0;
for (int i = 0; i < x.size(); i++) {
if (x[i] == ':') {
hh = 0;
continue;
}
if (hh) {
if (x[i] != '0') fh = 1;
if (fh) h += x[i];
} else {
if (x[i] != '0') fm = 1;
if (fm) m += x[i];
}
}
if (h.empty()) h = "0";
if (m.empty()) m = "0";
if (h.size() == 1 && m.size() == 1) {
if (chartoint(h[0]) >= 24)
cout << 0;
else
cout << -1;
return 0;
}
long long bas = 0, c = 0;
for (int i = 0; i < h.size(); i++)
bas = max((long long)(bas), chartoint(h[i]));
for (int i = 0; i < m.size(); i++) bas = max((long long)bas, chartoint(m[i]));
bas++;
if (toint(h, bas) < 24 && toint(m, bas) < 60) {
c++;
cout << bas << " ";
}
bas++;
while (1) {
if (toint(h, bas) < 24 && toint(m, bas) < 60)
cout << bas++ << " ";
else
break;
}
if (!c) cout << 0 << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char cc[12];
int aa[5], bb[5];
int main() {
cin >> cc;
int l = strlen(cc);
int n = 0;
int i = 0;
while (i < l && cc[i] != ':') {
aa[n++] = '0' <= cc[i] && cc[i] <= '9' ? cc[i] - '0' : cc[i] - 'A' + 10;
i++;
}
int m = 0;
int j = i + 1;
while (j < l) {
bb[m++] = '0' <= cc[j] && cc[j] <= '9' ? cc[j] - '0' : cc[j] - 'A' + 10;
j++;
}
int k = 0;
while (k < n && aa[k] == 0) k++;
for (int j = 0; j + k < n; j++) aa[j] = aa[j + k];
n -= k;
k = 0;
while (k < m && bb[k] == 0) k++;
for (int j = 0; j + k < m; j++) bb[j] = bb[j + k];
m -= k;
if ((n == 0 || n == 1 && aa[0] < 24) && m <= 1) {
cout << "-1\n";
return 0;
}
int b_ = 0;
for (int i = 0; i < n; i++) b_ = max(b_, aa[i] + 1);
for (int j = 0; j < m; j++) b_ = max(b_, bb[j] + 1);
int x = 0;
for (int i = 0; i < n; i++)
if ((x = x * b_ + aa[i]) >= 24) {
cout << "0\n";
return 0;
}
int y = 0;
for (int j = 0; j < m; j++)
if ((y = y * b_ + bb[j]) >= 60) {
cout << "0\n";
return 0;
}
for (int b = b_; b <= 60; b++) {
bool yes = true;
int x = 0;
for (int i = 0; i < n; i++)
if ((x = x * b + aa[i]) >= 24) {
yes = false;
break;
}
int y = 0;
for (int j = 0; j < m; j++)
if ((y = y * b + bb[j]) >= 60) {
yes = false;
break;
}
if (yes) cout << b << ' ';
}
cout << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[12] = {0};
char a[6] = {0};
char b[6] = {0};
int min_base = 99999999;
int max_base = 0;
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
int getVal(char c) {
if (isDigit(c)) {
return c - '0';
} else {
return (int)c - 55;
}
}
int isValid(int base) {
int i;
int aVal = 0;
for (i = 0; i < strlen(a); i++) {
aVal +=
(double)pow((double)base, (double)(strlen(a) - i - 1)) * getVal(a[i]);
}
if (aVal > 23) {
return 0;
}
int bVal = 0;
for (i = 0; i < strlen(b); i++) {
bVal +=
(double)pow((double)base, (double)(strlen(b) - i - 1)) * getVal(b[i]);
}
if (bVal > 59) {
return 0;
}
return 1;
}
int main() {
gets(s);
int i, j, flag, lead0;
j = 0;
flag = 1;
char min_ch = '0';
lead0 = 1;
for (i = 0; i < strlen(s); i++) {
if (s[i] == ':') {
flag = 0;
j = 0;
lead0 = 1;
continue;
}
if (s[i] > min_ch) {
min_ch = s[i];
}
if (flag) {
if (lead0) {
if (s[i] != '0') {
a[j++] = s[i];
lead0 = 0;
}
} else {
a[j++] = s[i];
}
} else {
if (lead0) {
if (s[i] != '0') {
b[j++] = s[i];
lead0 = 0;
}
} else {
b[j++] = s[i];
}
}
}
if (strlen(a) == 0) {
a[0] = '0';
}
if (strlen(b) == 0) {
b[0] = '0';
}
min_base = getVal(min_ch) + 1;
if (strlen(a) == 1 && strlen(b) == 1) {
if (getVal(a[0]) < 24 && getVal(b[0]) < 60) {
cout << "-1" << endl;
return 0;
}
}
if (!isValid(min_base)) {
cout << "0" << endl;
return 0;
} else {
cout << min_base;
}
for (i = min_base + 1;; i++) {
if (isValid(i)) {
cout << " " << i;
} else {
break;
}
}
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char cc[12];
int aa[5], bb[5];
int main() {
cin >> cc;
int l = strlen(cc);
int n = 0;
int i = 0;
while (i < l && cc[i] != ':') {
aa[n++] = '0' <= cc[i] && cc[i] <= '9' ? cc[i] - '0' : cc[i] - 'A' + 10;
i++;
}
int m = 0;
int j = i + 1;
while (j < l) {
bb[m++] = '0' <= cc[j] && cc[j] <= '9' ? cc[j] - '0' : cc[j] - 'A' + 10;
j++;
}
int k = 0;
while (k < n && aa[k] == 0) k++;
for (int j = 0; j + k < n; j++) aa[j] = aa[j + k];
n -= k;
k = 0;
while (k < m && bb[k] == 0) k++;
for (int j = 0; j + k < m; j++) bb[j] = bb[j + k];
m -= k;
if ((n == 0 || n == 1 && aa[0] < 24) && m <= 1) {
cout << "-1\n";
return 0;
}
int b_ = 0;
for (int i = 0; i < n; i++) b_ = max(b_, aa[i] + 1);
for (int j = 0; j < m; j++) b_ = max(b_, bb[j] + 1);
int x = 0;
for (int i = 0; i < n; i++)
if ((x = x * b_ + aa[i]) >= 24) {
cout << "0\n";
return 0;
}
int y = 0;
for (int j = 0; j < m; j++)
if ((y = y * b_ + bb[j]) >= 60) {
cout << "0\n";
return 0;
}
int b = 60;
while (b >= b_) {
bool yes = true;
int x = 0;
for (int i = 0; i < n; i++)
if ((x = x * b + aa[i]) >= 24) {
yes = false;
break;
}
int y = 0;
for (int j = 0; j < m; j++)
if ((y = y * b + bb[j]) >= 60) {
yes = false;
break;
}
if (yes) break;
b--;
}
while (b_ <= b) cout << b_++ << ' ';
cout << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<char, int> book;
bool pk(string val, int m, int maxx) {
int ans = 0;
int bei = 1;
for (int i = val.size() - 1; i >= 0; --i) {
ans += book[val[i]] * bei;
bei *= m;
}
return ans < maxx;
}
int main() {
for (int i = '0'; i <= '9'; ++i) book[i] = i - '0';
for (int i = 'A'; i <= 'Z'; ++i) book[i] = i - 'A' + 10;
string strh, strm;
getline(cin, strh, ':');
getline(cin, strm);
int pos = 0;
for (; pos < strh.size(); ++pos)
if (strh[pos] != '0') break;
strh = strh.substr(pos, strh.size() - pos);
pos = 0;
for (; pos < strm.size(); ++pos)
if (strm[pos] != '0') break;
strm = strm.substr(pos, strm.size() - pos);
int minm = 1;
for (int i = 0; i < strh.size(); ++i) minm = max(minm, book[strh[i]] + 1);
for (int i = 0; i < strm.size(); ++i) minm = max(minm, book[strm[i]] + 1);
if (!(pk(strh, minm, 24) && pk(strm, minm, 60)))
cout << 0;
else if (strh.size() <= 1 && strm.size() <= 1)
cout << -1;
else
while (pk(strh, minm, 24) && pk(strm, minm++, 60)) cout << minm - 1 << ' ';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long hour[10], minute[10];
long long hL, mL;
long long possible[1000], pL = 0;
long long POWER(long long k, long long p) {
long long i;
long long ans = 1;
for (i = 1; i <= p; i++) ans = ans * k;
return ans;
}
long long DecimalHours(long long base) {
long long i, onpower = 0;
long long num = 0;
for (i = hL; i >= 1; i--) {
num = num + hour[i] * POWER(base, onpower);
onpower++;
}
return num;
}
long long DecimalMins(long long base) {
long long i, onpower = 0;
long long num = 0;
for (i = mL; i >= 1; i--) {
num = num + minute[i] * POWER(base, onpower);
onpower++;
}
return num;
}
int main() {
string a;
long long decimalh, decimalm;
long long i;
bool passed = false;
long long largest = -1;
cin >> a;
for (i = 0; i < a.length(); i++) {
if (a[i] == ':') {
passed = true;
} else if (!passed) {
hL++;
if (a[i] <= '9' && a[i] >= '0')
hour[hL] = a[i] - '0';
else
hour[hL] = (a[i] - 'A') + 10;
if (hour[hL] > largest) largest = hour[hL];
} else {
mL++;
if (a[i] <= '9' && a[i] >= '0')
minute[mL] = a[i] - '0';
else
minute[mL] = (a[i] - 'A') + 10;
if (minute[mL] > largest) largest = minute[mL];
}
}
largest++;
for (i = largest; i <= 400; i++) {
decimalm = DecimalMins(i);
if (decimalm < 0 || decimalm > 59) continue;
decimalh = DecimalHours(i);
if (decimalh < 0 || decimalh > 23) continue;
pL++;
possible[pL] = i;
}
if (pL > 300) {
printf("-1\n");
return 0;
}
for (i = 1; i <= pL; i++) {
printf("%I64d", possible[i]);
if (i == pL)
printf("\n");
else
printf(" ");
}
if (pL == 0) printf("0\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool test(string t, int base, int valmax) {
int val = 0;
for (int i = 0; i < t.size(); ++i) {
val *= base;
if ('0' <= t[i] && '9' >= t[i]) {
if (t[i] - '0' >= base) return false;
val += t[i] - '0';
} else {
if (t[i] - 'A' + 10 >= base) return false;
val += t[i] - 'A' + 10;
}
}
if (val > valmax) return false;
return true;
}
int main() {
string a[2];
char t;
int ind = 0;
while (cin >> t) {
if (t == ':') {
ind++;
continue;
}
a[ind].push_back(t);
}
for (int i = 0; i < 2; ++i)
while (!a[i].empty() && a[i][0] == '0') a[i].erase(a[i].begin());
vector<int> ans;
for (int i = 1; i <= 61; ++i) {
if (test(a[0], i, 23) && test(a[1], i, 59)) ans.push_back(i);
}
if (ans.size() == 0)
cout << "0\n";
else if (ans[ans.size() - 1] == 61)
cout << "-1\n";
else
for (int i = 0; i < ans.size(); ++i)
cout << ans[i] << " \n"[i == ans.size() - 1];
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int n, long long int l) {
long long int odd = 1;
if (l == 1) return n;
if (l == 0) return 1;
while (l > 0) {
if (l % 2) {
odd *= n;
}
n = n * n;
l = l / 2;
}
return odd;
}
int main() {
char a[20], b[6], c[6];
long long int i, j, k, l, l1 = 0, l2 = 0, flag = 0, flag1 = 0;
cin >> a;
l = strlen(a);
for (i = 0; i < l; i++) {
if (a[i] == ':') flag = 1;
if (flag == 0) {
b[l1] = a[i];
l1++;
} else {
if (a[i] != ':') {
c[l2] = a[i];
l2++;
}
}
}
flag = 0;
int temp = 0;
for (i = l1 - 1; i >= 0; i--) {
if (b[l1 - i - 1] >= 65) {
temp += (b[l1 - i - 1] - 55) * power(60, i);
} else {
temp += (b[l1 - i - 1] - 48) * power(60, i);
}
}
if (temp >= 24) {
flag = 1;
}
temp = 0;
for (i = l2 - 1; i >= 0; i--) {
if (c[l2 - i - 1] >= 65) {
temp += (c[l2 - i - 1] - 55) * power(60, i);
} else {
temp += (c[l2 - i - 1] - 48) * power(60, i);
}
}
if (temp >= 60) flag = 1;
if (flag == 0)
printf("-1\n");
else {
for (j = 2; j <= 60; j++) {
temp = 0;
flag = 0;
for (i = l1 - 1; i >= 0; i--) {
if (b[l1 - i - 1] >= 65) {
temp += (b[l1 - i - 1] - 55) * power(j, i);
if (b[l1 - i - 1] - 55 >= j) flag = 1;
} else {
temp += (b[l1 - i - 1] - 48) * power(j, i);
if (b[l1 - i - 1] - 48 >= j) flag = 1;
}
}
if (temp >= 24) flag = 1;
temp = 0;
for (i = l2 - 1; i >= 0; i--) {
if (c[l2 - i - 1] >= 65) {
temp += (c[l2 - i - 1] - 55) * power(j, i);
if (c[l2 - i - 1] - 55 >= j) flag = 1;
} else {
temp += (c[l2 - i - 1] - 48) * power(j, i);
if (c[l2 - i - 1] - 48 >= j) flag = 1;
}
}
if (temp >= 60) flag = 1;
if (flag == 0) {
flag1 = 1;
printf("%lld ", j);
}
}
if (flag1 == 0) printf("0\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
int c2i(char c) {
if (c <= '9') return c - '0';
return c - 'A' + 10;
}
long long conv(string num, int base) {
long long res = 0;
for (int i = 0; i < (int)num.length(); i++) {
if (c2i(num[i]) >= base) return INF;
res = res * base + c2i(num[i]);
}
return res;
}
int main() {
string inp, h, m;
cin >> inp;
for (int i = 0; i < (int)inp.length(); i++)
if (inp[i] == ':') inp[i] = ' ';
istringstream sin(inp);
sin >> h >> m;
vector<int> res;
for (int base = 2; base <= 100; base++)
if (conv(h, base) < 24 && conv(m, base) < 60) res.push_back(base);
if (res.empty())
cout << 0 << endl;
else if (res.back() == 100)
cout << -1 << endl;
else {
for (int i = 0; i < (int)res.size(); i++) cout << res[i] << " ";
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const string digit = "0123456789ABCDEFGHIJKLMNOPQRSTUVXWYZ";
string s, hour, mins;
vector<int> ans;
int main() {
int base = 0;
cin >> s;
hour = s.substr(0, s.find(":"));
mins = s.substr(s.find(":") + 1);
for (int i = 0; i < hour.length(); i++)
base = max(base, (int)digit.find(hour[i]));
for (int i = 0; i < mins.length(); i++)
base = max(base, (int)digit.find(mins[i]));
base++;
while (base < 1000) {
long long ihour = 0, imins = 0;
for (int i = 0; i < hour.length(); i++)
ihour = ihour * base + digit.find(hour[i]);
for (int i = 0; i < mins.length(); i++)
imins = imins * base + digit.find(mins[i]);
if (ihour < 24 && imins < 60) ans.push_back(base);
base++;
}
if (ans.size() == 0)
cout << 0;
else if (ans.size() > 100)
cout << -1;
else
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int getdig(char ch) {
if (ch >= '0' && ch <= '9')
return ch - '0';
else
return ch - 'A' + 10;
}
int get(string str, int b) {
reverse((str).begin(), (str).end());
int po = 1, ret = 0, i;
for (i = 0; i < (str.size()); i++) {
int x = getdig(str[i]);
if (x >= b) return -1;
ret += po * x;
po *= b;
}
return ret;
}
int main() {
char h[100], m[100], str[100];
int i;
cin >> str;
for (i = 0; i < (strlen(str)); i++) {
if (str[i] == ':') str[i] = ' ';
}
sscanf(str, "%s %s", h, m);
string hour = h;
string min = m;
pair<int, int> last;
last.first = -1;
last.second = -1;
vector<int> v;
int c = 0;
for (i = 0; i < (100); i++) {
if (get(hour, i) >= 0 && get(hour, i) <= 23)
if (get(min, i) >= 0 && get(min, i) <= 59) {
pair<int, int> now;
now.first = get(hour, i);
now.second = get(min, i);
if (now.second != -1 && now.first != -1) {
if (now == last) {
c = 1;
break;
} else {
last = now;
v.push_back(i);
}
}
}
}
if (v.size() == 0) {
cout << 0 << endl;
} else if (c == 1) {
cout << -1 << endl;
} else {
for (i = 0; i < (v.size()); i++) {
if (i) cout << " ";
cout << v[i];
}
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s1[10], s2[10];
int Get(char s[]) {
int i = 0, Max = 0;
char str[10] = {0};
while (s[i] == '0') ++i;
strcpy(str, s + i);
strcpy(s, str);
i = 0;
while (s[i]) {
int tmp = s[i];
if (s[i] < 'A')
tmp -= '0';
else
tmp = tmp - 'A' + 10;
if (tmp > Max) Max = tmp;
++i;
}
return Max;
}
int judge(char s[], int r, int Max) {
int p = 0, i = 0;
while (s[i]) {
if (s[i] < 'A')
p = p * r + s[i++] - '0';
else
p = p * r + s[i++] - 'A' + 10;
}
if (p <= Max) return 1;
return 0;
}
int main() {
char ss[20];
while (scanf("%s", ss) == 1) {
memset(s1, 0, sizeof(s1));
;
memset(s2, 0, sizeof(s2));
;
int i = 0, j = 0;
while (ss[i] != ':') s1[j++] = ss[i++];
++i, j = 0;
while (ss[i]) s2[j++] = ss[i++];
int Min = 0;
Min = max(0, max(Get(s1), Get(s2)));
if (strlen(s1) <= 1 && strlen(s2) <= 1 && Get(s1) <= 23 && Get(s2) <= 59) {
puts("-1");
} else {
int f = 0;
Min++;
Min = max(2, Min);
while (Min <= 60) {
if (judge(s1, Min, 23) && judge(s2, Min, 59)) {
printf(f++ == 0 ? "%d" : " %d", Min);
}
Min++;
}
if (!f) printf("0");
puts("");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<char, int> m;
long long f(string r, int pos) {
long long sum = 0;
long long p = 1;
for (int i = r.length() - 1; i >= 0; --i) {
sum += m[r[i]] * p;
p *= pos;
}
return sum;
}
int main() {
string r = "", d = "";
char t;
while ((t = getchar()) != ':') {
r += t;
}
cin >> d;
int cnt = 1;
m['0'] = 0;
for (char i = '1'; i <= '9'; ++i) {
m[i] = cnt;
++cnt;
}
for (char i = 'A'; i <= 'Z'; ++i) {
m[i] = cnt;
++cnt;
}
int pos = 1;
for (int i = 0; i < r.length(); ++i) {
pos = max(pos, m[r[i]]);
}
for (int i = 0; i < d.length(); ++i) {
pos = max(pos, m[d[i]]);
}
++pos;
if (f(r, pos) >= 24 || f(d, pos) >= 60) {
cout << 0;
return 0;
}
if (f(r, 100) == f(r, 150) && f(d, 100) == f(d, 150)) {
cout << -1;
return 0;
}
while (f(r, pos) < 24 && f(d, pos) < 60) {
cout << pos << " ";
++pos;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int cc(char a) {
if (a == '0')
return 0;
else if (a == '1')
return 1;
else if (a == '2')
return 2;
else if (a == '3')
return 3;
else if (a == '4')
return 4;
else if (a == '5')
return 5;
else if (a == '6')
return 6;
else if (a == '7')
return 7;
else if (a == '8')
return 8;
else if (a == '9')
return 9;
else {
return a - 'A' + 10;
}
}
int power(int a, int b) {
int res = 1;
for (int i = 0; i < b; i++) {
res *= a;
}
return res;
}
int main() {
char buffer[100];
gets(buffer);
string A = "";
string B = "";
int sz = strlen(buffer);
bool next = false;
for (int i = 0; i < sz; i++) {
if (buffer[i] != ':' && !next) {
A += buffer[i];
} else if (buffer[i] == ':') {
next = true;
} else if (next) {
B += buffer[i];
}
}
int asz = A.size();
int bsz = B.size();
int hour = 0;
int min = 0;
int b = asz - 1;
for (int i = 0; i < asz; i++) {
hour += cc(A[i]) * power(50, b);
b--;
}
b = bsz - 1;
for (int i = 0; i < bsz; i++) {
min += cc(B[i]) * power(100, b);
b--;
}
int res = 0;
bool isInfinite = false;
bool isEligible = false;
if (hour <= 23 && min <= 59) {
res = -1;
isInfinite = true;
}
vector<int> output;
if (!isInfinite) {
for (int j = 1; j <= 60; j++) {
isEligible = true;
for (int i = 0; i < asz; i++) {
if (cc(A[i]) >= j) {
isEligible = false;
break;
}
}
for (int i = 0; i < bsz; i++) {
if (cc(B[i]) >= j) {
isEligible = false;
break;
}
}
if (isEligible) {
hour = 0;
min = 0;
b = asz - 1;
for (int i = 0; i < asz; i++) {
hour += cc(A[i]) * power(j, b);
b--;
}
b = bsz - 1;
for (int i = 0; i < bsz; i++) {
min += cc(B[i]) * power(j, b);
b--;
}
}
if (hour <= 23 && min <= 59) {
output.push_back(j);
}
}
}
if (isInfinite)
printf("%d\n", res);
else if (output.size() == 0)
printf("0\n");
else {
for (int i = 0; i < output.size() - 1; i++) {
printf("%d ", output[i]);
}
printf("%d\n", output[output.size() - 1]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-Ofast")
#pragma GCC optimize("trapv")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx2,tune=native")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-funroll-all-loops,-fpeel-loops,-funswitch-loops")
const int N = 1e5 + 40;
const int MAXK = 12;
const long long int INF = 1000000000000000000;
const int RANDOM =
chrono::high_resolution_clock::now().time_since_epoch().count();
long long int expo_pow(long long int x, long long int y) {
if (y == 0) return 1;
y = y % ((1000000007) - 1);
x %= (1000000007);
if (y == 0) y = (1000000007) - 1;
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % (1000000007);
x = (x * x) % (1000000007);
y >>= 1;
}
return res;
}
long long int modInverse(long long int a, long long int m = (1000000007)) {
return expo_pow(a, m - 2);
}
void solve() {
string second;
cin >> second;
int ind;
int cnt = 0;
int mx = 0;
map<char, int> m;
for (char c = '0'; c <= '9'; c++) m[c] = c - '0';
for (char c = 'A'; c <= 'Z'; c++) m[c] = c - 'A' + 10;
for (int i = (0); i < ((int)second.size()); i++) {
if (second[i] == ':') {
ind = i;
} else {
mx = max(mx, m[second[i]]);
}
if (second[i] == '0') cnt++;
}
mx++;
vector<int> ans;
for (int i = (mx); i < (65); i++) {
long long int ti = 1;
long long int cur = 0;
for (int j = (ind - 1); j > (-1); j -= 1) {
cur += (m[second[j]]) * ti;
ti *= i;
}
if (cur >= 24) break;
cur = 0;
ti = 1;
for (int j = (second.size() - 1); j > (ind); j -= 1) {
cur += (m[second[j]]) * ti;
ti *= i;
}
if (cur > 59) break;
ans.push_back(i);
if (i == 60) {
cout << -1 << '\n';
return;
}
}
if (ans.empty()) {
cout << 0 << '\n';
} else {
for (auto x : ans) {
cout << x << " ";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int getnum(string s, int b) {
int i, j = 0, k;
for (i = 0; i < s.size(); i++) {
if (s[i] >= '0' && s[i] <= '9')
k = s[i] - '0';
else
k = s[i] - 'A' + 10;
if (k >= b) return 61;
j *= b;
j += k;
if (j > 60) return 61;
}
return j;
}
int main() {
string s, a, b;
cin >> s;
a = s.substr(0, s.find(":"));
b = s.substr(s.find(":") + 1);
for (int i = 2; i < 200; i++)
if (getnum(a, i) < 24 && getnum(b, i) < 60) v.push_back(i);
if (v.size() == 0)
cout << "0";
else if (v.size() > 100)
cout << "-1";
else
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
string st;
int d[20], m;
bool test(int b) {
bool before = 1;
int be = 0, af = 0, p = 1;
for (int i = ((int)((st).size())) - 1; i >= 0; i--) {
if (st[i] == ':') {
before = 0;
p = 1;
continue;
}
if (before)
be += p * d[i];
else
af += p * d[i];
p *= b;
}
return (be < 60 && be >= 0 && af < 24 && af >= 0);
}
int main() {
cin >> st;
for (int i = 0; i < ((int)((st).size())); ++i) {
if (st[i] == ':') continue;
if (isdigit(st[i]))
d[i] = st[i] - '0';
else if (st[i] >= 'A' && st[i] <= 'Z')
d[i] = st[i] - 'A' + 10;
m = max(m, d[i]);
}
m++;
int t = m;
while (1) {
if (m > 70) {
cout << -1;
return 0;
}
if (!test(m)) {
if (t == m)
cout << 0;
else {
for (int i = t; i < m; i++) cout << i << " ";
}
return 0;
}
m++;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char buf[16], m[8], h[8];
int letter2digit(char c) {
if (isdigit(c))
return c - '0';
else
return c - 'A' + 10;
}
int str2num(char* s, int len, int radix) {
int p = 1, res = 0;
for (int i = len - 1; i >= 0; i--) {
res += p * letter2digit(s[i]);
p *= radix;
}
return res;
}
int main() {
cin >> buf;
int i = 0, lm = 0, lh = 0;
while (buf[i] == '0') i++;
while (buf[i] != ':') h[lh++] = buf[i++];
if (lh == 0) h[lh++] = '0';
i++;
while (buf[i] == '0') i++;
while (buf[i] != '\0') m[lm++] = buf[i++];
if (lm == 0) m[lm++] = '0';
int lowm, lowh, low;
lowm = lowh = 0;
for (i = 0; i < lh; i++) {
int temp = letter2digit(h[i]);
lowh = (lowh < temp ? temp : lowh);
}
for (i = 0; i < lm; i++) {
int temp = letter2digit(m[i]);
lowm = (lowm < temp ? temp : lowm);
}
low = max(lowh, lowm) + 1;
if (lh == 1 && lm == 1 && letter2digit(h[0]) < 24 && letter2digit(m[0]) < 60)
cout << -1 << endl;
else {
bool found = false;
int hh, mm;
while ((hh = str2num(h, lh, low)) < 24 && (mm = str2num(m, lm, low) < 60)) {
found = true;
cout << low++ << ' ';
}
if (!found) cout << 0;
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[15];
int p(char ch) {
if ('0' <= ch && ch <= '9') return ch - '0';
return ch - 'A' + 10;
}
int work(char s[], int base) {
int ans = 0, t;
for (int i = 0; s[i]; i++) {
t = p(s[i]);
if (t >= base) return 100;
ans = ans * base + t;
}
return ans;
}
int main() {
int i, j;
int m, n, k;
int a[61];
while (scanf("%s", s) != EOF) {
m = strlen(s);
for (i = 0; i < m; i++)
if (s[i] == ':') {
s[i] = '\0';
k = i;
}
for (i = 2, j = 0; i <= 60; i++)
if (work(s, i) < 24 && work(&s[k + 1], i) < 60) a[j++] = i;
if (j == 0)
printf("0\n");
else if (a[j - 1] == 60)
printf("-1\n");
else {
for (i = 0; i < j; i++)
if (i)
printf(" %d", a[i]);
else
printf("%d", a[i]);
printf("\n");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int getHour(char *s1, int len, int base) {
double hr = 0;
char *s = new char[10];
for (int i = 0; i < len; i++) {
s[i] = s1[i];
}
s[len] = 0;
reverse(s, s + len);
for (int i = 0; i < len; i++) {
char p = s[i];
int r = 0;
if (p > '9') {
r = 10 + p - 'A';
} else {
r = p - '0';
}
hr = hr + (r * pow(base, i));
}
return hr;
}
int main() {
vector<int> ans;
char *c = new char[20];
cin >> c;
char *a = new char[10];
char *b = new char[10];
bool f = false;
int lena = 0;
int lenb = 0;
char p = 0;
for (int i = 0; i < strlen(c); i++) {
if (c[i] == ':') {
f = true;
continue;
}
if (c[i] > p) {
p = c[i];
}
if (!f) {
a[lena++] = c[i];
} else {
b[lenb++] = c[i];
}
}
a[lena] = 0;
b[lenb] = 0;
int r = 0;
if (p > '9') {
r = 10 + p - 'A';
} else {
r = p - '0';
}
r++;
for (int i = r; i < 70; i++) {
if (i > 60) {
cout << -1;
return 0;
}
int hr = getHour(a, lena, i);
int minute = getHour(b, lenb, i);
if (hr < 24 && minute < 60) {
ans.push_back(i);
} else {
break;
}
}
if (ans.size() == 0) {
cout << 0 << endl;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int base;
int conv(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10;
}
int solve(string s) {
int ret = 0;
for (int i = 0; i < s.size(); i++) {
int t = conv(s[i]);
if (t >= base) return 1 << 30;
ret = ret * base + t;
if (ret > 100) return 1 << 30;
}
return ret;
}
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ':') s[i] = ' ';
}
stringstream ss(s);
string a, b;
ss >> a >> b;
vector<int> v;
for (base = 2; base <= 1000; base++) {
if (solve(a) < 24 && solve(b) < 60) v.push_back(base);
}
if (v.size() > 100) {
cout << -1;
return 0;
}
if (v.size() == 0) {
cout << 0;
return 0;
}
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool check(int base, string s, int limit) {
int val, res = 0;
for (typeof(0) i = (0); i < (((int)(s).size())); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z')
val = s[i] - 'A' + 10;
else
val = s[i] - '0';
res = res * base + val;
}
return res <= limit;
}
int main() {
string s, min, sec;
while (cin >> s) {
int x = s.find(':');
min = s.substr(0, x);
sec = s.substr(x + 1);
int i = 0;
while (min[i] == '0') ++i;
min = min.substr(i);
i = 0;
while (sec[i] == '0') ++i;
sec = sec.substr(i);
int base, ma = 0, val, ma2 = 0;
if (((int)(min).size()) <= 1 && ((int)(sec).size()) <= 1) {
bool ok = true;
for (typeof(0) i = (0); i < (((int)(min).size())); ++i)
if (min[i] - 'A' > 13) {
puts("0");
ok = false;
}
if (ok) puts("-1");
continue;
}
for (typeof(0) i = (0); i < (((int)(min).size())); ++i) {
if (min[i] >= 'A' && min[i] <= 'Z')
val = min[i] - 'A' + 10;
else
val = min[i] - '0';
ma = max(ma, val);
}
for (typeof(0) i = (0); i < (((int)(sec).size())); ++i) {
if (sec[i] >= 'A' && sec[i] <= 'Z')
val = sec[i] - 'A' + 10;
else
val = sec[i] - '0';
ma2 = max(ma2, val);
}
base = max(ma, ma2) + 1;
if (!check(base, min, 23) || !check(base, sec, 59)) {
puts("0");
continue;
} else {
for (int b = base; b < 60; ++b) {
if (check(b, min, 23) && check(b, sec, 59))
printf("%d ", b);
else
break;
}
printf("\n");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
bool judge(char c) {
if (c == '\0' || c >= '0' && c <= '9' || c >= 'A' && c <= 'N') return true;
return false;
}
int change(char c) {
if (c == '\0') return 0;
if (c >= '0' && c <= '9') return (c - '0');
if (c >= 'A' && c <= 'Z') return (c - 'A' + 10);
}
bool judge2(int n, char s1[], char s2[], int l1, int l2) {
int i;
int num = 0;
int k, l;
l = 1;
for (i = l1 - 1; i >= 0; i--) {
k = change(s1[i]);
num += k * l;
l = l * n;
if (k >= n || num > 23) return false;
}
num = 0;
k = 0;
l = 1;
for (i = l2 - 1; i >= 0; i--) {
k = change(s2[i]);
num += k * l;
l = l * n;
if (k >= n || num > 59) return false;
}
return true;
}
int main() {
char str[20];
char s1[10], s2[20];
int len1, len2;
int num, i;
bool flag;
int a[100];
while (scanf("%s", str) != EOF) {
num = 0;
memset(s1, 0, sizeof(s1));
memset(s2, 0, sizeof(s2));
flag = true;
for (i = 0; str[i] != ':'; i++) {
if (str[i] == '0' && flag) continue;
s1[num++] = str[i];
flag = false;
}
len1 = num;
num = 0;
flag = true;
for (i++; str[i]; i++) {
if (str[i] == '0' && flag == true) continue;
s2[num++] = str[i];
flag = false;
}
len2 = num;
if ((len1 <= 1 && judge(s1[0])) && len2 <= 1) {
printf("-1\n");
continue;
}
flag = false;
num = 0;
for (i = 2; i <= 59; i++) {
if (judge2(i, s1, s2, len1, len2)) {
a[num++] = i;
flag = true;
}
}
if (flag) {
for (i = 0; i < num - 1; i++) printf("%d ", a[i]);
printf("%d\n", a[i]);
} else
printf("0\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int toDigit(char c) {
if ('0' <= c && c <= '9') return c - '0';
return c - 'A' + 10;
}
int toInteger(string a, int k) {
int ret = 0;
for (int i = 0; i < (int)(a.length()); i++) {
int x = toDigit(a[i]);
if (x >= k) return -1;
ret = k * ret + x;
if (ret >= 60) return -1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
string str;
cin >> str;
size_t pos = str.find(':');
string a = str.substr(0, pos);
string b = str.substr(pos + 1);
vector<int> ret;
bool inf = false;
for (int k = 2; k < 60; k++) {
int x = toInteger(a, k);
int y = toInteger(b, k);
if (x < 0 || x > 23) continue;
if (y < 0 || y > 59) continue;
ret.push_back(k);
if (x < k && y < k) inf = true;
}
if (inf)
cout << -1 << endl;
else if (!ret.size())
cout << 0 << endl;
else {
for (int i = 0; i < (int)(ret.size()); i++) cout << ret[i] << " ";
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e8;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
const int N = 100;
int tonum(char c) {
if (c >= '0' && c <= '9')
return c - '0';
else
return c - 'A' + 10;
}
int main() {
ios::sync_with_stdio(false);
string h, m;
char c;
while (1) {
cin >> c;
if (c == ':') {
cin >> m;
break;
}
h.push_back(c);
}
reverse(((h).begin()), ((h).end()));
reverse(((m).begin()), ((m).end()));
bool all = true;
long long cnt = 0;
for (int j = 0; j < ((int)((h).size())); ++j)
cnt += pow(100, j) * tonum(h[j]);
if (cnt > 23) all = false;
cnt = 0;
for (int j = 0; j < ((int)((m).size())); ++j)
cnt += pow(100, j) * tonum(m[j]);
if (cnt > 59) all = false;
if (all) return cout << -1 << endl, 0;
int maxi = 0;
for (int i = 0; i < ((int)((h).size())); ++i)
if (tonum(h[i]) > maxi) maxi = tonum(h[i]);
for (int i = 0; i < ((int)((m).size())); ++i)
if (tonum(m[i]) > maxi) maxi = tonum(m[i]);
vector<int> ans;
for (int i = (maxi + 1); i < (int)(61); ++i) {
cnt = 0;
for (int j = 0; j < ((int)((h).size())); ++j)
cnt += pow(i, j) * tonum(h[j]);
if (cnt > 23) continue;
cnt = 0;
for (int j = 0; j < ((int)((m).size())); ++j)
cnt += pow(i, j) * tonum(m[j]);
if (cnt > 59) continue;
ans.push_back(i);
}
if (ans.size() == 0) return cout << 0 << endl, 0;
for (int i = 0; i < ((int)((ans).size())); ++i) cout << ans[i] << " ";
return 0;
}
| 8 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.