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 Kotlin (1.3.71) (judge verdict: Accepted)

fun main() {
    val N = readLine()!!.toInt()
    val S = readLine()!!

    val R = IntArray(N)
    val G = IntArray(N)
    val B = IntArray(N)

    when (S[0]) {
        'R' -> {
            R[0] = 1
        }
        'G' -> {
            G[0] = 1
        }
        'B' -> {
            B[0] = 1
        }
    }
    for (i in 1..S.lastIndex) {
        val c = S[i]
        when (c) {
            'R' -> {
                R[i] = R[i - 1] + 1
                G[i] = G[i - 1]
                B[i] = B[i - 1]
            }
            'G' -> {
                R[i] = R[i - 1]
                G[i] = G[i - 1] + 1
                B[i] = B[i - 1]
            }
            'B' -> {
                R[i] = R[i - 1]
                G[i] = G[i - 1]
                B[i] = B[i - 1] + 1
            }
        }
    }

    var sum = 0L
    for (i in 0..S.lastIndex - 2) {
        for (j in i + 1..S.lastIndex - 1) {
            if (S[i] == S[j]) {
                continue
            }
            val a = arrayOf(S[i], S[j])
            sum += when {
                !a.contains('R') -> {
                    var n = R[S.lastIndex] - R[j]
                    if ((j + (j - i)) <= S.lastIndex && S[j + (j - i)] == 'R') {
                        n--
                    }
                    n
                }
                !a.contains('G') -> {
                    var n = G[S.lastIndex] - G[j]
                    if ((j + (j - i)) <= S.lastIndex && S[j + (j - i)] == 'G') {
                        n--
                    }
                    n
                }
                !a.contains('B') -> {
                    var n = B[S.lastIndex] - B[j]
                    if ((j + (j - i)) <= S.lastIndex && S[j + (j - i)] == 'B') {
                        n--
                    }
                    n
                }
                else -> throw IllegalStateException("")
            }


        }
    }
    println(sum)
}