Equal Sum Arrays With Minimum Number of Operations

Equal Sum Arrays With Minimum Number of Operations - Problem

Equal Sum Arrays With Minimum Operations

Imagine you're a game master balancing two teams in a dice-based competition! You have two arrays nums1 and nums2 representing dice values (1-6) for each team. Your goal is to make both teams have equal total scores by changing the minimum number of dice values.

In each operation, you can change any die value in either array to any value between 1 and 6 (inclusive). Find the minimum number of operations needed to equalize the sums, or return -1 if it's impossible.

Key Challenge: Which dice should you change to maximize the impact of each operation?

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: Sum1 = 21, Sum2 = 10. We need to reduce the difference of 11. Change three 1's in nums2 to 6's: operations = 3, new difference = 11 - 3*5 = -4 ≤ 0.

example_2.py — Equal Arrays

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

› Output: 0

💡 Note: Both arrays have sum = 7. No operations needed.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: Sum1 = 12, Sum2 = 1. Even if we change nums2 to [6] and nums1 to [1,1], we get sums 2 and 6, which still can't be equal.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 6
All array elements are dice values (1-6)
Arrays may have different lengths

Visualization

Tap to expand

Understanding the Visualization

Calculate Team Scores

Sum up dice values for each team

Find Score Gap

Determine how much difference needs to be eliminated

Identify Best Moves

For each die, calculate the maximum score change possible

Make Greedy Choices

Always choose the move that closes the gap the most

Key Takeaway

🎯 Key Insight: Use greedy selection to always pick the dice change that maximizes the score adjustment toward the target balance.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a greedy approach. Calculate the sum difference, then greedily select dice changes that provide maximum impact toward balancing the arrays. Sort potential gains in descending order and apply changes until the difference is eliminated. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Two-Array Approach (Optimal)	O(n log n)	O(n)	Use greedy strategy to prioritize changes with maximum impact
Brute Force (Try All Combinations)	O(6^(m+n))	O(m+n)	Try all possible ways to change dice values until sums are equal

Greedy Two-Array Approach (Optimal) — Algorithm Steps

Calculate sum difference between the two arrays
If difference is 0, return 0 operations
Determine which array needs to increase/decrease
Create a list of potential gains from each possible change
Sort potential gains in descending order
Greedily select changes until difference is eliminated

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Difference

Find the sum difference between arrays

Identify Potential Gains

Calculate max gain from changing each die

Sort by Impact

Sort potential gains in descending order

Greedy Selection

Select changes until difference is eliminated

Code -

solution.c — C

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

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

int minOperations(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int sum1 = 0, sum2 = 0;
    for (int i = 0; i < nums1Size; i++) sum1 += nums1[i];
    for (int i = 0; i < nums2Size; i++) sum2 += nums2[i];
    
    if (sum1 == sum2) return 0;
    
    // Make sure sum1 is smaller
    if (sum1 > sum2) {
        int *temp = nums1; nums1 = nums2; nums2 = temp;
        int tempSize = nums1Size; nums1Size = nums2Size; nums2Size = tempSize;
        int tempSum = sum1; sum1 = sum2; sum2 = tempSum;
    }
    
    int diff = sum2 - sum1;
    int *gains = malloc((nums1Size + nums2Size) * sizeof(int));
    int gainsSize = 0;
    
    for (int i = 0; i < nums1Size; i++) {
        gains[gainsSize++] = 6 - nums1[i];
    }
    
    for (int i = 0; i < nums2Size; i++) {
        gains[gainsSize++] = nums2[i] - 1;
    }
    
    qsort(gains, gainsSize, sizeof(int), compare);
    
    int operations = 0;
    for (int i = 0; i < gainsSize && diff > 0; i++) {
        diff -= gains[i];
        operations++;
    }
    
    free(gains);
    return diff <= 0 ? operations : -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We need to sort the potential gains, where n is total array size

⚡ Linearithmic

Space Complexity

O(n)

Store potential gains for each element

⚡ Linearithmic Space

24.6K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Two-Array Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler