#include <bits/stdc++.h>
using namespace std;
 
const int N = 2e5 + 5;
 
int n;
string s;
vector<int> v;
 
void solve() {
    v.clear();
    cin >> n >> s;
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        if (s[i] == '0') v.push_back(i);
    }
    for (int i = 0; i < (int)v.size() - 1; ++i) {
        if (v[i + 1] - v[i] <= 2) ans += 2 - (v[i + 1] - v[i]) + 1;
    }
    cout << ans << '\n';
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t; cin >> t;
    while (t--) solve();
}

t = int(input())
for _ in range(t):
    n = input()
    s = input()
    ans = 0
    cnt = 2
    for c in s:
        if c == '1': cnt += 1
        else:
            ans += max(2 - cnt, 0)
            cnt = 0
    print(ans)
 
 

Assuming $$$g > 2$$$:

• If there exists a prime number $$$p > 2$$$ that $$$p \mid g$$$, there are $$$\left \lfloor \dfrac{n}{p} \right \rfloor$$$ numbers divisible by $$$p$$$, so we can match at most $$$2 \left \lfloor \dfrac{n}{3} \right \rfloor$$$ numbers into pairs, which is smaller than $$$n$$$.

• Otherwise, we can match odd numbers with even positions, and even numbers with odd positions, which leads to $$$2 \mid g$$$. Because $$$p_2$$$ is odd, $$$2 \cdot p_2$$$ is not divisible by $$$2^k$$$ with $$$k > 1$$$.

Therefore, $$$g\leq 2$$$.

#include <bits/stdc++.h>
using namespace std;

const int MOD = 998244353;

void solve() {
    int n; cin >> n;
    if (n & 1) {
        cout << "0\n";
        return;
    }
    long long ans = 1;
    for (int i = 1; i <= n / 2; ++i) {
        ans *= 1LL * i * i % MOD;
        ans %= MOD;
    }
    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t; cin >> t;
    while (t--) solve();
    return 0;
}

MOD = 998244353
t = int(input())

for _ in range(t):
	n = int(input())
	if n & 1:
	    print(0)
	    continue
	ans = 1
	for i in range(1, n // 2 + 1):
		ans = ans * i % MOD
	ans = ans * ans % MOD
	print(ans)

#include <bits/stdc++.h>
using namespace std;
 
void solve() {
    int n; cin >> n;
    vector<int> a(n);
    for (int &v: a) cin >> v;
    if (count(a.begin(), a.end(), 1) != 1) {
        cout << "NO\n";
        return;
    }
    int p = find(a.begin(), a.end(), 1) - a.begin();
    rotate(a.begin(), a.begin() + p, a.end());
    for (int i = 1; i < n; ++i) {
        if (a[i] - a[i - 1] > 1) {
            cout << "NO\n";
            return;
        }
    }
    cout << "YES\n";
}
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t; cin >> t;
    while (t--) solve();
    return 0;
}

import sys
input = sys.stdin.readline
 
t = int(input())
for _ in range (t):
    n = int(input())
    a = list(map(int, input().split()))
 
    if a.count(1) != 1:
        print("NO")
        continue
 
    a.append(a[0])
    ok = True
    for i in range (0, n):
        if a[i + 1] - a[i] > 1:
            ok = False
            break
    
    if ok: print("YES")
    else: print("NO")

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 5;
int p[N], cnt[32][2];
 
void solve() {
    memset(cnt, 0, sizeof cnt);
    int l, r; cin >> l >> r;
    for (int i = l; i <= r; ++i) {
    	int x; cin >> x;
    	for (int j = 0; j <= 30; ++j, x >>= 1)
    		cnt[j][x & 1]++;
    }
    int ans = 0;
    for (int i = 0; i <= 30; ++i) {
    	ans |= ((cnt[i][0] < cnt[i][1]) * (1 << i));
    }
    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t; cin >> t;
    while (t--) solve();
    return 0;
}

import sys
input = sys.stdin.readline
 
t = int(input())
for _ in range (t):
    l, r = map(int, input().split())
    a = list(map(int, input().split()))
    cnt = [[0] * 2 for _ in range (32)]
 
    for x in a:
        for i in range (31):
            cnt[i][x & 1] += 1
            x >>= 1
 
    ans = 0
    for i in range (31):
        if (cnt[i][0] < cnt[i][1]):
            ans |= (1 << i)
    
    print(ans)

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 5;
int a[N], l, r; 
set <int> s, s2;
 
void solve() {
    int mul = 1;
    s.clear();
    cin >> l >> r; 
    for (int i = l; i <= r; ++i) {
        cin >> a[i];
        s.insert(a[i]);
    }

    for (; l % 2 == 0 && r % 2 == 1; l >>= 1, r >>= 1, mul <<= 1) {
        s2.clear();
        for (int i: s) s2.insert(i >> 1);
        swap(s, s2);   
    }

    int ans;
    if (l % 2 == 0) ans = r;
    else ans = l;

    for (int i: s) {
        if (s.find(i ^ 1) == s.end()) {
            int cur = i ^ ans;
            bool f = true;
            for (int j : s)
                f &= ((cur ^ j) >= l && (cur ^ j) <= r);
            if (f) {
                ans = cur;
                break;
            }
        }
    }
    cout << ans * mul << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t; cin >> t;
    while (t--) solve();
    return 0;
}

import sys
input = sys.stdin.readline
 
def solve(l: int, r: int, s: set):
    if l % 2 == 0 and r % 2 == 1:
        t = set()
        for v in s: t.add(v >> 1)
        return solve(l >> 1, r >> 1, t) << 1
    else:
        for v in s:
            if (v ^ 1) not in s:
                ok = True
                ans = v
                if l % 2 == 0: ans ^= r
                else: ans ^= l
                for x in s:
                    if (x ^ ans) < l or (x ^ ans) > r:
                        ok = False
                        break
                if ok: return ans
            
 
