Two Pointers Questions at Deloitte: What to Expect

Two Pointers is a core algorithmic pattern that appears in 6 out of 38 coding questions at Deloitte, making it one of the most frequently tested techniques. For roles in analytics, engineering, and consulting, Deloitte assesses a candidate’s ability to write efficient, clean solutions under time constraints. Mastering Two Pointers demonstrates you can optimize beyond brute-force approaches—a skill directly applicable to data processing, log analysis, and performance-sensitive client work. Ignoring this pattern risks failing a significant portion of their technical screen.

What to Expect — Types of Problems

Deloitte’s Two Pointers problems typically fall into three categories, often presented in a 60–90 minute coding assessment.

Sorted Array/Duplicate Problems: These involve a sorted input where you find pairs, remove duplicates, or merge sorted sequences. Expect questions like “Remove duplicates from sorted array” or “Two Sum on sorted data.” The sorted condition is your cue to consider Two Pointers.

Sliding Window (Fixed or Variable): Used for subarray or substring problems, such as finding the longest substring without repeating characters or a subarray with a sum equal to a target. These test your ability to maintain a window and adjust pointers dynamically.

Opposite-End Pointers: Common in problems like “Container With Most Water” or “Valid Palindrome,” where you place pointers at the start and end and move them inward based on a condition. This tests logical reasoning and handling edge cases.

Problems are often framed in business contexts—e.g., “merge sorted client records” or “find overlapping meeting times”—but reduce to standard patterns.

How to Prepare — Study Tips with One Code Example

Focus on pattern recognition, not memorization. Start by identifying the problem type: if it involves sorted data, pairs, or subarrays, Two Pointers is likely applicable. Practice writing the pointer movement logic from scratch. Always analyze time complexity—optimal solutions are usually O(n).

A key pattern is the “opposite-end pointers” for finding a pair in a sorted array that meets a target sum. Below is the implementation in three languages.

def two_sum_sorted(numbers, target):
    left, right = 0, len(numbers) - 1
    while left < right:
        current_sum = numbers[left] + numbers[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return [-1, -1]

Recommended Practice Order

Build competency progressively:

1. Basic Operations: Start with “Remove Duplicates from Sorted Array” and “Valid Palindrome” to internalize pointer movement.
2. Two-Sum Variations: Practice the sorted two-sum pattern (as shown above) and its variants.
3. Sliding Window: Tackle fixed-size windows first (e.g., “Maximum Average Subarray”), then move to variable windows (“Longest Substring Without Repeating Characters”).
4. Opposite-End Complex Problems: Solve “Container With Most Water” and “Trapping Rain Water” to handle non-trivial pointer updates.
5. Deloitte-Specific Practice: Finally, work on problems tagged for Deloitte to acclimate to their problem framing and constraints.

Time yourself to simulate assessment conditions. Write clean, commented code—readability matters.

Practice Two Pointers at Deloitte