Largest Substring Between Two Equal Characters

class Solution {
public:
    int maxDistanceBetweenSameChars(string str) {
        unordered_map<char, int> indexMap;
        int maxDistance = -1;

        for (int idx = 0; idx < str.size(); idx++) {
            if (indexMap.count(str[idx])) {
                maxDistance = max(maxDistance, idx - indexMap[str[idx]] - 1);
            } else {
                indexMap[str[idx]] = idx;
            }
        }

        return maxDistance;
    }
};

This solution in C++ focuses on finding the maximum distance (number of characters between two same characters) between two identical characters in a string. Here’s how this code achieves the solution:

• Initially, define a helper function maxDistanceBetweenSameChars that takes a string str as its parameter.

• Use an unordered_map named indexMap to store characters from the string and their first occurring index.

• Initialize an integer maxDistance to -1 to handle cases where no two characters are the same.

• Iterate over each character of the string using a for-loop. During each iteration:

  • If the character is already present in indexMap, calculate the distance between its first occurrence (stored in the map) and the current index. Update maxDistance if this new calculated distance is greater than the existing maxDistance.

  • If the character is not present in the map, add the character and its index to the indexMap.

• After completing the loop, return the value of maxDistance, which represents the largest number of characters between the first and last occurrence of any character that appears more than once.

This approach ensures an efficient computation by using a hash map to store indices, allowing for constant time complexity checks and updates. The final returned value from the function provides the required maximum distance.

class Solution {
    public int maxDistanceBetweenSameChars(String input) {
        Map<Character, Integer> indexMap = new HashMap<>();
        int maximumDistance = -1;
        
        for (int index = 0; index < input.length(); index++) {
            char currentChar = input.charAt(index);
            if (indexMap.containsKey(currentChar)) {
                maximumDistance = Math.max(maximumDistance, index - indexMap.get(currentChar) - 1);
            } else {
                indexMap.put(currentChar, index);
            }
        }
        
        return maximumDistance;
    }
}

The provided Java solution helps find the largest substring between two equal characters in a given string. In this approach:

• A HashMap named indexMap is utilized to store characters and their first occurrence indices from the string.
• An integer maximumDistance initializes at -1 to track the maximum length of substrings found.
• The program iterates through the input string, examining each character.
• During each iteration, if the character already exists in indexMap, the program calculates the distance between the current index and the first occurrence index of that character, updating maximumDistance if this new distance is larger.
• If the character is not found in indexMap, the current index is saved as its first occurrence.
• After completing the loop, the result, held in maximumDistance, provides the length of the largest substring between two identical characters.

The solution effectively uses a map to reduce the complexity of tracking and comparing indices, resulting in an efficient approach to solving the problem.

class Solution:
    def maxLenBetweenEqualChars(self, string: str) -> int:
        index_map = {}
        max_distance = -1
        
        for index in range(len(string)):
            if string[index] in index_map:
                max_distance = max(max_distance, index - index_map[string[index]] - 1)
            else:
                index_map[string[index]] = index

        return max_distance

The given Python code snippet efficiently computes the longest substring distance between two identical characters in a given string. It implements the solution using a dictionary (index_map) to track the earliest index where each character appears and iteratively calculates the maximum distance.

• Initialize a dictionary index_map to store characters and their first index.
• Set max_distance to -1 as a starting value, considering the instance where no two characters are the same.
• Loop through the string by indexing each character:
  • If the character exists in index_map, update max_distance using the formula (index - index map[char] - 1). This tracks the longest span between duplicate characters.
• Update index_map with the current index of the character when it is encountered for the first time.
• Finally, it returns the computed maximum distance which is the length of the longest substring found between two identical characters. If no duplicate character is found, it would return -1.

Use this snippet to quickly get the distance of the largest substring situated between two matching characters in any given string.