Codestin Search App

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".

Constraints

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

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.

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 (Optimal)	O(n)	O(min(m,n))	Use sliding window technique with hash map to track character positions
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) — Algorithm Steps

Initialize left pointer, max_length, and character index map
Iterate through string with right pointer
If character exists in map and its index >= left pointer, move left pointer
Update character's index in map
Update max_length with current window size
Return max_length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize window

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, jump left pointer past the previous occurrence

Update maximum

Track the maximum window size seen so far

Code -

solution.c — C

#include <string.h>

int lengthOfLongestSubstring(char* s) {
    int charIndex[256];
    int n = strlen(s);
    int left = 0;
    int maxLength = 0;
    
    // Initialize all character indices to -1
    for (int i = 0; i < 256; i++) {
        charIndex[i] = -1;
    }
    
    for (int right = 0; right < n; right++) {
        unsigned char c = s[right];
        
        // If character is seen and within current window
        if (charIndex[c] != -1 && charIndex[c] >= left) {
            left = charIndex[c] + 1;
        }
        
        // Update character's latest index
        charIndex[c] = right;
        
        // Update maximum length
        int currentLength = right - left + 1;
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler