Reverse Pairs - Practice Coding Problems

Reverse Pairs - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

Reverse Pairs is a challenging array problem that tests your ability to count special inversions efficiently.

Given an integer array nums, you need to find the number of reverse pairs in the array. A reverse pair is defined as a pair of indices (i, j) where:

0 ≤ i < j < nums.length (i comes before j)
nums[i] > 2 * nums[j] (the first element is more than twice the second)

For example, in the array [1, 3, 2, 3, 1], we have reverse pairs at indices (1,4) because 3 > 2*1 = 2 and (3,4) because 3 > 2*1 = 2.

Your task: Return the total count of such reverse pairs.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The reverse pairs are (1,4) and (3,4). At index 1, nums[1]=3 and nums[4]=1, so 3 > 2*1 = 2. At index 3, nums[3]=3 and nums[4]=1, so 3 > 2*1 = 2.

example_2.py — No Pairs

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

› Output: 3

💡 Note: The reverse pairs are (1,4), (2,4), and (3,4). nums[1]=4 > 2*1=2, nums[2]=3 > 2*1=2, and nums[3]=5 > 2*1=2.

example_3.py — Single Element

$ Input: [1]

› Output: 0

💡 Note: With only one element, there are no pairs possible, so the answer is 0.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Watch out for integer overflow when computing 2 * nums[j]

Visualization

Tap to expand

Understanding the Visualization

Divide Phase

Split the array recursively into smaller subarrays, like creating tournament brackets

Conquer Phase

Process the smallest subarrays first and work your way up

Count Cross-pairs

When merging two sorted halves, count pairs where left element > 2 * right element

Merge Phase

Combine the sorted halves while maintaining the total count

Key Takeaway

🎯 Key Insight: By using merge sort's divide-and-conquer structure, we can count reverse pairs efficiently in O(n log n) time, much better than the O(n²) brute force approach.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a modified merge sort approach with O(n log n) time complexity. The key insight is to count reverse pairs during the merge process of divide-and-conquer, making it much more efficient than the O(n²) brute force approach. During each merge step, we can count cross-inversions between sorted halves in linear time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair (i,j) where i < j
Modified Merge Sort (Optimal)	O(n log n)	O(n)	Use divide-and-conquer with merge sort to count pairs efficiently

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each index i from 0 to n-2
For each i, iterate through index j from i+1 to n-1
Check if nums[i] > 2 * nums[j]
If condition is met, increment the count
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Compare nums[0] with all elements after it

Move to second element

Compare nums[1] with all elements after it

Continue pattern

Repeat for each element until end

Count valid pairs

Increment counter when nums[i] > 2 * nums[j]

Code -

solution.c — C

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

int reversePairs(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if ((long long)nums[i] > 2LL * nums[j]) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", reversePairs(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops: outer loop runs n times, inner loop runs up to n times, giving us n×n = n² operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store count and loop indices

✓ Linear Space

58.0K Views

Medium Frequency

~25 min Avg. Time

2.2K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler