Partition Array According to Given Pivot - Practice Coding Problems

Partition Array According to Given Pivot - Problem

You are given a 0-indexed integer array nums and an integer pivot. Rearrange nums such that the following conditions are satisfied:

• Every element less than pivot appears before every element greater than pivot
• Every element equal to pivot appears in between the elements less than and greater than pivot
• The relative order of the elements less than pivot and the elements greater than pivot is maintained

More formally, consider every pi, pj where pi is the new position of the ith element and pj is the new position of the jth element. If i < j and both elements are smaller (or larger) than pivot, then pi < pj.

Return nums after the rearrangement.

Input & Output

Example 1 — Basic Partitioning

$ Input: nums = [9,12,5,10,14,3,10], pivot = 10

› Output: [9,5,3,10,10,12,14]

💡 Note: Elements less than 10: [9,5,3] maintain relative order. Elements equal to 10: [10,10]. Elements greater than 10: [12,14] maintain relative order.

Example 2 — All Elements Same

$ Input: nums = [-3,-3,-3], pivot = -3

› Output: [-3,-3,-3]

💡 Note: All elements equal to pivot, so array remains unchanged.

Example 3 — No Pivot Elements

$ Input: nums = [1,2,3,4], pivot = 10

› Output: [1,2,3,4]

💡 Note: All elements are less than pivot 10, so they stay in original order. No equal or greater elements.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
-10⁶ ≤ pivot ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input

Original array with mixed element values

Partition

Group elements: less than, equal to, greater than pivot

Output

Rearranged array maintaining relative order within groups

Key Takeaway

🎯 Key Insight: Separate elements into three groups while maintaining original relative order within each group

Asked in

a Amazon 35 M Microsoft 28 G Google 22

The key insight is to maintain relative order while grouping elements into three categories. Best approach uses three separate arrays or counting with direct placement. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ In-Place with Counting	O(n)	O(n)	Count elements in each category first, then place them directly in result array
Three Separate Arrays	O(n)	O(n)	Create three arrays for less, equal, and greater elements, then combine

In-Place with Counting — Algorithm Steps

Count elements less than, equal to, and greater than pivot
Calculate starting positions for each section
Place elements directly into their final positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Count

Count elements in each category

Calculate

Determine starting positions

Place

Put elements in correct positions

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* solution(int* nums, int numsSize, int pivot, int* returnSize) {
    // Count elements in each category
    int lessCount = 0, equalCount = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < pivot) lessCount++;
        else if (nums[i] == pivot) equalCount++;
    }
    
    int* result = (int*)malloc(numsSize * sizeof(int));
    int lessIdx = 0;
    int equalIdx = lessCount;
    int greaterIdx = lessCount + equalCount;
    
    // Place elements in their correct positions
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < pivot) {
            result[lessIdx++] = nums[i];
        } else if (nums[i] == pivot) {
            result[equalIdx++] = nums[i];
        } else {
            result[greaterIdx++] = nums[i];
        }
    }
    
    *returnSize = numsSize;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int pivot;
    scanf("%d", &pivot);
    
    int returnSize;
    int* result = solution(nums, numsSize, pivot, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: one for counting, one for placement

✓ Linear Growth

Space Complexity

O(n)

Result array of size n, plus constant space for counters

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

In-Place with Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler