Problem:
Score : 500 points

Problem Statement

Takahashi has a string S of length N consisting of digits from 0 through 9.

He loves the prime number P. He wants to know how many non-empty (contiguous) substrings of S - there are N \times (N + 1) / 2 of them - are divisible by P when regarded as integers written in base ten.

Here substrings starting with a 0 also count, and substrings originated from different positions in S are distinguished, even if they are equal as strings or integers.

Compute this count to help Takahashi.

Constraints

1 \leq N \leq 2 \times 10^5

S consists of digits.

|S| = N

2 \leq P \leq 10000

P is a prime number.

Input

Input is given from Standard Input in the following format:

N P
S

Output

Print the number of non-empty (contiguous) substrings of S that are divisible by P when regarded as an integer written in base ten.

Sample Input 1

4 3
3543

Sample Output 1

6

Here S = 3543. There are ten non-empty (contiguous) substrings of S:

3: divisible by 3.

35: not divisible by 3.

354: divisible by 3.

3543: divisible by 3.

5: not divisible by 3.

54: divisible by 3.

543: divisible by 3.

4: not divisible by 3.

43: not divisible by 3.

3: divisible by 3.

Six of these are divisible by 3, so print 6.

Sample Input 2

4 2
2020

Sample Output 2

10

Here S = 2020. There are ten non-empty (contiguous) substrings of S, all of which are divisible by 2, so print 10.

Note that substrings beginning with a 0 also count.

Sample Input 3

20 11
33883322005544116655

Sample Output 3

68

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use competitive::prelude::*;
use std::convert::TryInto;
use std::ops::*;

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct GF(pub u64, pub u64);

impl std::fmt::Display for GF {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl Echo for GF {
    fn echo(&self, w: &mut impl std::io::Write) -> Result<(), std::io::Error> {
        write!(w, "{}", self.0)
    }
}

impl GF {
    pub fn new<T: TryInto<i64>>(v: T, p: u64) -> Self {
        Self(v.try_into().ok().unwrap().rem_euclid(p as i64) as u64, p)
    }

    pub fn pow(self, mut r: u64) -> Self {
        let mut k = self;
        let mut ret = GF::new(1, self.1);
        while r > 0 {
            if r % 2 != 0 {
                ret = ret * k;
            }
            r /= 2;
            k = k * k;
        }
        ret
    }

    // This requires P is prime
    pub fn recip(self) -> Self {
        self.pow(self.1 - 2)
    }
}

impl<T: Into<GF>> Add<T> for GF {
    type Output = Self;
    fn add(self, rhs: T) -> Self::Output {
        Self::new(self.0 + rhs.into().0, self.1)
    }
}

impl<T: Into<GF>> AddAssign<T> for GF {
    fn add_assign(&mut self, rhs: T) {
        *self = *self + rhs;
    }
}

impl<T: Into<GF>> Sub<T> for GF {
    type Output = Self;
    fn sub(self, rhs: T) -> Self::Output {
        Self::new(self.0 + self.1 - rhs.into().0, self.1)
    }
}

impl<T: Into<GF>> SubAssign<T> for GF {
    fn sub_assign(&mut self, rhs: T) {
        *self = *self - rhs;
    }
}

impl<T: Into<GF>> Mul<T> for GF {
    type Output = Self;
    fn mul(self, rhs: T) -> Self::Output {
        Self::new(self.0 * rhs.into().0, self.1)
    }
}

impl<T: Into<GF>> MulAssign<T> for GF {
    fn mul_assign(&mut self, rhs: T) {
        *self = *self * rhs;
    }
}

impl<T: Into<GF>> Div<T> for GF {
    type Output = Self;
    fn div(self, rhs: T) -> Self::Output {
        self * rhs.into().recip()
    }
}

impl<T: Into<GF>> DivAssign<T> for GF {
    fn div_assign(&mut self, rhs: T) {
        *self = *self / rhs;
    }
}

fn char_to_int(c: char) -> u64 {
    (c as u8 - '0' as u8) as _
}

fn main() {
    input! {
        n: usize,
        p: u64,
        s: Chars,
    }

    // sum [i, n)
    let mut acc = vec![GF::new(0, p); n + 1];
    let mut base = GF::new(1, p);
    let mut mm = BTreeMap::<u64, usize>::new();

    for i in (0..n).rev() {
        acc[i] = acc[i + 1] + GF::new(char_to_int(s[i]), p) * base;
        *mm.entry(acc[i].0).or_default() += 1;
        base *= GF::new(10, p);
    }
    *mm.entry(0).or_default() += 1;

    let mut base = GF::new(1, p);
    let mut ans = 0;

    for i in (1..=n).rev() {
        *mm.entry(acc[i].0).or_default() -= 1;

        // (x-right)/base = 0
        // x = right ???

        // ...ABC D...

        // dbg!(i, mm.get(&acc[i].0));

        ans += mm.get(&acc[i].0).unwrap_or(&0);

        base *= GF::new(10, p);
    }

    echo!(ans);
}
*/

fn main() {
    let exe = "/tmp/bin4CA18C7F";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";