How Many Numbers Are Smaller Than the Current Number - Problem

Given an array nums, for each nums[i] find out how many numbers in the array are smaller than it.

That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i].

Return the answer in an array.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: For 8: numbers 2,6,7,1,3 are smaller → count=4. For 2: only 1 is smaller → count=1. For 6: numbers 2,1,3 are smaller → count=3. For 7: numbers 2,6,1,3 are smaller → count=4. For 1: no numbers are smaller → count=0. For 3: numbers 2,1 are smaller → count=2.

Example 2 — Duplicate Values

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

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

💡 Note: For 6: numbers 5,4 are smaller → count=2. For 5: only 4 is smaller → count=1. For 4: no numbers are smaller → count=0. For 8: numbers 6,5,4 are smaller → count=3.

Example 3 — All Same Values

$ 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 count is 0.

Constraints

2 ≤ nums.length ≤ 500
0 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 Apple 8

The key insight is to count how many elements are smaller than each element. The brute force approach compares each element with all others in O(n²) time. The optimal sorting approach sorts the array first, then uses binary search to find positions efficiently in O(n log n) time, O(n) space.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force

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

For each number in the array, iterate through all other numbers and count how many are smaller. This is the most straightforward approach but inefficient for large arrays.

Frequency Counting

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

First count how many times each number appears, then for each element, sum up the frequencies of all numbers smaller than it. This avoids redundant comparisons by preprocessing the data.

Sort with Index Mapping

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

Create pairs of (value, original_index), sort by value, then for each element find its position in sorted array to determine how many elements are smaller. Handle duplicates carefully.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

void solution(int* nums, int numsSize, int* result) {
    for (int i = 0; i < numsSize; i++) {
        int count = 0;
        for (int j = 0; j < numsSize; j++) {
            if (j != i && nums[j] < nums[i]) {
                count++;
            }
        }
        result[i] = count;
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endptr;
        arr[(*size)++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Handle empty array
    if (strstr(input, "[]")) {
        printf("[]\n");
        return 0;
    }
    
    int nums[100];
    int size = 0;
    parseArray(input, nums, &size);
    
    int result[100];
    solution(nums, size, result);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.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