Find the Value of the Partition - Practice Coding Problems

Find the Value of the Partition - Problem

Array Sorting Medium

You are given a positive integer array nums and need to partition it into two non-empty arrays to minimize a specific value.

Goal: Split nums into two arrays nums1 and nums2 such that:

Each element belongs to exactly one array
Both arrays are non-empty
The partition value is minimized

The partition value is defined as: |max(nums1) - min(nums2)|

Example: For nums = [1, 3, 2, 4], if we partition into nums1 = [1, 2] and nums2 = [3, 4], then the partition value is |max([1,2]) - min([3,4])| = |2 - 3| = 1.

Return the minimum possible partition value.

Input & Output

example_1.py — Basic case

$ Input: [1, 3, 2, 4]

› Output: 1

💡 Note: After sorting: [1, 2, 3, 4]. The optimal partition is [1] and [2, 3, 4] where |max([1]) - min([2,3,4])| = |1 - 2| = 1. All consecutive pairs have difference 1, so minimum is 1.

example_2.py — Larger gaps

$ Input: [1, 10, 2, 7]

› Output: 1

💡 Note: After sorting: [1, 2, 7, 10]. Consecutive differences are: 2-1=1, 7-2=5, 10-7=3. The minimum difference is 1, achieved by partitioning into [1] and [2, 7, 10].

example_3.py — Two elements

$ Input: [5, 8]

› Output: 3

💡 Note: With only two elements, there's only one way to partition: [5] and [8]. The partition value is |5 - 8| = 3.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers
Array must be partitioned into exactly two non-empty parts

Visualization

Tap to expand

Understanding the Visualization

Line Up Players

Sort all players by their skill levels from weakest to strongest

Find Best Split Point

The fairest division occurs where consecutive skill levels are closest

Minimize Skill Gap

Choose the split that minimizes the gap between the strongest player on the weaker team and weakest player on the stronger team

Key Takeaway

🎯 Key Insight: Sort first, then the minimum partition value is simply the smallest difference between consecutive elements - no complex partition testing needed!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses the key insight that after sorting the array, the minimum partition value must occur between two consecutive elements. Simply sort the array and find the minimum difference between adjacent elements in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Optimal Insight	O(n log n)	O(1)	Sort array and find minimum difference between consecutive elements
Brute Force (Try All Partitions)	O(2^n)	O(n)	Generate all possible partitions and calculate the value for each

Sorting + Optimal Insight — Algorithm Steps

Sort the array in ascending order
Iterate through consecutive pairs in the sorted array
For each consecutive pair (a, b), the partition value would be |a - b| = b - a
Return the minimum difference found between consecutive elements
The partition is: nums1 contains all elements ≤ a, nums2 contains all elements ≥ b

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Arrange elements in ascending order

Check Consecutive Pairs

The optimal partition boundary is between consecutive elements

Find Minimum Gap

The smallest gap gives the minimum partition value

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int findValueOfPartition(int* nums, int n) {
    // Sort the array
    qsort(nums, n, sizeof(int), compare);
    
    // Find minimum difference between consecutive elements
    int minDiff = INT_MAX;
    for (int i = 0; i < n - 1; i++) {
        int diff = nums[i + 1] - nums[i];
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
    
    return minDiff;
}

int main() {
    int nums[1000];
    int n = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", findValueOfPartition(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then we scan through n-1 consecutive pairs in O(n) time

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space if we can sort in-place, O(n) if we create a copy

✓ Linear Space

26.2K 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

Sorting + Optimal Insight — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler