Reverse Only Letters - Practice Coding Problems

Reverse Only Letters - Problem

Given a string s, reverse the string according to the following rules:

All the characters that are not English letters remain in the same position.

All the English letters (lowercase or uppercase) should be reversed.

Return s after reversing it.

Input & Output

Example 1 — Basic Case

$ Input: s = "ab-cd"

› Output: "dc-ba"

💡 Note: Letters are a,b,c,d. Reversed: d,c,b,a. Place back: d at pos 0, c at pos 1, skip -, b at pos 3, a at pos 4

Example 2 — Mixed Characters

$ Input: s = "a-bC-dEf-ghIj"

› Output: "j-Ih-gfE-dCba"

💡 Note: Letters: a,b,C,d,E,f,g,h,I,j. Reversed: j,I,h,g,f,E,d,C,b,a. Non-letters stay in same positions

Example 3 — No Letters

$ Input: s = "Test1ng-Leet=code-Q!"

› Output: "Qedo1ct-eeLg=ntse-T!"

💡 Note: Only letters are reversed: T,e,s,t,n,g,L,e,e,t,c,o,d,e,Q become Q,e,d,o,c,t,e,e,L,g,n,t,s,e,T

Constraints

1 ≤ s.length ≤ 1000
s consists of printable ASCII characters.

Visualization

Tap to expand

Understanding the Visualization

Input

String with letters and non-letters mixed: "ab-cd"

Process

Reverse only the letters: a,b,c,d → d,c,b,a

Output

Non-letters stay in place: "dc-ba"

Key Takeaway

🎯 Key Insight: Use two pointers to swap only letters while skipping non-letters

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to reverse only English letters while keeping non-letters in place. Best approach is two pointers - swap letters from both ends moving inward. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Extract and Rebuild	O(n)	O(n)	Extract all letters, reverse them, then rebuild the string
Two Pointers	O(n)	O(1)	Use two pointers to swap letters from both ends moving inward

Extract and Rebuild — Algorithm Steps

Step 1: Extract all letters from string into array
Step 2: Reverse the letters array
Step 3: Rebuild string by placing reversed letters back at letter positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Letters

Pull out all letters: a, b, c

Reverse Array

Reverse to: c, b, a

Rebuild String

Place reversed letters back at letter positions

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char* solution(char* s) {
    int len = strlen(s);
    char* letters = (char*)malloc(len * sizeof(char));
    int letterCount = 0;
    
    // Extract all letters
    for (int i = 0; i < len; i++) {
        if (isalpha(s[i])) {
            letters[letterCount++] = s[i];
        }
    }
    
    // Reverse the letters
    for (int i = 0; i < letterCount / 2; i++) {
        char temp = letters[i];
        letters[i] = letters[letterCount - 1 - i];
        letters[letterCount - 1 - i] = temp;
    }
    
    // Rebuild string with reversed letters
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int letterIdx = 0;
    for (int i = 0; i < len; i++) {
        if (isalpha(s[i])) {
            result[i] = letters[letterIdx++];
        } else {
            result[i] = s[i];
        }
    }
    result[len] = '\0';
    
    free(letters);
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string: once to extract letters, once to rebuild

✓ Linear Growth

Space Complexity

O(n)

Extra array to store extracted letters and result string

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Extract and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler