How Many Numbers Are Smaller Than the Current Number

How Many Numbers Are Smaller Than the Current Number - Problem

Given an array nums, your task is to find out how many numbers are smaller than each element in the array.

For each element nums[i], count how many elements in the array have values strictly less than nums[i]. Note that we don't count the element itself - only other elements that are smaller.

Goal: Return an array where each position contains the count of smaller numbers for the corresponding element in the input array.

Example: If nums = [8,1,2,2,3], then:
• For 8: numbers 1,2,2,3 are smaller → count = 4
• For 1: no numbers are smaller → count = 0
• For 2: number 1 is smaller → count = 1
• For 2: number 1 is smaller → count = 1
• For 3: numbers 1,2,2 are smaller → count = 3
Result: [4,0,1,1,3]

Input & Output

example_1.py — Basic case

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

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

💡 Note: For 8: elements 1,2,2,3 are smaller (count=4). For first 1: no elements are smaller (count=0). For first 2: element 1 is smaller (count=1). For second 2: element 1 is smaller (count=1). For 3: elements 1,2,2 are smaller (count=3).

example_2.py — All same elements

$ Input: nums = [6,5,4,8]

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

💡 Note: For 6: elements 5,4 are smaller (count=2). For 5: element 4 is smaller (count=1). For 4: no elements are smaller (count=0). For 8: elements 6,5,4 are smaller (count=3).

example_3.py — Single element

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

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

💡 Note: All elements are equal, so no element is smaller than any other element. Each element has 0 elements smaller than it.

Visualization

Tap to expand

Understanding the Visualization

Collect All Scores

Each student reports their score: [8,1,2,2,3]

Count Frequency

Tally how many students got each score: 1→1 student, 2→2 students, 3→1 student, 8→1 student

Calculate Rankings

For each score, sum up students who scored lower: 1→0 lower, 2→1 lower, 3→3 lower, 8→4 lower

Assign Results

Each student gets their ranking: [4,0,1,1,3]

Key Takeaway

🎯 Key Insight: By using frequency counting, we transform an O(n²) problem into O(n + k²) or even O(n + k) with counting sort, dramatically improving efficiency for arrays with many duplicate values.

Time & Space Complexity

Time Complexity

⏱️

O(n + k²)

n for frequency count + k² for building smaller count map where k is unique numbers

✓ Linear Growth

Space Complexity

O(k)

Space for frequency map and smaller count map where k is number of unique elements

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 500
0 ≤ nums[i] ≤ 100
Follow-up: Can you solve it in O(n + k) time where k is the range of input values?

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 Apple 12

The optimal approach uses frequency counting to avoid redundant comparisons. First count the frequency of each number, then for each unique number, calculate how many total numbers are smaller by summing frequencies of smaller values. This reduces time complexity from O(n²) to O(n + k²) where k is the number of unique elements, and with counting sort optimization can achieve O(n + k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass with Frequency Count	O(n + k²)	O(k)	Count frequencies first, then calculate cumulative smaller counts
Brute Force (Nested Loops)	O(n²)	O(1)	Compare each element with every other element to count smaller ones
Sorting + Binary Search	O(n log n)	O(n)	Sort array with indices, then binary search for smaller elements count

Two-Pass with Frequency Count — Algorithm Steps

Create frequency map counting occurrences of each number
Create a smaller count map for each unique number
For each unique number, count how many other numbers are smaller
Build result array using the smaller count map

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency map of all numbers

Sort Unique Numbers

Get sorted list of unique numbers

Calculate Smaller Counts

For each number, sum frequencies of smaller numbers

Build Result

Map each original element to its smaller count

Code -

solution.c — C

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

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

int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    // Count frequencies (assuming values 0-100 based on typical constraints)
    int freq[101] = {0};
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
    }
    
    // Calculate smaller counts
    int smallerCount[101] = {0};
    for (int i = 0; i <= 100; i++) {
        if (freq[i] > 0) {
            int count = 0;
            for (int j = 0; j < i; j++) {
                count += freq[j];
            }
            smallerCount[i] = count;
        }
    }
    
    // Build result
    for (int i = 0; i < numsSize; i++) {
        result[i] = smallerCount[nums[i]];
    }
    
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c); // skip '['
    
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    int returnSize;
    int* result = smallerNumbersThanCurrent(nums, n, &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 + k²)

n for frequency count + k² for building smaller count map where k is unique numbers

✓ Linear Growth

Space Complexity

O(k)

Space for frequency map and smaller count map where k is number of unique elements

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 500
0 ≤ nums[i] ≤ 100
Follow-up: Can you solve it in O(n + k) time where k is the range of input values?

95.0K Views

Medium Frequency

~15 min Avg. Time

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

Two-Pass with Frequency Count — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler