#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a, I = b; i <= I; ++i)
#define per(i, a, b) for (int i = a, I = b; i >= I; --i)
using namespace std;
using i64 = long long;
using i128 = __int128_t;
template<typename T> void up(T &x, T y) { x < y ? x = y : 0; }
template<typename T> void down(T &x, T y) { x > y ? x = y : 0; }
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int rng(int l, int r) { return l + rnd() % (r - l + 1); }

const int N = 100005;
char s[N];
int n, f[N][10], g[N][10], dp[N][10], l, r, ans;

void up(int L, int R, int ANS) {
    if (ANS > ans) {
        ans = ANS;
        l = L, r = R;
    }
}

void solve(int l, int r) {
    if (l == r) return;
    int mid = (l + r) >> 1;
    rep(x, 0, 9) {
        memset(dp[mid], 0xcf, sizeof dp[mid]);
        memset(dp[mid + 1], 0xcf, sizeof dp[mid + 1]);
        rep(i, x, 9) dp[mid][i] = 0;
        rep(i, 0, x) dp[mid + 1][i] = 0;
        per(i, mid, l) {
            ++dp[i][s[i]];
            rep(j, x + 1, 9) up(dp[i][j], dp[i][j - 1]);
            if (i > l) memcpy(dp[i - 1], dp[i], sizeof dp[i]);
        }
        rep(i, mid + 1, r) {
            ++dp[i][s[i]];
            per(j, x - 1, 0) up(dp[i][j], dp[i][j + 1]);
            if (i < r) memcpy(dp[i + 1], dp[i], sizeof dp[i]);
        }
        rep(a, 0, x) rep(b, x, 9) {
            int lp = -1, lv = -1;
            int rp = -1, rv = -1;
            rep(i, l, mid) {
                int cv = dp[i][b] + f[i - 1][a];
                if (cv > lv) lv = cv, lp = i;
            }
            rep(i, mid + 1, r) {
                int cv = dp[i][a] + g[i + 1][b];
                if (cv > rv) rv = cv, rp = i;
            }
            up(lp, rp, lv + rv);
        }
    }
    solve(l, mid), solve(mid + 1, r);
}

void solve() {
    cin >> n >> (s + 1);
    rep(i, 1, n) s[i] -= '0';
    rep(i, 1, n) {
        memcpy(f[i], f[i - 1], sizeof f[i]);
        ++f[i][s[i]];
        rep(j, 1, 9) up(f[i][j], f[i][j - 1]);
    }
    memset(g[n + 1], 0, sizeof g[n + 1]);
    per(i, n, 1) {
        memcpy(g[i], g[i + 1], sizeof g[i]);
        ++g[i][s[i]];
        per(j, 8, 0) up(g[i][j], g[i][j + 1]);
    }

    l = r = 1, ans = f[n][9];
    solve(1, n);
    cout << ans << " " << l << " " << r << "\n";
}

int main() {
	ios::sync_with_stdio(0), cin.tie(0);

    int T; cin >> T;
    while (T--) solve();

	return 0;
}