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 Common Lisp (SBCL 2.0.3) (judge verdict: Time Limit Exceeded)

(defun search-index (v x)
  (declare (optimize (speed 3) (debug 0) (safety 0)))
  (loop for i from 0 below (length v)
        when (< x (aref v i))
        do (return i)
        finally (return (length v))))

(defun solve ()
  (declare (optimize (speed 3) (debug 0) (safety 0)))
  (let* ((n (read))
         (s (read-line))
         (si (make-array n :element-type 'fixnum))
         (count 0)
         r-list g-list b-list)
    (loop for i from 0 below n
          for c = (char s i)
          do (setf (aref si i)
                   (case c
                     (#\R 1)
                     (#\G 2)
                     (#\B 4)))
          do (case c
               (#\R (push i r-list))
               (#\G (push i g-list))
               (#\B (push i b-list))))
    (let ((v (vector (coerce (nreverse r-list) 'vector)
                     (coerce (nreverse g-list) 'vector)
                     (coerce (nreverse b-list) 'vector))))
      (labels ((get-index (c1 c2)
                 (case (+ c1 c2)
                   (3 2)
                   (5 1)
                   (6 0))))
      (loop for i from 0 below n
            do (loop for j from (+ i 1) below n
                     for k = (+ j (- j i))
                     when (/= (aref si i) (aref si j))
                     do (let* ((rgbv (aref v (get-index (aref si i)
                                                        (aref si j))))
                               (index (search-index rgbv j)))
                          (incf count (- (length rgbv) index)))
                     do (when (and (< k n)
                                   (/= (aref si i)
                                       (aref si j)
                                       (aref si k)))
                          (decf count))))
        (format t "~a~%" count)))))

(solve)