Meta·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

May 2026

Summary

Meta coding screen, one question the whole time, path normalization for a cd command. Seemed straightforward but there are enough edge cases to trip you up if you're not careful.

Questions Asked (1)

Implement a function that takes a current working directory and a path argument (as passed to a cd command) and returns the resulting absolute path. It should handle absolute paths, relative paths with dots and double-dots, multiple consecutive slashes, trailing slashes, and edge cases like cd-ing up from root or receiving empty input.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

Thought I had it locked in after the first few minutes, then the interviewer asked what happens when you do cd ..

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the requirements and edge cases, then propose a stack-based solution that processes the path components. Walk through an example to validate the logic, and discuss time/space complexity and potential trade-offs.

Pro tip: Mention that you would use a stack to handle '..' efficiently, and explicitly handle edge cases like empty input and root directory to show thoroughness.

1. Clarify requirements and edge cases

Ask clarifying questions about input formats, expected output, and edge cases such as empty strings, multiple slashes, and symbolic links. Confirm whether the function should handle only absolute and relative paths as described.

2. Choose data structures and algorithm

Decide to use a stack (or list) to store the canonical path components. Explain that you'll split the path by '/', process each component, and handle special cases like '.' and '..'.

3. Outline the algorithm step-by-step

Describe: 1) If path is absolute, start with empty stack; else initialize stack with components of current working directory. 2) Split path by '/', iterate over components. 3) For each component: if empty or '.', skip; if '..', pop from stack if not empty; else push component. 4) Join stack with '/' and prepend '/' for absolute path.

4. Analyze complexity and trade-offs

State that time complexity is O(n) where n is the length of the path, and space complexity is O(n) for the stack. Discuss alternative approaches like using built-in functions (e.g., os.path.normpath) and why implementing manually demonstrates understanding.

5. Test with examples and edge cases

Walk through examples: '/home/user', '../..', '/', '', 'a/b/../c', '//'. Show how the algorithm handles each, ensuring correctness.

Key Points to Mention

Handling absolute vs relative paths by checking if the path starts with '/'
Using a stack to efficiently process '..' by popping the last component
Skipping empty components and '.' to handle multiple slashes and current directory references
Edge cases: empty input (return current directory), root directory (cannot go above root), trailing slashes
Time and space complexity: O(n) time, O(n) space
Potential trade-offs: manual implementation vs using built-in functions, and considerations for symbolic links

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