Problem:
Score : 200 points

Problem Statement

We have a string S of length N consisting of uppercase English letters.

How many times does ABC occur in S as contiguous subsequences (see Sample Inputs and Outputs)?

Constraints

3 \leq N \leq 50

S consists of uppercase English letters.

Input

Input is given from Standard Input in the following format:

N
S

Output

Print number of occurrences of ABC in S as contiguous subsequences.

Sample Input 1

10
ZABCDBABCQ

Sample Output 1

2

Two contiguous subsequences of S are equal to ABC: the 2-nd through 4-th characters, and the 7-th through 9-th characters.

Sample Input 2

19
THREEONEFOURONEFIVE

Sample Output 2

0

No contiguous subsequences of S are equal to ABC.

Sample Input 3

33
ABCCABCBABCCABACBCBBABCBCBCBCABCB

Sample Output 3

5

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

/**
 * code generated by RHelper
 * More info: https://github.com/mkc1370/RHelper
 * @author 
 */

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;

public class BCountABC
{
    public void Solve()
    {
        var n = CINL;
        var s = CINS;
        var sum = 0;
        for (var i = 0; i < n-2; i++)
        {
            if (s[i] == 'A' && s[i + 1] == 'B' && s[i + 2] == 'C')
            {
                sum++;
            }
        }

        COUT(sum);
    }
    
    private readonly StringReader cin;
    private readonly StringWriter cout;
    private readonly Scanner scanner;

    public BCountABC(StringReader cin, StringWriter cout)
    {
        this.cin = cin;
        this.cout = cout;
        scanner = new Scanner(cin);
    }

    private long CINL => scanner.Long();
    private double CIND => scanner.Double();
    private string CINS => scanner.String();
    private static IEnumerable<T> Repeat<T>(T v, long n) => Enumerable.Repeat(v, (int)n);
    private List<long> CINVL(long n) => Repeat(0, n).Select(_ => CINL).ToList();
    private List<double> CINVD(long n) => Repeat(0, n).Select(_ => CIND).ToList();
    private List<string> CINVS(long n) => Repeat(0, n).Select(_ => CINS).ToList();

    private void COUT(object o) => cout.WriteLine(o);
}


public class Scanner
{
    public Scanner(StringReader stringReader)
    {
        this.stringReader = stringReader;
    }

    private readonly StringReader stringReader;
    private readonly char[] buffer = new char[1024];
    private int len, ptr;
    private bool isEof;

    private char Read()
    {
        if (isEof) throw new EndOfStreamException();
        if (ptr >= len)
        {
            ptr = 0;
            if ((len = stringReader.Read(buffer, 0, 1024)) <= 0)
            {
                isEof = true;
                return '\0';
            }
        }

        return buffer[ptr++];
    }

    public char Char()
    {
        char b;
        do b = Read();
        while (b < 33 || 126 < b);
        return b;
    }

    public string String()
    {
        var sb = new StringBuilder();
        for (char b = Char(); b >= 33 && b <= 126; b = Read())
            sb.Append(b);
        return sb.ToString();
    }

    public long Long()
    {
        long ret = 0;
        char b;
        var ng = false;
        do b = Read();
        while (b != '-' && (b < '0' || '9' < b));
        if (b == '-')
        {
            ng = true;
            b = Read();
        }

        for (;; b = Read())
        {
            if (b < '0' || '9' < b)
                return ng ? -ret : ret;
            else ret = ret * 10 + b - '0';
        }
    }

    public double Double()
    {
        return double.Parse(String(), CultureInfo.InvariantCulture);
    }
}

public struct ModInt
{
    public const int Mod = 1000000007;
    private const long Positivizer = ((long)Mod) << 31;
    private long data;
    public ModInt(long data) { if ((this.data = data % Mod) < 0) this.data += Mod; }
    public static implicit operator long(ModInt modInt) => modInt.data;
    public static implicit operator ModInt(long val) => new ModInt(val);
    public static ModInt operator +(ModInt a, int b) => new ModInt() { data = (a.data + b + Positivizer) % Mod };
    public static ModInt operator +(ModInt a, long b) => new ModInt(a.data + b);
    public static ModInt operator +(ModInt a, ModInt b) { long res = a.data + b.data; return new ModInt() { data = res >= Mod ? res - Mod : res }; }
    public static ModInt operator -(ModInt a, int b) => new ModInt() { data = (a.data - b + Positivizer) % Mod };
    public static ModInt operator -(ModInt a, long b) => new ModInt(a.data - b);
    public static ModInt operator -(ModInt a, ModInt b) { long res = a.data - b.data; return new ModInt() { data = res < 0 ? res + Mod : res }; }
    public static ModInt operator *(ModInt a, int b) => new ModInt(a.data * b);
    public static ModInt operator *(ModInt a, long b) => a * new ModInt(b);
    public static ModInt operator *(ModInt a, ModInt b) => new ModInt() { data = a.data * b.data % Mod };
    public static ModInt operator /(ModInt a, ModInt b) => new ModInt() { data = a.data * GetInverse(b) % Mod };
    public static bool operator ==(ModInt a, ModInt b) => a.data == b.data;
    public static bool operator !=(ModInt a, ModInt b) => a.data != b.data;
    public override string ToString() => data.ToString();
    public override bool Equals(object obj) => obj != null && (ModInt)obj == this;
    public override int GetHashCode() => (int)data;

    private static long GetInverse(long a)
    {
        long div, p = Mod, x1 = 1, y1 = 0, x2 = 0, y2 = 1;
        while (true)
        {
            if (p == 1) return x2 + Mod; div = a / p; x1 -= x2 * div; y1 -= y2 * div; a %= p;
            if (a == 1) return x1 + Mod; div = p / a; x2 -= x1 * div; y2 -= y1 * div; p %= a;
        }
    }
}


public class Output
{
	public static void Main()
	{
		var reader = new System.IO.StringReader(Console.In.ReadToEnd());
		var writer = new System.IO.StringWriter();
		var solver = new BCountABC(reader, writer);
		solver.Solve();
		System.Console.Write(writer.GetStringBuilder().ToString());
	}
}