#include<iostream>
#include<cstring>
#include<vector>
#include<random>
#include<chrono>
using namespace std;
using LL = long long;

using ULL = unsigned long long;
const int maxn = 5005;
static const ULL mod = (1ull << 61) - 1;
ULL power[maxn];
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<ULL> dist(mod / 2, mod - 1);
const ULL base = dist(rnd);

static inline ULL add(ULL a, ULL b){
    a += b;
    if (a >= mod) a -= mod;
    return a;
}

static inline ULL mul(ULL a, ULL b){
    __uint128_t c = __uint128_t(a) * b;
    return add(c >> 61, c & mod);
}

ULL merge(ULL h1, ULL h2, int len2){
    return add(mul(h1, power[len2]), h2);
}

void init(){
    power[0] = 1;
    for(int i = 1; i < maxn; i++)
        power[i] = mul(power[i - 1], base);
}

ULL query(const vector<ULL> &s, int l, int r){
    return add(s[r], mod - mul(s[l - 1], power[r - l + 1]));
}

vector<ULL> build(const string &s){
    int sz = s.size();
    vector<ULL> hashed(sz + 1);
    for (int i = 0; i < sz; i++){
        hashed[i + 1] = add(mul(hashed[i], base), s[i]);
    }
    return hashed;
}

template <typename T>
vector<ULL> build(const vector<T> &s){
    int sz = s.size();
    vector<ULL> hashed(sz + 1);
    for (int i = 0; i < sz; i++){
        hashed[i + 1] = add(mul(hashed[i], base), s[i]);
    }
    return hashed;
}

int lcp(const vector<ULL> &a, int l1, int r1, const vector<ULL> &b, int l2, int r2){
    int len = min(r1 - l1 + 1, r2 - l2 + 1);
    int l = 0, r = len;
    while(l < r){
        int mid = (l + r + 1) / 2;
        if (query(a, l1, l1 + mid - 1) == query(b, l2, l2 + mid - 1)) l = mid;
        else r = mid - 1;
    }
    return r;
}

pair<int, int> operator+(pair<int, int> a, pair<int, int> b){
    return {a.first + b.first, a.second + b.second};
}

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    init();
    int n;
    cin >> n;
    string s;
    cin >> s;
    auto hsh1 = build(s);
    reverse(s.begin(), s.end());
    for(auto &c : s){
        if (c == 'v') c = '^';
        else c = 'v';
    }

    auto hsh2 = build(s);
    vector<vector<pair<int, int> > > dp(n + 1, vector<pair<int, int> >(n + 1));
    for(int i = 1; i <= n; i++){
        dp[i][i] = {1, 0};
    }
    vector<vector<int> > pos1(n + 1, vector<int>(n + 1));
    vector<vector<int> > pos2(n + 1, vector<int>(n + 1));
    for(int i = 1; i <= n; i++){
        pos1[i][i] = i;
        for(int j = 2; j <= n; j++){
            pos1[i][j] = pos1[i][j - 1];
            if ((j - i + 1) % 2 == 1){
                int mid = (i + j) / 2;
                if (query(hsh1, i, mid - 1) == query(hsh2, n - j + 1, n - mid)){
                    pos1[i][j] = mid;
                }
            }
        }
    }
    for(int i = n; i >= 1; i--){
        pos2[i][i] = i;
        for(int j = i - 1; j >= 1; j--){
            pos2[j][i] = pos2[j + 1][i];
            if ((i - j + 1) % 2 == 1){
                int mid = (i + j) / 2;
                if (query(hsh1, j, mid - 1) == query(hsh2, n - i + 1, n - mid)){
                    pos2[j][i] = mid;
                }
            }
        }
    }
    for(int len = 2; len <= n; len++){
        for(int l = 1; l + len - 1 <= n; l++){
            int r = l + len - 1;
            {
                int pos = pos1[l][r];
                dp[l][r] = dp[pos + 1][r] + pair(1, ((r - pos) - (pos - l)));
            }
            {
                int pos = pos2[l][r];
                dp[l][r] = min(dp[l][r], dp[l][pos - 1] + pair(1, ((pos - l) - (r - pos))));
            }
            // cout << pos1[l][r] << ' ' << pos2[l][r] << '\n';
            // cout << l << ' ' << r << ' ' << dp[l][r].first << '\n';
        }
    }
    cout << dp[1][n].first << ' ' << dp[1][n].second << '\n';

}