Reverse Only Letters - Practice Coding Problems

Reverse Only Letters - Problem

Imagine you're a proofreader working with a document where all the English letters need to be reversed while keeping all other characters (numbers, symbols, spaces) in their exact positions!

Given a string s, your task is to reverse only the English letters according to these rules:

All characters that are not English letters (a-z, A-Z) must remain in the same position
All English letters (both lowercase and uppercase) should be reversed among themselves

Goal: Return the modified string after reversing only the letters.

Example: "ab-cd" becomes "dc-ba" - notice how the dash stays in position 2, but the letters a,b,c,d become d,c,b,a.

Input & Output

example_1.py — Basic Case

$ Input: s = "ab-cd"

› Output: "dc-ba"

💡 Note: The letters are 'a', 'b', 'c', 'd'. When reversed, they become 'd', 'c', 'b', 'a'. The non-letter character '-' stays in position 2. So we get 'd' + 'c' + '-' + 'b' + 'a' = "dc-ba".

example_2.py — Mixed Case with Numbers

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

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

💡 Note: Extract letters: a,b,C,d,E,f,g,h,I,j. Reversed: j,I,h,g,f,E,d,C,b,a. Place back while preserving positions of '-': "j-Ih-gfE-dCba".

example_3.py — Edge Case - No Letters

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

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

💡 Note: Letters are: T,e,s,t,n,g,L,e,e,t,c,o,d,e,Q. Reversed: Q,e,d,o,c,t,e,e,L,g,n,t,s,e,T. Numbers and symbols stay in their positions.

Constraints

1 ≤ s.length ≤ 100
s consists of printable ASCII characters
Letters include both uppercase and lowercase English letters (a-z, A-Z)

Visualization

Tap to expand

Understanding the Visualization

Survey the Gallery

Walk through and identify which display cases contain letters vs other artifacts

Two Curator Strategy

Position one curator at the entrance, another at the exit - they work toward the middle

Find and Swap

Each curator moves inward until finding a letter display, then they swap those artifacts

Continue Until Meeting

Repeat the process until both curators meet in the middle - all letters are now reversed!

Key Takeaway

🎯 Key Insight: The two-pointer approach elegantly handles this problem by treating letters and non-letters differently - we only swap letters while completely ignoring the positions of other characters. This results in optimal O(n) time complexity with a single pass through the string.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses the two pointers technique with O(n) time and O(n) space complexity. Initialize pointers at both ends, move them inward until both find letters, then swap. This avoids the need for separate extraction and reversal steps, making it both time and space efficient. The key insight is that we only need to swap letters with each other while preserving the positions of non-letter characters.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Extract and Replace)	O(n)	O(n)	Extract all letters, reverse them, then replace back into original positions
Two Pointers (Optimal)	O(n)	O(n)	Use two pointers from both ends, swapping only when both point to letters

Brute Force (Extract and Replace) — Algorithm Steps

Convert string to character array for mutability
Extract all English letters into a separate list
Reverse the extracted letters list
Scan through original string again, replacing each letter position with letters from reversed list
Return the modified string

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with input string containing letters and non-letters

Extract Letters

Scan through string and collect all letters into separate array

Reverse Letters

Reverse the extracted letters array

Replace Back

Scan original string again, replacing each letter with reversed letters

Code -

solution.c — C

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

void reverseOnlyLetters(char* s) {
    int len = strlen(s);
    char letters[1001];
    int letterCount = 0;
    
    // Extract all letters
    for (int i = 0; i < len; i++) {
        if (isalpha(s[i])) {
            letters[letterCount++] = s[i];
        }
    }
    
    // Replace letters back into original positions (from end of letters array)
    int letterIndex = letterCount - 1;
    for (int i = 0; i < len; i++) {
        if (isalpha(s[i])) {
            s[i] = letters[letterIndex--];
        }
    }
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    reverseOnlyLetters(s);
    printf("\"%s\"\n", s);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through string of length n, plus O(k) to reverse letters where k ≤ n

✓ Linear Growth

Space Complexity

O(n)

Extra space for character array conversion and extracted letters list

⚡ Linearithmic Space

24.8K Views

Medium Frequency

~12 min Avg. Time

892 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

Brute Force (Extract and Replace) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler