String Transforms Into Another String - Practice Coding Problems

String Transforms Into Another String - Problem

You're given two strings str1 and str2 of equal length. Your task is to determine whether you can transform str1 into str2 through a series of character conversions.

In each conversion operation, you can:

Choose any character that appears in str1
Replace all occurrences of that character with any other lowercase English letter

The challenge is that this transformation must be consistent - if you map character 'a' to 'b', then every 'a' in the string must become 'b'. Think of it as a character substitution cipher where each character has exactly one mapping.

Examples:

"abc" → "bca" is possible: a→b, b→c, c→a
"ab" → "aa" is impossible: both 'a' and 'b' would need to map to 'a'
"abcdefghijklmnopqrstuvwxyz" → "bcdefghijklmnopqrstuvwxyza" is impossible: no free character to use as intermediate

Input & Output

example_1.py — Python

$ Input: str1 = "aabcc", str2 = "ccdee"

› Output: true

💡 Note: We can transform by mapping: a→c, b→d, c→e. This creates the mapping {a:c, b:d, c:e} which is one-to-one and we have unused characters (a,b,f-z) available.

example_2.py — Python

$ Input: str1 = "leetcode", str2 = "codeleet"

› Output: false

💡 Note: We need mapping: l→c, e→o, e→d, t→e, c→l, o→e, d→e, e→t. But 'e' cannot map to both 'o' and 'd' simultaneously. The mapping is inconsistent.

example_3.py — Python

$ Input: str1 = "abcdefghijklmnopqrstuvwxyz", str2 = "bcdefghijklmnopqrstuvwxyza"

› Output: false

💡 Note: This creates a cycle where every character maps to the next one (a→b→c→...→z→a), but there's no unused character to help break the cycle since all 26 letters are used.

Constraints

1 ≤ str1.length ≤ 10⁴
str2.length == str1.length
str1 and str2 consist of lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Build Character Mapping

Create a mapping from each character in str1 to its corresponding character in str2

Validate Consistency

Ensure each character maps to exactly one target (no contradictions)

Check One-to-One Property

Verify no two different characters map to the same target

Verify Cycle Breaking

Ensure unused characters exist to handle transformation cycles

Key Takeaway

🎯 Key Insight: The transformation is possible if and only if: (1) the character mapping is consistent and one-to-one, AND (2) there's at least one unused character in the alphabet to serve as a temporary placeholder for breaking cycles.

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses a one-pass hash table approach to build character mappings while simultaneously validating constraints. Key insights: (1) Each character in str1 must map to exactly one character in str2, (2) No two different characters can map to the same target (one-to-one property), and (3) We need at least one unused character in the alphabet to break cycles during transformation. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(1)	Build character mapping and validate constraints simultaneously in single pass
Brute Force Character Mapping	O(n²)	O(1)	Try all possible character mappings and validate each one

One-Pass Hash Table (Optimal) — Algorithm Steps

Iterate through both strings simultaneously
For each character pair, update mapping and check consistency
Track all target characters to verify one-to-one mapping
Count unique characters in str2 to check if spare chars available
Return false immediately if any constraint is violated

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Position

Examine char pairs (str1[i], str2[i]) sequentially

Update Mapping

Add new mappings or validate existing ones

Track Constraints

Monitor one-to-one property and used characters

Final Validation

Check if enough unused characters exist

Code -

solution.c — C

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

bool canTransform(char* str1, char* str2) {
    int len = strlen(str1);
    if (strcmp(str1, str2) == 0) return true;
    
    // Arrays for a-z characters (0-25 indices)
    char mapping[26];
    bool hasMapping[26] = {false};
    bool usedTargets[26] = {false};
    bool mappedTargets[26] = {false};
    
    for (int i = 0; i < len; i++) {
        int idx1 = str1[i] - 'a';
        int idx2 = str2[i] - 'a';
        
        // Mark target as used
        usedTargets[idx2] = true;
        
        if (hasMapping[idx1]) {
            // Check consistency
            if (mapping[idx1] != str2[i]) {
                return false;
            }
        } else {
            // Check if target already mapped by another char
            if (mappedTargets[idx2]) {
                return false;
            }
            mapping[idx1] = str2[i];
            hasMapping[idx1] = true;
            mappedTargets[idx2] = true;
        }
    }
    
    // Count used targets
    int usedCount = 0;
    for (int i = 0; i < 26; i++) {
        if (usedTargets[i]) usedCount++;
    }
    
    // If all 26 characters used, impossible
    return usedCount < 26;
}

int main() {
    printf("%d\n", canTransform("aabcc", "ccdee"));  // 1
    printf("%d\n", canTransform("leetcode", "codeleet"));  // 0
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings of length n

✓ Linear Growth

Space Complexity

O(1)

Hash maps are bounded by 26 lowercase letters, so O(26) = O(1)

✓ Linear Space

31.2K Views

Medium-High Frequency

~25 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler