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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    string s;
    cin >> s;

    int ans = 0;
    for (int i = 1; i < n; i++) {
        if (s[i] == s[i - 1]) {
            ans++;
            // Chọn ký tự khác với trước đó và (nếu có) khác với tiếp theo
            for (char c : {'A', 'B', 'C'}) {
                if (c != s[i - 1] && (i + 1 == n || c != s[i + 1])) {
                    s[i] = c;
                    break;
                }
            }
        }
    }

    cout << ans << "\n";
    return 0;
}

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

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;

    if (n == 0) {
        cout << 0;
        return 0;
    }

    // dp[i][0]: số lần đổi ít nhất cho đến i mà người thứ i giữ nguyên
    // dp[i][1]: số lần đổi ít nhất cho đến i mà người thứ i bị đổi
    // Tuy nhiên, code mẫu chỉ phân biệt 2 trạng thái 'giữ' và 'đổi', không phân biệt loại cụ thể.
    // Để đơn giản cho giải thích, ta tư duy theo hướng: tối ưu chi phí cho đến vị trí i.

    // Code thực tế từ giải pháp 2:
    vector<int> a(n + 1);
    for(int i=1; i<=n; i++) a[i] = s[i-1]-'A';

    // dp[i][0]: người thứ i không đổi (hoặc đổi thành đúng loại cũ)
    // dp[i][1]: người thứ i đổi thành loại khác
    // *Lưu ý: Code mẫu có thể chưa hoàn thiện logic cho mọi trường hợp 3 loại, nhưng cho thấy tư duy DP.*

    // Dưới đây là logic DP chuẩn chỉnh hơn cho bài toán này:
    // dp[i][char_idx] là số lần đổi ít nhất đến vị trí i, với người thứ i là char_idx (0=A, 1=B, 2=C)
    vector<vector<int>> dp(n + 1, vector<int>(3, 1e9));

    // Khởi tạo vị trí đầu tiên
    for (int k = 0; k < 3; k++) {
        dp[1][k] = (k + 'A' == s[0] ? 0 : 1);
    }

    for (int i = 2; i <= n; i++) {
        for (int curr = 0; curr < 3; curr++) { // Trạng thái hiện tại (người thứ i)
            for (int prev = 0; prev < 3; prev++) { // Trạng thái trước đó (người thứ i-1)
                if (curr == prev) continue; // Không được để 2 người giống nhau đứng cạnh
                int cost = (curr + 'A' == s[i-1] ? 0 : 1);
                dp[i][curr] = min(dp[i][curr], dp[i-1][prev] + cost);
            }
        }
    }

    int ans = 1e9;
    for (int k = 0; k < 3; k++) ans = min(ans, dp[n][k]);
    cout << ans;
    return 0;
}

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

int main() {
    int n;
    cin >> n;
    string s;
    if (n > 0) cin >> s;

    // Chỉ cần lưu 2 trạng thái trước đó thay vì cả mảng N
    // dp_prev[k]: chi phí tối ưu đến i-1 với người i-1 là k
    // dp_curr[k]: chi phí tối ưu đến i với người i là k
    vector<int> dp_prev(3, 0);

    // Khởi tạo cho i=0
    for (int k = 0; k < 3; k++) {
        dp_prev[k] = (n > 0 && k + 'A' == s[0]) ? 0 : 1;
    }

    if (n == 0) {
        cout << 0;
        return 0;
    }

    for (int i = 1; i < n; i++) {
        vector<int> dp_curr(3, 1e9);
        for (int curr = 0; curr < 3; curr++) {
            for (int prev = 0; prev < 3; prev++) {
                if (curr == prev) continue;
                int cost = (curr + 'A' == s[i] ? 0 : 1);
                dp_curr[curr] = min(dp_curr[curr], dp_prev[prev] + cost);
            }
        }
        dp_prev = dp_curr;
    }

    int ans = 1e9;
    for (int k = 0; k < 3; k++) ans = min(ans, dp_prev[k]);
    cout << ans;
    return 0;
}