Reverse Only Letters

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

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

✓ Extract and Rebuild

⏱️ Time: O(n) Space: O(n)

First pass extracts all English letters into a separate array, reverses it, then second pass rebuilds the original string by placing reversed letters back into letter positions.

Two Pointers

⏱️ Time: O(n) Space: O(1)

Convert string to character array, then use left and right pointers. Move pointers inward, skip non-letters, and swap letters when both pointers point to letters.

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