Longest Substring Without Repeating Characters

Longest Substring Without Repeating Characters - Problem

Given a string s, find the length of the longest substring without repeating characters.

A substring is a contiguous sequence of characters within a string. Your goal is to find the maximum possible length of a substring where all characters are unique.

Example: In the string "abcabcbb", the longest substring without repeating characters is "abc" with length 3.

Input & Output

example_1.py — Basic case with repeating characters

$ Input: s = "abcabcbb"

› Output: 3

💡 Note: The answer is "abc", with the length of 3. Other valid substrings include "bca", "cab", but "abc" appears first when reading left to right.

example_2.py — All same characters

$ Input: s = "bbbbb"

› Output: 1

💡 Note: The answer is "b", with the length of 1. Since all characters are the same, the longest substring without repeating characters can only be of length 1.

example_3.py — Mixed pattern

$ Input: s = "pwwkew"

› Output: 3

💡 Note: The answer is "wke", with the length of 3. Note that "pwke" is a subsequence (not substring) and thus doesn't count. The longest valid substring is "wke".

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty window and hash map

Expand

Add characters to window while they're unique

Contract

When duplicate found, jump left pointer efficiently

Continue

Keep expanding and update maximum length

Key Takeaway

🎯 Key Insight: The sliding window with hash map approach transforms an O(n³) brute force solution into an elegant O(n) algorithm by efficiently skipping past duplicate characters instead of rechecking substrings.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with constant time hash map operations

✓ Linear Growth

Space Complexity

O(min(m,n))

Hash map stores at most min(charset_size, string_length) characters

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 5 × 10⁴
s consists of English letters, digits, symbols and spaces

Asked in

a Amazon 127 G Google 95 ⊞ Microsoft 73 f Meta 68 Apple 45 B Bloomberg 42

The optimal solution uses the sliding window technique with a hash map to track character positions. This approach achieves O(n) time complexity by efficiently handling duplicates through pointer jumping, making it significantly faster than the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map	O(n)	O(k)	Use sliding window technique with hash map to track character positions
Brute Force (Check All Substrings)	O(n³)	O(min(m,n))	Check every possible substring to find the longest one without duplicates
Sliding Window with Hash Map (Optimal)	O(n)	O(min(m,n))	Use sliding window technique with hash map to track character positions

Sliding Window with Hash Map — Algorithm Steps

Initialize left pointer, max length, and hash map for character positions
Expand right pointer through the string
If current character exists in hash map and its position is within current window
Move left pointer to position after the previous occurrence
Update character position in hash map
Update maximum length with current window size

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize pointers

Start with left=0, right=0, empty hash map

Expand window

Move right pointer and add characters to hash map

Handle duplicates

When duplicate found, move left pointer past previous occurrence

Update maximum

Continuously track the maximum window size encountered

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int lengthOfLongestSubstring(char* s) {
    int charIndex[128];
    for (int i = 0; i < 128; i++) {
        charIndex[i] = -1;
    }
    
    int left = 0;
    int maxLength = 0;
    int n = strlen(s);
    
    for (int right = 0; right < n; right++) {
        char c = s[right];
        
        // If character is seen and within current window
        if (charIndex[c] >= left) {
            left = charIndex[c] + 1;
        }
        
        charIndex[c] = right;
        int currentLength = right - left + 1;
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char s[1000];
    int len = strlen(input);
    strncpy(s, input + 1, len - 3);
    s[len - 3] = '\0';
    
    printf("%d\n", lengthOfLongestSubstring(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string where each character is visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(k)

O(k) where k is the size of the character set. In worst case, k can be O(n) if all characters are unique

✓ Linear Space

Constraints

0 ≤ s.length ≤ 5 × 10⁴
s consists of English letters, digits, symbols and spaces

89.3K Views

Very High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window with Hash Map — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler