Software Engineer Technical Interview Questions & Answers (2026)

I'd first clarify: can there be multiple valid pairs? Can the same element be used twice? Assuming one unique solution and no element reuse. The brute-force approach checks every pair: two nested loops, O(n²) time, O(1) space. To optimize, I'd use a hash map storing each number's complement (target - num) as I iterate. For each number, I check if it exists in the map. If yes, return both indices. If no, add current number and index to the map. This gives O(n) time, O(n) space. Implementation: create an empty dict, iterate with enumerate, for each num check if target-num is in dict, if so return [dict[target-num], i], else dict[num] = i. Edge cases: empty array returns None, single element returns None. I'd test with [2,7,11,15] target=9, expecting [0,1]. Then test with negative numbers [-3,4,3,90] target=0, expecting [0,2]. The hash map approach is optimal because you can't do better than O(n) when you need to examine every element at least once.

An LRU cache needs O(1) lookup (hash map) and O(1) insertion/removal at both ends (doubly-linked list). I'd combine them: the hash map stores key → node pointer, and the doubly-linked list maintains access order with most recent at the head. For get(key): if key exists in the map, move its node to the head of the list (O(1) with direct pointer) and return the value. If not, return -1. For put(key, value): if key exists, update value and move to head. If key is new and at capacity, remove the tail node (least recently used), delete its key from the map, then add new node at head and to map. I'd implement a Node class with key, value, prev, next. The LRUCache class has capacity, map, and sentinel head/tail nodes for clean edge-case handling. The sentinel nodes eliminate null checks when adding/removing. I'd test with capacity=2: put(1,1), put(2,2), get(1) returns 1 and moves key 1 to front, put(3,3) evicts key 2 as LRU. Thread safety: in production, I'd wrap operations with a lock or use a concurrent data structure.

First, I'd clarify: is this a binary search tree or general binary tree? For a general binary tree, I'd use recursive DFS. Base cases: if root is None, return None. If root equals either target node, return root. Recurse on left and right subtrees. If both return non-None, root is the LCA (the two nodes are in different subtrees). If only one returns non-None, that result is the LCA (both nodes are in the same subtree, and we found the higher one first). Implementation: def lca(root, p, q): if not root or root == p or root == q return root. left = lca(root.left, p, q). right = lca(root.right, p, q). if left and right return root. return left or right. Time: O(n) visiting each node once. Space: O(h) for recursion stack where h is height. For a BST, we can optimize by comparing values: if both nodes are less than root, go left; if both greater, go right; otherwise root is LCA. I'd test with a balanced tree where p and q are in different subtrees, then test where one is an ancestor of the other.

I'd use Floyd's tortoise and hare algorithm. Two pointers: slow moves 1 step, fast moves 2 steps. If there's a cycle, they'll meet. If fast reaches null, no cycle. Once they meet, to find the cycle start: reset one pointer to head and move both at speed 1. They'll meet at the cycle start. The math: if the non-cycle length is 'a' and the cycle length is 'c', when they first meet, slow has traveled a+b steps and fast has traveled a+b+nc for some n. Since fast = 2*slow: a+b+nc = 2(a+b), so nc = a+b, meaning a = nc-b. Moving a steps from the meeting point equals moving nc-b steps in the cycle, which lands at the cycle start. Implementation: def detectCycle(head): slow = fast = head. while fast and fast.next: slow = slow.next, fast = fast.next.next. if slow == fast: slow = head, while slow != fast: slow = slow.next, fast = fast.next, return slow. return None. Time: O(n), Space: O(1). I'd test with a cycle at position 2 in a 5-node list, a single-node cycle, and no cycle.

I'd use a sliding window with a hash map storing each character's most recent index. Maintain a left pointer for the window start and iterate with right pointer. For each character at right: if it's in the map and its stored index >= left, move left to stored_index + 1 (shrink window to exclude the duplicate). Update the map with the current character's position. Track max_length = max(max_length, right - left + 1). Implementation: def lengthOfLongestSubstring(s): char_map = {}, left = 0, max_len = 0. for right, char in enumerate(s): if char in char_map and char_map[char] >= left: left = char_map[char] + 1. char_map[char] = right. max_len = max(max_len, right - left + 1). return max_len. Time: O(n) single pass. Space: O(min(n, alphabet_size)). Test with 'abcabcbb' → 3 ('abc'), 'bbbbb' → 1 ('b'), 'pwwkew' → 3 ('wke'). The key insight is that when we find a duplicate, we don't need to move left one step at a time — we can jump directly past the previous occurrence.