Advantage Shuffle - Practice Coding Problems

Advantage Shuffle - Problem

Advantage Shuffle - The Strategic Card Game Problem

Imagine you're playing a card game where you need to maximize your wins! You have two decks of cards with numbers: nums1 (your deck) and nums2 (opponent's deck). The goal is to rearrange your deck to beat as many of your opponent's cards as possible.

🎯 The Rules:
• You win a round when your card value > opponent's card value at the same position
• Your advantage is the total number of rounds you win
• You can shuffle your deck in any order, but the opponent's deck stays fixed

Input: Two integer arrays of equal length
Output: Any permutation of nums1 that maximizes the number of positions where nums1[i] > nums2[i]

Example: If your cards are [2,7,11,15] and opponent has [1,10,4,11], you could arrange yours as [2,11,7,15] to win 3 out of 4 rounds!

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [2,7,11,15], nums2 = [1,10,4,11]

› Output: [2,11,7,15]

💡 Note: We can beat all opponent cards! 2>1, 11>10, 7>4, 15>11. This gives us maximum advantage of 4.

example_2.py — Strategic Sacrifice

$ Input: nums1 = [12,24,8,32], nums2 = [13,25,32,11]

› Output: [24,32,8,12]

💡 Note: Strategic assignment: 24>13, 32>25, sacrifice 8 to 32, 12>11. Total advantage: 3 out of 4.

example_3.py — Edge Case

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

› Output: [1,2] or [2,1]

💡 Note: No card can beat any opponent card, so any arrangement gives 0 advantage. We can return any permutation.

Visualization

Tap to expand

Understanding the Visualization

Intelligence Gathering

Sort your cards and opponent's cards to understand the battlefield

Strategic Assignment

For tough opponent cards, use your best available card that can win

Tactical Sacrifice

When you can't win, sacrifice your weakest card to save stronger ones

Key Takeaway

🎯 Key Insight: The greedy strategy of using the smallest card that can win (or sacrificing the smallest when losing) maximizes our advantage by preserving stronger cards for tougher future battles!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for n binary searches

⚡ Linearithmic

Space Complexity

O(n)

Space for sorted array, availability tracking, and result

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length ≤ 10⁵
nums2.length == nums1.length
0 ≤ nums1[i], nums2[i] ≤ 10⁹
Both arrays contain the same number of elements

Asked in

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

The optimal solution uses a greedy two-pointers approach with O(n log n) time complexity. Key insight: sort both arrays and for each opponent card (processed from largest to smallest), either use our smallest winning card or sacrifice our smallest card when we can't win. This maximizes future winning opportunities and guarantees the maximum possible advantage.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n)	O(n)	Sort nums1 and for each nums2 element, binary search for the smallest winning card
Two Pointers with Greedy Strategy (Optimal)	O(n log n)	O(n)	Sort both arrays and use greedy matching with two pointers to maximize advantage
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible permutations of nums1 and find the one with maximum advantage

Sorting + Binary Search — Algorithm Steps

Sort nums1 while keeping track of availability
For each element in nums2, binary search for smallest card > current element
If found, assign it and mark as used
If not found, assign smallest available card
Handle used cards by maintaining availability status

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort and Prepare

Sort nums1 and prepare binary search structure

Binary Search

For each opponent card, binary search for smallest winning card

Assign or Sacrifice

Assign winning card or sacrifice smallest available

Code -

solution.c — C

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

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

int binarySearch(int* arr, int n, int target) {
    int left = 0, right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int* advantageCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    int n = nums1Size;
    *returnSize = n;
    
    // Create sorted copy of nums1 with original indices
    int* sortedNums1 = (int*)malloc(n * sizeof(int));
    int* indices = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        sortedNums1[i] = nums1[i];
        indices[i] = i;
    }
    
    // Sort indices based on nums1 values
    for (int i = 0; i < n-1; i++) {
        for (int j = i+1; j < n; j++) {
            if (nums1[indices[i]] > nums1[indices[j]]) {
                int temp = indices[i];
                indices[i] = indices[j];
                indices[j] = temp;
            }
        }
    }
    
    // Create sorted values array
    for (int i = 0; i < n; i++) {
        sortedNums1[i] = nums1[indices[i]];
    }
    
    bool* used = (bool*)calloc(n, sizeof(bool));
    int* result = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        int target = nums2[i];
        int pos = binarySearch(sortedNums1, n, target);
        
        // Find first unused card from pos onwards
        bool assigned = false;
        for (int j = pos; j < n; j++) {
            if (!used[j]) {
                result[i] = sortedNums1[j];
                used[j] = true;
                assigned = true;
                break;
            }
        }
        
        // If no winning card, use smallest available
        if (!assigned) {
            for (int j = 0; j < n; j++) {
                if (!used[j]) {
                    result[i] = sortedNums1[j];
                    used[j] = true;
                    break;
                }
            }
        }
    }
    
    free(sortedNums1);
    free(indices);
    free(used);
    return result;
}

int main() {
    int nums1[] = {2, 7, 11, 15};
    int nums2[] = {1, 10, 4, 11};
    int returnSize;
    
    int* result = advantageCount(nums1, 4, nums2, 4, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for n binary searches

⚡ Linearithmic

Space Complexity

O(n)

Space for sorted array, availability tracking, and result

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length ≤ 10⁵
nums2.length == nums1.length
0 ≤ nums1[i], nums2[i] ≤ 10⁹
Both arrays contain the same number of elements

58.2K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler