← UiPath Interview Insights

UiPath·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say
Jun 2026

Summary

UiPath software engineer interview with a coding question that had a few layers to it. Started straightforward enough but kept expanding into streaming and Unicode territory which I wasn't fully ready for.

Questions Asked (1)

Q1

Given a string, find the length of the longest substring with no repeated characters, where letter casing is ignored (so 'A' and 'a' count as the same). All ASCII characters including whitespace are valid. Explain your algorithm's time and space complexity, cover edge cases like empty strings or all-duplicate inputs, and describe how you'd handle Unicode. Then, for inputs too large to fit in memory, walk through a streaming approach and its trade-offs.

Algorithms & Data StructuresTechnical Trade-offsSystem Design
Author's notes

Sliding window with a set, got that part out pretty quickly.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and edge cases, then present the sliding window algorithm with a hash map for the in-memory solution, including complexity analysis. Next, discuss Unicode handling and the streaming approach for large inputs, emphasizing trade-offs and practical considerations.

Pro tip: Demonstrate awareness of real-world constraints by proactively discussing how you'd handle Unicode normalization and memory limits, and tie the streaming solution to UiPath's need for processing large logs or documents efficiently.

1. Clarify Requirements and Edge Cases

Confirm that casing is ignored, all ASCII including whitespace are valid, and discuss edge cases like empty string, all duplicates, and single character. Also ask about Unicode expectations.

2. Present In-Memory Algorithm

Describe the sliding window approach with a hash map (or array for ASCII) to track last seen indices, updating the window start when a duplicate is found. Walk through a small example.

3. Analyze Complexity and Edge Cases

State time complexity O(n) and space O(min(n, alphabet size)). Explain how the algorithm handles empty strings, all duplicates, and mixed case by normalizing to lowercase.

4. Address Unicode Handling

Discuss that Unicode requires considering code points vs. grapheme clusters, normalization, and using a hash map keyed by normalized code points. Mention that full grapheme support may need external libraries.

5. Propose Streaming Approach for Large Inputs

Explain that for inputs too large for memory, you can process the string in chunks, maintaining a sliding window state across chunks. Discuss trade-offs: increased complexity, need for careful boundary handling, and potential for approximate results if memory is bounded.

Key Points to Mention

  • Sliding window technique with a hash map for O(n) time complexity.
  • Case normalization (e.g., toLowerCase) to ignore casing.
  • Edge cases: empty string returns 0, all duplicates returns 1, whitespace counts as valid characters.
  • Unicode: code points vs. grapheme clusters, normalization, and using a map keyed by normalized code points.
  • Streaming: process in chunks, maintain state, handle boundaries, and trade-offs like complexity and memory vs. accuracy.
  • Space complexity: O(min(n, alphabet size)) for in-memory; streaming may use O(alphabet size) memory.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.