/*
@Author: Ayush Shah :)
@Institution: BIT Mesra :)
*/

#include<bits/stdc++.h>
using namespace std;

#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;


template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;

#define deb(x) cout << #x << " " << x << endl;
#define deb1(x, y) cout << #x << " " << x << " " << #y << " " << y << endl;
#define deb2(x, y, z) cout << #x << " " << x << " " << #y << " " << y << " " << #z << " " << z << endl;
#define fast  ios_base::sync_with_stdio(false), cin.tie(NULL) , cout.tie(NULL)
#define test int T1; cin >> T1; while(T1--)
#define ui  unsigned int
#define ll  long long int 
#define ld  long double
#define pb  push_back
#define mp  make_pair
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
#define vll vector<ll>
#define pi pair<int, int>
#define pll pair<ll, ll>
#define vpll vector< pll >
#define bigint int64_t
#define mod 1000000007
#define endl '\n'

#define forn(i,a,n) for(ll (i) = a;(i) <= (n); (i)++)
#define forr(i,a,n) for(ll (i) = n; (i) >= (a); (i)--)

template <typename... T>
void read(T&...args){
     ((cin >> args), ...);
}

typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

////////////////////////////////***NUMBER THEORY***////////////////////////////////////////////////

vll seive;
void Seive (ll N) {
    seive.resize(N+1);
    forn (i, 1, N)
    seive[i] = i;
    for (ll i = 4; i <= N; i += 2)
    seive[i] = 2;
    for (ll i = 3; i*i <= N; i++) {
        if (seive[i] == i) {
            for (ll j = i*i; j <= N; j += i) {
                if (seive[j] == j)
                seive[j] = i;
            }
        }
    }
}

ll Power(ll x, ll n){
    if(n==0)
    return 1;
    
    if(n%2)
    return x*Power(x*x, (n-1)/2);
    else
    return Power(x*x, n/2);
}

ll Power_with_mod(ll x, ll n, ll m = mod){
    if(n==0)
    return 1;
    
    if(n%2)
    return (x*Power_with_mod((x*x)%m, (n-1)/2))%m;
    else
    return Power_with_mod((x*x)%m, n/2);
}

ll gcd(ll a, ll b){
    if(b == 0)
    return a;

    return gcd(b, a%b);
}

ll x, y, d;
void extended_euclid(ll a, ll b){
    if(b == 0){
        x = 1;
        y = 0;
        d = a;
    }
    else{
        extended_euclid(b, a%b);
        ll temp = x;
        x = y;
        y = temp - (a/b)*y;
    }
}

ll mod_inverse(ll a, ll m = mod){
    extended_euclid(a, m);
    return((x+m)%m);
}

///////////////////////////////////////////////////////////////////////////////////////////////////

template<typename T>
class DSU{
    public:
      T parent [200005];
      T size [200005];
      void init(T x){
          parent[x] = x;
          size[x] = 1;
      }
      T root(T x){
          if(parent[x] == x)
          return x;
          return parent[x] = root(parent[x]);
      }
      void Union(T x, T y){
          x = root(x);
          y = root(y);
          if(x != y){
              if(size[x] < size[y])
              swap(x, y);
              parent[y] = x;
              size[x] += size[y];
          }
      }
};

template <typename T>
class Segment_Tree{
    public:
      ll tree[4*100005];
      ll a[100005];
      void build(ll node, ll s, ll e){
          if(s == e)
          tree[node] = a[s];
          else{
              ll mid = (s + e)/2;
              build(2*node, s, mid);
              build(2*node+1, mid+1, e);
              tree[node] = (tree[2*node] | tree[2*node+1]);
          }
      }

      void update(ll node, ll s, ll e, ll pos, ll val){
          if(s == e){
              tree[node] = val;
              a[pos] = val;
          }
          else{
              ll mid = (s + e)/2;
              if(pos <= mid)
              update(2*node, s, mid, pos, val);
              else
              update(2*node+1, mid+1, e, pos, val);
              tree[node] = (tree[2*node] | tree[2*node+1]);
          }
      }

      ll query(ll node, ll s, ll e, ll l, ll r){
          if(s >= l && e <= r)
          return tree[node];
          else if(e < l || s > r)
          return 0ll;
          else{
              ll mid = (s + e)/2;
              ll left = query(2*node, s, mid, l, r);
              ll right = query(2*node+1, mid+1, e, l, r);
              return (left | right);
          }
      }
};  

ll n;
string s;

ll bakchodi(vll &r, vll &g, vll &b) {
    ll ans = 0;
    for (auto it: r) {
        for (auto it1 : g) {
            if (it1 <= it)
            continue;
            if (lower_bound(b.begin(), b.end(), it1) != b.end()) {
            ans += b.size() - (lower_bound(b.begin(), b.end(), it1) - b.begin() + 1) + 1;
            if (s[it1 + it1 - it -1] != s[it1-1] && s[it1 + it1 - it -1] != s[it-1] && it1 + it1 - it -1 < n) {
                ans--;
            }
            }
        }
    }
    return ans;
}

int main()
{

     fast;

     #ifndef ONLINE_JUDGE
         freopen("/home/ayush/Desktop/CP/in.txt", "r", stdin);
         freopen("/home/ayush/Desktop/CP/out.txt", "w", stdout);
     #endif

//////////////////////////////////////////////////////////////////////////////////////////////////////////

    /* test {
         ll o, ni;
         read(o, ni);
         ll n;
         read(n);
         ll Ox[n+1], Ni[n+1], W[n+1];
         forn (i, 1, n)
         read(Ox[i], Ni[i], W[i]);
         ll dp[23][80][n+1];
         forn (i, 0, 22) {
             forn (j, 0, 80) {
                 forn (k, 0, n) {
                     dp[i][j][k] = LLONG_MAX;
                     if (j == 0 && i == 0)
                     dp[i][j][k] = 0;
                 }
             }
         }

         dp[0][0][0] = 0;

         forn (i, 1, 21) {
             forn (j, 1, 79) {
                 forn (k, 1, n) {
                     if (Ox[k] < i && Ni[k] < j && dp[i-Ox[k]][j-Ni[k]][k-1] != LLONG_MAX)
                     dp[i][j][k] = dp[i-Ox[k]][j-Ni[k]][k-1] + W[k];
                     else 
                     dp[i][j][k] = W[k] + dp[0][0][k-1];
                     dp[i][j][k] = min(dp[i][j][k], dp[i][j][k-1]);
                 }
             }
         }
         ll ans = LLONG_MAX;
         forn (i, o, 21) {
             forn (j, ni, 79) {
                 forn (k, 1, n) {
                     ans = min(ans, dp[i][j][k]);
                 }
             }
         }
         cout << dp[o][ni][n] << endl;
     }*/

     vll r, g, b;
     read(n, s);

     forn (i, 0, s.length()-1) {
         if (s[i] == 'R')
         r.pb(i+1);
         else if (s[i] == 'G')
         g.pb(i+1);
         else
         b.pb(i+1);
     }

     ll ans = 0;
     ans += bakchodi(r, g, b);

     ans += bakchodi(r, b, g);

     ans += bakchodi(g, r, b);

     ans += bakchodi(g, b, r);

     ans += bakchodi(b, r, g);

     ans += bakchodi(b, g, r);

     cout << ans;


/////////////////////////////////////////////////////////////////////////////////////////////////////////

      #ifndef ONLINE_JUDGE
          cout << endl << "Time Elapsed: " << 1.0*clock() / CLOCKS_PER_SEC << " sec" <<endl;
      #endif

    return 0;

}


Measured memory_bytes: 3684