Skip to content
Related Articles

Related Articles

Improve Article

Count smaller elements present in the array for each array element

  • Last Updated : 11 Jun, 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[0](= 3) are {1, 1, 2}. Hence, the count is 3.
The elements which are smaller than arr[1](= 4) are {1, 1, 2, 3}. Hence, the count is 4.
The elements arr[2](= 1) and arr[3](= 1) are the smallest possible. Hence, the count is 0.
The elements which are smaller than arr[4](= 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 <bits/stdc++.h>
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[0]);
 
    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




<script>
 
// Javascript program for the above approach
 
// Function to count for each array
// element, the number of elements
// that are smaller than that element
function smallerNumbers(arr, N)
{
    var i;
    // Traverse the array
    for(i = 0; i < N; i++) {
 
        // Stores the count
        var count = 0;
 
        // Traverse the array
        for (j = 0; j < N; j++) {
 
            // Increment count
            if (arr[j] < arr[i]) {
                count += 1;
            }
        }
 
        // Print the count of smaller
        // elements for the current element
        document.write(count + " ");
    }
}
 
// Driver Code
    var arr = [3, 4, 1, 1, 2]
    var N = arr.length;
 
    smallerNumbers(arr, N);
 
</script>
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 <bits/stdc++.h>
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[100000] = { 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[0]);
 
    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[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)
        {
            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

Javascript




<script>
 
    // JavaScript program for the above approach
     
    // Function to count for each array
    // element, the number of elements
    // that are smaller than that element
    function smallerNumbers(arr, N)
    {
 
        // Stores the frequencies
        // of array elements
        let hash = new Array(100000);
        hash.fill(0);
 
        // Traverse the array
        for(let i = 0; i < N; i++)
 
            // Update frequency of arr[i]
            hash[arr[i]]++;
 
        // Initialize sum with 0
        let sum = 0;
 
        // Compute prefix sum of the array hash[]
        for(let i = 1; i < 100000; i++)
        {
            hash[i] += hash[i - 1];
        }
 
        // Traverse the array arr[]
        for(let i = 0; i < N; i++)
        {
 
            // If current element is 0
            if (arr[i] == 0)
            {
                document.write("0" + "</br>");
                continue;
            }
 
            // Print the resultant count
            document.write(hash[arr[i] - 1] + " ");
        }
    }
     
    let arr = [ 3, 4, 1, 1, 2 ];
    let N = arr.length;
  
    smallerNumbers(arr, N);
     
</script>
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 DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up