Find the Maximum Number of Marked Indices

Find the Maximum Number of Marked Indices - Problem

Imagine you're organizing pairs of numbers where one number is at least double the other! You have an array of integers, and your goal is to create as many valid pairs as possible.

The Challenge: Given a 0-indexed integer array nums, you need to find the maximum number of indices you can mark by pairing them strategically.

Pairing Rule: You can pick two different unmarked indices i and j where 2 * nums[i] ≤ nums[j], then mark both indices. This means nums[j] must be at least twice as large as nums[i].

Goal: Return the maximum possible number of marked indices. Since each successful pairing marks 2 indices, you want to maximize the number of valid pairs you can form.

Example: In array [3, 5, 2, 4], you can pair index 2 (value 2) with index 1 (value 5) since 2 * 2 ≤ 5, marking 2 indices total.

Input & Output

example_1.py — Basic Pairing

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

› Output: 2

💡 Note: We can pair index 2 (value 2) with index 1 (value 5) since 2 * 2 = 4 ≤ 5. This marks 2 indices. We cannot form any more pairs with the remaining elements [3,4] since 2 * 3 = 6 > 4.

example_2.py — Multiple Pairs

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

› Output: 4

💡 Note: After sorting: [1,2,3,4]. We can pair 1 with 2 (since 2*1=2 ≤ 2), and pair 3 with 4 (since 2*3=6 > 4, but we can't pair them). Actually, we pair 1 with 3 and 2 with 4, marking all 4 indices.

example_3.py — No Valid Pairs

$ Input: [1,1]

› Output: 2

💡 Note: We can pair the two 1's together since 2 * 1 = 2 ≥ 1. Both indices get marked, so the answer is 2.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
nums.length is always even (important for optimal pairing)

Visualization

Tap to expand

Understanding the Visualization

Line Up Dancers

Sort all dancers by height from shortest to tallest

Greedy Pairing

Always pair the shortest available dancer with the shortest compatible tall dancer

Maximize Pairs

This greedy strategy ensures we get the maximum number of dance pairs possible

Key Takeaway

🎯 Key Insight: The greedy approach of pairing the smallest unused number with the smallest valid partner (that's at least twice as large) guarantees the maximum number of pairs. This works because using a larger partner wastes future pairing opportunities.

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 29

The optimal approach uses a greedy two-pointer strategy after sorting. The key insight is that we should always try to pair the smallest available number with the smallest number that's at least twice as large. This greedy approach guarantees maximum pairings because using a larger partner for a small number wastes the opportunity to pair that larger number with an even larger partner later.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n)	O(n)	Sort array, then use binary search to find optimal partners for each element
Two Pointers (Greedy Optimal)	O(n log n)	O(1)	Sort array and greedily pair smallest with smallest valid partner
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try all possible pairing combinations using backtracking

Sorting + Binary Search — Algorithm Steps

Sort the array in ascending order
Create a boolean array to track used elements
For each unused element in first half of array
Binary search for smallest unused element that's ≥ 2*current
If found, mark both elements as used and increment pair count
Return total number of marked indices (pairs * 2)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Track

Sort array and track original indices

Pick Element

Choose next unused element to find partner for

Binary Search

Search for smallest element ≥ 2*current

Mark Pair

Mark both elements as used if valid partner found

Code -

solution.c — C

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

typedef struct {
    int value;
    int index;
} IndexedNum;

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

int findMaximumMarks(int* nums, int n) {
    IndexedNum* indexedNums = (IndexedNum*)malloc(n * sizeof(IndexedNum));
    for (int i = 0; i < n; i++) {
        indexedNums[i].value = nums[i];
        indexedNums[i].index = i;
    }
    
    qsort(indexedNums, n, sizeof(IndexedNum), compare);
    bool* used = (bool*)calloc(n, sizeof(bool));
    int pairs = 0;
    
    for (int i = 0; i < n; i++) {
        if (used[i]) continue;
        
        long long target = 2LL * indexedNums[i].value;
        int left = i + 1, right = n - 1;
        int partnerIdx = -1;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            if (!used[mid] && indexedNums[mid].value >= target) {
                partnerIdx = mid;
                right = mid - 1;
            } else if (indexedNums[mid].value < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        if (partnerIdx != -1) {
            used[i] = used[partnerIdx] = true;
            pairs++;
        }
    }
    
    free(indexedNums);
    free(used);
    return pairs * 2;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c);
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    printf("%d\n", findMaximumMarks(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting is O(n log n), and we do binary search O(log n) for each of n/2 elements

⚡ Linearithmic

Space Complexity

O(n)

Additional boolean array to track used elements

⚡ Linearithmic Space

43.2K Views

Medium Frequency

~18 min Avg. Time

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

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler