Minimum Operations to Halve Array Sum

Minimum Operations to Halve Array Sum - Problem

You are given an array nums of positive integers. In one operation, you can choose any number from nums and reduce it to exactly half the number. (Note that you may choose this reduced number in future operations.)

Return the minimum number of operations to reduce the sum of nums by at least half.

Input & Output

Example 1 — Basic Case

$ Input: nums = [5,19,8,1]

› Output: 3

💡 Note: Original sum = 33, target reduction ≥ 16.5. Operations: halve 19→9.5 (reduction=9.5), halve 9.5→4.75 (total=14.25), halve 8→4 (total=18.25≥16.5). Answer: 3 operations.

Example 2 — Small Array

$ Input: nums = [3,8,20]

› Output: 3

💡 Note: Original sum = 31, target reduction ≥ 15.5. Operations: halve 20→10 (reduction=10), halve 10→5 (total=15), halve 8→4 (total=19≥15.5). Answer: 3 operations.

Example 3 — Edge Case

$ Input: nums = [1,1]

› Output: 2

💡 Note: Original sum = 2, target reduction ≥ 1. Operations: halve 1→0.5 (reduction=0.5), halve 1→0.5 (total=1≥1). Answer: 2 operations.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

a Amazon 35 G Google 28 M Microsoft 22 f Meta 15

The key insight is that to minimize operations, we should always halve the largest element for maximum sum reduction. The optimal approach uses a max heap to efficiently track the largest element. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible combinations of operations and find the minimum that reduces sum by at least half. This involves exponential search through all possible operation sequences.

Greedy with Sorting

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

Sort the array after each operation to always identify the largest element to halve next. This greedy approach ensures maximum reduction per operation.

Max Heap (Optimal)

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

Use a max heap (priority queue) to efficiently maintain the largest element at the top. This avoids the need for sorting after each operation and provides optimal performance.

Brute Force - Try All Combinations — Algorithm Steps

Calculate target (half of original sum)
Try all possible operation sequences
For each sequence, check if sum reduction >= target
Return minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with [5,19,8,1], sum = 33, target = 16.5

Try All Combinations

Recursively try halving each element

Find Minimum

Return shortest sequence that reduces sum by ≥16.5

Code -

solution.c — C

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

void heapifyUp(double* heap, int idx) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    if (heap[parent] > heap[idx]) {
        double temp = heap[parent];
        heap[parent] = heap[idx];
        heap[idx] = temp;
        heapifyUp(heap, parent);
    }
}

void heapifyDown(double* heap, int size, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < size && heap[left] < heap[smallest]) {
        smallest = left;
    }
    if (right < size && heap[right] < heap[smallest]) {
        smallest = right;
    }
    
    if (smallest != idx) {
        double temp = heap[idx];
        heap[idx] = heap[smallest];
        heap[smallest] = temp;
        heapifyDown(heap, size, smallest);
    }
}

void heapPush(double* heap, int* size, double val) {
    heap[*size] = val;
    heapifyUp(heap, *size);
    (*size)++;
}

double heapPop(double* heap, int* size) {
    double min = heap[0];
    (*size)--;
    heap[0] = heap[*size];
    heapifyDown(heap, *size, 0);
    return min;
}

int solution(int* nums, int numsSize) {
    double originalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        originalSum += nums[i];
    }
    double target = originalSum / 2;
    
    // Use negative values for max heap
    double* maxHeap = (double*)malloc(10000 * sizeof(double));
    int heapSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        heapPush(maxHeap, &heapSize, -((double)nums[i]));
    }
    
    int operations = 0;
    double totalReduction = 0;
    
    while (totalReduction < target) {
        // Get the largest element
        double largest = -heapPop(maxHeap, &heapSize);
        
        // Halve it
        double halved = largest / 2;
        double reduction = largest - halved;
        totalReduction += reduction;
        
        // Put the halved value back
        heapPush(maxHeap, &heapSize, -halved);
        
        operations += 1;
    }
    
    free(maxHeap);
    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() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int count;
    parseArray(line, nums, &count);
    
    printf("%d\n", solution(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each element can be halved 0 to log(max_value) times, creating exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current state

✓ Linear Space

32.1K Views

Medium Frequency

~25 min Avg. Time

856 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