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

Constraints

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

Visualization

Tap to expand

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

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force (Check All Substrings)

⏱️ Time: O(n³) Space: O(min(m,n))

Generate all possible substrings and for each substring, check if it contains duplicate characters. Keep track of the maximum length found.

Sliding Window with Hash Map

⏱️ Time: O(n) Space: O(k)

Maintain a sliding window with two pointers (left and right). Use a hash map to store the most recent position of each character. When a duplicate is found, move the left pointer to skip the previous occurrence of the duplicate character.

Sliding Window with Hash Map (Optimal)

⏱️ Time: O(n) Space: O(min(m,n))

Maintain a sliding window using two pointers (left and right). Use a hash map to store the most recent index of each character. When a duplicate is found, move the left pointer to skip the duplicate efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    char from;
    char to;
} CharMapping;

bool canMatchWithMap(char* s, char* sub, CharMapping* charMap, int mapSize, int start) {
    int subLen = strlen(sub);
    for (int j = 0; j < subLen; j++) {
        char sChar = s[start + j];
        char subChar = sub[j];
        
        if (sChar == subChar) {
            continue;
        }
        
        bool found = false;
        for (int k = 0; k < mapSize; k++) {
            if (charMap[k].from == subChar && charMap[k].to == sChar) {
                found = true;
                break;
            }
        }
        
        if (!found) {
            return false;
        }
    }
    return true;
}

bool solution(char* s, char* sub, char mappings[][2], int mappingCount) {
    // Build mapping array (simpler than hash map in C)
    CharMapping charMap[1001];
    int mapSize = 0;
    
    for (int i = 0; i < mappingCount; i++) {
        charMap[mapSize].from = mappings[i][0];
        charMap[mapSize].to = mappings[i][1];
        mapSize++;
    }
    
    int n = strlen(s), m = strlen(sub);
    
    for (int i = 0; i <= n - m; i++) {
        if (canMatchWithMap(s, sub, charMap, mapSize, i)) {
            return true;
        }
    }
    return false;
}

int main() {
    char s[5001], sub[5001], line[10001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    fgets(sub, sizeof(sub), stdin);
    sub[strcspn(sub, "\n")] = 0;
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char mappings[1001][2];
    int mappingCount = 0;
    
    // Improved JSON parsing
    if (strcmp(line, "[]") != 0) {
        char* ptr = line + 1; // Skip opening [
        while (*ptr && *ptr != ']') {
            // Look for ["char","char"] pattern
            if (*ptr == '[' && ptr[1] == '"' && ptr[3] == '"' && ptr[4] == ',' && ptr[5] == '"' && ptr[7] == '"' && ptr[8] == ']') {
                mappings[mappingCount][0] = ptr[2];
                mappings[mappingCount][1] = ptr[6];
                mappingCount++;
                ptr += 9;
            } else {
                ptr++;
            }
        }
    }
    
    bool result = solution(s, sub, mappings, mappingCount);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

89.4K 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