Maximize Greatness of an Array - Practice Coding Problems

Maximize Greatness of an Array - Problem

Imagine you have an array of numbers, and you want to create the most impressive rearrangement possible! You're given a 0-indexed integer array nums, and you can permute (rearrange) it into any order you want to create a new array perm.

The greatness of your arrangement is defined as the number of positions where perm[i] > nums[i] - essentially, how many elements in your rearranged array are greater than the corresponding elements in the original array.

Goal: Return the maximum possible greatness you can achieve by optimally rearranging the array.

Example: If nums = [1,3,5,2,1,3,1], you could rearrange it to perm = [3,5,1,3,2,1,1]. Comparing position by position: 3>1 ✓, 5>3 ✓, 1>5 ✗, 3>2 ✓, 2>1 ✓, 1>3 ✗, 1>1 ✗. That gives us a greatness of 4!

Input & Output

example_1.py — Basic Case

$ Input: [1,3,5,2,1,3,1]

› Output: 4

💡 Note: We can rearrange nums into [3,5,1,3,2,1,1]. Comparing with original: 3>1✓, 5>3✓, 1>5✗, 3>2✓, 2>1✓, 1>3✗, 1>1✗. Total greatness = 4.

example_2.py — All Same Elements

$ Input: [1,1,1,1,1]

› Output: 0

💡 Note: Since all elements are identical, no matter how we rearrange, we can never have perm[i] > nums[i] at any position. Greatness = 0.

example_3.py — Perfect Ascending

$ Input: [1,2,3,4,5]

› Output: 4

💡 Note: We can arrange as [2,3,4,5,1]. This gives us: 2>1✓, 3>2✓, 4>3✓, 5>4✓, 1>5✗. Maximum possible greatness = 4.

Visualization

Tap to expand

Understanding the Visualization

Rank Players

Sort both rosters by skill level from weakest to strongest

Strategic Pairing

For each player in the original roster, find the weakest player from the rearranged roster who can still beat them

Greedy Matching

Always use the weakest possible winning player - this saves stronger players for tougher opponents

Count Victories

Sum up all the successful matches to get maximum greatness

Key Takeaway

🎯 Key Insight: The greedy approach works because using the smallest possible winning element for each match preserves stronger elements for future tougher opponents, maximizing overall victories!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting both arrays takes O(n log n), then single pass with two pointers takes O(n)

⚡ Linearithmic

Space Complexity

O(n)

Need extra space to store the sorted copy of the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
The array can contain duplicate elements

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses a greedy two-pointer strategy after sorting. The key insight is that to maximize greatness, we should match each element with the smallest possible element that can still beat it. This ensures we don't "waste" larger elements on easier matches, leaving them available for harder ones. Time complexity: O(n log n) due to sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Greedy Approach)	O(n log n)	O(n)	Sort both arrays and use greedy matching with two pointers
Brute Force (Try All Permutations)	O(n! × n)	O(n!)	Generate all possible permutations and find the one with maximum greatness

Two Pointers (Greedy Approach) — Algorithm Steps

Create a copy of the original array and sort both arrays
Use two pointers: one for original array, one for the copy
For each element in original array, find the smallest element in copy that's greater
Count successful matches and move both pointers accordingly
Return the total count of successful matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Arrays

Sort both original and permutation arrays

Initialize Pointers

Set two pointers at the beginning of both arrays

Greedy Match

For each element, find the smallest element that can beat it

Count Matches

Increment greatness for each successful match

Code -

solution.c — C

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

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

int maximizeGreatness(int* nums, int size) {
    // Create and sort both arrays
    int* originalSorted = (int*)malloc(size * sizeof(int));
    int* permSorted = (int*)malloc(size * sizeof(int));
    
    memcpy(originalSorted, nums, size * sizeof(int));
    memcpy(permSorted, nums, size * sizeof(int));
    
    qsort(originalSorted, size, sizeof(int), compare);
    qsort(permSorted, size, sizeof(int), compare);
    
    int i = 0, j = 0; // Two pointers
    int greatness = 0;
    
    // Greedy matching: for each element in original,
    // find the smallest element in perm that can beat it
    while (i < size && j < size) {
        if (permSorted[j] > originalSorted[i]) {
            // Found a match! This element can beat original[i]
            greatness++;
            i++; // Move to next element in original
            j++; // This element is now "used"
        } else {
            // Current perm element can't beat original[i]
            // Try the next larger element in perm
            j++;
        }
    }
    
    free(originalSorted);
    free(permSorted);
    return greatness;
}

int main() {
    int nums[] = {1, 3, 5, 2, 1, 3, 1};
    int size = sizeof(nums) / sizeof(nums[0]);
    
    printf("%d\n", maximizeGreatness(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting both arrays takes O(n log n), then single pass with two pointers takes O(n)

⚡ Linearithmic

Space Complexity

O(n)

Need extra space to store the sorted copy of the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
The array can contain duplicate elements

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Two Pointers (Greedy Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler