Fair Candy Swap - Practice Coding Problems

Fair Candy Swap - Problem

Alice and Bob are sharing their Halloween candy collections! They have different amounts of candy in total, but being good friends, they want to make it fair.

You're given two arrays:

aliceSizes[] - where aliceSizes[i] is the number of candies in Alice's i-th box
bobSizes[] - where bobSizes[j] is the number of candies in Bob's j-th box

Goal: Find exactly one box from Alice and one box from Bob to swap so that after the exchange, both friends have the same total number of candies.

Return: An array [alice_box_size, bob_box_size] representing the sizes of boxes they should exchange.

Note: It's guaranteed that at least one valid answer exists!

Input & Output

example_1.py — Basic Case

$ Input: aliceSizes = [1, 2], bobSizes = [2, 3]

› Output: [1, 2]

💡 Note: Alice has 1+2=3 candies, Bob has 2+3=5 candies. If Alice gives her box of 1 candy and receives Bob's box of 2 candies: Alice will have 3-1+2=4 candies, Bob will have 5-2+1=4 candies. Both have equal amounts!

example_2.py — Larger Numbers

$ Input: aliceSizes = [1, 2, 5], bobSizes = [2, 4]

› Output: [5, 4]

💡 Note: Alice has 1+2+5=8 candies, Bob has 2+4=6 candies. If Alice gives her box of 5 candies and receives Bob's box of 4 candies: Alice will have 8-5+4=7 candies, Bob will have 6-4+5=7 candies. Perfect balance!

example_3.py — Multiple Solutions

$ Input: aliceSizes = [2, 2], bobSizes = [1, 1]

› Output: [2, 1]

💡 Note: Alice has 4 candies, Bob has 2 candies. Any exchange of Alice's 2-candy box for Bob's 1-candy box results in both having 3 candies. Multiple valid answers exist, any one is acceptable.

Constraints

1 ≤ aliceSizes.length, bobSizes.length ≤ 10⁴
1 ≤ aliceSizes[i], bobSizes[i] ≤ 10⁵
Alice and Bob have different total amounts of candy
There will always be at least one valid answer

Visualization

Tap to expand

Understanding the Visualization

Identify the Imbalance

Alice has 15 candies, Bob has 9 candies. Total difference is 6 candies.

Calculate Required Exchange

To balance, Alice needs to give 3 more than she receives: diff = (15-9)/2 = 3

Find the Perfect Match

If Alice gives 4 candies, she needs to receive 4-3=1 candy from Bob

Verify Balance

After swap: Alice = 15-4+1 = 12, Bob = 9-1+4 = 12 ✅ Perfect balance!

Key Takeaway

🎯 Key Insight: The mathematical relationship `needed_bob_box = alice_box - (alice_total - bob_total)/2` directly gives us the required exchange partner, making hash table lookup the optimal O(n+m) solution!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 23

The optimal solution uses a hash table approach with mathematical insight: calculate the difference diff = (alice_total - bob_total) / 2, then for each Alice box, check if Bob has the required box of size alice_box - diff. This achieves O(n+m) time complexity and solves the problem in a single pass through Alice's boxes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n×m)	O(1)	Try every possible combination of Alice's and Bob's candy boxes
Sorting + Binary Search	O(n log m + m log m)	O(1)	Sort Bob's array and binary search for the complement of each Alice box
Hash Table (Optimal)	O(n + m)	O(m)	Use mathematical formula to find the exact box Bob needs, then check if it exists

Brute Force (Nested Loops) — Algorithm Steps

Calculate Alice's total candies and Bob's total candies
For each box in Alice's collection:
For each box in Bob's collection:
Calculate new totals after swapping these boxes
If new totals are equal, return this pair

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Totals

Alice: 15 candies, Bob: 9 candies

Try First Pair

Test Alice[1]=1 with Bob[1]=2 → Alice: 16, Bob: 8 ❌

Try Second Pair

Test Alice[1]=1 with Bob[2]=3 → Alice: 17, Bob: 7 ❌

Found Solution

Test Alice[2]=2 with Bob[2]=3 → Alice: 16, Bob: 8 ❌

Code -

solution.c — C

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

int* fairCandySwap(int* aliceSizes, int aliceLen, int* bobSizes, int bobLen, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    int aliceTotal = 0, bobTotal = 0;
    
    for (int i = 0; i < aliceLen; i++) aliceTotal += aliceSizes[i];
    for (int i = 0; i < bobLen; i++) bobTotal += bobSizes[i];
    
    for (int i = 0; i < aliceLen; i++) {
        for (int j = 0; j < bobLen; j++) {
            int aliceNew = aliceTotal - aliceSizes[i] + bobSizes[j];
            int bobNew = bobTotal - bobSizes[j] + aliceSizes[i];
            
            if (aliceNew == bobNew) {
                result[0] = aliceSizes[i];
                result[1] = bobSizes[j];
                return result;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

We check every combination of Alice's n boxes with Bob's m boxes

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track totals and current boxes

✓ Linear Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler