Count Substrings with Only One Distinct Letter

class Solution {
    public int sumOfRepeatingChars(String str) {
        int sum = 1, consecutive = 1;
        for (int index = 1; index < str.length(); index++) {
            if (str.charAt(index) == str.charAt(index - 1)) {
                consecutive++;
            } else {
                consecutive = 1;
            }
            sum += consecutive;
        }
        return sum;
    }
}

The given Java program is designed to calculate the number of substrings where all characters are the same in a given string. It achieves this by iterating through the string and counting the length of consecutive characters that are identical. Each time it encounters a character that matches the previous character, it increases the count of consecutive characters. Otherwise, it resets this count to one. The sum of these counts over the entire string gives the total number of such substrings. The method sumOfRepeatingChars returns this sum. Here's how the code implements this:

• Initialize two integer variables, sum and consecutive, to 1. sum holds the cumulative number of valid substrings, and consecutive tracks the length of the current sequence of identical characters.
• Iterate through the string starting from the second character.
• For each character, check if it matches the previous character. If it does, increment the consecutive variable. If not, reset consecutive to 1.
• Add the current value of consecutive to sum with each iteration.
• After the loop completes, return the value of sum, which is the total count of substrings with identical consecutive characters.

class Solution:
    def computeTotalLetters(self, string: str) -> int:
        overallSum = 1
        consecutive = 1
        for index in range(1, len(string)):
            if string[index] == string[index - 1]:
                consecutive += 1
            else:
                consecutive = 1
            overallSum += consecutive
        return overallSum

The solution provided is a Python 3 implementation for counting the sum of the lengths of all substrings in a given string that have only one distinct letter. Follow the approach below to understand the solution’s logic:

1. The function computeTotalLetters takes a single string as an argument.
2. Initialize overallSum to 1, which will keep the count of total substrings with identical letters. Start with 1 to account for the first character trivially being a substring.
3. Set consecutive to 1, which tracks the length of the current consecutive substring with identical letters.
4. Iterate through the string starting from the second character:
   • Compare each character with the previous character.
   • If they match, the current character continues a substring of identical characters (consecutive increment by 1).
   • If they differ, reset consecutive to 1 as a new set of identical letters starts.
   • Add the value of consecutive to overallSum during each iteration; this adds the number of new substrings formed by adding the current letter.
5. Once the loop completes, return overallSum, which is the total count of all substrings in which all characters are the same.

This function effectively and efficiently calculates the desired total by leveraging the nature of consecutive identical characters in substrings. The use of a simple loop and accumulative counting ensures optimal performance.