t = int(input())
for _ in range (t):
    l, r = map(int, input().split())
    s = set(map(int, input().split()))
    print(solve(l, r, s))

#include <bits/stdc++.h>
using namespace std;

const int N = 2e3 + 5;
bool f[N][N];
int l, r, u, d, n, k;
vector<array<int, 5>> v;

bool check(int i, int j) {
    return (abs(i - u) <= k && abs(i - d) <= k && abs(j - l) <= k && abs(j - r) <= k);
}

void solve(){
    cin >> n >> k;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            f[i][j] = false;
            int x; cin >> x;
            v.push_back({x, i, j, i + j, j - i});
        }
    }

    sort(v.begin(), v.end(), greater<array<int, 5>>());
    l = v[0][4], r = v[0][4], u = v[0][3], d = v[0][3];
    for (array<int, 5> cell: v) {
        if (check(cell[3], cell[4])) {
            f[cell[1]][cell[2]] = true;
            l = min(l, cell[4]);
            r = max(r, cell[4]);
            u = min(u, cell[3]);
            d = max(d, cell[3]);
        }
    }

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (f[i][j]) cout << 'M';
            else cout << 'G';
        }
        cout << '\n';
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    solve();
    return 0;
}

It is easy to show that the cuteness of $$$s$$$ is $$$\dfrac{b}{n}$$$.

What is the number of $$$\texttt{1}$$$ in the concatenated string needed so that the answer exists?

The cuteness of $$$s$$$ is $$$\dfrac{b}{n} = \dfrac{b}{b+w}$$$ by definition.

Now consider $$$t = s[l_1, r_1] + [l_2, r_2] + \dots + s[l_k, r_k]$$$, the cuteness of the concatenated string.

The cuteness of $$$t$$$ is $$$\dfrac{b}{b+w}$$$, so the number of $$$\texttt{1}$$$ needed is $$$k = \dfrac{m \cdot w}{b + w}$$$.

If $$$k$$$ is not an integer then there will be no answer, so $$$m$$$ must be a multiple of $$$\dfrac{b+w}{gcd(b, w)}$$$.

Let $$$c_i =$$$ (the number of $$$\texttt{1}$$$ in $$$s[i \dots i + m - 1]$$$).

For convenient, from now let assume the array and string is wrapped around: $$$s[i] = s[i + n]$$$ and $$$c_i = c_{i+n}$$$.

We have $$$|c_i-c_{i+1}| \leq 1$$$ and there exists $$$c_i = y$$$ for all $$$y$$$ that $$$min(c_i) \leq y \leq max(c_i)$$$.

GM+ smax provides a simple and clean answer here.

Let $$$L = min(c_i)$$$, $$$R = max(c_i)$$$ and we are doing with wrap around arrays for convenient.

We want to prove that for any $$$y$$$ that $$$L \leq y \leq R$$$ there will be some $$$c_i = y$$$.

Let $$$d_i = max(c_p, c_{p+1}, \dots, c_i)$$$ for $$$p$$$ is the minimal position that $$$c_p = L$$$.

Let $$$f_x$$$ is the first position $$$i$$$ starting $$$p$$$ that $$$d_i = x$$$, we have $$$d_{f_x} = c_{f_x}$$$

[1] Since $$$L \leq y \leq R$$$ and, we have $$$L = d_p \leq d_{p+1} \leq \dots \leq d_{p+n-1} = R$$$.

[2] Since $$$|c_{i+1} - c_i| \leq 1$$$ we can show that.

[3] Since $$$c_i \in \mathbb{N}$$$, we also have $$$d_i \in \mathbb{N}$$$

From [1], [2], [3], if there is $$$d_i = v > L$$$ then there will be $$$d_j = v - 1$$$ for some $$$j$$$ that $$$p + (v - L) \leq j < i$$$.

$$$\Leftrightarrow \forall v, min(d_i) \leq v \leq max(d_i) \rightarrow \exists d_{f_i} = v$$$

$$$\Leftrightarrow \exists d_{f_i} = y$$$

$$$\Leftrightarrow \exists c_{f_i} = y$$$

If there exist such position $$$p$$$ that $$$1 \leq p \leq n - m + 1$$$ and $$$s[p, p + m - 1]$$$ have the same cuteness as $$$s[1, n]$$$ then we found an answer.

If there exist such position $$$p$$$ that $$$1 \leq p < m$$$ and $$$s[1, p] \cup s[n - (m - p) + 1, n]$$$ have the same cuteness as $$$s[1, n]$$$ then we found an answer.

#include <bits/stdc++.h>
using namespace std;
 
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t; cin >> t;
    while (t--) {
        int n, k; cin >> n >> k;
        string s; cin >> s;
        int one = count_if(s.begin(), s.end(), [](char c) { return c == '1'; });
        if (1LL * one * k % n != 0) {
            cout << "-1\n";
        } else {
            one = 1LL * one * k / n;
            vector<int> suf(2 * n + 1);
            for (int i = 1; i <= 2 * n; i++) {
                suf[i] = suf[i - 1] + (s[(i - 1) % n] == '1');
                if (i >= k && suf[i] == suf[i - k] + one) {
                    if (i <= n) {
                        cout << "1\n";
                        cout << i - k + 1 << " " << i << '\n';
                    } else {
                        cout << "2\n";
                        cout << 1 << " " << i - n << '\n';
                        cout << i - k + 1 << " " << n << '\n';
                    }
                    break;
                }
            }
        }
    }
}