Rearranging Fruits - Practice Coding Problems

Rearranging Fruits - Problem

Fruit Basket Equalizer - The Great Swap Challenge!

Imagine you're a fruit vendor with two baskets, each containing n fruits of different costs. Your goal is to make both baskets identical by swapping fruits between them.

You're given two arrays basket1 and basket2 representing the cost of each fruit. You can perform swaps where:
• Choose any fruit from basket1 and any fruit from basket2
• Swap them with a cost equal to min(cost1, cost2)
• Two baskets are equal when sorted arrays are identical

Return the minimum total cost to equalize the baskets, or -1 if impossible.

Example: basket1=[4,2,2,2], basket2=[1,4,1,2] → After optimal swaps, both become [1,2,2,4] with minimum cost.

Input & Output

example_1.py — Basic Case

$ Input: basket1 = [4,2,2,2], basket2 = [1,4,1,2]

› Output: 2

💡 Note: We need to swap fruits to make both baskets [1,2,2,4]. Swap basket1[0]=4 with basket2[0]=1 (cost=1), then swap basket1[1]=2 with basket2[2]=1 (cost=1). Total cost = 2.

example_2.py — Impossible Case

$ Input: basket1 = [4,79,32], basket2 = [91,2,105]

› Output: -1

💡 Note: Each fruit appears exactly once across both baskets, so each has an odd frequency. Since we can't split odd numbers evenly, it's impossible to make the baskets equal.

example_3.py — Already Equal

$ Input: basket1 = [1,2,3], basket2 = [1,2,3]

› Output: 0

💡 Note: The baskets are already equal when sorted, so no swaps are needed. Total cost = 0.

Constraints

1 ≤ basket1.length == basket2.length ≤ 10⁵
1 ≤ basket1[i], basket2[i] ≤ 10⁹
Both baskets have equal number of fruits

Visualization

Tap to expand

Understanding the Visualization

Inventory Check

Count all fruit types across both vendors - if any fruit type has odd total quantity, balancing is impossible

Identify Imbalances

Find which fruits each vendor has too many of and needs to trade away

Strategic Sorting

Sort excess inventory: expensive fruits first for vendor 1, cheap fruits first for vendor 2

Optimal Trading

Execute greedy trades: pair most expensive excess with cheapest needed, or use indirect trades through cheapest fruit

Key Takeaway

🎯 Key Insight: The greedy approach works because we always want to minimize the cost of each trade. By pairing the most expensive excess items with the cheapest available options, we ensure the lowest total trading cost while achieving perfect balance.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses a greedy strategy with frequency counting. First, verify if a solution exists by checking that all fruits appear an even number of times total. Then, identify excess fruits in each basket that need to be swapped out. Finally, use greedy pairing: sort excess fruits and pair the most expensive excess fruits with the cheapest available options (either direct swap or indirect swap through the minimum element). Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Sorting (Optimal)	O(n log n)	O(n)	Count frequencies, identify swaps needed, then greedily pair expensive excess with cheap needed fruits
Brute Force (Try All Swaps)	O(2^(n²))	O(n²)	Try every possible sequence of swaps until baskets are equal

Greedy with Sorting (Optimal) — Algorithm Steps

Count frequency of each fruit across both baskets
Identify fruits that appear odd number of times (impossible case)
Collect excess fruits from each basket that need to be swapped out
Sort excess fruits in descending order for greedy pairing
For each expensive excess fruit, choose cheaper swap option

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count each fruit type across both baskets

Find Excess

Identify which fruits each basket has too many of

Sort Strategically

Sort excess fruits for optimal pairing

Greedy Pairing

Pair expensive excess with cheapest options

Code -

solution.c — C

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

#define MAX_FRUITS 1000

typedef struct {
    int fruit;
    int count;
} FruitCount;

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

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

long long minCost(int* basket1, int* basket2, int n) {
    // Use arrays for counting (assuming fruit values are reasonable)
    int count[MAX_FRUITS] = {0};
    int count1[MAX_FRUITS] = {0};
    int count2[MAX_FRUITS] = {0};
    
    int minFruit = INT_MAX, maxFruit = 0;
    
    // Count frequencies
    for (int i = 0; i < n; i++) {
        count[basket1[i]]++;
        count1[basket1[i]]++;
        count[basket2[i]]++;
        count2[basket2[i]]++;
        
        if (basket1[i] < minFruit) minFruit = basket1[i];
        if (basket2[i] < minFruit) minFruit = basket2[i];
        if (basket1[i] > maxFruit) maxFruit = basket1[i];
        if (basket2[i] > maxFruit) maxFruit = basket2[i];
    }
    
    // Check if solution exists
    for (int i = minFruit; i <= maxFruit; i++) {
        if (count[i] % 2 != 0) return -1;
    }
    
    // Find excess fruits
    int excess1[MAX_FRUITS], excess2[MAX_FRUITS];
    int excess1Size = 0, excess2Size = 0;
    
    for (int fruit = minFruit; fruit <= maxFruit; fruit++) {
        if (count[fruit] == 0) continue;
        
        int target = count[fruit] / 2;
        int excess1Count = count1[fruit] - target;
        int excess2Count = count2[fruit] - target;
        
        for (int i = 0; i < excess1Count; i++) {
            excess1[excess1Size++] = fruit;
        }
        for (int i = 0; i < excess2Count; i++) {
            excess2[excess2Size++] = fruit;
        }
    }
    
    // Sort for greedy pairing
    qsort(excess1, excess1Size, sizeof(int), compare_desc);
    qsort(excess2, excess2Size, sizeof(int), compare_asc);
    
    long long totalCost = 0;
    
    for (int i = 0; i < excess1Size; i++) {
        long long directCost = (excess1[i] < excess2[i]) ? excess1[i] : excess2[i];
        long long indirectCost = 2LL * minFruit;
        totalCost += (directCost < indirectCost) ? directCost : indirectCost;
    }
    
    return totalCost;
}

int main() {
    int basket1[] = {4, 2, 2, 2};
    int basket2[] = {1, 4, 1, 2};
    printf("%lld\n", minCost(basket1, basket2, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the excess fruits dominates the time complexity

⚡ Linearithmic

Space Complexity

O(n)

Extra space for frequency counting and storing excess fruits

⚡ Linearithmic Space

38.5K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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 with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler