JavaScript Program to Count Unequal Element Pairs from the Given Array

Last Updated : 29 Aug, 2024

Unequal element pairs in an array refer to pairs of distinct elements within the array that have different values. These pairs consist of two elements that are not equal to each other, highlighting their inequality when compared in the context of the array's values.

Examples:

Input: arr[] = {6, 5, 2, 3, 5, 2, 2, 1} 
Output: 2 
Explanation: (arr[1], arr[4]) and (arr[2], arr[5]) are the only possible pairs.
Input: arr[] = {1, 2, 3, 1, 2} 
Output: 2

Using Sort() method

In this approach, the function countUnequalPairs sorts the input array, and then iterates through unique elements. For each element, it compares with the rest of the array, counting unequal pairs. The result represents the count of unequal pairs.

Syntax

array.sort()

Example: This example shows the use of the above-explained approach.

JavaScript

const countUnequalPairs = (
    inputArray) => {
    inputArray.sort((a, b) => a - b);
    let unEqualPairsCount = 0;
    for (
        let i = 0;
        i < inputArray.length;) {
        let currentElement =
            inputArray[i];
        let j = i + 1;
        for (let num of inputArray.slice(j)) {
            if (
                num !== currentElement) {
                unEqualPairsCount++;
            }
        }
        i = j;}
    return unEqualPairsCount;
};

const testArray = [1, 1, 2];
console.log(
    countUnequalPairs(testArray)
);

Output

Using Hash Map

In this approach, we use a hash map (or an object in JavaScript) to count the occurrences of each element in the array. By leveraging the counts of each element, we can determine the number of unequal pairs efficiently.

JavaScript

function countUnequalPairs(arr) {
    const frequency = {};
    let totalPairs = 0;
    let unequalPairs = 0;

    // Step 1: Build frequency object
    for (const element of arr) {
        frequency[element] = (frequency[element] || 0) + 1;
    }

    // Step 2: Calculate total pairs
    for (const key in frequency) {
        totalPairs += frequency[key];
    }

    // Step 3: Calculate unequal pairs
    for (const key in frequency) {
        const count = frequency[key];
        unequalPairs += count * (totalPairs - count);
    }

    // Since each pair is counted twice, divide the result by 2
    return unequalPairs / 2;
}

// Example usage:
const arr1 = [6, 5, 2, 3, 5, 2, 2, 1];
console.log(countUnequalPairs(arr1)); // Output: 24

const arr2 = [1, 2, 3, 1, 2];
console.log(countUnequalPairs(arr2)); // Output: 8

Output

24
8

Using a Set to Count Unique Elements and Calculate Pairs

In this approach, we use a Set to count the occurrences of each unique element in the array. By leveraging the counts of each unique element, we can determine the number of unequal pairs efficiently without needing nested loops or sorting.

Example:

JavaScript

function countUnequalPairs(arr) {
  const elementCount = new Map();
  let totalPairs = 0;
  let totalElements = arr.length;

  arr.forEach(num => {
    if (elementCount.has(num)) {
      elementCount.set(num, elementCount.get(num) + 1);
    } else {
      elementCount.set(num, 1);
    }
  });

  elementCount.forEach(count => {
    totalPairs += count * (totalElements - count);
    totalElements -= count;
  });

  return totalPairs;
}
let arr1 = [6, 5, 2, 3, 5, 2, 2, 1];
console.log(countUnequalPairs(arr1)); 
let arr2 = [1, 2, 3, 1, 2];
console.log(countUnequalPairs(arr2));

Output

24
8

Using Single-Pass Approach (Optimized)

Use an efficient method to count unequal pairs in a single pass through the array, avoiding nested loops. This method Optimized for large arrays, avoiding nested loops for efficient performance.

Example:

JavaScript

function countUnequalPairs(arr) {
    const count = new Map();
    let totalPairs = 0;
    let totalElements = 0;

    for (const num of arr) {
        if (count.has(num)) {
            totalPairs += (totalElements - count.get(num));
            count.set(num, count.get(num) + 1);
        } else {
            count.set(num, 1);
            totalPairs += totalElements;
        }
        totalElements++;
    }

    return totalPairs;
}

let arr1 = [6, 5, 2, 3, 5, 2, 2, 1];
console.log(countUnequalPairs(arr1));

let arr2 = [1, 2, 3, 1, 2];
console.log(countUnequalPairs(arr2));

Output

24
8

Combinatorial Approach with Basic Array Operations

Calculate Total Pairs: Calculate the total number of possible pairs in the array using combinatorics.
Count Equal Pairs: Iterate through the array to count pairs where both elements are equal.
Compute Unequal Pairs: Subtract the count of equal pairs from the total pairs to get the number of unequal pairs.

Steps:

Calculate Total Pairs: Use the formula n(n−1)/2, where n is the length of the array, to find the total number of pairs.
Count Equal Pairs: Use nested loops to count the number of pairs with equal elements.
Subtract Equal Pairs: Subtract the count of equal pairs from the total pairs to get the number of unequal pairs.

Example:

JavaScript

function countUnequalPairs(arr) {
    const n = arr.length;
    let totalPairs = 0;
    let equalPairs = 0;

    // Calculate total number of pairs
    totalPairs = (n * (n - 1)) / 2;
    for (let i = 0; i < n; i++) {
        for (let j = i + 1; j < n; j++) {
            if (arr[i] === arr[j]) {
                equalPairs++;
            }
        }
    }
    const unequalPairs = totalPairs - equalPairs;
    return unequalPairs;
}
const arr1 = [6, 5, 2, 3, 5, 2, 2, 1];
const arr2 = [1, 2, 3, 1, 2];
console.log(countUnequalPairs(arr1)); 
console.log(countUnequalPairs(arr2));

Output

24
8

kohliami558i

Improve

Article Tags :

JavaScript Program to Count Unequal Element Pairs from the Given Array

Using Sort() method

Syntax

Using Hash Map

Using a Set to Count Unique Elements and Calculate Pairs

Using Single-Pass Approach (Optimized)

Combinatorial Approach with Basic Array Operations

Similar Reads

Thank You!

What kind of Experience do you want to share?