#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <limits>
#include <numeric>
#include <cmath>

using namespace std;

template<class T>
class Input {
public:
    auto operator()() const {
        T v;
        cin >> v;
        return v;
    }
};

template<class L, class R>
class Input<pair<L, R>> {
public:
    auto operator()() const {
        L l;
        R r;
        cin >> l >> r;
        return make_pair(l, r);
    }
};

template<class U>
class Input<vector<U>> {
public:
    auto operator()() const {
        Input<size_t> in{};
        auto n = in();
        return (*this)(n);
    }
    auto operator()(size_t n) const {
        vector<U> v;
        v.reserve(n);
        Input<U> in{};
        for (size_t i = 0; i < n; ++i) {
            auto u = in();
            v.emplace_back(move(u));
        }
        return v;
    }
};

template<class U>
class Input<vector<vector<U>>> {
public:
    auto operator()() const {
        Input<size_t> in{};
        auto n = in();
        auto m = in();
        return (*this)(n, m);
    }
    auto operator()(size_t n, size_t m) const {
        vector<vector<U>> v;
        v.reserve(n);
        Input<vector<U>> in{};
        for (size_t i = 0; i < n; ++i) {
            auto u = in(m);
            v.emplace_back(move(u));
        }
        return v;
    }
};

class InputType
{
public:
    template<class T>
    operator T() const {
        Input<T> i{};
        return i();
    }
};

class InputType2
{
public:
    InputType2(size_t n)
        : n_(n)
    {}
    template<class T>
    operator T() const {
        Input<T> i{};
        return i(n_);
    }
private:
    size_t n_;
};

auto input() {
    return InputType();
}

template<class... Args>
auto input(Args&&... args) {
    return InputType2(std::forward<Args>(args)...);
}

size_t bitcount(size_t n) {
    size_t c = 0;
    while (n) {
        if (n & 1ull)
            ++c;
        n >>= 1;
    }
    return c;
}

auto make_order(size_t n) {
    vector<size_t> a(n, 0);
    iota(begin(a), end(a), 0);
    return a;
}

template<class T>
auto next_permutation(T&& x) {
    using std::begin;
    using std::end;
    return next_permutation(begin(x), end(x));
}

using ll = long long;
using ull = unsigned long long;

auto gcd(size_t l, size_t r) {
    if (r == 0)
        return l;
    return gcd(r, l % r);
}

auto gcd(size_t a, size_t b, size_t c) {
    return gcd(gcd(gcd(a, b), gcd(a, c)), gcd(b, c));
}

int main() {
    size_t n = input();
    string s = input();
    vector<map<char, pair<vector<size_t>, size_t>>> t;
    t.resize(s.size());
    for (size_t i = 1; i < n; ++i) {
        auto& m = t[i];
        for (size_t j = i + 1; j < n; ++j) {
            auto a = s[i];
            auto b = s[j];
            if (a != b) {
                auto d = j - i;
                if (a == 'R' && b == 'G' || a == 'G' && b == 'R') {
                    auto& e = m['B'];
                    ++e.second;
                    if (e.first.empty())
                        e.first.resize(4000, 0);
                    ++e.first[d];
                } else if (a == 'R' && b == 'B' || a == 'B' && b == 'R') {
                    auto& e = m['G'];
                    ++e.second;
                    if (e.first.empty())
                        e.first.resize(4000, 0);
                    ++e.first[d];
                }  else if (a == 'G' && b == 'B' || a == 'B' && b == 'G'){
                    auto& e = m['R'];
                    ++e.second;
                    if (e.first.empty())
                        e.first.resize(4000, 0);
                    ++e.first[d];
                }
            }
        }
    }
    size_t c = 0;
    for (size_t i = 0; i + 2 < n; ++i) {
        for (size_t j = i + 1; j + 1 < n; ++j) {
            auto& e = t[j][s[i]];
            auto a = e.second;
            if (a > 0) {
                c += a;
                auto d = j - i;
                c -= e.first[d];
            }
        }
    }
    cout << c << endl;
    return 0;
}


Measured memory_bytes: 254460