Isomorphic Strings

Published at16 Mar 2026

Like0

Two strings are isomorphic when the character pattern in one string can be matched to the character pattern in the other string with a consistent one-to-one mapping.

That means if a character in the first string appears again later, it must map to the same character again in the second string. It also means two different characters from the first string are not allowed to collapse into the same character in the second string.

For example, "egg" and "add" are isomorphic because e -> a and g -> d stay consistent across the whole string. But "foo" and "bar" are not isomorphic because the repeated o would need to map inconsistently.

So the task is to check whether one stable one-to-one character mapping can explain every position in both strings.

Example Input & Output

Example 1

Input

s = "egg", t = "add"

Output

true

Explanation

e->a and g->d is consistent.

Example 2

Input

s = "foo", t = "bar"

Output

false

Explanation

o cannot map to both a and r.

Example 3

Input

s = "paper", t = "title"

Output

true

Explanation

A consistent one-to-one mapping exists.

Algorithm Flow

Recommendation Algorithm Flow for Isomorphic Strings

Solution Approach

The cleanest hash table solution is to keep two maps: one from characters in s to characters in t, and one from characters in t back to characters in s.

Using two maps matters because consistency has to work in both directions. If we only store s -> t, we could miss a bad case where two different characters in s both point to the same character in t.

We scan the strings position by position. At index i, let the characters be a = s[i] and b = t[i]. There are two checks.

If a was seen before, it must map to exactly b. If not, the strings are not isomorphic. If b was seen before in the reverse map, it must map back to exactly a. If not, the strings are also not isomorphic.

If both checks pass, we store the pair in both maps and continue:

mapST.set(a, b); mapTS.set(b, a);

If we finish the loop without any contradiction, then every repeated letter followed the same pattern and no two letters tried to share the same partner. That means the strings are isomorphic. This solution runs in O(n) time with O(k) extra space.

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

java

import java.util.*;
class Solution {
    public boolean isomorphic_strings(String s, String t) {
        if (s.length() != t.length()) return false;
        Map<Character, Character> st = new HashMap<>();
        Map<Character, Character> ts = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char a = s.charAt(i), b = t.charAt(i);
            if (st.containsKey(a) && st.get(a) != b) return false;
            if (ts.containsKey(b) && ts.get(b) != a) return false;
            st.put(a, b);
            ts.put(b, a);
        }
        return true;
    }
}

javascript

function isomorphic_strings(s, t) {
    if (s.length !== t.length) return false;
    const st = {}, ts = {};
    for (let i = 0; i < s.length; i++) {
        const a = s[i], b = t[i];
        if (st[a] !== undefined && st[a] !== b) return false;
        if (ts[b] !== undefined && ts[b] !== a) return false;
        st[a] = b;
        ts[b] = a;
    }
    return true;
}

php

<?php
function isomorphic_strings($s, $t) {
    if (strlen($s) !== strlen($t)) return false;
    $st = []; $ts = [];
    for ($i = 0; $i < strlen($s); $i++) {
        $a = $s[$i]; $b = $t[$i];
        if (isset($st[$a]) && $st[$a] !== $b) return false;
        if (isset($ts[$b]) && $ts[$b] !== $a) return false;
        $st[$a] = $b;
        $ts[$b] = $a;
    }
    return true;
}
?>

python

def isomorphic_strings(s: str, t: str) -> bool:
    if len(s) != len(t):
        return False
    st, ts = {}, {}
    for a, b in zip(s, t):
        if a in st and st[a] != b:
            return False
        if b in ts and ts[b] != a:
            return False
        st[a] = b
        ts[b] = a
    return True

rust

use std::collections::HashMap;
fn isomorphic_strings(s: String, t: String) -> bool {
    if s.len() != t.len() { return false; }
    let mut st: HashMap<char, char> = HashMap::new();
    let mut ts: HashMap<char, char> = HashMap::new();
    let sa: Vec<char> = s.chars().collect();
    let ta: Vec<char> = t.chars().collect();
    for i in 0..sa.len() {
        let a = sa[i];
        let b = ta[i];
        if let Some(v) = st.get(&a) { if *v != b { return false; } }
        if let Some(v) = ts.get(&b) { if *v != a { return false; } }
        st.insert(a, b);
        ts.insert(b, a);
    }
    true
}

typescript

function isomorphic_strings(s: string, t: string): boolean {
    if (s.length !== t.length) return false;
    var st: { [key: string]: string } = {};
    var ts: { [key: string]: string } = {};
    for (var i = 0; i < s.length; i++) {
        var a = s.charAt(i);
        var b = t.charAt(i);
        if (st[a] !== undefined && st[a] !== b) return false;
        if (ts[b] !== undefined && ts[b] !== a) return false;
        st[a] = b;
        ts[b] = a;
    }
    return true;
}

Related Hash Table Challenges

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this Challenge.

Isomorphic Strings

Example Input & Output

Algorithm Flow

Solution Approach

Best AnswersThese are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

Solutions Coming Soon

Related Hash Table Challenges

Subarray Sum Equals K

Top K Frequent Elements

Longest Substring Without Repeating Characters

Four Sum Count

Duplicate Indices Map

First Unique Character

Comments (0)

Join the Discussion

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.