Largest Substring Between Two Equal Characters

Largest Substring Between Two Equal Characters - Problem

Given a string s, return the length of the longest substring between two equal characters, excluding the two characters themselves. If no such substring exists, return -1.

A substring is a contiguous sequence of characters within a string.

Example: In the string "abca", the characters 'a' appear at indices 0 and 3. The substring between them is "bc" with length 2.

Your task is to find the maximum possible length among all such substrings formed by pairs of equal characters.

Input & Output

example_1.py — Basic Case

$ Input: s = "abca"

› Output: 2

💡 Note: The characters 'a' appear at indices 0 and 3. The substring between them is "bc" with length 2.

example_2.py — Multiple Pairs

$ Input: s = "cbzxy"

› Output: -1

💡 Note: No two equal characters exist in the string, so return -1.

example_3.py — Adjacent Characters

$ Input: s = "aa"

› Output: 0

💡 Note: The characters 'a' appear at indices 0 and 1. The substring between them is empty with length 0.

Visualization

Tap to expand

Understanding the Visualization

Walk along the shelf

Process each character position one by one

Remember first bookends

Store the first position where each character appears

Measure distances

When we see a character again, calculate the distance from its first occurrence

Track maximum

Keep the longest distance found so far

Key Takeaway

🎯 Key Insight: We only need to remember the first occurrence of each character. Any subsequent occurrence will give us a valid substring, and later occurrences naturally provide longer distances.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters in the string (at most 26 for lowercase letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 300
s contains only lowercase English letters
The string may contain duplicate characters

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a hash table to track the first occurrence of each character. In a single pass through the string, we calculate the distance between matching characters and keep track of the maximum length. This achieves O(n) time complexity and O(k) space complexity where k is the number of unique characters.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(k)	Track first occurrence of each character and calculate distances in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of indices for matching characters

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a hash map to store first occurrence indices
Initialize max_length to -1
Iterate through the string with index i
If character is in hash map, calculate length i - first_index - 1
Update max_length if current length is greater
If character not in hash map, store its first occurrence
Return max_length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize hash map

Create empty hash map for first occurrences

Process each character

Check if character was seen before

Calculate or store

If seen: calculate distance; if not: store first occurrence

Update maximum

Keep track of the longest substring found

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

int largestSubstringBetweenEqualCharacters(char* s) {
    int firstOccurrence[256];
    bool seen[256] = {false};
    int maxLength = -1;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        char c = s[i];
        if (seen[c]) {
            int currentLength = i - firstOccurrence[c] - 1;
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        } else {
            firstOccurrence[c] = i;
            seen[c] = true;
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        for (int i = 1; i < len - 1; i++) {
            s[i-1] = s[i];
        }
        s[len-2] = '\0';
    }
    printf("%d\n", largestSubstringBetweenEqualCharacters(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters in the string (at most 26 for lowercase letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 300
s contains only lowercase English letters
The string may contain duplicate characters

28.5K Views

Medium Frequency

~12 min Avg. Time

980 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler