Minimum Absolute Sum Difference - Practice Coding Problems

Minimum Absolute Sum Difference - Problem

You're given two positive integer arrays nums1 and nums2, both of length n.

The absolute sum difference of these arrays is defined as the sum of |nums1[i] - nums2[i]| for each index 0 ≤ i < n.

Here's the twist: You can replace at most one element of nums1 with any other element that already exists in nums1 to minimize the absolute sum difference.

Goal: Return the minimum possible absolute sum difference after performing this optional replacement. Since the answer may be large, return it modulo 10⁹ + 7.

Example: If nums1 = [1,7,5] and nums2 = [2,3,5], the initial differences are [1,4,0] with sum = 5. By replacing nums1[1] = 7 with nums1[0] = 1, we get differences [1,2,0] with sum = 3.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: Initial differences: [|1-2|, |7-3|, |5-5|] = [1, 4, 0], sum = 5. Replace nums1[1]=7 with nums1[0]=1: new differences = [1, |1-3|, 0] = [1, 2, 0], sum = 3.

example_2.py — No Improvement

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

› Output: 20

💡 Note: Initial sum = |1-1|+|10-3|+|4-5|+|4-1|+|2-3|+|7-4| = 0+7+1+3+1+3 = 15. Best replacement saves 5, giving minimum sum of 20-5+5 = 20... Actually 15 total initially.

example_3.py — Large Numbers

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

› Output: 8

💡 Note: Initial differences: [4,2,0,2,4], sum=12. Best improvement is replacing either end element, reducing sum by 4 to get 8.

Constraints

n == nums1.length
n == nums2.length
1 ≤ n ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁵
You can replace at most one element

Visualization

Tap to expand

Understanding the Visualization

Assess Current Situation

Calculate total price difference across all products

Create Price Catalog

Sort all your existing prices for quick lookup

Find Best Match

For each product, find which of your prices best matches competitor

Calculate Savings

Determine which price change gives maximum improvement

Apply Best Strategy

Make the single change that minimizes total difference

Key Takeaway

🎯 Key Insight: By sorting our price catalog first, we can use binary search to quickly find the optimal price match for each product, reducing time complexity from O(n²) to O(n log n).

Asked in

G Google 24 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses sorting + binary search to achieve O(n log n) time complexity. First, sort nums1 to enable efficient searching. Then, for each position, use binary search to find the element in nums1 that would minimize the difference with nums2[i]. Track the maximum improvement possible and subtract it from the initial sum. This is much more efficient than the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Replacements)	O(n²)	O(1)	Try replacing each element with every other element and calculate the new sum
Sorting + Binary Search (Optimal)	O(n log n)	O(n)	Sort nums1, then use binary search to find the closest element for each position

Brute Force (Try All Replacements) — Algorithm Steps

Calculate the initial absolute sum difference
For each position i, try replacing nums1[i] with nums1[j] for all j ≠ i
Calculate the new sum difference after replacement
Keep track of the minimum sum found
Return the minimum sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Initial Sum

Sum all |nums1[i] - nums2[i]| differences

Try Each Position

For each position i, consider replacing nums1[i]

Try All Replacements

Replace with every other element in nums1

Track Minimum

Keep track of the minimum sum found

Code -

solution.c — C

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

int abs_diff(int a, int b) {
    return a >= b ? a - b : b - a;
}

int minimumAbsoluteSumDiff(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    const int MOD = 1000000007;
    int n = nums1Size;
    
    // Calculate initial sum
    long long initialSum = 0;
    for (int i = 0; i < n; i++) {
        initialSum += abs_diff(nums1[i], nums2[i]);
    }
    
    long long minSum = initialSum;
    
    // Try replacing each element
    for (int i = 0; i < n; i++) {
        int originalDiff = abs_diff(nums1[i], nums2[i]);
        
        // Try replacing nums1[i] with nums1[j]
        for (int j = 0; j < n; j++) {
            if (i != j) {
                int newDiff = abs_diff(nums1[j], nums2[i]);
                long long newSum = initialSum - originalDiff + newDiff;
                if (newSum < minSum) {
                    minSum = newSum;
                }
            }
        }
    }
    
    return (int)(minSum % MOD);
}

int main() {
    int nums1[] = {1, 7, 5};
    int nums2[] = {2, 3, 5};
    printf("%d\n", minimumAbsoluteSumDiff(nums1, 3, nums2, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we try n-1 other elements as replacements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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 Replacements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler