Maximize Greatness of an Array

Maximize Greatness of an Array - Problem

You are given a 0-indexed integer array nums. You are allowed to permute nums into a new array perm of your choosing.

We define the greatness of nums to be the number of indices 0 <= i < nums.length for which perm[i] > nums[i].

Return the maximum possible greatness you can achieve after permuting nums.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Optimal permutation is [2,4,5,3,1]. Comparing with original [1,3,5,2,4]: positions 0 (2>1), 1 (4>3), and 3 (3>2) satisfy perm[i] > nums[i], giving greatness = 3.

Example 2 — All Same Elements

$ Input: nums = [1,1,1,1]

› Output: 0

💡 Note: All elements are identical, so no matter how we permute, perm[i] can never be greater than nums[i]. Maximum greatness = 0.

Example 3 — Ascending Order

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

› Output: 4

💡 Note: Optimal permutation is [2,3,4,5,1]. This gives us 4 positions where perm[i] > nums[i]: 2>1, 3>2, 4>3, 5>4.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a greedy approach after sorting. Sort the array and use two pointers to match each element with the smallest available larger element. This maximizes the number of positions where perm[i] > nums[i]. Best approach uses two pointers on sorted array with Time: O(n log n), Space: O(1).

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Brute Force - Try All Permutations

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

Generate every possible permutation of the array and for each permutation, count how many positions have perm[i] > nums[i]. Keep track of the maximum count found.

Optimized Two Pointers

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

Sort only once and use two pointers on the same array. The key insight is that we only need to count how many elements can be 'promoted' to a higher position in the sorted order.

Sort and Greedy Match

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

Sort the array and use two pointers to greedily match each element with the smallest available element that is larger. This maximizes the number of successful matches.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

847 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