Find the Maximum Number of Marked Indices - Problem

You are given a 0-indexed integer array nums.

Initially, all of the indices are unmarked. You are allowed to make this operation any number of times:

Pick two different unmarked indices i and j such that 2 * nums[i] <= nums[j], then mark i and j.

Return the maximum possible number of marked indices in nums using the above operation any number of times.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: We can mark indices 2 and 3 since 2 * nums[2] = 2 * 2 = 4 ≤ nums[3] = 4. No other valid pairs exist.

Example 2 — Multiple Pairs Possible

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

› Output: 2

💡 Note: We can mark indices 0 and 1 since 2 * nums[0] = 2 * 1 = 2 ≤ nums[1] = 3. Alternatively, we could mark indices 2 and 3 since 2 * nums[2] = 2 * 2 = 4 ≤ nums[3] = 4. Both give 2 marked indices.

Example 3 — No Valid Pairs

$ Input: nums = [7,6,8]

› Output: 0

💡 Note: No pair (i,j) exists where 2 * nums[i] ≤ nums[j], so no indices can be marked.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to sort the array first, then use a greedy two-pointer approach. We try to pair each smaller element with the smallest possible larger element that satisfies the condition 2*nums[i] ≤ nums[j]. Best approach is Sort + Two Pointers. Time: O(n log n), Space: O(1)

Common Approaches

✓ Kadane

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

Brute Force - Try All Combinations

⏱️ Time: O(2^n) Space: O(n)

Generate all possible combinations of element pairs that satisfy the condition 2*nums[i] <= nums[j], then use backtracking to find the maximum number of pairs possible.

Optimized Greedy with Binary Search

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

After sorting, for each element in the first half, use binary search to find the smallest element in the second half that can pair with it, maximizing future pairing opportunities.

Sort + Two Pointers

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

Sort the array to arrange elements in ascending order, then use two pointers approach where we try to pair the smallest available element with a suitable larger element.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

285 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