use proconio::{
    input,
    marker::{Bytes, Usize1},
};
use std::io::Write;

fn main() {
    input! {
        _n: usize, q: usize,
        s: Bytes,
        queries: [(Usize1, usize); q]
    }

    let mut by_digit = vec![vec![]; 10];
    for (i, &d) in s.iter().enumerate() {
        let d = (d - b'0') as usize;
        by_digit[d].push(i);
    }

    let mul8 = (0..1000)
        .step_by(8)
        .map(|mut x| {
            let a = x % 10;
            x /= 10;
            let b = x % 10;
            x /= 10;
            let c = x % 10;
            (c, b, a)
        })
        .collect::<Vec<_>>();

    let mut right = [0; 10];
    let mut writer = std::io::BufWriter::new(std::io::stdout().lock());
    for &(l, r) in &queries {
        let mut ans = usize::MAX;

        for &(c, b, a) in &mul8 {
            right.fill(r);
            let Some(i) = find_rightmost(&by_digit[a], right[a]) else {
                continue;
            };
            if i < l {
                continue;
            }
            right[a] = i;
            let Some(j) = find_rightmost(&by_digit[b], right[b]) else {
                continue;
            };
            if j < l {
                continue;
            }
            right[b] = j;
            let Some(k) = find_rightmost(&by_digit[c], right[c]) else {
                continue;
            };
            if k < l {
                continue;
            }

            let mut cand = 3 * r - 6 - i - j - k;
            cand += (i < j) as usize + (j < k) as usize + (i < k) as usize;
            ans = ans.min(cand);
        }

        writeln!(writer, "{}", ans as isize).unwrap();
    }
}

fn find_rightmost(v: &[usize], r: usize) -> Option<usize> {
    let i = v.partition_point(|&x| x < r);
    if i == 0 {
        None
    } else {
        Some(v[i - 1])
    }
}