Problem:
Score : 400 points

Problem Statement

We have a string S of length N consisting of R, G, and B.

Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:

S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.

j - i \neq k - j.

Constraints

1 \leq N \leq 4000

S is a string of length N consisting of R, G, and B.

Input

Input is given from Standard Input in the following format:

N
S

Output

Print the number of triplets in question.

Sample Input 1

4
RRGB

Sample Output 1

1

Only the triplet (1,~3,~4) satisfies both conditions. The triplet (2,~3,~4) satisfies the first condition but not the second, so it does not count.

Sample Input 2

39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB

Sample Output 2

1800

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

fn main() {
    proconio::input! {
        n: usize,
        s: proconio::marker::Chars,
    }
    let (num_r, num_g, num_b) = {
        let (mut r, mut g, mut b) = (0, 0, 0);
        for c in s.iter() {
            match c {
                'R' => r += 1,
                'G' => g += 1,
                'B' => b += 1,
                _ => unreachable!(),
            }
        }
        (r, g, b)
    };
    let (remain_r, remain_g, remain_b) = {
        let (mut r, mut g, mut b) = (vec![], vec![], vec![]);
        let (mut num_r, mut num_g, mut num_b) = (num_r, num_g, num_b);
        for c in s.iter() {
            r.push(num_r);
            g.push(num_g);
            b.push(num_b);
            match c {
                'R' => {
                    num_r -= 1;
                }
                'G' => {
                    num_g -= 1;
                }
                'B' => {
                    num_b -= 1;
                }
                _ => unreachable!(),
            }
        }
        (r, g, b)
    };
    let (cr, cg, cb) = (remain_r.clone(), remain_g.clone(), remain_b.clone());
    let mut sum = 0;
    for i in 0..n - 2 {
        for j in i + 1..n - 1 {
            if s[i] == s[j] {
                continue;
            }
            let diff_ji = j - i;
            let same_distance_k = j + diff_ji;
            let color_k = if s[i] != 'R' && s[j] != 'R' {
                'R'
            } else if s[i] != 'G' && s[j] != 'G' {
                'G'
            } else {
                'B'
            };
            let mut remain = match color_k {
                'R' => remain_r[j + 1],
                'G' => remain_g[j + 1],
                'B' => remain_b[j + 1],
                _ => unreachable!(),
            };
            if n <= same_distance_k {
                // can not take same distance
            } else if s[same_distance_k] == color_k {
                remain -= 1;
            }
            sum += remain;
        }
    }
    assert_eq!(cr, remain_r);
    assert_eq!(cg, remain_g);
    assert_eq!(cb, remain_b);
    println!("{}", sum);
}