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 solve(input: String): Long {
    val len = input.length 
 
    val red_list: MutableList<Int> = mutableListOf()
    val green_list: MutableList<Int> = mutableListOf()
    val blue_list: MutableList<Int> = mutableListOf()

    (0 until len).forEach { 
        when(input[it]) {
            'R' -> {
                red_list.add(it)
            }
            'G' -> {
                green_list.add(it)
            }
            'B' -> {
                blue_list.add(it)
            }
            else -> {}
        }
    }
    assert(red_list.size + green_list.size + blue_list.size == len)
    val first_matched = red_list.size.toLong() * green_list.size.toLong() * blue_list.size.toLong()
    var diff = 0L
    for(i in 0 until len) {
        for(j in (i + 1) until len) {
            val k = 2 * j - i
            diff += if(k < len && input[i] != input[j] && input[j] != input[k] && input[i] != input[k])  { 1 } else {0}
        }
    }

    return first_matched - diff
} 


fun main(args: Array<String>) {
    val N = readLine()!!.toInt()
    val S = readLine()!!
    assert(S.length == N)
 
    solve(S).run(::println)
}