Sorting Questions at Accenture: What to Expect

Sorting questions appear in roughly 12.5% of Accenture's technical problem set (18 out of 144). This frequency reflects a core expectation: you must understand how to organize data efficiently, as this is fundamental to data processing, system optimization, and clean code—all critical in Accenture's consulting and delivery work. You won't be asked to implement complex sorts from scratch like quicksort. Instead, you'll apply sorting as a tool to simplify real-world problems, often as a crucial first step in your solution. Mastering this pattern directly impacts your ability to write performant, logical code during their technical assessments.

What to Expect — types of problems

Accenture's sorting questions typically fall into two categories. The first is Direct Application, where sorting the input is the obvious, necessary step to solve the problem. Examples include finding the top K elements, identifying duplicates, or merging sorted lists. The second, more common category is Sorting as an Enabler. Here, sorting isn't the final answer but a strategic pre-processing step that transforms the problem, making the subsequent logic (often involving greedy approaches or two-pointer techniques) straightforward. Classic problems include finding the minimum number of swaps, arranging numbers to form the largest possible number, or finding all pairs with a given sum. You will be expected to know your language's built-in sort functions and understand their time complexity (typically O(n log n)).

How to Prepare — study tips with one code example

Focus on pattern recognition, not memorization. When you read a problem, ask: "Would ordering this data simplify the logic?" If the answer is yes, sort it first. Practice using custom comparators, as many problems require sorting by specific rules (e.g., by absolute value, by a property, or in descending order). Always analyze if sorting will improve the brute-force time complexity without exceeding constraints.

A key pattern is the "Two-Pointer Technique on Sorted Data." After sorting an array, you can often solve problems involving pairs or triplets in O(n²) or O(n) time instead of O(n³). The example below finds all unique pairs that sum to a target value.

def two_sum_pairs(nums, target):
    nums.sort()
    left, right = 0, len(nums) - 1
    pairs = []
    while left < right:
        current_sum = nums[left] + nums[right]
        if current_sum == target:
            pairs.append([nums[left], nums[right]])
            # Skip duplicates
            while left < right and nums[left] == nums[left + 1]:
                left += 1
            while left < right and nums[right] == nums[right - 1]:
                right -= 1
            left += 1
            right -= 1
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return pairs

Recommended Practice Order

Start with fundamental sorting applications: finding Kth largest/smallest and merging sorted arrays. Next, tackle problems that use sorting to enable efficient searching or pairing, like the two-sum example above. Then, move to more complex problems requiring custom comparators, such as sorting strings by custom rules or arranging numbers to form the largest value. Finally, practice integrated problems where sorting is one step in a broader algorithm, like interval merging or task scheduling. This progression builds from simple utility to strategic problem-solving.

Practice Sorting at Accenture