Longest Substring Without Repeating Characters

import java.util.*;
class Solution {
    public int longest_substring_without_repeating_characters(String s) {
        Map<Character, Integer> last = new HashMap<>();
        int left = 0, ans = 0;
        for (int right = 0; right < s.length(); right++) {
            char ch = s.charAt(right);
            if (last.containsKey(ch) && last.get(ch) >= left) {
                left = last.get(ch) + 1;
            }
            last.put(ch, right);
            ans = Math.max(ans, right - left + 1);
        }
        return ans;
    }
}

function longest_substring_without_repeating_characters(s) {
    const last = {};
    let left = 0, ans = 0;
    for (let right = 0; right < s.length; right++) {
        const ch = s[right];
        if (last[ch] !== undefined && last[ch] >= left) {
            left = last[ch] + 1;
        }
        last[ch] = right;
        ans = Math.max(ans, right - left + 1);
    }
    return ans;
}

<?php
function longest_substring_without_repeating_characters($s) {
    $last = [];
    $left = 0;
    $ans = 0;
    $n = strlen($s);
    for ($right = 0; $right < $n; $right++) {
        $ch = $s[$right];
        if (isset($last[$ch]) && $last[$ch] >= $left) {
            $left = $last[$ch] + 1;
        }
        $last[$ch] = $right;
        $cur = $right - $left + 1;
        if ($cur > $ans) $ans = $cur;
    }
    return $ans;
}
?>

def longest_substring_without_repeating_characters(s: str) -> int:
    last = {}
    left = 0
    ans = 0
    for right, ch in enumerate(s):
        if ch in last and last[ch] >= left:
            left = last[ch] + 1
        last[ch] = right
        ans = max(ans, right - left + 1)
    return ans

use std::collections::HashMap;
fn longest_substring_without_repeating_characters(s: String) -> i32 {
    let mut last: HashMap<char, i32> = HashMap::new();
    let mut left: i32 = 0;
    let mut ans: i32 = 0;
    let chars: Vec<char> = s.chars().collect();
    for right in 0..chars.len() {
        let ch = chars[right];
        if let Some(pos) = last.get(&ch) {
            if *pos >= left {
                left = *pos + 1;
            }
        }
        last.insert(ch, right as i32);
        let cur = right as i32 - left + 1;
        if cur > ans { ans = cur; }
    }
    ans
}

function longest_substring_without_repeating_characters(s: string): number {
    var last: { [key: string]: number } = {};
    var left = 0, ans = 0;
    for (var right = 0; right < s.length; right++) {
        var ch = s.charAt(right);
        if (last[ch] !== undefined && last[ch] >= left) {
            left = last[ch] + 1;
        }
        last[ch] = right;
        var cur = right - left + 1;
        if (cur > ans) ans = cur;
    }
    return ans;
}