How do you approach Isomorphic Strings?

You need to check the mapping in both directions.

What is the time complexity of Isomorphic Strings?

Time complexity: O(n) - single pass through both strings. Space complexity: O(1) - at most 256 ASCII characters in the maps.

What are common mistakes on Isomorphic Strings?

Storing the current value before checking for its complement, which lets an element pair with itself. Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n). Using a plain object as the map when keys may be numbers or __proto__; a real hash-map type keeps key identity intact.

gitGood.dev

← Back to problems

Isomorphic Strings

EasyAlgorithms

Description

Given two strings `s` and `t`, determine if they are isomorphic. Two strings `s` and `t` are isomorphic if the characters in `s` can be replaced to get `t`, with the following rules: - Each character in `s` maps to exactly one character in `t`. - No two characters in `s` map to the same character in `t`. - The order of characters is preserved.

Example 1

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

Output: true

Explanation: e -> a, g -> d. The mapping is consistent.

Example 2

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

Output: false

Explanation: o maps to both a and r, which is not allowed.

Example 3

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

Output: true

Constraints

- 1 <= s.length <= 5 * 10^4 - t.length == s.length - s and t consist of any valid ASCII character.

Isomorphic Strings: approach, complexity and pitfalls

An easy arrays & hashing problem, graded against 7 test cases (4 of them hidden).

The pattern: Arrays & Hashing

Hash maps and sets to trade memory for time - the most common first instinct in interviews.

Reach for it when you see: "Have I seen this before?", counting occurrences, or an O(n²) scan you want to make O(n).

More Arrays & Hashingproblems →

If you are stuck

Show the 3-step hint ladder

You need to check the mapping in both directions.
Use two hash maps: one for s->t mapping and one for t->s mapping.
If a character already has a mapping that conflicts with the current pair, return false.

The optimal approach

Show the approach: Two Hash Maps

Use two hash maps to track mappings in both directions (s to t and t to s). For each pair of characters, check:

1. If s[i] is already mapped to a different character than t[i], return false.

2. If t[i] is already mapped from a different character than s[i], return false.

Otherwise, add the mappings and continue.

Time: O(n) - single pass through both strings
Space: O(1) - at most 256 ASCII characters in the maps

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

Common Arrays & Hashing mistakes

These apply to the pattern as a whole, not just this problem.

Storing the current value before checking for its complement, which lets an element pair with itself.
Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n).
Using a plain object as the map when keys may be numbers or `__proto__`; a real hash-map type keeps key identity intact.

← Back to problems

Isomorphic Strings

EasyAlgorithms

Description

Example 1

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

Output: true

Explanation: e -> a, g -> d. The mapping is consistent.

Example 2

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

Output: false

Explanation: o maps to both a and r, which is not allowed.

Example 3

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

Output: true

Constraints

- 1 <= s.length <= 5 * 10^4 - t.length == s.length - s and t consist of any valid ASCII character.

Isomorphic Strings: approach, complexity and pitfalls

An easy arrays & hashing problem, graded against 7 test cases (4 of them hidden).

The pattern: Arrays & Hashing

Hash maps and sets to trade memory for time - the most common first instinct in interviews.

Reach for it when you see: "Have I seen this before?", counting occurrences, or an O(n²) scan you want to make O(n).

More Arrays & Hashingproblems →

If you are stuck

Show the 3-step hint ladder

You need to check the mapping in both directions.
Use two hash maps: one for s->t mapping and one for t->s mapping.
If a character already has a mapping that conflicts with the current pair, return false.

The optimal approach

Show the approach: Two Hash Maps

Use two hash maps to track mappings in both directions (s to t and t to s). For each pair of characters, check:

1. If s[i] is already mapped to a different character than t[i], return false.

2. If t[i] is already mapped from a different character than s[i], return false.

Otherwise, add the mappings and continue.

Time: O(n) - single pass through both strings
Space: O(1) - at most 256 ASCII characters in the maps

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

Common Arrays & Hashing mistakes

These apply to the pattern as a whole, not just this problem.

Storing the current value before checking for its complement, which lets an element pair with itself.
Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n).
Using a plain object as the map when keys may be numbers or `__proto__`; a real hash-map type keeps key identity intact.