Count of Smaller Numbers After Self - Practice Coding Problems

Count of Smaller Numbers After Self - Problem

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

Count of Smaller Numbers After Self

Imagine you're standing in a line with friends, and you want to know how many people behind you are shorter than you. This classic problem asks: given an integer array nums, return an array counts where counts[i] represents the number of elements to the right of position i that are smaller than nums[i].

For example, if nums = [5,2,6,1]:
• Position 0 (value 5): Elements [2,6,1] are to the right, and 2 of them (2,1) are smaller than 5
• Position 1 (value 2): Elements [6,1] are to the right, and 1 of them (1) is smaller than 2
• Position 2 (value 6): Elements [1] are to the right, and 1 of them (1) is smaller than 6
• Position 3 (value 1): No elements to the right, so 0

Result: [2,1,1,0]

This problem appears frequently in coding interviews and has multiple elegant solutions ranging from brute force to advanced data structures.

Input & Output

example_1.py — 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.py — All Decreasing

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

› Output: [5,4,3,2,1,0]

💡 Note: Since the array is decreasing, each element has all remaining elements to its right as smaller elements. Element 6 has 5 smaller elements to its right, element 5 has 4 smaller elements, and so on.

example_3.py — Single Element

$ Input: nums = [1]

› Output: [0]

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

Visualization

Tap to expand

Understanding the Visualization

Start from the rightmost

Begin with the last element - it has 0 elements to its right

Build sorted collection

As we move left, maintain a sorted list of elements we've seen

Binary search for position

For each new element, binary search tells us how many seen elements are smaller

Insert and continue

Add current element to sorted list and move to next position

Key Takeaway

🎯 Key Insight: Process from right-to-left while maintaining sorted order enables efficient counting through binary search, transforming an O(n²) problem into a more manageable solution.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan up to n-1 remaining elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only constant extra space besides the result array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
Array elements can be negative, positive, or zero
Duplicate elements are allowed

Asked in

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

The optimal approach uses binary search with a sorted list or advanced data structures like Binary Indexed Trees. Process elements from right to left, maintaining a sorted structure to efficiently count smaller elements. The binary search approach achieves O(n²) time in worst case due to insertions, while BIT/Segment Tree solutions achieve O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each element, scan all elements to its right and count smaller ones
Binary Search with Sorted List	O(n²)	O(n)	Process elements right-to-left, maintaining sorted list for binary search

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array with zeros
For each position i from 0 to n-1:
For each position j from i+1 to n-1:
If nums[j] < nums[i], increment count for position i
Store the count in result[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at first element

Compare element 5 with all elements to its right [2,6,1]

Count smaller elements

2 < 5 ✓, 6 < 5 ✗, 1 < 5 ✓ → count = 2

Move to next element

Compare element 2 with [6,1] → count = 1

Continue process

Repeat for all remaining elements

Code -

solution.c — C

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

int* countSmaller(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)calloc(numsSize, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        int count = 0;
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[j] < nums[i]) {
                count++;
            }
        }
        result[i] = count;
    }
    
    return result;
}

int main() {
    int nums[] = {5, 2, 6, 1};
    int numsSize = 4;
    int returnSize;
    
    int* result = countSmaller(nums, numsSize, &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 of n elements, we scan up to n-1 remaining elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only constant extra space besides the result array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
Array elements can be negative, positive, or zero
Duplicate elements are allowed

47.3K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler