Minimum Number of Operations to Make Arrays Similar

Minimum Number of Operations to Make Arrays Similar - Problem

Array Transformation Challenge: Transform one array to have the same frequency distribution as another using balanced operations!

You're given two positive integer arrays nums and target of equal length. Your mission is to make them similar - meaning they should have the same frequency of each element (like anagrams for arrays).

The Rules:
• In each operation, pick two different indices i and j
• Add 2 to nums[i] and subtract 2 from nums[j]
• Each operation maintains the total sum (it's balanced!)

Goal: Find the minimum number of operations to make nums similar to target.

Key Insight: Since we can only add/subtract 2, the parity (odd/even nature) of each element never changes! This is crucial for solving efficiently.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We need 2 operations: First separate by parity - evens: [4,2] → [6,2], odds: [3,5] → [1,5]. For evens: 4→6 needs 1 operation. For odds: 3→1 needs 1 operation. Total: 2 operations.

example_2.py — Already Similar

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

› Output: 0

💡 Note: The arrays already have the same frequency of each element (just different order), so they are already similar. No operations needed.

example_3.py — Complex Transformation

$ Input: nums = [8,7,6,5], target = [2,3,10,11]

› Output: 6

💡 Note: Separate by parity - evens: [8,6] → [2,10], odds: [7,5] → [3,11]. For evens: 8→2 needs 3 ops, 6→10 needs 2 ops (but 6→10 means we need extra from the 8→2). For odds: 7→3 needs 2 ops, 5→11 needs 3 ops (but we have excess from 7→3). Total operations: 6.

Constraints

n == nums.length == target.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i], target[i] ≤ 10⁶
The test cases are generated such that nums can always be made similar to target

Visualization

Tap to expand

Understanding the Visualization

Separate Container Types

Group containers by capacity type (odd vs even liters)

Sort by Capacity

Arrange containers from smallest to largest capacity in each group

Greedy Matching

Transfer excess water from overfull to underfull containers optimally

Count Transfers

Each 2-liter transfer represents one operation

Key Takeaway

🎯 Key Insight: Parity constraints split the problem into two independent subproblems, making a complex transformation problem solvable with simple greedy matching!

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses parity separation - since operations only add/subtract 2, odd numbers stay odd and even numbers stay even. We solve two independent subproblems by separating elements by parity, sorting each group, and using greedy matching to minimize operations. Time complexity: O(n log n) for sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Parity Separation (Optimal)	O(n log n)	O(n)	Separate by parity, sort both arrays, then greedily match with two pointers
Brute Force (Try All Combinations)	O(2^(n²))	O(n² * max_operations)	Try all possible sequences of operations until arrays become similar

Two Pointers with Parity Separation (Optimal) — Algorithm Steps

Separate nums and target into odd and even elements
Sort odd elements of both nums and target
Sort even elements of both nums and target
For each parity group, use two pointers to match elements
Calculate total operations needed across both groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Separate by Parity

Split nums and target into odd/even groups

Sort Groups

Sort each parity group independently

Match with Two Pointers

Greedily match sorted elements in each group

Calculate Operations

Sum operations needed for excess elements

Code -

solution.c — C

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

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

int calculateOperations(int* source, int* targetArr, int size) {
    int operations = 0;
    for (int i = 0; i < size; i++) {
        if (source[i] > targetArr[i]) {
            operations += (source[i] - targetArr[i]) / 2;
        }
    }
    return operations;
}

int minimumOperations(int* nums, int numsSize, int* target, int targetSize) {
    int numsOdd[1000], numsEven[1000], targetOdd[1000], targetEven[1000];
    int oddCount = 0, evenCount = 0, targetOddCount = 0, targetEvenCount = 0;
    
    // Separate by parity
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] % 2 == 1) {
            numsOdd[oddCount++] = nums[i];
        } else {
            numsEven[evenCount++] = nums[i];
        }
    }
    
    for (int i = 0; i < targetSize; i++) {
        if (target[i] % 2 == 1) {
            targetOdd[targetOddCount++] = target[i];
        } else {
            targetEven[targetEvenCount++] = target[i];
        }
    }
    
    // Sort all arrays
    qsort(numsOdd, oddCount, sizeof(int), compare);
    qsort(numsEven, evenCount, sizeof(int), compare);
    qsort(targetOdd, targetOddCount, sizeof(int), compare);
    qsort(targetEven, targetEvenCount, sizeof(int), compare);
    
    // Calculate operations for each parity group
    int oddOps = calculateOperations(numsOdd, targetOdd, oddCount);
    int evenOps = calculateOperations(numsEven, targetEven, evenCount);
    
    return oddOps + evenOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting both odd and even elements takes O(n log n) time

⚡ Linearithmic

Space Complexity

O(n)

Extra space needed to store separated odd and even elements

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~25 min Avg. Time

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

Two Pointers with Parity Separation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler