Isomorphic Strings - Practice Coding Problems

Isomorphic Strings - Problem

Isomorphic Strings is a classic string mapping problem that tests your understanding of character relationships and hash table usage.

Given two strings s and t, determine if they are isomorphic. Two strings are isomorphic if the characters in s can be replaced to get t while maintaining these rules:

• Consistent mapping: All occurrences of a character must be replaced with the same character
• Order preservation: The relative order of characters must remain the same
• One-to-one mapping: No two characters may map to the same character (bijective function)
• Self-mapping allowed: A character may map to itself

Example: "egg" and "add" are isomorphic because 'e' maps to 'a' and 'g' maps to 'd'.

Input & Output

example_1.py — Basic Isomorphic Match

$ Input: s = "egg", t = "add"

› Output: true

💡 Note: The strings are isomorphic because 'e' maps to 'a' and 'g' maps to 'd'. The mapping is consistent: e→a, g→d, g→d.

example_2.py — Non-Isomorphic Strings

$ Input: s = "foo", t = "bar"

› Output: false

💡 Note: The strings are not isomorphic. Character 'o' appears twice in s but would need to map to both 'a' and 'r' in t, which violates the consistent mapping rule.

example_3.py — Edge Case Same String

$ Input: s = "paper", t = "title"

› Output: true

💡 Note: The strings are isomorphic with mapping: p→t, a→i, p→t, e→l, r→e. Each character maps consistently throughout both strings.

Constraints

1 ≤ s.length ≤ 5 × 10⁴
t.length == s.length
s and t consist of any valid ASCII character

Visualization

Tap to expand

Understanding the Visualization

Initialize Cipher Tables

Set up two cipher tables to track character mappings in both directions

Process Character Pairs

For each position, check if the character mapping is consistent with existing cipher rules

Verify Bijection

Ensure each character maps to exactly one other character and vice versa

Determine Isomorphism

If all mappings are consistent, the strings are isomorphic

Key Takeaway

🎯 Key Insight: Isomorphic strings require a perfect bijective mapping where each character in the first string maps to exactly one character in the second string, and vice versa. Using two hash maps allows us to verify this bidirectional relationship efficiently in O(n) time.

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 29 f Meta 25

The optimal solution uses a one-pass hash table approach with two hash maps to track bidirectional character mappings. This ensures O(n) time complexity while maintaining the crucial bijective relationship between characters in both strings.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(k)	Build and verify bidirectional mapping simultaneously in one pass
Brute Force (Character by Character Verification)	O(n²)	O(1)	For each character, scan entire strings to verify consistent mapping

One-Pass Hash Table (Optimal) — Algorithm Steps

Create two hash maps: s_to_t and t_to_s
Iterate through both strings simultaneously
For each character pair (s[i], t[i]):
Check if s[i] already has a mapping in s_to_t
Check if t[i] already has a mapping in t_to_s
If mappings exist, verify consistency; if not, create new mappings
Return false if any inconsistency found, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'e' → 'a'

Create mapping e→a in sToT and a→e in tToS

Process 'g' → 'd'

Create mapping g→d in sToT and d→g in tToS

Verify 'g' → 'd'

Check existing mapping: g already maps to d ✓, d already maps to g ✓

Code -

solution.c — C

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

bool isIsomorphic(char* s, char* t) {
    int lenS = strlen(s);
    int lenT = strlen(t);
    
    if (lenS != lenT) {
        return false;
    }
    
    // Using arrays as hash maps for ASCII characters
    char sToT[256] = {0};
    char tToS[256] = {0};
    
    for (int i = 0; i < lenS; i++) {
        char charS = s[i];
        char charT = t[i];
        
        // Check s to t mapping
        if (sToT[(unsigned char)charS] != 0) {
            if (sToT[(unsigned char)charS] != charT) {
                return false;
            }
        } else {
            sToT[(unsigned char)charS] = charT;
        }
        
        // Check t to s mapping
        if (tToS[(unsigned char)charT] != 0) {
            if (tToS[(unsigned char)charT] != charS) {
                return false;
            }
        } else {
            tToS[(unsigned char)charT] = charS;
        }
    }
    
    return true;
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    
    // Remove newlines and quotes
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    if (s[0] == '"') memmove(s, s+1, strlen(s));
    if (s[strlen(s)-1] == '"') s[strlen(s)-1] = 0;
    if (t[0] == '"') memmove(t, t+1, strlen(t));
    if (t[strlen(t)-1] == '"') t[strlen(t)-1] = 0;
    
    printf("%s\n", isIsomorphic(s, t) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings, with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique characters, worst case O(n) for all unique characters

✓ Linear Space

98.4K Views

High 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler