Related Articles
Count smaller elements present in the array for each array element
• Last Updated : 28 Apr, 2021

Given an array arr[] consisting of N integers, the task is for each array element, say arr[i], is to find the number of array elements that are smaller than arr[i].

Examples:

Input: arr[] = {3, 4, 1, 1, 2}
Output: 3 4 0 0 2
Explanation:
The elements which are smaller than arr(= 3) are {1, 1, 2}. Hence, the count is 3.
The elements which are smaller than arr(= 4) are {1, 1, 2, 3}. Hence, the count is 4.
The elements arr(= 1) and arr(= 1) are the smallest possible. Hence, the count is 0.
The elements which are smaller than arr(= 2) are {1, 1}. Hence, the count is 2.

Input: arr[] = {1, 2, 3, 4}
Output: 0 1 2 3

Naive Approach: The simplest approach is to traverse the array and for each array element, count the number of array elements that are smaller than them and print the counts obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count for each array``// element, the number of elements``// that are smaller than that element``void` `smallerNumbers(``int` `arr[], ``int` `N)``{``    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Stores the count``        ``int` `count = 0;` `        ``// Traverse the array``        ``for` `(``int` `j = 0; j < N; j++) {` `            ``// Increment count``            ``if` `(arr[j] < arr[i]) {``                ``count++;``            ``}``        ``}` `        ``// Print the count of smaller``        ``// elements for the current element``        ``cout << count << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 4, 1, 1, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``smallerNumbers(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to count for each array``// element, the number of elements``// that are smaller than that element``static` `void` `smallerNumbers(``int` `arr[], ``int` `N)``{``    ` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Stores the count``        ``int` `count = ``0``;` `        ``// Traverse the array``        ``for``(``int` `j = ``0``; j < N; j++)``        ``{``            ` `            ``// Increment count``            ``if` `(arr[j] < arr[i])``            ``{``                ``count++;``            ``}``        ``}` `        ``// Print the count of smaller``        ``// elements for the current element``        ``System.out.print(count + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``3``, ``4``, ``1``, ``1``, ``2` `};``    ``int` `N = arr.length;` `    ``smallerNumbers(arr, N);``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to count for each array``# element, the number of elements``# that are smaller than that element``def` `smallerNumbers(arr, N):` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# Stores the count``        ``count ``=` `0` `        ``# Traverse the array``        ``for` `j ``in` `range``(N):` `            ``# Increment count``            ``if` `(arr[j] < arr[i]):``                ``count ``+``=` `1` `        ``# Print the count of smaller``        ``# elements for the current element``        ``print``(count, end``=``" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``3``, ``4``, ``1``, ``1``, ``2``]``    ``N ``=` `len``(arr)` `    ``smallerNumbers(arr, N)` `    ``# This code is contributed by ukasp.`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{` `  ``// Function to count for each array``  ``// element, the number of elements``  ``// that are smaller than that element``  ``static` `void` `smallerNumbers(``int``[] arr, ``int` `N)``  ``{` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{` `      ``// Stores the count``      ``int` `count = 0;` `      ``// Traverse the array``      ``for``(``int` `j = 0; j < N; j++)``      ``{` `        ``// Increment count``        ``if` `(arr[j] < arr[i])``        ``{``          ``count++;``        ``}``      ``}` `      ``// Print the count of smaller``      ``// elements for the current element``      ``Console.Write(count + ``" "``);``    ``}``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main()``  ``{``    ``int``[] arr = { 3, 4, 1, 1, 2 };``    ``int` `N = arr.Length;` `    ``smallerNumbers(arr, N);``  ``}``}` `// This code is contributed by sanjoy_62,`

## Javascript

 ``
