Equal Sum Arrays With Minimum Number of Operations - Problem

You are given two arrays of integers nums1 and nums2, possibly of different lengths. The values in the arrays are between 1 and 6, inclusive.

In one operation, you can change any integer's value in any of the arrays to any value between 1 and 6, inclusive.

Return the minimum number of operations required to make the sum of values in nums1 equal to the sum of values in nums2. Return -1 if it is not possible to make the sum of the two arrays equal.

Input & Output

Example 1 — Basic Case

$ Input: nums1 = [1,2,3,4,5,6], nums2 = [1,1,2,2,2,2]

› Output: 3

💡 Note: Sum of nums1 is 21, sum of nums2 is 10. We need to reduce difference of 11. Change nums1[4] from 5→1 (gain 4), nums1[3] from 4→1 (gain 3), nums1[2] from 3→1 (gain 2). Total gain = 9. Change nums2[0] from 1→3 (gain 2). Total operations = 4, but we only need 3 to reduce difference to 0.

Example 2 — Equal Sums

$ Input: nums1 = [1,1,1,1,1,1,1], nums2 = [6]

› Output: 1

💡 Note: Sum of nums1 is 7, sum of nums2 is 6. Difference is 1. Change any element in nums1 from 1→0 is invalid, but change nums2[0] from 6→7 is invalid too. Actually, change nums1[0] from 1→2 reduces difference by -1, making sums equal. Wait, let me recalculate: change nums2[0] from 6→7 isn't valid since max is 6. Change nums1[6] from 1→0 isn't valid since min is 1. We can change nums2[0] from 6→5 (reduces sum by 1) or change nums1 element from 1→2 (increases sum by 1). Either takes 1 operation.

Example 3 — Impossible Case

$ Input: nums1 = [6,6], nums2 = [1]

› Output: 3

💡 Note: nums1 sum is 12, nums2 sum is 1. Using greedy approach: swap to make nums1=[1], nums2=[6,6]. Need to reduce difference of 11. Available gains: increase nums1[0] from 1→6 (gain 5), decrease nums2[0] from 6→1 (gain 5), decrease nums2[1] from 6→1 (gain 5). After 3 operations with gains [5,5,1], the difference becomes 0.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 6

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to greedily prioritize changes that provide maximum impact in reducing the sum difference. Calculate potential gains from each element change and apply the most beneficial changes first. Greedy approach works optimally here. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(6^n) Space: O(1)

Generate all possible combinations of changing elements in both arrays and check which gives minimum operations to equalize sums.

Greedy - Maximize Impact

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

Calculate potential gain from each element change and prioritize changes that reduce the sum difference most effectively.

Brute Force - Try All Combinations — Algorithm Steps

Calculate initial sum difference
Try all possible element changes
For each combination, count operations needed
Return minimum operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Arrays with different sums

Try Changes

Recursively try changing each element to values 1-6

Find Minimum

Return minimum operations to equalize sums

Code -

solution.c — C

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

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

int solution(int* nums1, int n1, int* nums2, int n2) {
    int sum1 = 0, sum2 = 0;
    for (int i = 0; i < n1; i++) sum1 += nums1[i];
    for (int i = 0; i < n2; i++) sum2 += nums2[i];
    
    if (sum1 == sum2) return 0;
    
    // Check if it's possible
    int minSum1 = n1, maxSum1 = n1 * 6;
    int minSum2 = n2, maxSum2 = n2 * 6;
    
    if (maxSum1 < minSum2 || minSum1 > maxSum2) return -1;
    
    int diff = sum1 - sum2;
    int operations = 0;
    
    // Create array of possible gains
    int gains[200];
    int gainCount = 0;
    
    if (diff > 0) {
        // sum1 > sum2, need to decrease sum1 or increase sum2
        // Decrease nums1 elements to 1
        for (int i = 0; i < n1; i++) {
            if (nums1[i] > 1) {
                gains[gainCount++] = nums1[i] - 1;
            }
        }
        // Increase nums2 elements to 6
        for (int i = 0; i < n2; i++) {
            if (nums2[i] < 6) {
                gains[gainCount++] = 6 - nums2[i];
            }
        }
    } else {
        // sum2 > sum1, need to decrease sum2 or increase sum1
        diff = -diff;
        // Decrease nums2 elements to 1
        for (int i = 0; i < n2; i++) {
            if (nums2[i] > 1) {
                gains[gainCount++] = nums2[i] - 1;
            }
        }
        // Increase nums1 elements to 6
        for (int i = 0; i < n1; i++) {
            if (nums1[i] < 6) {
                gains[gainCount++] = 6 - nums1[i];
            }
        }
    }
    
    // Sort gains in descending order
    qsort(gains, gainCount, sizeof(int), compare);
    
    // Greedily apply operations
    for (int i = 0; i < gainCount && diff > 0; i++) {
        diff -= gains[i];
        operations++;
    }
    
    return diff <= 0 ? operations : -1;
}

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;
        
        char* endptr;
        int val = (int)strtol(p, &endptr, 10);
        if (endptr != p) {
            arr[(*size)++] = val;
            p = endptr;
        } else {
            p++;
        }
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    static int nums1[100], nums2[100];
    int n1 = 0, n2 = 0;
    
    parseArray(line1, nums1, &n1);
    parseArray(line2, nums2, &n2);
    
    printf("%d\n", solution(nums1, n1, nums2, n2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(6^n)

Each element can be changed to 6 possible values, trying all combinations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Equal Sum Arrays With Minimum Number of Operations - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler