LeetCode #3 - Longest Substring Without Repeating Characters

#include <iostream>
#include <unordered_map>
#include <algorithm>
#include <string>

using namespace std;

int longestUniqueSubstring(const string &s) {
    unordered_map<char, int> charIndexMap;
    int maxLength = 0;
    int start = 0;

    for (int i = 0; i < s.size(); i++) {
        char charAtI = s[i];
        if (charIndexMap.count(charAtI)) {
            start = max(start, charIndexMap[charAtI] + 1);
        }
        charIndexMap[charAtI] = i;
        maxLength = max(maxLength, i - start + 1);
    }

    return maxLength;
}

int main() {
    string inputString = "abcabcbb";
    cout << longestUniqueSubstring(inputString) << endl;
    return 0;
}

package main

import (
    "fmt"
)

func longestUniqueSubstring(s string) int {
    charIndexMap := make(map[rune]int)
    maxLength := 0
    start := 0

    for i, char := range s {
        if lastIndex, exists := charIndexMap[char]; exists {
            start = max(start, lastIndex+1)
        }
        charIndexMap[char] = i
        maxLength = max(maxLength, i-start+1)
    }

    return maxLength
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func main() {
    inputString := "abcabcbb"
    fmt.Println(longestUniqueSubstring(inputString))
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        String inputString = "abcabcbb";
        System.out.println(longestUniqueSubstring(inputString));
    }

    public static int longestUniqueSubstring(String s) {
        HashMap<Character, Integer> charIndexMap = new HashMap<>();
        int maxLength = 0;
        int start = 0;

        for (int i = 0; i < s.length(); i++) {
            char charAtI = s.charAt(i);
            if (charIndexMap.containsKey(charAtI)) {
                start = Math.max(start, charIndexMap.get(charAtI) + 1);
            }
            charIndexMap.put(charAtI, i);
            maxLength = Math.max(maxLength, i - start + 1);
        }

        return maxLength;
    }
}

function longestUniqueSubstring(s) {
    const charIndexMap = {};
    let maxLength = 0;
    let start = 0;

    for (let i = 0; i < s.length; i++) {
        const char = s[i];
        if (charIndexMap[char] !== undefined) {
            start = Math.max(start, charIndexMap[char] + 1);
        }
        charIndexMap[char] = i;
        maxLength = Math.max(maxLength, i - start + 1);
    }

    return maxLength;
}

// Example usage:
const inputString = 'abcabcbb';
console.log(longestUniqueSubstring(inputString));

<?php
function longestUniqueSubstring($s) {
    $charIndexMap = [];
    $maxLength = 0;
    $start = 0;

    for ($i = 0; $i < strlen($s); $i++) {
        $char = $s[$i];
        if (isset($charIndexMap[$char])) {
            $start = max($start, $charIndexMap[$char] + 1);
        }
        $charIndexMap[$char] = $i;
        $maxLength = max($maxLength, $i - $start + 1);
    }

    return $maxLength;
}

// Example usage:
$inputString = 'abcabcbb';
echo longestUniqueSubstring($inputString);
?>

def longest_unique_substring(s):
    char_index_map = {}
    max_length = 0
    start = 0

    for i, char in enumerate(s):
        if char in char_index_map:
            start = max(start, char_index_map[char] + 1)
        char_index_map[char] = i
        max_length = max(max_length, i - start + 1)

    return max_length

# Example usage:
input_string = 'abcabcbb'
print(longest_unique_substring(input_string))