text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long res = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (x >= 4 && x <= 15) {
res ^= 1;
} else if (x >= 16 && x <= 81) {
res ^= 2;
} else if (x >= 6724 && x <= 50625) {
res ^= 3;
} else if (x >= 50626 && x <= 2562991875LL) {
res ^= 1;
} else if (x >= 2562991876LL) {
res ^= 2;
}
}
if (res == 0)
cout << "Rublo\n";
else
cout << "Furlo\n";
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long l, r, sg;
Node() {}
Node(long long a, long long b, long long c) {
l = a;
r = b;
sg = c;
}
} cover[10];
int main() {
int n;
long long x;
cover[0] = Node(1LL, 3LL, 0LL);
cover[1] = Node(4LL, 15LL, 1LL);
cover[2] = Node(16LL, 81LL, 2LL);
cover[3] = Node(82LL, 6723LL, 0LL);
cover[4] = Node(6724LL, 50625LL, 3LL);
cover[5] = Node(50626LL, 2562991875LL, 1LL);
cover[6] = Node(2562991876LL, 777777777777LL, 2LL);
scanf("%d", &n);
long long sg = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &x);
for (int i = 0; i < 7; i++) {
if (cover[i].l <= x && cover[i].r >= x) {
sg ^= cover[i].sg;
break;
}
}
}
if (sg)
printf("Furlo\n");
else
printf("Rublo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const int inf = 0x3f3f3f3f;
int memo[1000005];
inline int go(int n) {
if (n == 0) return 0;
int &ret = memo[n];
if (ret != -1) return ret;
int y = min(n - 1, (int)sqrt(n));
int x = pow(n, 1.0 / 4);
if (x * x * x * x < n) ++x;
bool arr[200];
memset(arr, 0, sizeof arr);
for (int i = (x), __ = (y + 1); i < __; ++i) arr[go(i)] = 1;
ret = 0;
while (arr[ret]) ++ret;
return ret;
}
int mark[1000005], passo = 0;
int calc(int x, int y) {
if (x >= 6724) return 0;
if (x >= 82) {
if (y <= 50625) return 1;
return 2;
}
if (x >= 16) {
if (y <= 81) return 0;
if (y <= 50625) return 1;
return 4;
}
if (x >= 4) {
if (y <= 81) return 0;
if (y <= 6723) return 3;
return 4;
}
if (y <= 3) return 1;
if (y <= 15) return 2;
if (y <= 6723) return 3;
return 4;
}
int main() {
memset(memo, -1, sizeof memo);
int n;
scanf("%d", &n);
long long ans = 0;
for (int i = (0), __ = (n); i < __; ++i) {
long long a;
cin >> a;
long long y = min(a - 1, (long long)sqrt(a));
long long x = pow(a, 1.0 / 4);
if (x * x * x * x != a) ++x;
int _xor = 0;
if (x <= y) _xor = calc(x, y);
ans ^= _xor;
}
if (ans)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, rlt;
long long nim(long long x) {
if (x <= 3) return 0;
if (x <= 15) return 1;
if (x <= 81) return 2;
if (x <= 6723) return 0;
if (x <= 50625) return 3;
if (x <= 2562991875ll) return 1;
return 2;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
rlt ^= nim(x);
}
if (rlt)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sg(long long x) {
if (x <= 3) return 0;
if (x <= 15) return 1;
if (x <= 81) return 2;
if (x <= 6723) return 0;
if (x <= 50625) return 3;
if (x <= 2562991875) return 1;
return 2;
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
long long ans = 0;
while (n--) {
long long t;
cin >> t;
ans ^= sg(t);
}
if (ans)
cout << "Furlo" << endl;
else
cout << "Rublo" << endl;
}
}
|
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::copy;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::greater;
using std::istream;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::multiset;
using std::next_permutation;
using std::nth_element;
using std::ostream;
using std::pair;
using std::priority_queue;
using std::queue;
using std::reverse;
using std::rotate;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::tie;
using std::tuple;
using std::unique;
using std::unordered_map;
using std::unordered_set;
using std::upper_bound;
using std::vector;
int const INF = (int)1e9;
long long const INFL = (long long)1e18;
long double const PI = 3.1415926535897932384626433832795028;
int const A = 890890;
int const AA = 955;
int const L = 35;
int mex[A];
int cnt[A];
int pref[A + 1][L];
int calcR(long long v, int type) {
int l = 0;
int r = type == 2 ? A : AA;
while (r - l > 1) {
int m = (l + r) / 2;
long long val = (long long)m * m;
if (type == 4) val *= val;
if (val > v || (val == v && type == 4)) {
r = m;
} else {
l = m;
}
}
return r;
}
int calcMex(long long v) {
if (v < A) return mex[v];
int r4 = calcR(v, 4);
int r2 = calcR(v, 2);
for (int res = 0; res < L; ++res) {
if (pref[r4][res] == pref[r2][res]) {
return res;
}
}
assert(false);
}
void solve() {
mex[0] = 0;
int r4 = 0, r2 = 1;
cnt[0] = 1;
pref[0][1] = 0;
for (int i = 1; i < A; ++i) {
while (r4 * r4 * r4 * r4 < i) {
--cnt[mex[r4]];
++r4;
}
while (r2 < i && r2 * r2 <= i) {
++cnt[mex[r2]];
++r2;
}
while (cnt[mex[i]]) {
++mex[i];
}
copy(pref[i], pref[i] + L, pref[i + 1]);
++pref[i + 1][mex[i]];
}
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; ++i) {
long long x;
scanf("%lld", &x);
int cur = calcMex(x);
ans ^= cur;
}
cout << (ans ? "Furlo" : "Rublo") << endl;
}
int main() {
cout.precision(15);
cout << fixed;
cerr.precision(6);
cerr << fixed;
srand(1510);
solve();
}
|
#include <bits/stdc++.h>
int n, i, ans = 0;
long long k;
int f(long long k) {
if (k >= 2562991876) return 2;
if (k >= 50626) return 1;
if (k >= 6724) return 3;
if (k >= 82) return 0;
if (k >= 16) return 2;
if (k >= 4) return 1;
return 0;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &k);
ans ^= f(k);
}
if (ans)
printf("Furlo\n");
else
printf("Rublo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2000001;
long long n, b[maxn], sg[maxn], ans2, x, ans1, my, m, me, ans = 0;
long long get(long long x) {
if (x <= 3) return 0;
if (x <= 15) return 1;
if (x <= 81) return 2;
if (x <= 6723) return 0;
if (x <= 50625) return 3;
if (x <= 2562991875) return 1;
return 2;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> x, ans = ans ^ get(x);
if (ans)
cout << "Furlo";
else
cout << "Rublo";
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:300000000")
const long double eps = 1e-20;
const long double pi = acos(-1.0);
const long long inf = 1000 * 1000 * 1000 * 1000 * 1000 * 1000;
const long long base = 1000 * 1000 * 1000 + 7;
const int nn = 3333333;
using namespace std;
int g[nn + 10], y;
long long x;
bool ok[50];
int grandi(long long x) {
if (x <= 3) return 0;
if (x <= 15) return 1;
if (x <= 81) return 2;
if (x <= 6723) return 0;
if (x <= 50625) return 3;
if (x <= 2562991875ll) return 1;
return 2;
}
int main() {
int res, test;
cin >> test;
for (int i = 0; i < (test); i++) {
cin >> x;
res ^= grandi(x);
}
if (res)
printf("Furlo");
else
printf("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long a[10][2] = {
{1, 0}, {4, 1}, {16, 2}, {82, 0}, {256, 0},
{6724, 3}, {50626, 1}, {43046722, 1}, {45212176, 1}, {2562991876LL, 2}};
void lemon() {
int n;
scanf("%d", &n);
int ss = 0;
for (int i = (1); i <= (n); i++) {
long long x;
scanf("%I64d", &x);
int y;
for (int k = (0); k <= (9); k++)
if (x >= a[k][0]) y = a[k][1];
ss ^= y;
}
if (ss)
printf("Furlo\n");
else
printf("Rublo\n");
}
int main() {
lemon();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 77779;
const long long M = 777777777777, MM = 10000007;
void por() {
vector<pair<pair<long long, long long>, int> > v;
v.push_back(make_pair(make_pair(0, 0), 0));
for (long long i = 1; i <= MM; ++i) {
long double rr = i;
rr = sqrt(rr);
long double ll = sqrt(rr);
long long l = ll;
if (ll != l) ++l;
long long r = rr;
set<int> s;
for (int j = 0; j < v.size(); ++j) {
if (max(l, v[j].first.first) <= min(r, v[j].first.second))
s.insert(v[j].second);
}
for (int k = 0;; ++k) {
if (s.find(k) == s.end()) {
if (k == v.back().second)
v.back().first.second++;
else {
cout << i << ' ' << k << endl;
v.push_back(make_pair(make_pair(i, i), k));
}
break;
}
}
}
long long bl = MM + 1;
long long br = M;
long long ans = -1;
int kk = -1;
while (bl <= br) {
long long i = (bl + br) / 2;
long double rr = i;
rr = sqrt(rr);
long double ll = sqrt(rr);
long long l = ll;
if (ll != l) ++l;
long long r = rr;
set<int> s;
for (int j = 0; j < v.size(); ++j) {
if (max(l, v[j].first.first) <= min(r, v[j].first.second))
s.insert(v[j].second);
}
int k;
for (k = 0;; ++k) {
if (s.find(k) == s.end()) break;
}
if (k == 1)
bl = i + 1;
else {
kk = k;
ans = i;
br = i - 1;
}
}
cout << ans << ' ' << kk << endl;
}
void solv() {
int ans = 0;
int n;
scanf("%d", &n);
while (n--) {
long long x;
scanf("%I64d", &x);
if (x >= 2562991876LL)
ans ^= 2;
else if (x >= 50626)
ans ^= 1;
else if (x >= 6724)
ans ^= 3;
else if (x >= 82)
ans ^= 0;
else if (x >= 16)
ans ^= 2;
else if (x >= 4)
ans ^= 1;
}
if (ans)
printf("Furlo\n");
else
printf("Rublo\n");
}
int main() {
solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
int sprague[1001000];
long long piles[100010];
int calcspg(long long cur) {
if (cur <= 1000000) return sprague[int(cur)];
double sq = sqrt(double(cur));
int U = (int)floor(sq + EPS), L = (int)ceil(sqrt(sq) - EPS);
if (U <= 225 * 225) return 1;
if (L > 81) return 2;
return 3;
}
int main() {
int i, j, k, n, mex;
long long ipt;
sprague[1] = sprague[2] = sprague[3] = 0;
for (i = 4; i < 16; i++) sprague[i] = 1;
for (; i <= 81; i++) sprague[i] = 2;
for (; i < 82 * 82; i++) sprague[i] = 0;
for (; i <= 225 * 225; i++) sprague[i] = 3;
for (; i <= 1000000; i++) sprague[i] = 1;
while (cin >> n) {
int ans = 0;
while (n--) {
cin >> ipt;
ans ^= calcspg(ipt);
}
cout << (ans ? "Furlo\n" : "Rublo\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int sg(long long x) {
if (x < 4) return 0;
if (x < 16) return 1;
if (x < 82) return 2;
if (x < 6724) return 0;
if (x < 50626) return 3;
long long t = 50626;
t = t * t;
if (x < t)
return 1;
else
return 2;
}
int main() {
int n;
scanf("%d", &n);
int s = 0;
for (int i = 0; i < n; i++) {
long long t;
scanf("%I64d", &t);
s ^= sg(t);
}
if (s)
printf("Furlo\n");
else
printf("Rublo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long int n, a, i, p = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (a >= 4 && a <= 15) p ^= 1;
if (a >= 16 && a <= 81) p ^= 2;
if (a >= 6724 && a <= 50625) p ^= 3;
if (a >= 50626 && a <= 2562991875LL) p ^= 1;
if (a >= 2562991876LL) p ^= 2;
}
if (p == 0)
cout << "Rublo";
else
cout << "Furlo";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimize("TKACHENKO-GORYACHENKO")
#pragma GCC optimize("O3")
using namespace std;
const long long maxn = 1e6;
long long n, m, k;
long long A[maxn];
long long D[maxn];
long long C[maxn];
vector<pair<long long, long long> > L;
vector<pair<long long, long long> > R;
vector<pair<long long, long long> > B;
vector<long long> Q;
vector<long long> QQ;
long long mex = 0;
void add(long long x) {
C[x]++;
while (C[mex] != 0) {
mex++;
}
}
void del(long long x) {
C[x]--;
if (mex > x && C[x] == 0) {
mex = x;
}
}
int main() {
long long q, w, e, a, b, c;
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (q = 0; q < n; q++) {
cin >> A[q];
B.push_back(make_pair(A[q], q));
}
for (q = 0; q < maxn; q++) {
Q.push_back(q * q);
if (q <= 1e4) {
QQ.push_back(q * q * q * q);
}
}
for (q = 0; q < n; q++) {
if (A[q] == 1) {
continue;
}
L.push_back(
make_pair(lower_bound(QQ.begin(), QQ.end(), A[q]) - QQ.begin(), q));
R.push_back(
make_pair(upper_bound(Q.begin(), Q.end(), A[q]) - Q.begin() - 1, q));
}
long long l = 1, r = 0;
for (q = 2; q < maxn; q++) {
while ((r + 1) * (r + 1) <= q) {
r++;
add(D[r]);
}
while (l * l * l * l <= q) {
del(D[l]);
l++;
}
D[q] = mex;
}
sort(L.begin(), L.end());
sort(R.begin(), R.end());
mex = 0;
for (q = 0; q < maxn; q++) {
C[q] = 0;
}
long long ans = 0;
l = 1, r = 0;
for (q = 0; q < L.size(); q++) {
while (r < R[q].first) {
r++;
add(D[r]);
}
while (l < L[q].first) {
del(D[l]);
l++;
}
ans = ans ^ mex;
}
if (ans == 0) {
cout << "Rublo";
} else {
cout << "Furlo";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const double PI = acos(-1.0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long mex(set<long long> &se) {
long long c = 0;
while (se.count(c)) c++;
return c;
}
const long long N = 1e6 + 5;
long long grundy[N];
map<pair<long long, long long>, long long> mp;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
mp[{0, 3}] = 0;
mp[{4, 15}] = 1;
mp[{16, 81}] = 2;
mp[{82, 6723}] = 0;
mp[{6724, 50625}] = 3;
mp[{50626, 1000000}] = 1;
long long n;
cin >> n;
long long ar[n];
for (long long i = 0; i < n; i++) {
cin >> ar[i];
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long x = ar[i];
long long grundy = -1;
for (auto it : mp) {
long long l = it.first.first;
long long r = it.first.second;
if (x >= l && x <= r) {
grundy = it.second;
break;
}
}
if (grundy != -1) {
ans ^= grundy;
continue;
}
long long lb = pow(x, 0.25);
while (lb * lb * lb * lb < x) lb++;
long long ub = pow(x, 0.5) + 5;
while (ub * ub > x) ub--;
set<long long> se;
for (auto it : mp) {
long long l = it.first.first;
long long r = it.first.second;
if (r >= lb && l <= ub) {
se.insert(it.second);
}
}
grundy = mex(se);
ans ^= grundy;
}
if (ans == 0) {
cout << "Rublo\n";
} else {
cout << "Furlo\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
long long bigmod(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % 1000000007;
b >>= 1;
a = (a * a) % 1000000007;
}
return ret;
}
long long inverse(long long n) { return bigmod(n, 1000000007 - 2); }
bool checkBit(int n, int i) { return (n & (1 << i)); }
int setBit(int n, int i) { return (n | (1 << i)); }
int resetBit(int n, int i) { return (n & (~(1 << i))); }
int dp[1000010], cnt[1000010][10];
int f(int n) {
if (n < 2) return 0;
int &ret = dp[n];
if (ret != -1) return ret;
double sq = sqrt(n);
int start = ceil(sqrt(sq));
int end = floor(sq);
int a[300] = {0};
for (int y = start; y <= end; ++y) a[f(y)] = 1;
ret = 0;
while (a[ret]) ++ret;
return ret;
}
int main() {
cnt[1][0] = 1;
for (int i = 2; i < 1000010; ++i) {
double sq = sqrt(i);
int start = ceil(sqrt(sq));
int end = floor(sq);
for (int j = 0; j < 10; ++j) {
if (cnt[end][j] - cnt[start - 1][j] == 0) {
dp[i] = j;
++cnt[i][j];
break;
}
}
for (int j = 0; j < 10; ++j) cnt[i][j] += cnt[i - 1][j];
}
int n;
long long x;
scanf("%d", &n);
long long nim = 0;
for (int i = 0; i < n; ++i) {
scanf("%lld", &x);
if (x < 1000010)
nim ^= dp[x];
else {
double sq = sqrt(x);
int start = ceil(sqrt(sq));
int end = floor(sq);
for (int j = 0;; ++j) {
if (cnt[end][j] - cnt[start - 1][j] == 0) {
nim ^= j;
break;
}
}
}
}
printf("%s\n", nim ? "Furlo" : "Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, long long* A) {
for (int i(0); i < N; i++) scanf("%lld", A + i);
}
struct MEX {
int p[(1024) << 1], C[(1024)];
void CLR() { (memset(C, 0, sizeof(C))), (memset(p, 0, sizeof(p))); }
int st(int b, int v, int u, int B, int E) {
if (B > b || E < b) return p[u];
if (B == E) return p[u] += v;
return p[u] = st(b, v, u << 1, B, (B + E) >> 1) +
st(b, v, u << 1 | 1, (B + E) / 2 + 1, E);
}
int get() { return gt(1, 0, (1024) - 1); }
int gt(int u, int B, int E) {
if (B == E) return B;
if (p[u << 1] == (B + E) / 2 - B + 1)
return gt(u << 1 | 1, (B + E) / 2 + 1, E);
return gt(u << 1, B, (B + E) >> 1);
}
void add(int I) {
if (!C[I]++) st(I, 1, 1, 0, (1024) - 1);
}
void del(int I) {
if (!--C[I]) st(I, -1, 1, 0, (1024) - 1);
}
} T;
int G[(1000006)] = {0, 0}, O[(1000006)], I, J, N, a, X;
long long A[(1000006)], U, V;
int main(void) {
T.CLR();
for (int k(2); k < (1000006); k++) {
while (J * J <= k) T.add(G[J++]);
while (I * I * I * I < k) T.del(G[I++]);
G[k] = T.get();
}
scanf("%d", &N), ga(N, A), sort(A, A + N), T.CLR();
for (int i(0); i < N; i++) {
if (A[i] < 2) {
X ^= G[A[i]];
continue;
}
while (V * V <= A[i]) T.add(G[V++]);
while (U * U * U * U < A[i]) T.del(G[U++]);
X ^= T.get();
}
puts(!X ? "Rublo" : "Furlo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g[100];
int gn(long long x) {
if (x >= 82 && x < 6724) return 0;
if (x >= 6724 && x < 50626)
return 3;
else if (x >= 50626 && x < 2562991876LL)
return 1;
else if (x >= 2562991876LL)
return 2;
int& ret = g[x];
if (~ret) return ret;
set<int> s;
long long start = ceil(pow(x, 1.0 / 4));
long long fim = floor(pow(x, 1.0 / 2));
fim = min(fim, x - 1);
for (int i = (start); i < (fim + 1); ++i) {
s.insert(gn(i));
}
ret = 0;
while (s.count(ret)) ++ret;
return ret;
}
int main() {
memset(g, -1, sizeof g);
int n;
scanf("%d", &n);
int rsp = 0;
for (int i = (0); i < (n); ++i) {
long long a;
scanf("%I64d", &a);
rsp ^= gn(a);
}
if (rsp)
printf("Furlo\n");
else
printf("Rublo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f(long long n) {
if (n < 4) return 0;
if (n < 16) return 1;
if (n < 82) return 2;
if (n < 6724) return 0;
if (n < 50626) return 3;
if (n < 2562890625LL) return 1;
return 2;
}
int main() {
int n;
long long x, now = 0;
scanf("%d", &n);
scanf("%I64d", &now);
now = f(now);
for (int i = 1; i < n; i++) {
scanf("%I64d", &x);
now ^= f(x);
}
if (now == 0)
printf("Rublo\n");
else
printf("Furlo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sg() {
long long x;
cin >> x;
if (x < 4) return 0;
if (x < 16) return 1;
if (x < 82) return 2;
if (x < 6724) return 0;
if (x < 50626) return 3;
if (x < 2562991876LL) return 1;
return 2;
}
int main() {
int n, ans = 0;
scanf("%d", &n);
while (n--) ans ^= sg();
puts(ans ? "Furlo" : "Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> raiz, quarta;
int grundy[900000];
pair<int, int> limites(long long num) {
pair<int, int> resp = make_pair(0, 0);
resp.first = lower_bound(quarta.begin(), quarta.end(), num) - quarta.begin();
resp.second = upper_bound(raiz.begin(), raiz.end(), num) - raiz.begin();
--resp.second;
return resp;
}
int soma[900000][4];
void pre() {
for (long long i = 0; i * i < 777777779777LL; ++i) raiz.push_back(i * i);
for (long long i = 0; i * i * i * i < 777777779777LL; ++i)
quarta.push_back(i * i * i * i);
int greatest = 0;
for (int k = 2; k < 900000; ++k) {
pair<int, int> inter = limites(k);
if (inter.first <= inter.second) {
grundy[k] = -1;
for (int i = 0; i < 4; ++i) {
if (!(soma[inter.second][i] - soma[inter.first - 1][i])) {
grundy[k] = i;
break;
}
}
if (grundy[k] == -1) throw 123;
}
for (int i = 0; i < 4; ++i) soma[k][i] = soma[k - 1][i] + (grundy[k] == i);
}
}
int number(long long num) {
if (num < 900000) return grundy[num];
pair<int, int> inter = limites(num);
for (int i = 0; i < 4; ++i) {
if (soma[inter.second][i] - soma[inter.first - 1][i] == 0) {
return i;
}
}
throw 1;
}
int main() {
ios::sync_with_stdio(false);
pre();
int nim = 0, n;
long long tmp;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> tmp;
nim ^= number(tmp);
}
if (nim)
cout << "Furlo" << endl;
else
cout << "Rublo" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, int> dp;
long long int arr[20] = {0, 4, 16, 82, 6724, 50626, 10000000};
long long int ttt[20] = {0, 1, 2, 0, 3, 1};
bool icer(long long int a, long long int b, long long int c, long long int d) {
return b >= c and d >= a;
}
long long int bul(long long int x) {
if (dp.find(x) != dp.end()) return dp[x];
if (x < 4) return dp[x] = 0;
if (x < 16) return dp[x] = 1;
if (x < 82) return dp[x] = 2;
if (x < 6724) return dp[x] = 0;
if (x < 50626) return dp[x] = 3;
if (x <= 10000000) return dp[x] = 1;
set<long long int> S;
long long int t = ceil(pow(x, 0.25)), k = floor(pow(x, 0.5));
for (int i = 0; i <= 5; i++) {
if (icer(t, k, arr[i], arr[i + 1] - 1)) S.insert(ttt[i]);
}
long long int ind = 0;
while (S.find(ind) != S.end()) ind++;
return dp[x] = ind;
}
int main() {
long long int n, x, XOR = 0;
cin >> n;
while (n--) {
cin >> x;
XOR ^= bul(x);
}
if (XOR)
puts("Furlo");
else
puts("Rublo");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
map<long long int, long long int> mp[N];
long long int g[N];
long long int grundy(long long int u) {
long long int a = sqrt(u);
long long int b = sqrt(a);
while (b * b * b * b < u) b++;
int ans = 0;
while (b <= a && mp[a][ans] != mp[b - 1][ans]) ans++;
return ans;
}
int main() {
long long int n, aux;
mp[0][0] = 1;
mp[1][0] = 2;
g[0] = g[1] = 0;
for (int i = 2; i < N; i++) {
aux = grundy(i);
mp[i] = mp[i - 1];
mp[i][aux]++;
g[i] = aux;
}
while (scanf("%I64d", &n) != EOF) {
long long int ans = 0;
for (int i = int(0); i < int(n); i++) {
scanf("%I64d", &aux);
if (aux < N)
ans ^= g[aux];
else
ans ^= grundy(aux);
}
if (!ans)
puts("Rublo");
else
puts("Furlo");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long int n, a, i, p = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (a < 3) p ^= 0;
if (a >= 4 && a <= 15) p ^= 1;
if (a >= 16 && a <= 81) p ^= 2;
if (a >= 82 && a <= 6723) p ^= 0;
if (a >= 6724 && a <= 50625) p ^= 3;
if (a >= 50626 && a <= 2562991875LL) p ^= 1;
if (a >= 2562991876LL) p ^= 2;
}
if (p == 0)
cout << "Rublo";
else
cout << "Furlo";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000007;
const long long f[] = {0, 4, 16, 82, 6724, 50626};
const long long s[] = {3, 15, 81, 6723, 50625, 1000000};
const long long val[] = {0, 1, 2, 0, 3, 1};
int get(long long n) {
int used[5];
memset(used, false, sizeof(used));
if (n <= 1000000) {
for (int i = 0; i <= 5; ++i)
if (f[i] <= n && s[i] >= n) return val[i];
}
long long up = (long long)(sqrt(double(n)) - 2);
while ((up + 1) * (up + 1) <= n) ++up;
long long low = (long long)sqrt(sqrt(double(n))) + 2;
while ((low - 1) * (low - 1) >= n) --low;
for (int i = 0; i <= 5; ++i)
if (f[i] > up || s[i] < low)
;
else
used[val[i]] = true;
int ans = 0;
while (used[ans]) ++ans;
return ans;
}
int main() {
int n;
cin >> n;
int t = 0;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
t ^= get(x);
}
cout << (t ? "Furlo" : "Rublo") << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, x = 0, n, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
if (a > 3 && a < 16) x ^= 1;
if (a > 15 && a < 82) x ^= 2;
if (a >= 82 * 82 && a <= 15 * 15 * 15 * 15) x ^= 3;
if (a > 15 * 15 * 15 * 15 && a <= 2562991875LL) x ^= 1;
if (a > 2562991875LL) x ^= 2;
}
if (x != 0)
cout << "Furlo";
else
cout << "Rublo";
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, long long* A) {
for (int i(0); i < N; i++) scanf("%lld", A + i);
}
struct MEX {
int p[(8) << 1], C[(8)];
void CLR() { (memset(C, 0, sizeof(C))), (memset(p, 0, sizeof(p))); }
int st(int b, int v, int u, int B, int E) {
if (B > b || E < b) return p[u];
if (B == E) return p[u] += v;
return p[u] = st(b, v, u << 1, B, (B + E) >> 1) +
st(b, v, u << 1 | 1, (B + E) / 2 + 1, E);
}
int get() { return gt(1, 0, (8) - 1); }
int gt(int u, int B, int E) {
if (B == E) return B;
if (p[u << 1] == (B + E) / 2 - B + 1)
return gt(u << 1 | 1, (B + E) / 2 + 1, E);
return gt(u << 1, B, (B + E) >> 1);
}
void add(int I) {
if (!C[I]++) st(I, 1, 1, 0, (8) - 1);
}
void del(int I) {
if (!--C[I]) st(I, -1, 1, 0, (8) - 1);
}
} T;
int G[(1000006)] = {0, 0}, O[(1000006)], I, J, N, a, X;
long long A[(1000006)], U, V;
int main(void) {
T.CLR();
for (int k(2); k < (1000006); k++) {
while (J * J <= k) T.add(G[J++]);
while (I * I * I * I < k) T.del(G[I++]);
G[k] = T.get();
}
scanf("%d", &N), ga(N, A), sort(A, A + N), T.CLR();
for (int i(0); i < N; i++) {
if (A[i] < 2) {
X ^= G[A[i]];
continue;
}
while (V * V <= A[i]) T.add(G[V++]);
while (U * U * U * U < A[i]) T.del(G[U++]);
X ^= T.get();
}
puts(!X ? "Rublo" : "Furlo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 881918, K = 881918;
int f[N];
long long num[N];
int sg[N];
int n;
struct BIT {
int bit[N];
void add(int x, int val) {
for (int i = x; i < N; i |= i + 1) bit[i] += val;
}
int get(int x) {
int res = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) res += bit[i];
return res;
}
int get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
} bit[4];
long long pw(long long x, int p) {
if (p == 2)
return 1LL * x * x;
else
return 1LL * x * x * x * x;
}
int sqrt_k(long long x, int k) {
int l = 0, r = (int)min(x - 1, 1LL * (k == 4 ? 950 : 900000)), mid;
while (l + 1 < r) {
mid = (l + r) / 2;
bool flag;
if (k == 2)
flag = pw(mid, k) > x;
else
flag = pw(mid, k) >= x;
if (flag)
r = mid;
else
l = mid;
}
return r;
}
int get_sg(long long i) {
int l = sqrt_k(i, 4), r = sqrt_k(i, 2) - 1;
for (int k = 0; k < 4; k++)
if (bit[k].get(l, r) == 0) return k;
return 4;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int mx = 0;
for (int i = 0; i < N; i++) {
f[i] = get_sg(i);
if (f[i] == -1) assert(false);
bit[f[i]].add(i, 1);
}
cout << endl;
cin >> n;
int xorsum = 0;
for (int i = 0; i < n; i++) {
cin >> num[i];
sg[i] = num[i] < N ? f[num[i]] : get_sg(num[i]);
xorsum ^= sg[i];
}
if (xorsum == 0)
cout << "Rublo" << endl;
else
cout << "Furlo" << endl;
}
|
#include <bits/stdc++.h>
int main() {
int n;
long long a;
int Xor = 0;
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) {
scanf("%I64d", &a);
if (a >= 2562991876LL)
Xor ^= 2;
else if (a >= 50626)
Xor ^= 1;
else if (a >= 6724)
Xor ^= 3;
else if (a >= 82)
Xor ^= 0;
else if (a >= 16)
Xor ^= 2;
else if (a >= 4)
Xor ^= 1;
else
Xor ^= 0;
}
if (Xor == 0)
printf("Rublo");
else
printf("Furlo");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
int cnt_v = 1;
int tree[N * 4];
void build() {
while (cnt_v < N) cnt_v <<= 1;
fill(tree, tree + cnt_v * 2 - 1, 0);
}
void add(int x, int v) {
x += cnt_v - 1;
tree[x] += v;
while (x > 0) {
x = (x - 1) / 2;
tree[x] = min(tree[x * 2 + 1], tree[x * 2 + 2]);
}
}
int get(int x, int lx, int rx) {
if (rx - lx == 1)
return x - (cnt_v - 1);
else if (tree[x * 2 + 1] == 0)
return get(x * 2 + 1, lx, (lx + rx) / 2);
else
return get(x * 2 + 2, (lx + rx) / 2, rx);
}
int grundy[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
build();
int n;
cin >> n;
set<long long> a;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (a.find(x) == a.end())
a.insert(x);
else
a.erase(x);
}
grundy[0] = grundy[1] = grundy[2] = grundy[3] = 0;
add(0, 1);
long long cur4 = 2, cur2 = 2;
for (int i = 4; i < N; i++) {
while ((cur2 + 1) * (cur2 + 1) <= i) {
cur2++;
add(grundy[cur2], 1);
}
while (cur4 * cur4 * cur4 * cur4 < i) {
add(grundy[cur4], -1);
cur4++;
}
grundy[i] = get(0, 0, cnt_v);
}
int ans = 0;
build();
add(0, 1);
cur4 = 2;
cur2 = 2;
for (long long i : a) {
if (i < 4) continue;
while ((cur2 + 1) * (cur2 + 1) <= i) {
cur2++;
add(grundy[cur2], 1);
}
while (cur4 * cur4 * cur4 * cur4 < i) {
add(grundy[cur4], -1);
cur4++;
}
ans ^= get(0, 0, cnt_v);
}
cout << (ans != 0 ? "Furlo" : "Rublo") << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s;
long long x;
int SG(long long x) {
if (x >= 2562991876LL) return 2;
if (x >= 50626) return 1;
if (x >= 6724) return 3;
if (x >= 82) return 0;
if (x >= 16) return 2;
if (x >= 4) return 1;
return 0;
}
int main() {
cin >> n;
while (n--) cin >> x, s ^= SG(x);
puts(s ? "Furlo" : "Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5, mod = 1e9 + 7, inf = 1e9 + 7;
long long n, ans;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x;
if (x < 4) {
y = 0;
} else if (x < 16) {
y = 1;
} else if (x < 82) {
y = 2;
} else if (x < 6724) {
y = 0;
} else if (x < 50626) {
y = 3;
} else if (x < 2562991876ll) {
y = 1;
} else {
y = 2;
}
ans ^= y;
}
if (ans > 0) {
cout << "Furlo";
} else {
cout << "Rublo";
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> visGrundy;
int Grundy(long long first) {
if (first < 4) return 0;
if (first < 16) return 1;
if (first < 82) return 2;
if (first < 6724) return 0;
if (first < 50626) return 3;
if (first < 2562991876LL) return 1;
return 2;
double sqrts = sqrt(first);
long long L = ceil(sqrt(sqrts));
long long R = floor(sqrts);
bool vis[20] = {0};
for (int i = (L); i < (R + 1); ++i) vis[Grundy(i)] = 1;
for (int i = (0); i < (20); ++i)
if (!vis[i]) return visGrundy[first] = i;
}
int main(int argc, char **argv) {
int N;
cin >> N;
int res = 0;
for (int i = (0); i < (N); ++i) {
long long first;
cin >> first;
res ^= Grundy(first);
}
puts(res ? "Furlo" : "Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
int N;
int dn[MAXN][10];
long long a;
long long res;
int f(long long a) {
if (a < MAXN) {
for (int i = 0; i < 10; i++)
if (dn[a][i] != dn[a - 1][i]) return i;
return 10;
}
int x = sqrt(a);
int y = sqrt(x);
if (1LL * y * y * y * y == a) y--;
for (int i = 0; i < 10; i++)
if (dn[x][i] == dn[y][i]) return i;
return 10;
}
int main() {
dn[0][0] = 1;
dn[1][0] = 2;
dn[2][0] = 3;
dn[3][0] = 4;
for (int i = 4; i < MAXN; i++) {
for (int j = 0; j < 10; j++) dn[i][j] = dn[i - 1][j];
int a = sqrt(i);
int b = sqrt(a);
if (b * b * b * b == i) b--;
for (int j = 0; j < 10; j++)
if (dn[a][j] == dn[b][j]) {
dn[i][j]++;
break;
}
}
cin >> N;
while (N--) {
cin >> a;
res ^= f(a);
}
if (res)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
constexpr long long kP[] = {3, 15, 81, 6723, 50625, 2562991875};
constexpr int kSg[] = {0, 1, 2, 0, 3, 1, 2};
int n;
int main(int argc, char const *argv[]) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
long long x;
std::cin >> x;
ans ^= kSg[std::lower_bound(kP, kP + 6, x) - kP];
}
if (ans) {
std::cout << "Furlo";
} else {
std::cout << "Rublo";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 881918, K = 881918;
int f[N];
long long num[N];
int sg[N];
int n;
struct BIT {
int bit[N];
void add(int x, int val) {
for (int i = x; i < N; i |= i + 1) bit[i] += val;
}
int get(int x) {
int res = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) res += bit[i];
return res;
}
int get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
} bit[4];
long long pw(long long x, int p) {
if (p == 2)
return 1LL * x * x;
else
return 1LL * x * x * x * x;
}
int sqrt_k(long long x, int k) {
int l = 0, r = (int)min(x - 1, 1LL * (k == 4 ? 950 : 900000)), mid;
while (l + 1 < r) {
mid = (l + r) / 2;
bool flag;
if (k == 2)
flag = pw(mid, k) > x;
else
flag = pw(mid, k) >= x;
if (flag)
r = mid;
else
l = mid;
}
return r;
}
int get_sg(long long i) {
int l = sqrt_k(i, 4), r = sqrt_k(i, 2) - 1;
for (int k = 0; k < 4; k++)
if (bit[k].get(l, r) == 0) return k;
return 4;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int mx = 0;
for (int i = 0; i < N; i++) {
f[i] = get_sg(i);
bit[f[i]].add(i, 1);
}
cin >> n;
int xorsum = 0;
for (int i = 0; i < n; i++) {
cin >> num[i];
sg[i] = num[i] < N ? f[num[i]] : get_sg(num[i]);
xorsum ^= sg[i];
}
if (xorsum == 0)
cout << "Rublo" << endl;
else
cout << "Furlo" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
long long int t, n, m, a[1000005] = {0};
vector<pair<pair<long long int, long long int>, long long int> > v;
long long int grundy(long long int num) {
for (auto it : v) {
if (num >= it.first.first && num <= it.first.second) return it.second;
}
long long int r = sqrt(num);
long long int l = sqrt(r);
while ((l * l * l * l) < num) l++;
r = min(r, num - 1);
set<long long int> st;
for (long long int i = l; i <= r; i++) {
long long int found = 0;
for (auto it : v) {
if (i >= it.first.first && i <= it.first.second) {
found = 1;
st.insert(it.second);
i = it.first.second;
break;
}
}
if (found == 0) st.insert(grundy(i));
}
long long int i = 0;
while (st.find(i) != st.end()) i++;
return i;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, x, y;
v.push_back({{1, 3}, 0});
v.push_back({{4, 15}, 1});
v.push_back({{16, 81}, 2});
v.push_back({{82, 6723}, 0});
v.push_back({{6724, 50625}, 3});
v.push_back({{50626, 10000000}, 1});
cin >> n;
x = 0;
for (i = 1; i <= n; i++) {
cin >> y;
x = (x ^ grundy(y));
}
if (x)
cout << "Furlo";
else
cout << "Rublo";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int cdigittoint(char ch) { return ch - '0'; }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
const int L = 881920;
int DP[L];
map<int, int> cnt[L];
void Grandy() {
DP[1] = 0;
for (int j = 2; j < L; j++) {
double sq = sqrt(j);
int ed = floor(sq);
int st = ceil(sqrt(sq));
if (st <= ed) {
for (int i = 0;; i++) {
if (cnt[ed][i] - cnt[st - 1][i] == 0) {
DP[j] = i;
break;
}
}
}
cnt[j] = cnt[j - 1];
cnt[j][DP[j]]++;
}
}
int main() {
Grandy();
int(n);
scanf("%d", &n);
long long int ans = 0;
for (int i = 1; i <= n; i++) {
long long int x;
scanf("%lld", &x);
if (x < L) {
ans ^= DP[x];
continue;
}
double sq = sqrt(x);
long long int st = ceil(sqrt(sq));
long long int ed = floor(sq);
for (int i = 0;; i++) {
if (cnt[ed][i] - cnt[st - 1][i] == 0) {
ans ^= i;
break;
}
}
}
if (ans)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long flag[10] = {3, 15, 81, 82 * 82 - 1, 15 * 15 * 15 * 15, 2562991875LL};
long long fuck[10] = {0, 1, 2, 0, 3, 1, 2};
long long n, ans, x;
long long work() {
int i;
for (i = 0; i < 6; i++) {
if (x <= flag[i]) break;
}
return fuck[i];
}
int main() {
while (~scanf("%I64d", &n)) {
ans = 0;
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &x);
ans ^= work();
}
if (ans)
printf("Furlo\n");
else
printf("Rublo\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sg(long long x) {
if (x <= 3) return 0;
if (x <= 15) return 1;
if (x <= 81) return 2;
if (x <= 6723) return 0;
if (x <= 50625) return 3;
if (x <= 2562991875LL)
return 1;
else
return 2;
}
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
ans ^= sg(x);
}
if (ans)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kN = 1000 * 1000 + 1;
const int kM = 5;
int sum[kN][kM];
int gr[kN];
long long Sqrt4(long long n) {
long long l = 0, r = 10 * 1000;
while (l < r) {
long long m = (l + r) / 2;
if (m * m * m * m < n)
l = m + 1;
else
r = m;
}
return l;
}
long long Sqrt(long long n) {
long long l = 0, r = 1000 * 1000 * 1000;
while (l < r) {
long long m = (l + r + 1) >> 1;
if (m * m > n)
r = m - 1;
else
l = m;
}
return l;
}
void PreCalc() {
sum[1][0] = 1;
gr[1] = 0;
sum[2][0] = 2;
gr[2] = 0;
sum[3][0] = 3;
gr[3] = 0;
for (int n = 4; n < kN; ++n) {
int l = Sqrt4(n), r = Sqrt(n);
int cnt[kM];
for (int i = 0; i < kM; ++i) {
sum[n][i] = sum[n - 1][i];
cnt[i] = sum[r][i] - sum[l - 1][i];
}
for (int i = 0; i < kM; ++i)
if (cnt[i] == 0) {
++sum[n][i];
gr[n] = i;
break;
}
}
}
int Gr(long long n) {
if (n < kN) return gr[n];
int l = Sqrt4(n), r = Sqrt(n);
int cnt[kM];
for (int i = 0; i < kM; ++i) cnt[i] = sum[r][i] - sum[l - 1][i];
for (int i = 0; i < kN; ++i)
if (cnt[i] == 0) return i;
}
int main() {
PreCalc();
int n;
cin >> n;
int x = 0;
for (int i = 0; i < n; ++i) {
long long value;
cin >> value;
x ^= Gr(value);
}
cout << (x == 0 ? "Rublo" : "Furlo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int getfastergrundy(long long pos) {
if (pos < 4)
return 0;
else if (pos < 16)
return 1;
else if (pos < 82)
return 2;
else if (pos < 6724)
return 0;
else if (pos < 50626)
return 3;
else if (pos < 2562991876)
return 1;
else
return 2;
}
int getgrundy(long long pos) {
if (pos <= 2300000000) return getfastergrundy(pos);
set<long long> s;
long long ret = 0;
long long st = ceil(pow(pos, 1.0 / 4.0));
long long en = (long long)pow(pos, 1.0 / 2.0);
for (int i = st; i <= min(pos - 1, en); i++) s.insert(getgrundy(i));
while (s.count(ret)) ret++;
return ret;
}
int main() {
int n;
while (cin >> n) {
long long a;
long long out = 0;
for (long long i = 0; i < n; i++) {
cin >> a;
out ^= getfastergrundy(a);
}
if (!out)
cout << "Rublo\n";
else
cout << "Furlo\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int n;
vector<pair<pair<long long int, long long int>, int> > range;
int main() {
range.push_back(make_pair(make_pair(0, 3), 0));
range.push_back(make_pair(make_pair(4, 15), 1));
range.push_back(make_pair(make_pair(16, 81), 2));
range.push_back(make_pair(make_pair(82, 6723), 0));
range.push_back(make_pair(make_pair(6724, 50625), 3));
range.push_back(make_pair(make_pair(50626ll, 2562991875ll), 1));
range.push_back(make_pair(make_pair(2562991876ll, 1e13), 2));
cin >> n;
int sum = 0;
for (int i = 0; i < n; ++i) {
long long int a;
cin >> a;
for (int j = 0; j < range.size(); ++j)
if (range[j].first.first <= a && a <= range[j].first.second) {
sum ^= range[j].second;
}
}
if (sum)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gr[1000000 + 100];
set<int> cnj;
long long vs[1000000 + 10];
int cnt[1000000 + 10];
void f1(long long &p1, long long &p2) {
p2++;
cnt[gr[p2]]++;
if (p1 <= p2 && cnt[gr[p2]] == 1) cnj.erase(gr[p2]);
}
void f2(long long &p1, long long &p2) {
cnt[gr[p1]]--;
if (p1 <= p2 && cnt[gr[p1]] == 0) cnj.insert(gr[p1]);
p1++;
}
int main() {
cin.sync_with_stdio(false);
long long p1 = 2, p2 = 2;
for (int i = 0; i < 10; i++) cnj.insert(i);
cnt[0]++, cnj.erase(0);
gr[0] = 0;
int mm = 0;
for (int i = 4; i < 1000000 + 10; i++) {
while (p2 + 1 < i && (p2 + 1) * (p2 + 1) <= i) f1(p1, p2);
while (p1 * p1 * p1 * p1 < i) f2(p1, p2);
if (cnj.size() == 0) throw 0;
gr[i] = *cnj.begin();
mm = max(mm, gr[i]);
}
while (p1 <= p2) f2(p1, p2);
int n;
cin >> n;
long long rsp = 0;
for (int i = 0; i < n; i++) cin >> vs[i];
sort(vs, vs + n);
for (int i = 0; i < 100000; i++) cnj.insert(i);
cnt[0]++, cnj.erase(0);
p1 = p2 = 2;
for (int i = 0; i < n; i++) {
if (vs[i] < 4) continue;
while (p2 + 1 < vs[i] && (p2 + 1) * (p2 + 1) <= vs[i]) f1(p1, p2);
while (p1 * p1 * p1 * p1 < vs[i]) f2(p1, p2);
rsp ^= *cnj.begin();
}
if (rsp)
cout << "Furlo" << endl;
else
cout << "Rublo" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int a[7] = {1, 4, 16, 82, 6724, 50626, 1000000000},
b[7] = {0, 1, 2, 0, 3, 1, 114514};
int mark[100];
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; ++i) {
ll temp;
cin >> temp;
int lb = ceil(pow(temp, 0.25)), hb = min(temp - 1, (ll)floor(sqrt(temp)));
for (int j = 0; j < 6; ++j)
if (a[j] <= hb && a[j + 1] - 1 >= lb) mark[b[j]] = i;
if (lb <= hb) {
for (int j = 0;; ++j)
if (mark[j] != i) {
ans ^= j;
break;
}
}
}
cout << (ans == 0 ? "Rublo" : "Furlo");
}
|
#include <bits/stdc++.h>
using namespace std;
int f(long long n) {
if (n < 4) return 0;
if (n < 16) return 1;
if (n < 82) return 2;
if (n < 6724) return 0;
if (n < 50626) return 3;
if (n < 50626LL * 50626LL) return 1;
return 2;
}
int main() {
int n;
long long x, now = 0;
scanf("%d", &n);
scanf("%I64d", &now);
now = f(now);
for (int i = 1; i < n; i++) {
scanf("%I64d", &x);
now ^= f(x);
}
if (now == 0)
printf("Rublo\n");
else
printf("Furlo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sg(long long x) {
if (x < 4) return 0;
if (x < 16) return 1;
if (x < 82) return 2;
if (x < 6724) return 0;
if (x < 50626) return 3;
if (x < 2562991876LL) return 1;
return 2;
}
int main() {
int n, ans = 0;
long long x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) cin >> x, ans ^= sg(x);
if (ans)
puts("Furlo");
else
puts("Rublo");
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
while (~scanf("%d", &n)) {
long long x;
int ans = 0;
for (int i = 0; i < n; i++) {
scanf("%I64d", &x);
if (x < 4)
ans ^= 0;
else if (x < 16)
ans ^= 1;
else if (x < 82)
ans ^= 2;
else if (x < 6724)
ans ^= 0;
else if (x < 50626)
ans ^= 3;
else if (x < 2562991876LL)
ans ^= 1;
else
ans ^= 2;
}
if (ans)
puts("Furlo");
else
puts("Rublo");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f(long long n) {
if (n < 4) return 0;
if (n < 16) return 1;
if (n < 82) return 2;
if (n < 6724) return 0;
if (n < 50626) return 3;
if (n < 2562890626LL) return 1;
return 2;
}
int main() {
int n;
long long x, now = 0;
scanf("%d", &n);
scanf("%I64d", &now);
now = f(now);
for (int i = 1; i < n; i++) {
scanf("%I64d", &x);
now ^= f(x);
}
if (now == 0)
printf("Rublo\n");
else
printf("Furlo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[] = {3, 15, 81, 6723, 50625, 2562991875};
int b[] = {0, 1, 2, 0, 3, 1, 2};
int main() {
int n;
cin >> n;
int grundy = 0;
for (int i = 0; i < n; ++i) {
long long y;
cin >> y;
grundy ^= b[lower_bound(a, a + 6, y) - a];
}
if (grundy == 0)
cout << "Rublo" << endl;
else
cout << "Furlo" << endl;
return 0;
}
|
#include <bits/stdc++.h>
size_t mex(std::unordered_set<size_t>& s) {
size_t result = 0;
while (s.find(result) != s.end()) {
result += 1;
}
return result;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
const int64_t limit = 1000000;
std::vector<std::tuple<int64_t, int64_t, size_t>> comp;
comp.emplace_back(0, 0, 0);
comp.emplace_back(1, 1, 1);
comp.emplace_back(2, 3, 0);
for (int64_t i = 4; i <= limit; ++i) {
std::unordered_set<size_t> local;
for (size_t j = comp.size() - 1; j < comp.size(); --j) {
const auto [l, r, sg] = comp[j];
if (r * r >= i || r * r * r >= i || r * r * r * r >= i) {
if (l * l <= i) {
local.insert(sg);
}
} else {
break;
}
}
const size_t sg = mex(local);
if (sg == std::get<2>(comp.back())) {
std::get<1>(comp.back()) += 1;
} else {
comp.emplace_back(i, i, sg);
}
}
size_t n;
std::cin >> n;
size_t result = 0;
for (size_t i = 0; i < n; ++i) {
int64_t a;
std::cin >> a;
std::unordered_set<size_t> local;
for (size_t j = comp.size() - 1; j < comp.size(); --j) {
const auto [l, r, sg] = comp[j];
if (r * r >= a || r * r * r >= a || r * r * r * r >= a) {
if (l * l <= a) {
local.insert(sg);
}
} else {
break;
}
}
result ^= mex(local);
}
if (result == 0) {
std::cout << "Rublo\n";
} else {
std::cout << "Furlo\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int X = 5;
int dp[N][X];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 2; i < N; i++) {
int l = ceil(pow(i, 0.25));
int r = sqrt(i);
int ok = 0;
for (int j = 0; j < X; j++) {
if (dp[r][j] - dp[l - 1][j] == 0) {
dp[i][j] = 1;
ok = 1;
break;
}
}
assert(ok);
for (int j = 0; j < X; j++) {
dp[i][j] += dp[i - 1][j];
}
}
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
long long a;
cin >> a;
if (a == 1) continue;
int l = ceil(pow(a, 0.25));
int r = sqrt(a);
int ok = 0;
for (int j = 0; j < X; j++) {
if (dp[r][j] - dp[l - 1][j] == 0) {
ans ^= j;
ok = 1;
break;
}
}
assert(ok);
}
if (ans)
cout << "Furlo\n";
else
cout << "Rublo\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, res;
res = 0;
scanf("%I64d", &n);
for (i = 1; i <= (n); i++) {
scanf("%I64d", &m);
if (m <= 3)
res = res ^ 0;
else if (m <= 15)
res = res ^ 1;
else if (m <= 81)
res = res ^ 2;
else if (m <= 6723)
res = res ^ 0;
else if (m <= 50625)
res = res ^ 3;
else if (m <= 2562991875)
res = res ^ 1;
else
res = res ^ 2;
}
if (res == 0)
printf("Rublo");
else
printf("Furlo");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[77800], grundy[881925];
multiset<int> st;
void pre() {
long long maxx = 881920;
int l = 1, r = 1, nl, nr, j, i;
grundy[1] = 0;
st.insert(grundy[1]);
for (i = 2; i <= maxx; i++) {
nl = ceil(sqrt((double)sqrt(i)));
nr = sqrt(i);
if (nr < nl) continue;
while (r < nr) {
r++;
st.insert(grundy[r]);
}
while (l < nl) {
multiset<int>::iterator it = st.find(grundy[l]);
st.erase(it);
l++;
}
j = 0;
while (st.find(j) != st.end()) j++;
grundy[i] = j;
}
st.clear();
}
int main() {
long long n, ans = 0;
long long l = 1, r = 1, nl, nr, j, i;
scanf("%I64d", &n);
for (i = 0; i < n; i++) scanf("%I64d", &arr[i]);
pre();
sort(arr, arr + n);
l = r = 1;
st.insert(grundy[1]);
for (i = 0; i < n; i++) {
if (arr[i] == 1) continue;
nl = ceil(sqrt((double)sqrt(arr[i])));
nr = sqrt(arr[i]);
if (nr < nl) continue;
while (r < nr) {
r++;
st.insert(grundy[r]);
}
while (l < nl) {
multiset<int>::iterator it = st.find(grundy[l]);
st.erase(it);
l++;
}
j = 0;
while (st.find(j) != st.end()) j++;
ans ^= j;
}
if (ans == 0)
printf("Rublo\n");
else
printf("Furlo\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int n;
int main() {
scanf("%s", s + 2);
n = strlen(s + 2);
int now = n + 1, ans = 0;
while (1) {
while (s[now] == '0') now--;
if (s[now] == 0) break;
int m = now;
while (s[m] == '1') m--;
if (m + 1 == now)
ans++, now = m;
else {
s[m] = '1';
now = m;
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000500;
char s[N];
int n;
int main() {
gets(s);
n = strlen(s);
reverse(s, s + n);
for (int i = n; i < N; i++) s[i] = '0';
int ptr = -1;
for (int i = 0; i < n; i++) {
if (s[i] != '1') ptr = -1;
if (ptr == -1 && s[i] == '1') ptr = i;
if (ptr != -1 && ptr < i && (i + 1 >= n || s[i + 1] != '1')) {
for (int j = ptr + 1; j <= i; j++) s[j] = '0';
s[ptr] = '2';
if (i + 1 >= n) n++;
if (s[i + 1] == '1')
s[i + 1] = '0';
else
s[i + 1] = '1';
ptr = -1;
}
}
int cnt = 0;
for (int i = 0; i < n; i++)
if (s[i] != '0') cnt++;
printf("%d", cnt);
return 0;
}
|
#include <bits/stdc++.h>
int N, M;
char st[1000001];
void init();
void doit();
int main() {
init();
doit();
return 0;
}
void init() { gets(st); }
void doit() {
int y, ans = 1, x = 1, L = strlen(st);
while ((y = x) < L) {
while (st[x] == st[y]) y++;
ans += (st[x] == '1' || y < L);
x = y + 1;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
int a = 0, b = 1;
cin >> n;
for (int i = 0; i < n.size(); i++)
if (n[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
cout << min(b + 1, a);
{
char _;
cin >> _;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int n_ = 1e5 + 5;
string s;
int dp[1000005][2];
int solve(int i = s.size() - 1, int f = 0) {
if (i == -1) return 0;
int &ret = dp[i][f];
if (~ret) return ret;
if (s[i] == ('0' + f)) return ret = solve(i - 1, f);
return ret = 1 + min(solve(i - 1, f), solve(i - 1, !f));
}
int main() {
cin >> s;
reverse(s.begin(), s.end());
s.push_back('0');
reverse(s.begin(), s.end());
memset(dp, -1, sizeof dp);
cout << solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1000006];
int dp[1000006][2];
int n;
int go(int pos, bool b) {
int &ret = dp[pos][b];
if (ret != -1) return ret;
if (pos == n) return ret = 0;
int val, v1, v2;
if (b) {
if (a[pos] == '1') {
ret = go(pos + 1, 1);
} else {
v1 = go(pos + 1, 1) + 1;
v2 = go(pos + 1, 0);
ret = ((v1) < (v2) ? (v1) : (v2));
}
} else {
if (a[pos] == '0') {
ret = go(pos + 1, 0);
} else {
v1 = go(pos + 1, 0) + 1;
v2 = go(pos + 1, 1) + 2;
ret = ((v1) < (v2) ? (v1) : (v2));
}
}
return ret;
}
int main() {
cin >> a;
n = strlen(a);
memset((dp), (-1), sizeof(dp));
go(0, 0);
cout << dp[0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
const int N = 1000005;
int dp[N][2];
int call(int pos, int tp) {
if (pos == str.size()) {
if (tp == 0)
return 0;
else
return 1e9;
}
if (dp[pos][tp] != -1) return dp[pos][tp];
int ret = 1e9;
int d = str[pos] - '0';
if (tp == 0) {
ret = min(ret, d + call(pos + 1, tp));
if (d < 1) ret = min(ret, d + 1 + call(pos + 1, 1 - tp));
} else {
int f = 2 - d - 1;
ret = min(ret, f + call(pos + 1, tp));
ret = min(ret, f + 1 + call(pos + 1, 1 - tp));
}
return dp[pos][tp] = ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
memset(dp, -1, sizeof(dp));
cin >> str;
reverse(str.begin(), str.end());
str += "0";
reverse(str.begin(), str.end());
cout << call(0, 0) << "\n";
}
|
#include <bits/stdc++.h>
char str[1000010];
int main() {
int len, ans = 0, n1 = 0, n0 = 0, j = 0, i;
str[0] = '0';
scanf("%s", str + 1);
len = strlen(str);
if (len > 2) {
for (i = len; i > 0; i--) {
if (str[i] == '1') {
j = i;
while (str[i - 1] == '1') {
str[i] = '0';
i--;
}
if (i < j) {
ans++;
str[i--] = '0';
str[i++] = '1';
}
}
}
for (i = 0; i < len; i++) {
ans += (str[i] - '0');
}
} else if (str[1] == '1')
ans++;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
char a[1001000];
int main() {
int i, len, n;
while (gets(a)) {
n = 0;
len = strlen(a);
for (i = len; i >= 0; i--)
if (a[i] == '1') {
if (i == 0) {
n++;
break;
}
if (a[i - 1] == '0') {
n++;
i--;
} else {
while (i >= 0 && a[i] != '0') i--;
n++;
if (i < 0) {
n++;
break;
}
a[i] = '1';
i++;
}
}
printf("%d\n", n);
}
return 0;
}
|
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
int main(void) {
char s[1000001];
int i, len, m[2], p[2], j;
scanf("%s", s);
len = strlen(s);
p[0] = 0;
p[1] = 2;
for (j = 1; j <= len; j++) {
m[0] = min(p[0] + (s[j - 1] == '1'), p[1] + (s[j - 1] == '1'));
m[1] = min(p[1] + (s[j - 1] == '0'), p[0] + 2);
p[0] = m[0];
p[1] = m[1];
}
printf("%d\n", min(m[0], m[1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n;
string s;
long long cache[N][2];
long long dp(long long idx, long long carry) {
if (idx == -1) return carry;
long long &ans = cache[idx][carry];
if (ans != -1) return ans;
long long cur = (s[idx] - '0' + carry) % 2;
long long newcarry = (s[idx] - '0' + carry) / 2;
ans = dp(idx - 1, newcarry) + cur;
cur = (s[idx] - '0' + carry + 1) % 2;
newcarry = (s[idx] - '0' + carry + 1) / 2;
ans = min(ans, dp(idx - 1, newcarry) + cur + 1);
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(cache, -1, sizeof(cache));
cin >> s;
n = s.size();
long long ans = dp(n - 1, 0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
template <class T>
T absolute(T a) {
if (a > 0)
return a;
else
return -a;
}
inline long long power(long long base, long long p) {
long long ans = 1;
while (p > 0) ans *= base, p -= 1;
return ans;
}
int main() {
string bin;
int len;
getline(cin, bin);
len = bin.length();
int zero = 0, count = 0, one = 0;
for (int i = 0; i < len; i++) {
if (bin[i] == '1')
one++;
else
zero++;
if (one == 0) {
zero = 0;
continue;
}
if (bin[i] == '0') {
if (bin[i - 1] == '0') {
count += min(one, zero);
zero = 0;
one = 0;
}
}
}
if (len == 1) {
if (bin[len - 1] == '0')
count = 0;
else
count = 1;
} else {
if (!(bin[len - 1] == '0' && bin[len - 2] == '0')) {
count += min(one, zero + 2);
if (one >= zero + 2 && bin[len - 1] == '0') count--;
}
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s = "0" + s + "0";
int res = 0;
for (int i = 1; i < s.length() - 1; i++) {
if (s.substr(i - 1, 3) == "101") {
res++;
s[i] = '1';
}
if (s.substr(i - 1, 3) == "010") {
res++;
s[i] = '0';
}
}
for (int i = 0; i < s.length() - 1; i++)
if (s[i] == '1' && s[i + 1] == '0') res += 2;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int get(int x) {
int ret = 0;
while (x) {
x = x / 2;
ret++;
}
return ret;
}
const int M = 25;
char s[1000005];
int n, i, j, ans, f[2][2][50];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
memset(f, 0x7f, sizeof(f));
f[0][0][M] = 0;
for (i = 1; i <= n; i++)
for (j = 1; j < 50; j++) {
f[i & 1][0][j] = f[i & 1][1][j] = 1e9;
if (s[i] == '1') {
f[i & 1][0][j] =
min(f[(i - 1) & 1][0][j] + 1, f[(i - 1) & 1][1][j - 1] + 1);
f[i & 1][1][j] =
min(f[(i - 1) & 1][1][j], f[(i - 1) & 1][0][j + 1] + 1);
} else {
f[i & 1][1][j] =
min(f[(i - 1) & 1][1][j] + 1, f[(i - 1) & 1][0][j + 1] + 1);
f[i & 1][0][j] =
min(f[(i - 1) & 1][0][j], f[(i - 1) & 1][0][j - 1] + 1);
}
}
ans = 1e9;
for (i = 1; i < 50; i++) {
ans = min(ans, f[n & 1][1][i] + get(abs(i - M)));
ans = min(ans, f[n & 1][0][i] + get(abs(i - M)));
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000100];
int n, ans;
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
for (int i = 0; i < n; i++) ans += s[i] == '1';
for (int i = 0, j; i + 1 < n; i++)
if (s[i] == '1' && s[i + 1] == '1') {
for (j = i; j + 1 < n && s[j + 1] == '1'; j++)
;
s[j + 1] = '1';
ans -= j - i + 1 - 2;
i = j;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
int main() {
int dp[1000005][2];
string temp;
cin >> temp;
int d = temp.length();
if (temp[d - 1] == '1') {
dp[d - 1][0] = 1;
dp[d - 1][1] = 1;
} else {
dp[d - 1][0] = 0;
dp[d - 1][1] = 1001001001;
}
for (int i = d - 2; i >= 0; i--) {
if (temp[i] == '0') {
dp[i][0] = min(dp[i + 1][0], dp[i + 1][1] + 1);
dp[i][1] = dp[i + 1][1] + 1;
} else {
dp[i][0] = dp[i + 1][0] + 1;
dp[i][1] = min(dp[i + 1][0] + 1, dp[i + 1][1]);
}
}
printf("%d", min(dp[0][0], dp[0][1] + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int dnp[1000005], dnn[1000005];
char s[1000005], last;
int main() {
scanf(" %s", s);
N = strlen(s);
dnp[N - 1] = (s[N - 1] == '1');
dnn[N - 1] = 1;
for (int i = N - 2; i >= 0; i--) {
if (s[i] == '0') {
dnp[i] = dnp[i + 1];
dnn[i] = 1 + min(dnn[i + 1], dnp[i + 1]);
} else {
dnp[i] = 1 + min(dnp[i + 1], dnn[i + 1]);
dnn[i] = dnn[i + 1];
}
}
printf("%d\n", dnp[0]);
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int i = 0;
int N = s.size();
int cnt = 0;
for (int i = 0; i < N; i++)
if (s[i] == '0') cnt++;
int ans = 0;
int tmp = 0;
while (i < N) {
bool flag = false;
int num = 0;
while (i < N && s[i] == '0') i++, num++;
if (num == 1 && tmp > 1) {
flag = true;
}
if (flag == false) tmp = 0;
if (i >= N) break;
while (i < N && s[i] == '1') {
tmp++;
i++;
}
if (flag)
ans++;
else if (tmp == 1)
ans += 1;
else
ans += 2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int dpO[1000010], dpZ[1000010], ones[1000010], zeros[1000010];
string s;
int real(int pos) { return s[pos] == '0' ? dpZ[pos] : dpO[pos]; }
int main() {
int n;
cin >> s;
s = "0" + s;
ones[0] = -1;
zeros[0] = 0;
n = int((s).size());
for (int i = 1; i < n; i++) {
ones[i] = ones[i - 1];
zeros[i] = zeros[i - 1];
if (s[i] == '0')
zeros[i] = i;
else
ones[i] = i;
}
dpO[0] = 1;
dpZ[0] = 0;
for (int i = 1; i < n; i++) {
dpO[i] = min(dpO[zeros[i - 1]] + 1, real(i - 1) + 1);
dpZ[i] = min(dpZ[ones[i - 1]] + 1, real(i - 1));
}
printf("%d\n", real(n - 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000001];
int dp[1000001][2];
int main() {
int i, len;
scanf("%s", s);
len = strlen(s);
for (i = 0; i <= len; i++) {
dp[i][0] = 999999999;
dp[i][1] = 999999999;
}
dp[0][0] = 0;
for (i = 1; i <= len; i++) {
if (s[i - 1] == '1') {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + 1;
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1]);
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1]) + 1;
}
}
printf("%d\n", min(dp[len][0], dp[len][1]));
}
|
#include <bits/stdc++.h>
using namespace std;
const int inv = numeric_limits<int>::max();
const int minv = numeric_limits<int>::min();
const int max_n = 1000010;
int n;
char s[max_n + 5];
int dp[max_n + 1][2];
int main() {
scanf("%s", s);
for (n = 0; s[n] != '\0'; ++n)
;
while (s[n - 1] == '0') --n;
if (n == 0) {
printf("%d\n", 2);
return 0;
}
reverse(s, s + n);
dp[1][0] = 1;
dp[1][1] = 1;
for (int i = 2; i < n + 1; ++i) {
if (s[i - 1] == '1') {
dp[i][0] = min(1 + dp[i - 1][0], 1 + dp[i - 1][1]);
dp[i][1] = min(dp[i - 1][1], 2 + dp[i - 1][0]);
} else {
dp[i][0] = min(dp[i - 1][0], 2 + dp[i - 1][1]);
dp[i][1] = min(1 + dp[i - 1][1], 1 + dp[i - 1][0]);
}
}
printf("%d\n", dp[n][0]);
return 0;
}
|
#include <bits/stdc++.h>
char str[1000010];
int dp[1000010][2];
int min(int a, int b) { return a < b ? a : b; }
int main() {
int i;
while (~scanf("%s%*c", str)) {
dp[0][0] = 1, dp[0][1] = 2;
for (i = 1; str[i]; i++) {
if (str[i] == '0') {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
dp[i][1] = min(dp[i - 1][0] + 3, dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0] + 1, dp[i - 1][1] + 1);
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1]);
}
}
printf("%d\n", min(dp[i - 1][0], dp[i - 1][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maps[501][501];
int xx[5] = {1, 0, -1, 0};
int yy[5] = {0, -1, 0, 1};
int sum[2000010];
int num[2000010];
void init() {}
char str[2000010];
int main() {
int n, i, t;
while (~scanf("%s", str)) {
int len = strlen(str);
for (i = len; i >= 1; i--) {
num[i] = str[i - 1] - '0';
}
int leap = 0;
int ms;
ms = 0;
num[0] = 0;
for (i = len; i >= 0; i--) {
if (num[i] == 0) {
if (leap != 0) {
if (i == 0) {
ms++;
continue;
}
num[i] = 1;
leap = 0;
i++;
}
} else {
if (leap == 0) {
if (num[i - 1] == 1) {
leap = 1;
ms++;
} else {
ms++;
leap = 0;
}
}
}
}
if (num[0] == 1) ms++;
cout << ms << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int N = s.size();
int total = 0;
s = "0" + s + "0";
bool chain = false;
int zd = 0;
for (int i = 1, j = 0; j < N; i++, j++) {
if (s[i] == '1') {
zd = 0;
if (s[i - 1] == '0' && s[i + 1] == '0')
total += 1;
else if (s[i - 1] == '0' && s[i + 1] == '1')
total += (chain ? 0 : 1);
else {
chain = true;
if (s[i - 1] == '1' && s[i + 1] == '0')
total += 1;
else if (s[i - 1] == '1' && s[i + 1] == '1')
total += 0;
}
} else
zd += 1;
if (zd > 1) chain = false;
}
cout << total << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int f(int i, int pre, vector<vector<int>>& dp) {
if (i == n) return 0;
if (dp[i][pre] != -1) return dp[i][pre];
if (s[i] == '0') {
if (pre == 0) dp[i][pre] = f(i + 1, 0, dp);
if (pre == 1) dp[i][pre] = 1 + min(f(i + 1, 0, dp), f(i + 1, 1, dp));
} else {
if (pre == 1) dp[i][pre] = f(i + 1, 1, dp);
if (pre == 0) dp[i][pre] = 1 + min(f(i + 1, 1, dp), f(i + 1, 0, dp));
}
return dp[i][pre];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
reverse((s).begin(), (s).end());
s.push_back('0');
n = s.length();
vector<vector<int>> dp(n, vector<int>(2, -1));
cout << f(0, 0, dp) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000006;
char s[maxn];
int n;
void read() {
scanf("%s", s);
n = strlen(s);
}
int dp[maxn][2];
void solve() {
dp[0][0] = 0;
dp[0][1] = 2;
for (int i = 0; i < n; ++i) {
if (s[i] == '1') {
dp[i + 1][0] = min(dp[i][0] + 1, dp[i][1]);
dp[i + 1][1] = min(dp[i][0] + 2, dp[i][1]);
} else {
dp[i + 1][0] = min(dp[i][0], dp[i][1]);
dp[i + 1][1] = min(dp[i][0] + 2, dp[i][1] + 1);
}
}
cout << min(dp[n][0], dp[n][1]) << endl;
;
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
int ans = 0, one = 0;
for (int k = n - 1; k >= 0; --k) {
if (s[k] == '1')
++one;
else if (one > 1)
one = 1, ++ans;
else if (one == 1)
one = 0, ++ans;
else
one = 0;
}
if (one == 1)
++ans;
else
ans += 2;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
string s;
int n, dp[N][2];
bool vis[N][2];
int fun(int pos, int cur) {
if (pos == -1) return cur;
int &ret = dp[pos][cur];
if (vis[pos][cur]) return ret;
vis[pos][cur] = true;
int add = (s[pos] - '0' + cur) % 2;
int nwcur = (s[pos] - '0' + cur) / 2;
ret = fun(pos - 1, nwcur) + add;
add = (s[pos] - '0' + cur + 1) % 2;
nwcur = (s[pos] - '0' + cur + 1) / 2;
ret = min(ret, fun(pos - 1, nwcur) + add + 1);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> s;
n = s.size();
cout << fun(n - 1, 0) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == '1') ans++;
int cnt = 0;
bool fl = 0;
for (int i = 0; i < s.size();) {
int j = i;
while (j < s.size() && s[j] == '0') j++;
int t = j;
while (j < s.size() && s[j] == '1') j++;
if (t - i > 1) fl = 0;
if (j - t == 0) break;
if (j - t == 1) cnt++;
if (j - t > 1) {
if (fl == 0) cnt++;
cnt++;
fl = 1;
}
i = j;
}
ans = min(ans, cnt);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int dp[1000005][2];
int main() {
int i, l;
scanf("%s", s);
l = strlen(s);
for (i = 0; i <= l; i++) {
dp[i][0] = 999999999;
dp[i][1] = 999999999;
}
dp[0][0] = 0;
for (i = 1; i <= l; i++) {
if (s[i - 1] == '1') {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + 1;
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1]);
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1]) + 1;
}
}
printf("%d\n", min(dp[l][0], dp[l][1]));
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1000100;
int n, d[mxn][2], pr[mxn];
char s[mxn];
int main() {
gets(s);
n = strlen(s);
int pr = -1;
for (int i = 0, j; i < n; i = j) {
if (s[i] == '0')
j = i + 1;
else {
for (j = i; s[j] == '1'; ++j)
;
int k = j - i;
if (pr == -1) {
d[j - 1][0] = min(k, 2);
d[j - 1][1] = 2;
} else {
int l = i - pr - 1;
d[j - 1][0] = min(d[pr][0] + min(k, 2), d[pr][1] + l);
d[j - 1][1] = min(d[pr][0] + 2, d[pr][1] + l);
}
pr = j - 1;
}
}
printf("%d\n", d[pr][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1123456][2];
string s[2];
int sz;
int f(int pos, int p) {
int &res = dp[pos][p];
if (res != -1) return res;
if (pos == sz) return res = 0;
if (s[p][pos] == '1')
res = f(pos + 1, p) + 1;
else
res = min(f(pos + 1, p), f(pos + 1, 1 - p) + 1);
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s[0];
sz = s[0].size();
bool preste = false;
for (int i = sz - 1; i >= 0; i--) {
char act = '0';
if (s[0][i] == '0' and preste) act = '1';
if (s[0][i] == '1' and !preste) {
act = '1';
preste = true;
}
s[1].push_back(act);
}
reverse(s[1].begin(), s[1].end());
memset(dp, -1, sizeof dp);
cout << min(f(0, 0), f(0, 1) + 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int N = s.size();
int total = 0;
s = "0" + s + "0";
bool chain = false;
int zd = 0;
for (int i = 1, j = 0; j < N; i++, j++) {
if (s[i] == '1') {
zd = 0;
if (s[i - 1] == '0' && s[i + 1] == '0')
total += 1;
else if (s[i - 1] == '0' && s[i + 1] == '1')
total += (chain ? 0 : 1);
else {
chain = true;
if (s[i - 1] == '1' && s[i + 1] == '0')
total += 1;
else if (s[i - 1] == '1' && s[i + 1] == '1')
total += 0;
}
} else
zd += 1;
if (zd > 1) chain = false;
}
cout << total << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
const int N = 1000005;
char s[N];
int dp[N][2];
int one_cnts[N];
int main() {
while (cin >> (s + 1)) {
int len = strlen(s + 1);
dp[0][0] = 0;
dp[0][1] = 2;
for (int i = 1; i <= len; ++i) {
if (s[i] == '0') {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 2);
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0] + 1, dp[i - 1][1]);
dp[i][1] = min(dp[i - 1][1], dp[i - 1][0] + 2);
}
}
cout << min(dp[len][0], dp[len][1] + 2) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int abs(int a) {
if (a < 0) return -1 * a;
return a;
}
int big(int a, int b) {
if (a > b) return a;
return b;
}
int small(int a, int b) {
if (a < b) return a;
return b;
}
int compare(const void *a, const void *b) {
int *p1 = (int *)a;
int *p2 = (int *)b;
return *p1 - *p2;
}
char s[1000005];
int main() {
int m, l, ans, sum, min, max, n, i, j, k, x, y, t;
scanf("%s", s);
n = strlen(s);
i = n - 1;
int count = 0;
while (i >= 0) {
if (s[i] == '0') {
i--;
continue;
}
count++;
if (i == 0) {
i--;
continue;
}
if (s[i - 1] == '0') {
i--;
continue;
}
while (s[i] != '0' && i) i--;
if (i == 0) {
count++;
i--;
continue;
}
s[i] = '1';
}
printf("%d", count);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
string s;
cin >> s;
vector<int> v;
int index = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') {
index = i;
break;
}
}
bool flag;
for (int i = index; i < s.size(); ++i) {
int qtd = 1;
while (i < s.size() - 1 && s[i + 1] == s[i]) {
qtd++;
++i;
}
v.push_back(qtd);
}
flag = false;
for (int i = 0; i < v.size(); i++) {
if (i & 1) {
if (v[i] > 1) flag = false;
} else {
if (v[i] >= 2) {
if (flag)
ans++;
else {
ans += 2;
flag = true;
}
} else {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int a[2] = {0, 1};
char c;
while (cin >> c) a['1' - c] = min(a[0], a[1]) + 1;
cout << a[0];
return 0;
}
|
#include <bits/stdc++.h>
char s[1000001];
int dp[1000001][2];
int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%s", s);
int n = strlen(s);
int i;
for (i = 0; i <= n; i++) {
dp[i][0] = 100000000;
dp[i][1] = 100000000;
}
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
int acos = s[i - 1] == '0' ? 0 : 1;
int bcos = s[i - 1] == '0' ? 1 : 0;
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + acos;
dp[i][1] = min(dp[i - 1][0] + 2, dp[i - 1][1]) + bcos;
}
printf("%d\n", min(dp[n][0], dp[n][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1100000];
int main() {
cin >> str;
int len = strlen(str);
int cnt = 0;
for (int i = len - 1; i >= 0; i--) {
if (str[i] == '1' && i > 0 && str[i - 1] == '1') {
cnt++;
str[i] = '0';
int j = i - 1;
while (j >= 0) {
if (str[j] == '1')
str[j] = '0';
else {
str[j] = '1';
break;
}
j--;
}
} else if (str[i] == '1') {
cnt++;
}
}
if (str[0] == '0') cnt++;
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
int n, c, x, y;
char s[1111111];
int main() {
gets(s), n = strlen(s), c = x = 1;
while ((y = x) < n) {
while (s[y] == s[x]) ++y;
c += (s[x] == '1' || y < n), x = y + 1;
}
printf("%d", c);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const long long LINF = (1ll << 62) - 1;
const int DIRX[] = {-1, 0, 0, 1, -1, -1, 1, 1},
DIRY[] = {0, -1, 1, 0, -1, 1, -1, 1};
const double ERR = 1e-11, PI = (2 * acos(0.0));
template <class T>
inline T MIN(T a, T b) {
return ((a < b) ? (a) : (b));
}
template <class T>
inline T MAX(T a, T b) {
return ((b < a) ? (a) : (b));
}
template <class T>
inline T ABS(T a) {
return ((a < 0) ? (-a) : (a));
}
template <class T>
inline void checkMIN(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMAX(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline T SQR(T x) {
return (x * x);
}
template <class T>
T GCD(T a, T b) {
return ((!b) ? (a) : GCD(b, a % b));
}
template <class T>
T fastPow(T Base, T Power) {
T Result = 1;
while (Power > 0) {
if (Power & ((T)1)) Result *= Base;
Power >>= 1;
Base *= Base;
}
return Result;
}
template <class T>
T fastModPow(T Base, T Power, T Mod) {
T Result = 1;
while (Power > 0) {
if (Power & ((T)1)) Result = (Result * Base) % Mod;
Power >>= 1;
Base = (Base * Base) % Mod;
}
return (Result % Mod);
}
inline int compDouble(double x, double y) {
double d = x - y;
if (d - ERR > 0.0)
return 1;
else if (d + ERR < 0.0)
return -1;
else
return 0;
}
char a[1000012];
int main() {
int _kase = 1;
while (_kase--) {
for (int i = 0; i < 10; i++) a[i] = '0';
scanf("%s", &a[9]);
int len = strlen(a);
for (int i = 0; i < len; i++) a[i] -= '0';
for (int i = 1; i < len; i++) {
if (i < 1) i = 1;
if (a[i] == 1 && a[i + 1] == 1) {
a[i - 1] = 1;
a[i] = 0;
a[i + 1] = -1;
i -= 5;
}
if (a[i] == -1 && a[i + 1] == 1) {
a[i] = 0;
a[i + 1] = -1;
}
}
int ans = 0;
for (int i = 0; i < len; i++)
if (a[i] != 0) ans++;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
char s[1000100];
int a[1000100];
int main() {
while (~scanf("%s", s)) {
int n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '1') a[n - 1 - i] = 1;
int num = 0;
int i = 0, j;
for (i = 0; i < n; ++i) {
if (a[i] == 0) continue;
j = i;
while (a[j]) j++;
if (j - i >= 2) {
a[i] = -1;
for (int k = i + 1; k <= j; k++) a[k] = 0;
a[j] = 1;
}
i = j - 1;
}
for (i = 0; i <= n; i++)
if (a[i] == 1 || a[i] == -1) num++;
cout << num << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2] = {0, 1};
char c;
int main() {
while (~scanf("%c", &c)) a['1' - c] = min(a[0], a[1]) + 1;
printf("%d\n", *a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s = "00" + s;
int ree = 0, answer = 0;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '1')
ree++;
else if (ree > 1) {
ree = 1;
answer++;
} else if (ree == 1) {
ree = 0;
answer++;
}
}
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
vector<pair<int, int> > v;
cin >> s;
int n = (int)s.length(), last = 0;
for (int i = 0; i < n; i++) {
if (i == n - 1 || s[i] != s[i + 1]) {
if (s[i] == '1') {
v.push_back({n - last, 1});
v.push_back({n - (i + 1), -1});
}
last = i + 1;
}
}
stack<pair<int, int> > S;
for (int i = 0; i < v.size(); i++) {
if (S.empty()) {
S.push(v[i]);
continue;
}
if (S.top().first == v[i].first + 1 && S.top().second + v[i].second == 0) {
S.pop();
S.push({v[i].first, -v[i].second});
} else
S.push(v[i]);
}
cout << (int)S.size() << '\n';
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.