Skip to main content

3. Longest Substring Without Repeating Characters

mediumAsked at Hugging Face

Find the length of the longest substring with all unique characters. Hugging Face asks this to test sliding-window thinking — the same pattern used to scan a fixed-size context window over a token sequence during chunked inference on long documents.

By Alex Chen, Founder, InterviewChamp.AI · Last verified

Source citations

Public interview reports confirming this problem appears in Hugging Face loops.

  • Glassdoor (2026-Q1)— Cited in Hugging Face SWE onsite reports as a standard sliding-window medium problem.
  • Blind (2025-10)— Hugging Face threads list this as a high-frequency medium used to screen for window-based algorithm fluency.

Problem

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

Constraints

  • 0 <= s.length <= 5 * 10^4
  • s consists of English letters, digits, symbols, and spaces.

Examples

Example 1

Input
s = "abcabcbb"
Output
3

Explanation: The answer is "abc" with length 3.

Example 2

Input
s = "bbbbb"
Output
1

Explanation: The answer is "b" with length 1.

Example 3

Input
s = "pwwkew"
Output
3

Explanation: The answer is "wke" with length 3.

Approaches

1. Sliding window with Map (jump-ahead)

Maintain a left pointer and a Map from character to its last-seen index. When a repeat is found, jump left to max(left, lastSeen + 1) to skip past the previous occurrence.

Time
O(n)
Space
O(min(m,n)) where m is the charset size
function lengthOfLongestSubstring(s) {
  const lastSeen = new Map();
  let left = 0;
  let maxLen = 0;
  for (let right = 0; right < s.length; right++) {
    const ch = s[right];
    if (lastSeen.has(ch) && lastSeen.get(ch) >= left) {
      left = lastSeen.get(ch) + 1;
    }
    lastSeen.set(ch, right);
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}

Tradeoff: O(n) — each character is processed once. The jump-ahead avoids shrinking the window one step at a time, making it faster in practice than the two-pointer Set approach.

2. Sliding window with Set (shrink-left)

Use a Set for the current window. When a repeat is found, shrink from the left until the duplicate is removed.

Time
O(n)
Space
O(min(m,n))
function lengthOfLongestSubstring(s) {
  const window = new Set();
  let left = 0, maxLen = 0;
  for (let right = 0; right < s.length; right++) {
    while (window.has(s[right])) {
      window.delete(s[left]);
      left++;
    }
    window.add(s[right]);
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}

Tradeoff: Also O(n) amortized (each element is added and removed at most once), but slower in practice due to the inner while loop. Easier to explain the correctness invariant.

Hugging Face-specific tips

Hugging Face interviewers often ask: 'What is the invariant of your window?' Be precise: 'At every step, the window s[left..right] contains only unique characters.' Then connect it to ML: 'This sliding window is analogous to the context window in chunked document inference — we slide a fixed-size window over a long document and process only unique tokens in scope.' The Map-based jump-ahead is preferred because it avoids O(n) worst-case inner loops.

Common mistakes

  • Not guarding lastSeen.get(ch) >= left — without this, you might jump left backward to a position outside the current window.
  • Updating maxLen after the left pointer moves but before adding the new character — compute the window size after both updates.
  • Using an array of size 128 for ASCII — fine, but discuss charset assumptions with the interviewer.
  • Not handling the empty string — return 0 immediately (the loop handles it, but state it explicitly).

Follow-up questions

An interviewer at Hugging Face may pivot to one of these next:

  • Longest Substring with At Most Two Distinct Characters (LC 159).
  • Longest Substring with At Most K Distinct Characters (LC 340).
  • How would you find the longest unique-token sequence in a tokenized document without loading the entire token array into memory?

Solve it now

Free. No sign-up. Python and JavaScript run instantly in your browser.

Output

Press Run or Cmd+Enter to execute

FAQ

Why use a Map instead of a Set for the jump-ahead approach?

A Map stores the last-seen index of each character, letting us jump left directly to lastSeen + 1. A Set only tells us whether a character is in the window, requiring a one-step shrink loop.

Is the time complexity truly O(n)?

Yes — in both approaches, each character is added at most once and removed at most once. The total work across all iterations is O(n).

What if the string contains Unicode characters?

Use a Map (handles arbitrary keys). An array indexed by char code only works for ASCII.

Practice these live with InterviewChamp.AI

Drill Longest Substring Without Repeating Characters and other Hugging Face interview questions under real-loop conditions with instant feedback on your reasoning, complexity claims, and code.

Practice these live with InterviewChamp.AI →