Isomorphic Strings

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;
    }
}

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
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;
}
?>

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

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
}

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;
}