Output:
`3 4 0 0 2`

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using Hashing. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count for each array``// element, the number of elements``// that are smaller than that element``void` `smallerNumbers(``int` `arr[], ``int` `N)``{``    ``// Stores the frequencies``    ``// of array elements``    ``int` `hash = { 0 };` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++)` `        ``// Update frequency of arr[i]``        ``hash[arr[i]]++;` `    ``// Initialize sum with 0``    ``int` `sum = 0;` `    ``// Compute prefix sum of the array hash[]``    ``for` `(``int` `i = 1; i < 100000; i++) {``        ``hash[i] += hash[i - 1];``    ``}` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If current element is 0``        ``if` `(arr[i] == 0) {``            ``cout << ``"0"``;``            ``continue``;``        ``}` `        ``// Print the resultant count``        ``cout << hash[arr[i] - 1]``             ``<< ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 4, 1, 1, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``smallerNumbers(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to count for each array``// element, the number of elements``// that are smaller than that element``static` `void` `smallerNumbers(``int` `arr[], ``int` `N)``{``    ` `    ``// Stores the frequencies``    ``// of array elements``    ``int` `hash[] = ``new` `int``[``100000``];` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)` `        ``// Update frequency of arr[i]``        ``hash[arr[i]]++;` `    ``// Initialize sum with 0``    ``int` `sum = ``0``;` `    ``// Compute prefix sum of the array hash[]``    ``for``(``int` `i = ``1``; i < ``100000``; i++)``    ``{``        ``hash[i] += hash[i - ``1``];``    ``}` `    ``// Traverse the array arr[]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// If current element is 0``        ``if` `(arr[i] == ``0``)``        ``{``            ``System.out.println(``"0"``);``            ``continue``;``        ``}` `        ``// Print the resultant count``        ``System.out.print(hash[arr[i] - ``1``] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``3``, ``4``, ``1``, ``1``, ``2` `};``    ``int` `N = arr.length;` `    ``smallerNumbers(arr, N);``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to count for each array``# element, the number of elements``# that are smaller than that element``def` `smallerNumbers(arr, N):` `    ``# Stores the frequencies``    ``# of array elements``    ``hash` `=` `[``0``] ``*` `100000` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# Update frequency of arr[i]``        ``hash``[arr[i]] ``+``=` `1` `    ``# Initialize sum with 0``    ``sum` `=` `0` `    ``# Compute prefix sum of the array hash[]``    ``for` `i ``in` `range``(``1``, ``100000``):``        ``hash``[i] ``+``=` `hash``[i ``-` `1``]` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):` `        ``# If current element is 0``        ``if` `(arr[i] ``=``=` `0``):``            ``print``(``"0"``)``            ``continue` `        ``# Print the resultant count``        ``print``(``hash``[arr[i] ``-` `1``], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[ ``3``, ``4``, ``1``, ``1``, ``2` `]``    ``N ``=` `len``(arr)` `    ``smallerNumbers(arr, N)` `# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to count for each array``// element, the number of elements``// that are smaller than that element``static` `void` `smallerNumbers(``int` `[]arr, ``int` `N)``{``    ` `    ``// Stores the frequencies``    ``// of array elements``    ``int` `[]hash = ``new` `int``;` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ` `        ``// Update frequency of arr[i]``        ``hash[arr[i]]++;` `    ``// Initialize sum with 0``    ``//int sum = 0;` `    ``// Compute prefix sum of the array hash[]``    ``for``(``int` `i = 1; i < 100000; i++)``    ``{``        ``hash[i] += hash[i - 1];``    ``}` `    ``// Traverse the array arr[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// If current element is 0``        ``if` `(arr[i] == 0)``        ``{``            ``Console.WriteLine(``"0"``);``            ``continue``;``        ``}` `        ``// Print the resultant count``        ``Console.Write(hash[arr[i] - 1] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `[]arr = { 3, 4, 1, 1, 2 };``    ``int` `N = arr.Length;` `    ``smallerNumbers(arr, N);``}``}` `// This code is contributed by AnkThon`
Output:
`3 4 0 0 2`

Time Complexity: O(N)
Auxiliary Space: O(105)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up