Letter Case Permutation

Letter Case Permutation - Problem

Given a string s, you can transform every letter individually to be lowercase or uppercase to create another string.

Return a list of all possible strings we could create. Return the output in any order.

Note: Only alphabetic characters can be transformed - digits and special characters remain unchanged.

Input & Output

Example 1 — Basic Case

$ Input: s = "a1b2"

› Output: ["a1b2","a1B2","A1b2","A1B2"]

💡 Note: Two letters 'a' and 'b' can each be upper or lower case. 2×2 = 4 combinations total.

Example 2 — Single Character

$ Input: s = "3z4"

› Output: ["3z4","3Z4"]

💡 Note: Only one letter 'z', so 2 possibilities: lowercase 'z' or uppercase 'Z'.

Example 3 — No Letters

$ Input: s = "12345"

› Output: ["12345"]

💡 Note: No letters to transform, so only one result: the original string.

Constraints

1 ≤ s.length ≤ 12
s consists of lowercase English letters, uppercase English letters, and digits

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that each letter has exactly 2 states (upper/lower), creating 2^n total combinations. Best approach uses backtracking or bit manipulation to systematically generate all permutations. Time: O(2^n × n), Space: O(2^n × n)

Common Approaches

✓ Dp 2d

⏱️ Time: N/A Space: N/A

Binary Search Answer

⏱️ Time: N/A Space: N/A

Bit Manipulation

⏱️ Time: O(2^n × m) Space: O(2^n × m)

Treat each letter position as a bit. For n letters, iterate through all 2^n possible bitmasks, where each bit determines if that letter should be uppercase (1) or lowercase (0).

Brute Force - Generate All Combinations

⏱️ Time: O(2^n × n) Space: O(2^n × n)

For each letter in the string, generate all possible combinations by considering both uppercase and lowercase versions. Use recursion to build all permutations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int abs_int(int x) {
    return x < 0 ? -x : x;
}

int solution(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    // Create 2D DP table
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    int maxLen = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (s[i-1] == s[j-1] && abs_int(i - j) >= dp[i-1][j-1] + 1) {
                dp[i][j] = dp[i-1][j-1] + 1;
                if (dp[i][j] > maxLen) {
                    maxLen = dp[i][j];
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return maxLen;
}

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

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

185.0K Views

Medium Frequency

~15 min Avg. Time

2.8K 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