3. Longest Substring Without Repeating Characters
mediumAsked at Hugging FaceFind 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 Sam K., 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^4s consists of English letters, digits, symbols, and spaces.
Examples
Example 1
s = "abcabcbb"3Explanation: The answer is "abc" with length 3.
Example 2
s = "bbbbb"1Explanation: The answer is "b" with length 1.
Example 3
s = "pwwkew"3Explanation: 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.
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.