Advantage Shuffle

Advantage Shuffle - Problem

You are given two integer arrays nums1 and nums2 both of the same length. The advantage of nums1 with respect to nums2 is the number of indices i for which nums1[i] > nums2[i].

Return any permutation of nums1 that maximizes its advantage with respect to nums2.

Input & Output

Example 1 — Basic Advantage

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

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

💡 Note: We rearrange nums1 to [2,11,7,15]. Comparing with nums2=[1,10,4,11]: 2>1 ✓, 11>10 ✓, 7>4 ✓, 15>11 ✓. All 4 positions give advantage.

Example 2 — Partial Advantage

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

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

💡 Note: Optimal arrangement: 24>13 ✓, 32>25 ✓, 8≤32 ✗, 12>11 ✓. We get 3 advantages out of 4 possible.

Example 3 — Minimum Case

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

› Output: [5,3]

💡 Note: With 2 elements: 5≤6 ✗, 3≤4 ✗. No advantage possible, but [5,3] is one valid arrangement.

Constraints

1 ≤ nums1.length ≤ 10⁵
nums2.length == nums1.length
0 ≤ nums1[i], nums2[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 A Apple 12

The key insight is to use a greedy strategy: for each element in nums2, assign the smallest element from nums1 that can beat it, or waste the smallest element if no win is possible. Best approach is Greedy with Sorting with Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all possible permutations of nums1, calculate the advantage for each permutation against nums2, and return the permutation with the highest advantage count.

Greedy with Sorting

⏱️ Time: O(n log n) Space: O(n)

Sort nums1 in ascending order and create index-value pairs for nums2. For each element in nums2 (sorted by value), try to beat it with the smallest possible element from nums1, or use the smallest remaining element if no win is possible.

Brute Force - Try All Permutations — Algorithm Steps

Generate all permutations of nums1
For each permutation, count advantages against nums2
Return the permutation with maximum advantage

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of nums1

Count Advantages

For each arrangement, count wins against nums2

Find Maximum

Return arrangement with most wins

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int* arr, int start, int end, int* nums2, int* maxAdvantage, int* bestPerm, int n) {
    if (start == end) {
        int advantage = 0;
        for (int i = 0; i < n; i++) {
            if (arr[i] > nums2[i]) advantage++;
        }
        if (advantage > *maxAdvantage) {
            *maxAdvantage = advantage;
            for (int i = 0; i < n; i++) {
                bestPerm[i] = arr[i];
            }
        }
        return;
    }
    
    for (int i = start; i <= end; i++) {
        swap(&arr[start], &arr[i]);
        permute(arr, start + 1, end, nums2, maxAdvantage, bestPerm, n);
        swap(&arr[start], &arr[i]);
    }
}

int* solution(int* nums1, int* nums2, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* bestPerm = (int*)malloc(numsSize * sizeof(int));
    int* temp = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        bestPerm[i] = nums1[i];
        temp[i] = nums1[i];
    }
    
    int maxAdvantage = -1;
    permute(temp, 0, numsSize - 1, nums2, &maxAdvantage, bestPerm, numsSize);
    
    free(temp);
    return bestPerm;
}

int main() {
    int nums1[1000], nums2[1000];
    int n = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' || token[0] == '-') {
            nums1[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int m = 0;
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' || token[0] == '-') {
            nums2[m++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* result = solution(nums1, nums2, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to evaluate advantage

⚡ Linearithmic

Space Complexity

O(n)

Space to store current permutation and track maximum

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler