Count number of Inversion in a Binary Array

Last Updated : 13 Jan, 2023

Given a Binary Array arr[], the task is to count the number of inversions in it. The number of inversions in an array is the number of pairs of indices i, j such that i < j and a[i] > a[j].

Examples:

Input: arr[] = {1, 0, 1, 0, 0, 1, 0}
Output: 8
Explanation: Pairs of the index (i, j) are (0, 1), (0, 3), (0, 4), (0, 6), (2, 3), (2, 4), (2, 6), (5, 6).

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

Approach: Follow the below steps to solve the problem:

Initialize the variable count = 0, for storing the count of zeroes occur so far.
Ans, res = 0, for storing the number of inversions in an array.
Now, run a loop i from the last element of the array to the front.
And check, if arr[i] = 0, then, Increment count by 1.
Else, Add count in res.
Return res after executing the loop.

Below is the implementation of the above approach:

C++

   // C++ code to implement the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of
// inversions in the binary array
 
int solve(bool* arr, int N)
{
 
    // Initialize the variables
    int count = 0, res = 0;
 
    // Run a loop from back
    for (int i = N - 1; i >= 0; i--) {
 
        // arr[i] is 1
        if (arr[i]) {
            res += count;
        }
 
        // arr[i] is 0
        else {
            count++;
        }
    }
 
    // Return the resultant answer
    return res;
}
 
// Driver Code
int main()
{
 
    bool arr[] = { 1, 0, 1, 0, 0, 1, 0 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << solve(arr, N) << endl;
 
    bool arr2[] = { 1, 0 };
    int M = sizeof(arr2) / sizeof(arr2[0]);
    cout << solve(arr2, M) << endl;
    return 0;
}
 
  

Java

   // Java code to implement the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
  // Function to count the number of
  // inversions in the binary array
  public static int solve(boolean[] arr, int N)
  {
 
    // Initialize the variables
    int count = 0, res = 0;
 
    // Run a loop from back
    for (int i = N - 1; i >= 0; i--) {
 
      // arr[i] is 1
      if (arr[i]) {
        res += count;
      }
 
      // arr[i] is 0
      else {
        count++;
      }
    }
 
    // Return the resultant answer
    return res;
  }
 
  public static void main(String[] args)
  {
    boolean[] arr = { true,  false, true, false,
                     false, true,  false };
    int N = arr.length;
    System.out.println(solve(arr, N));
 
    boolean[] arr2 = { true, false };
    int M = arr2.length;
    System.out.println(solve(arr2, M));
  }
}
 
// This code is contributed by lokesh.
 
  

Python3

   # Python code for the above approach
# Function to count the number of
# inversions in the binary array
def solve(arr, N):
   
    # Initialize the variables
    count = 0
    res = 0
 
    # Run a loop from back
    for i in range(N-1, -1, -1):
        # arr[i] is 1
        if arr[i]:
            res += count
        # arr[i] is 0
        else:
            count += 1
 
    # Return the resultant answer
    return res
 
# Driver Code
arr1 = [1, 0, 1, 0, 0, 1, 0]
N = len(arr1)
print(solve(arr1, N))
 
arr2 = [1, 0]
M = len(arr2)
print(solve(arr2, M))
 
# This code is contributed by Potta Lokesh
 
  

C#

   // C# code to implement the approach
using System;
using System.Collections.Generic;
 
public class Gfg {
 
    static int solve(int[] arr, int N)
    {
     
        // Initialize the variables
        int count = 0, res = 0;
     
        // Run a loop from back
        for (int i = N - 1; i >= 0; i--) {
     
            // arr[i] is 1
            if (arr[i]==1) {
                res += count;
            }
     
            // arr[i] is 0
            else {
                count++;
            }
        }
     
        // Return the resultant answer
        return res;
    }
     
    // Driver Code
    public static void Main(string[] args)
    {
     
        int[] arr = { 1, 0, 1, 0, 0, 1, 0 };
        int N = arr.Length;
        Console.WriteLine(solve(arr, N));
       
        //Console.WriteLine("\n");
        int[] arr2 = { 1, 0 };
        int M = arr2.Length;
        Console.WriteLine(solve(arr2, M));
    }
}
 
// This code is contributed by poojaagarwal2.
 
  

Javascript

   // Function to count the number of
// inversions in the binary array
function solve(arr, N)
{
 
  // Initialize the variables
  let count = 0;
  let res = 0;
 
  // Run a loop from back
  for (let i = N - 1; i >= 0; i--) {
    // arr[i] is 1
    if (arr[i]) {
      res += count;
    }
    // arr[i] is 0
    else {
      count++;
    }
  }
 
  // Return the resultant answer
  return res;
}
 
// Test cases
console.log(solve([1, 0, 1, 0, 0, 1, 0], 7)); // Output: 4
console.log(solve([1, 0], 2)); // Output: 1
 
// This code is contributed by ksam24000
 
  