How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a Medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at Lowe's.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Lowe's during technical interviews.

Find longest unique substring | Lowe's Coding Question

Quick Overview

This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Find longest unique substring states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

Find longest unique substring

Company: Lowe's

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: Medium

Interview Round: Technical Screen

Given a string s, find the length and one example of the longest substring of s that contains no repeated characters. If multiple answers exist, return any valid one. Explain your algorithm, prove its correctness at a high level, analyze time and space complexity, and discuss edge cases (e.g., empty string, all identical characters, presence of Unicode code points).

Quick Answer: This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Find longest unique substring states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

Given a string `s`, find the length and one example of the longest substring of `s` that contains no repeated characters. Return the result as a two-element list `[length, example_substring]`. If multiple substrings achieve the maximum length, return any one of them. A substring is a contiguous run of characters within the string. Treat the empty string as having a longest-unique-substring length of 0 with an empty example. **Examples** - `s = "abcabcbb"` -> `[3, "abc"]` (the answer `"bca"` or `"cab"` would also be acceptable in length). - `s = "bbbbb"` -> `[1, "b"]`. - `s = "pwwkew"` -> `[3, "wke"]` (note `"pwke"` is a subsequence, not a substring, so it does not count). - `s = ""` -> `[0, ""]`.

Constraints

0 <= len(s) <= 10^5
s may contain any Unicode code points (ASCII letters, digits, symbols, spaces).
Characters are compared by exact code-point equality (case-sensitive: 'A' != 'a').
If s is empty, return [0, ""].

Examples

Input: ("abcabcbb",)

Expected Output: [3, "abc"]

Explanation: The first window of length 3 with all-unique chars is 'abc'; later windows like 'bca'/'cab' tie but the algorithm reports the first one found.

Input: ("bbbbb",)

Expected Output: [1, "b"]

Explanation: Every character repeats, so the longest unique substring is any single 'b' of length 1.

Input: ("pwwkew",)

Expected Output: [3, "wke"]

Explanation: The longest unique substring is the contiguous 'wke' (length 3); 'pwke' would be a subsequence, not a substring.

Input: ("",)

Expected Output: [0, ""]

Explanation: Empty-string edge case: length 0 with an empty example.

Input: ("a",)

Expected Output: [1, "a"]

Explanation: Single-character string is trivially unique.

Input: ("dvdf",)

Expected Output: [3, "vdf"]

Explanation: When 'd' repeats at index 2, the window restarts after the first 'd', yielding 'vdf' of length 3 rather than an incorrect 'dvdf'.

Input: ("abba",)

Expected Output: [2, "ab"]

Explanation: Boundary check: when the second 'a' appears, its previous index 0 is already left of the current window start, so the window is not shrunk incorrectly; the max length stays 2 ('ab').

Input: ("tmmzuxt",)

Expected Output: [5, "mzuxt"]

Explanation: After the repeated 'm', the window grows to 'mzuxt' (length 5); the trailing 't' was last seen before the window start, so it does not force a shrink.

Hints

Use a sliding window with two pointers: a left boundary `start` and a right boundary `i` scanning the string.
Keep a hash map from each character to the most recent index where you saw it. When the current character was last seen at index >= start, jump `start` to one past that index to drop the duplicate from the window.
Track the best (longest) window length and its start index as you go, so you can slice out one example substring at the end. The left pointer never moves backward, which is why the whole scan is O(n).

Quick Overview