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

You are given an integer array nums and a non-negative integer k. In one operation, you can increase or decrease any element by 1.

Return the minimum number of operations needed to make the median of nums equal to k.

The median of an array is defined as the middle element when the array is sorted in non-decreasing order. If there are two choices for a median, the larger of the two values is taken.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Sort array to [1,2,3,4]. Median is at index 2 with value 3. Need |3-2|=1 operation to make median 2. All elements satisfy constraints: 1,2 ≤ 2 and 4 ≥ 2. Total: 1 operation.

Example 2 — Already Optimal

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

› Output: 0

💡 Note: Sort array to [1,2,3]. Median is 2 which equals k. All elements satisfy median property: 1 ≤ 2 and 3 ≥ 2. No operations needed.

Example 3 — Large Adjustment

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

› Output: 2

💡 Note: Sort array to [1,5,6]. Median is 5. Need |5-3|=2 operations to make median 3. All elements satisfy constraints: 1 ≤ 3 and 6 ≥ 3. Total: 2 operations.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 10 M Microsoft 8

The key insight is to sort the array first to identify the median position, then use a greedy strategy: adjust the median to target k, ensure all elements before median are ≤ k, and all elements after median are ≥ k. Best approach is Greedy with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Operations

⏱️ Time: O(2^(n×m)) Space: O(n)

Generate all possible ways to modify the array elements and check if the median equals k. This explores every combination of operations.

Optimal Greedy Strategy

⏱️ Time: O(n log n) Space: O(1)

After sorting, identify the median position and apply greedy strategy: adjust the median to target k, ensure all elements before median are ≤ k, and all elements after median are ≥ k.

Sort and Greedy Adjustment

⏱️ Time: O(n log n) Space: O(1)

Sort the array to find the median position, then determine minimum operations by adjusting the median element and elements that affect it to achieve the target median.

Brute Force - Try All Operations — Algorithm Steps

Generate all possible operation sequences
For each sequence, apply operations and check median
Return minimum operations that achieve target median

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array

Try Operations

Recursively try +1/-1 on each element

Check Median

Sort and check if median equals target

Code -

solution.c — C

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

void sortArray(int* arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int solution(int* nums, int numsSize, int k) {
    // Sort the array to find median position
    sortArray(nums, numsSize);
    int n = numsSize;
    
    // Find median index (for even length, take the larger of two middle elements)
    int median_idx;
    if (n % 2 == 1) {
        median_idx = n / 2;
    } else {
        median_idx = n / 2;  // This gives us the larger of the two middle elements
    }
    
    int operations = 0;
    
    // Operations to change median to k
    operations += abs(nums[median_idx] - k);
    nums[median_idx] = k;
    
    // Fix elements before median - they should be <= k
    for (int i = 0; i < median_idx; i++) {
        if (nums[i] > k) {
            operations += nums[i] - k;
            nums[i] = k;
        }
    }
    
    // Fix elements after median - they should be >= k
    for (int i = median_idx + 1; i < n; i++) {
        if (nums[i] < k) {
            operations += k - nums[i];
            nums[i] = k;
        }
    }
    
    return operations;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int k;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    parseArray(line, nums, &numsSize);
    
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×m))

Exponential combinations where n is array size and m is max operations needed

⚡ Linearithmic

Space Complexity

O(n)

Space for array copy and recursion stack

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler