Minimum Operations to Make Median of Array Equal to K

Minimum Operations to Make Median of Array Equal to K - Problem

Transform Array to Target Median

You're given an integer array nums and a target value k. Your goal is to make the median of the array equal to k using the minimum number of operations.

In each operation, you can increase or decrease any element by exactly 1.

What's the median?
The median is the middle element when the array is sorted. For arrays with even length, we take the larger of the two middle elements.

Example: In array [1, 3, 6, 2, 7, 9], after sorting we get [1, 2, 3, 6, 7, 9]. The median is 6 (larger of the two middle elements 3 and 6).

Return the minimum operations needed to achieve this transformation.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,5,6,9,1], k = 5

› Output: 4

💡 Note: After sorting: [1,2,5,6,9]. Median is 5 (index 2). To make median = 5: already 5, but we need 9 → 5 (4 operations). Total: 4 operations.

example_2.py — Even Length Array

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

› Output: 0

💡 Note: After sorting: [1,2,3,4]. For even length, median is larger middle element = 3. To make median = 4: change 3 → 4 (1 operation), but 4 becomes new median and it's already 4. Actually, median is at index n//2 = 2, which is 3. Need 1 operation to change 3→4.

example_3.py — All Same Elements

$ Input: nums = [7,7,7,7,7], k = 1

› Output: 18

💡 Note: Median is 7 (middle element). Need to change median to 1 (6 operations). Also need to ensure elements to right of median are ≥ 1, but they're all 7 which is fine. Only median needs changing: 6 operations. Wait, let me recalculate: median at index 2 needs 7→1 (6 ops), elements at indices 3,4 need to be ≥1 but are 7 (fine), elements at indices 0,1 need to be ≤1, so 7→1 each (6+6=12 ops). Total: 6+12=18.

Visualization

Tap to expand

Understanding the Visualization

Line up students by height

Sort the array to arrange students from shortest to tallest

Find the middle position

Locate the median position (middle student in the line)

Adjust left side students

Students shorter than median who are taller than k need to shrink

Adjust right side students

Students taller than median who are shorter than k need to grow

Adjust the middle student

The median student grows or shrinks to exactly height k

Key Takeaway

🎯 Key Insight: After sorting, we only adjust elements that 'block' the median from reaching target k - left elements that are too big, right elements that are too small, and the median itself.

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each element, we can increase, decrease, or keep same, leading to 3^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and array storage

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
The median follows the larger middle element rule for even-length arrays

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a greedy strategy after sorting the array. The key insight is that we only need to adjust elements that prevent the median from reaching the target value k. Elements to the left of the median position should be ≤ k, elements to the right should be ≥ k, and the median itself should equal k. This gives us O(n log n) time complexity due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^n)	O(n)	Try all possible combinations of operations to reach target median
Greedy Approach (Optimal)	O(n log n)	O(1)	Sort array and greedily adjust elements that block the target median

Brute Force (Try All Combinations) — Algorithm Steps

For each element, try all possible values it could be changed to
Recursively explore all combinations
For each combination, sort and check if median equals k
Track minimum operations across all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with original array

Begin with the given array [2, 5, 6, 9, 1]

Branch for each element

For each element, try different values (increase, decrease, keep same)

Check all combinations

Recursively explore all possible combinations

Find minimum operations

Among valid combinations (median = k), return minimum operations

Code -

solution.c — C

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

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

int getMedian(int* arr, int n) {
    qsort(arr, n, sizeof(int), compare);
    return n % 2 == 1 ? arr[n / 2] : arr[n / 2];
}

int backtrack(int index, int* currentNums, int n, int operations, int k, int* original) {
    if (index == n) {
        int* temp = malloc(n * sizeof(int));
        for (int i = 0; i < n; i++) temp[i] = currentNums[i];
        int median = getMedian(temp, n);
        free(temp);
        return median == k ? operations : INT_MAX;
    }
    
    int minOps = INT_MAX;
    int orig = original[index];
    
    for (int newVal = orig - 100; newVal <= orig + 100; newVal++) {
        currentNums[index] = newVal;
        int ops = operations + abs(newVal - orig);
        int result = backtrack(index + 1, currentNums, n, ops, k, original);
        if (result < minOps) minOps = result;
    }
    
    currentNums[index] = orig;
    return minOps;
}

int minOperationsToMakeMedianK(int* nums, int numsSize, int k) {
    int* temp = malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) temp[i] = nums[i];
    int result = backtrack(0, temp, numsSize, 0, k, nums);
    free(temp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each element, we can increase, decrease, or keep same, leading to 3^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and array storage

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
The median follows the larger middle element rule for even-length arrays

43.6K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler