Count of Smaller Numbers After Self

Count of Smaller Numbers After Self - Problem

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

Given an integer array nums, return an integer array counts where counts[i] is the number of smaller elements to the right of nums[i].

For each element at index i, count how many elements with indices j > i satisfy nums[j] < nums[i].

Example:

Input: nums = [5,2,6,1]
Output: [2,1,1,0]

Explanation:

To the right of 5 there are 2 smaller elements (2 and 1)
To the right of 2 there is 1 smaller element (1)
To the right of 6 there is 1 smaller element (1)
To the right of 1 there are 0 smaller elements

Input & Output

Example 1 — Basic Case

$ Input: nums = [5,2,6,1]

› Output: [2,1,1,0]

💡 Note: To the right of 5 there are 2 smaller elements (2 and 1). To the right of 2 there is 1 smaller element (1). To the right of 6 there is 1 smaller element (1). To the right of 1 there are 0 smaller elements.

Example 2 — Single Element

$ Input: nums = [1]

› Output: [0]

💡 Note: There are no elements to the right of the single element, so count is 0.

Example 3 — Sorted Array

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

› Output: [0,0,0,0]

💡 Note: Array is sorted in ascending order, so no element has smaller elements to its right.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to use advanced data structures or divide-and-conquer to avoid O(n²) brute force. Best approach is merge sort with inversion counting achieving optimal Time: O(n log n), Space: O(n).

Common Approaches

✓ Binary Search with Sorted Array

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

Iterate from right to left, maintaining a sorted array of seen elements. For each element, use binary search to find insertion position which gives count of smaller elements.

Brute Force

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

For each element at index i, iterate through all elements from index i+1 to end and count how many are smaller than nums[i]. Store the count in result array.

Merge Sort with Counting

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

Modify merge sort to count inversions. During merge step, when an element from right subarray is smaller than left subarray element, it contributes to the count of all remaining elements in left subarray.

Binary Search with Sorted Array — Algorithm Steps

Process array from right to left
For each element, binary search in sorted array to find insertion position
The insertion position equals count of smaller elements
Insert current element to maintain sorted order

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from rightmost

Process array from right to left

Binary search position

Find where element would be inserted

Insert and continue

Insert element and move to next

Code -

solution.c — C

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

static int counts[100000];
static int nums[100000];

void merge(int* indices, int start, int mid, int end) {
    int temp[100000];
    for (int idx = start; idx <= end; idx++) {
        temp[idx - start] = indices[idx];
    }
    
    int i = 0, j = mid - start + 1, k = start;
    
    while (i <= mid - start && j <= end - start) {
        if (nums[temp[i]] <= nums[temp[j]]) {
            indices[k] = temp[i];
            i++;
        } else {
            indices[k] = temp[j];
            counts[temp[j]] += mid - start + 1 - i;
            j++;
        }
        k++;
    }
    
    while (i <= mid - start) {
        indices[k] = temp[i];
        i++;
        k++;
    }
    
    while (j <= end - start) {
        indices[k] = temp[j];
        j++;
        k++;
    }
}

void mergeSort(int* indices, int start, int end) {
    if (start >= end) {
        return;
    }
    
    int mid = (start + end) / 2;
    mergeSort(indices, start, mid);
    mergeSort(indices, mid + 1, end);
    merge(indices, start, mid, end);
}

int* solution(int* inputNums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    
    for (int i = 0; i < numsSize; i++) {
        nums[i] = inputNums[i];
        counts[i] = 0;
    }
    
    int indices[100000];
    for (int i = 0; i < numsSize; i++) {
        indices[i] = i;
    }
    
    mergeSort(indices, 0, numsSize - 1);
    
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        result[i] = counts[i];
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int numsInput[100000];
    int size = 0;
    char* token = strtok(line + 1, ",]]");
    while (token != NULL) {
        numsInput[size++] = (int)strtol(token, NULL, 10);
        token = strtok(NULL, ",]]");
    }
    
    int returnSize;
    int* result = solution(numsInput, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element we do O(log n) binary search but O(n) insertion, so overall O(n²)

⚡ Linearithmic

Space Complexity

O(n)

Need to maintain sorted array of seen elements

⚡ Linearithmic Space

98.4K Views

Medium Frequency

~35 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

Binary Search with Sorted Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler