Minimize Deviation in Array - Practice Coding Problems

Minimize Deviation in Array - Problem

Problem: You are given an array nums of n positive integers. Your goal is to minimize the deviation of the array through strategic operations.

Available Operations:
• If an element is even, you can divide it by 2
• If an element is odd, you can multiply it by 2

The deviation is defined as the maximum difference between any two elements in the array after performing operations.

Example: Given [1,2,3,4], you could transform it to [2,1,6,1] by: multiply 1→2, divide 2→1, multiply 3→6, divide 4→2→1. The deviation would be 6-1=5.

Goal: Return the minimum possible deviation after performing any number of operations.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Start with [1,2,3,4]. Double odds: [2,2,6,4]. Then systematically reduce: 6→3, 4→2→1. Final possible arrays include [1,1,3,1] with deviation 3-1=2, or [2,1,3,1] with deviation 3-1=2, or [2,2,3,2] with deviation 3-2=1. The minimum deviation is 1.

example_2.py — All Even Numbers

$ Input: nums = [4,1,5,20,3]

› Output: 3

💡 Note: Double odds: [4,2,10,20,6]. Systematically reduce maximums: 20→10→5, then 10→5, then 6→3. Through optimal reductions, we can achieve arrays like [4,2,5,5,3] with deviation 5-2=3.

example_3.py — Single Element

$ Input: nums = [2]

› Output: 0

💡 Note: With only one element, the deviation is always 0 since max - min = element - element = 0.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Heat All Odd Rooms

First, heat up all rooms at odd temperatures (multiply by 2) since they can only be heated once

Track Temperatures

Keep track of the hottest room (max heap) and the coldest temperature ever seen

Cool Down Systematically

Always cool down the hottest room (if even temperature) and update the temperature range

Stop When Optimal

Stop when the hottest room is at an odd temperature (can't cool further)

Key Takeaway

🎯 Key Insight: Always maximize odd numbers first (they can only increase once), then systematically reduce the maximum element while tracking the global minimum. This greedy approach guarantees the optimal solution.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal solution uses a priority queue (max heap) with a greedy approach. First, double all odd numbers to maximize them (since odds can only be doubled once). Then systematically reduce the largest element by dividing by 2 while it's even, tracking the minimum value seen. This ensures we explore all meaningful combinations efficiently in O(n log n log(max)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(n×log(max)))	O(2^(n×log(max)))	Generate all possible arrays through operations and find minimum deviation
Priority Queue (Heap) - Optimal	O(n log n log(max))	O(n)	Use max heap to always reduce the largest element while tracking minimum seen

Brute Force (Try All Combinations) — Algorithm Steps

For each element, determine all possible values it can become
Generate all combinations of these possible values
For each combination, calculate deviation (max - min)
Return the minimum deviation found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Possibilities

For each element, find all possible values through operations

Explore Combinations

Try every combination of values across all positions

Calculate Deviations

For each combination, compute max - min

Track Minimum

Keep track of the smallest deviation found

Code -

solution.c — C

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

int minDeviation = INT_MAX;

void getAllValues(int num, int* values, int* count) {
    int temp[32];
    int tempCount = 0;
    
    if (num % 2 == 1) {
        temp[tempCount++] = num;
        num *= 2;
    }
    
    while (num % 2 == 0) {
        temp[tempCount++] = num;
        num /= 2;
    }
    temp[tempCount++] = num;
    
    // Remove duplicates
    *count = 0;
    for (int i = 0; i < tempCount; i++) {
        int found = 0;
        for (int j = 0; j < *count; j++) {
            if (values[j] == temp[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            values[(*count)++] = temp[i];
        }
    }
}

void backtrack(int index, int* current, int currentSize, int** possibilities, int* counts, int numsSize) {
    if (index == numsSize) {
        int maxVal = current[0], minVal = current[0];
        for (int i = 1; i < currentSize; i++) {
            if (current[i] > maxVal) maxVal = current[i];
            if (current[i] < minVal) minVal = current[i];
        }
        if (maxVal - minVal < minDeviation) {
            minDeviation = maxVal - minVal;
        }
        return;
    }
    
    for (int i = 0; i < counts[index]; i++) {
        current[currentSize] = possibilities[index][i];
        backtrack(index + 1, current, currentSize + 1, possibilities, counts, numsSize);
    }
}

int minimumDeviation(int* nums, int numsSize) {
    int** possibilities = malloc(numsSize * sizeof(int*));
    int* counts = malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        possibilities[i] = malloc(32 * sizeof(int));
        getAllValues(nums[i], possibilities[i], &counts[i]);
    }
    
    int* current = malloc(numsSize * sizeof(int));
    backtrack(0, current, 0, possibilities, counts, numsSize);
    
    free(current);
    for (int i = 0; i < numsSize; i++) {
        free(possibilities[i]);
    }
    free(possibilities);
    free(counts);
    
    return minDeviation;
}

int main() {
    int nums[] = {1, 2, 3, 4};
    int result = minimumDeviation(nums, 4);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×log(max)))

Each element can have multiple possible values (log factor for divisions), leading to exponential combinations

⚡ Linearithmic

Space Complexity

O(2^(n×log(max)))

Need to store all possible combinations

⚡ Linearithmic Space

67.2K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler