Finding ABA Substrings

This challenge involves identifying and counting specific types of substrings within a given string. Understanding these patterns is fundamental in various string processing tasks, such as bioinformatics (e.g., DNA sequence analysis) and data validation. You'll need to develop an efficient algorithm to pinpoint all occurrences of these "ABA" patterns.

Problem Description

An "ABA" substring is defined as a substring of length 3 where the first and the third characters are the same, and the second character is different from the first (and third) character. For example, "aba", "cdc", "xyx" are ABA substrings. "aaa" is not an ABA substring because the first and second characters are the same. "abc" is not an ABA substring because the first and third characters are different.

Your task is to write a Python function that takes a string as input and returns the total count of all ABA substrings within that string.

Key Requirements:

1. Identify ABA substrings: Accurately detect all substrings of length 3 that match the ABA pattern.
2. Count occurrences: Sum up the total number of such substrings found.
3. Case sensitivity: The comparison should be case-sensitive. 'a' is different from 'A'.

Expected Behavior:

The function should iterate through the input string and check every possible substring of length 3. For each such substring, it should determine if it conforms to the ABA pattern.

Edge Cases:

• Empty string: If the input string is empty, the count should be 0.
• String shorter than 3 characters: If the input string has fewer than 3 characters, no ABA substrings can be formed, so the count should be 0.
• String with repeating characters: Ensure the logic correctly handles strings with consecutive identical characters (e.g., "aaaaa").

Examples

Example 1:

Input: "abacaba"
Output: 4
Explanation: The ABA substrings are:
- "aba" at index 0
- "bac" at index 1 (not ABA)
- "aca" at index 2
- "cab" at index 3 (not ABA)
- "aba" at index 4
The ABA substrings are "aba" (indices 0, 4) and "aca" (index 2). There are two occurrences of "aba" and one of "aca". However, the problem asks for ANY ABA substring, so we count all of them. Looking again, the ABA substrings are:
- "aba" (indices 0)
- "aca" (indices 2)
- "aba" (indices 4)
Wait, the definition states the second character must be *different* from the first and third. Let's re-evaluate.

Input: "abacaba"
Output: 3
Explanation: The ABA substrings are:
- "aba" at index 0 (a == a, b != a)
- "aca" at index 2 (a == a, c != a)
- "aba" at index 4 (a == a, b != a)
The substring "bac" at index 1 is not ABA because 'b' != 'c'.
The substring "cab" at index 3 is not ABA because 'c' != 'b'.

Example 2:

Input: "aaaaa"
Output: 0
Explanation: No substring of length 3 has the first and third characters the same AND the second character different. For instance, "aaa" at index 0 has 'a' == 'a' for first and third, but 'a' == 'a' for the second, violating the condition.

Example 3:

Input: "xyzxy"
Output: 1
Explanation:
- "xyz" at index 0 is not ABA.
- "yzx" at index 1 is not ABA.
- "zxy" at index 2 is not ABA.
Ah, I made a mistake in the explanation. Let's correct.

Input: "xyzxy"
Output: 0
Explanation:
- "xyz" at index 0: x != z
- "yzx" at index 1: y != x
- "zxy" at index 2: z != y
There are no ABA substrings.

Let's try a better Example 3.

Input: "level"
Output: 1
Explanation:
- "lev" at index 0: l != v
- "eve" at index 1: e == e, v != e. This is an ABA substring.
- "vel" at index 2: v != l

Constraints

• The input string s will contain only lowercase and uppercase English letters.
• The length of the input string s will be between 0 and 1000, inclusive.
• Your solution should aim for a time complexity of O(n), where n is the length of the input string.

Notes

Consider how you can efficiently iterate through the string to check all possible 3-character substrings without redundant checks. Remember that Python string slicing is a powerful tool for this.