Check Distances Between Same Letters - Practice Coding Problems

Check Distances Between Same Letters - Problem

Imagine you're a quality inspector for a text formatting company! You've been given a special string where each letter appears exactly twice, and you need to verify if the spacing between identical letters meets specific requirements.

Here's what you have:

A string s containing only lowercase letters, where each letter appears exactly twice
An array distance of length 26, where distance[i] tells you how many letters should be between the two occurrences of the i-th letter of the alphabet

Your mission: Determine if the string is "well-spaced" - meaning the actual distance between each pair of identical letters matches the required distance.

Example: If s = "abaccb" and we need 1 letter between the two 'a's, we check: the 'a's are at positions 0 and 2, so there's 1 letter ('b') between them. Perfect! ✅

Return true if the string meets all spacing requirements, false otherwise.

Input & Output

example_1.py — Basic Valid Case

$ Input: s = "abaccb", distance = [1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

› Output: true

💡 Note: The letter 'a' appears at indices 0 and 2, with 1 letter between them (distance[0] = 1 ✓). The letter 'b' appears at indices 1 and 5, with 3 letters between them (distance[1] = 3 ✓). The letter 'c' appears at indices 3 and 4, with 0 letters between them (distance[2] = 0 ✓). All conditions are satisfied.

example_2.py — Invalid Case

$ Input: s = "aa", distance = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

› Output: false

💡 Note: The letter 'a' appears at indices 0 and 1, with 0 letters between them. However, distance[0] = 1, which means we need exactly 1 letter between the two 'a's. Since 0 ≠ 1, the string is not well-spaced.

example_3.py — Adjacent Letters Valid

$ Input: s = "aabb", distance = [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

› Output: true

💡 Note: The letter 'a' appears at indices 0 and 1 with 0 letters between (distance[0] = 0 ✓). The letter 'b' appears at indices 2 and 3 with 0 letters between, but we need 1 letter between them (distance[1] = 1). Wait - actually 'b' at positions 2,3 has 0 letters between, but distance[1] = 1. This should be false. Let me recalculate... Actually for this to be true, we need distance = [0,0,...].

Visualization

Tap to expand

Understanding the Visualization

First Car Arrives

When we see a car type for the first time, we record its parking spot number

Twin Car Arrives

When the same car type arrives again, we check if it parked at the correct distance

Instant Validation

We immediately know if the parking rule is followed or violated

Continue or Stop

If valid, continue; if invalid, reject the entire parking arrangement

Key Takeaway

🎯 Key Insight: Just like a parking attendant who remembers where the first car parked and checks the distance when the twin arrives, we store the first occurrence position and validate immediately on the second occurrence - achieving optimal O(n) efficiency!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character processed exactly twice (once for each occurrence)

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k unique characters where k is the number of unique letters (at most 26)

✓ Linear Space

Constraints

2 ≤ s.length ≤ 52
s consists only of lowercase English letters
Each letter appears in s exactly twice
distance.length == 26
0 ≤ distance[i] ≤ 50

Asked in

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

The optimal solution uses a hash table with single pass approach. Store each character's first occurrence position, then validate the distance immediately when encountering the second occurrence. This achieves O(n) time complexity with early termination on invalid distances.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each character, find both occurrences by scanning the string twice
One-Pass Hash Table (Optimal)	O(n)	O(k)	Track first occurrence and validate distance when finding second occurrence in single pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each character in the string
For each character, find its first occurrence position
Search through the remaining string to find the second occurrence
Calculate the distance between the two positions
Check if this distance matches the required distance from the array
If any character fails the check, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First 'a'

Start from position 0, found 'a' at index 0

Search for Second 'a'

Scan from index 1 onwards until we find the matching 'a'

Calculate Distance

Count letters between the two 'a' positions

Validate Against Required

Check if actual distance matches distance[0]

Code -

solution.c — C

bool checkDistances(char* s, int* distance, int distanceSize) {
    int n = strlen(s);
    bool processed[26] = {false};
    
    for (int i = 0; i < n; i++) {
        char ch = s[i];
        int charIndex = ch - 'a';
        
        if (processed[charIndex]) {
            continue;
        }
        
        // Find the second occurrence
        int secondPos = -1;
        for (int j = i + 1; j < n; j++) {
            if (s[j] == ch) {
                secondPos = j;
                break;
            }
        }
        
        // Calculate actual distance
        int actualDistance = secondPos - i - 1;
        int requiredDistance = distance[charIndex];
        
        if (actualDistance != requiredDistance) {
            return false;
        }
        
        processed[charIndex] = true;
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each character (O(n)), we potentially scan the entire string (O(n)) to find its pair

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures needed

✓ Linear Space

Constraints

2 ≤ s.length ≤ 52
s consists only of lowercase English letters
Each letter appears in s exactly twice
distance.length == 26
0 ≤ distance[i] ≤ 50

23.2K Views

Medium Frequency

~15 min Avg. Time

847 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler