Count quadruples (i, j, k, l) in an array such that i < j < k < l and arr[i] = arr[k] and arr[j] = arr[l]

0 0 5 minutes read

Given an array arr[] consisting of N integers, the task is to count the number of tuples (i, j, k, l) from the given array such that i < j < k < l and arr[i] = arr[k] and arr[j] = arr[l].

Examples:

Input: arr[] = {1, 2, 1, 2, 2, 2}
Output: 4
Explanation:
The tuples which satisfy the given condition are:
1) (0, 1, 2, 3) since arr[0] = arr[2] = 1 and arr[1] = arr[3] = 2
2) (0, 1, 2, 4) since arr[0] = arr[2] = 1 and arr[1] = arr[4] = 2
3) (0, 1, 2, 5) since arr[0] = arr[2] = 1 and arr[1] = arr[5] = 2
4) (1, 3, 4, 5) since arr[1] = arr[4] = 2 and arr[3] = arr[5] = 2

Input: arr[] = {2, 5, 2, 2, 5, 4}
Output: 2

Naive Approach: The simplest approach is to generate all the possible quadruples and check if the given condition holds true. If found to be true, then increase the final count. Print the final count obtained.

Time Complexity: O(N⁴)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use Hashing. Below are the steps:

For each index j iterate to find a pair of indices (j, l) such that arr[j] = arr[l] and j < l.
Use a hash table to keep count of the frequency of all array elements present in the indices [0, j – 1].
While traversing through index j to l, simply add the frequency of each element between j and l to the final count.
Repeat this process for every such possible pair of indices (j, l).
Print the total count of quadruples after the above steps.

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 total number
// of required tuples
int countTuples(int arr[], int N)
{
    int ans = 0, val = 0;
 
    // Initialize unordered map
    unordered_map<int, int> freq;
 
    for (int j = 0; j < N - 2; j++) {
        val = 0;
 
        // Find the pairs (j, l) such
        // that arr[j] = arr[l] and j < l
        for (int l = j + 1; l < N; l++) {
 
            // elements are equal
            if (arr[j] == arr[l]) {
 
                // Update the count
                ans += val;
            }
 
            // Add the frequency of
            // arr[l] to val
            val += freq[arr[l]];
        }
 
        // Update the frequency of
        // element arr[j]
        freq[arr[j]]++;
    }
 
    // Return the answer
    return ans;
}
 
// Driver code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, 1, 2, 2, 2 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << countTuples(arr, N);
 
    return 0;
}

Java

// Java program for 
// the above approach
import java.util.*;
class GFG{
 
// Function to count total number
// of required tuples
static int countTuples(int arr[], 
                       int N)
{
  int ans = 0, val = 0;
 
  // Initialize unordered map
  HashMap<Integer,
          Integer> freq = new HashMap<Integer,
                                      Integer>();
 
  for (int j = 0; j < N - 2; j++) 
  {
    val = 0;
 
    // Find the pairs (j, l) such
    // that arr[j] = arr[l] and j < l
    for (int l = j + 1; l < N; l++) 
    {
      // elements are equal
      if (arr[j] == arr[l]) 
      {
        // Update the count
        ans += val;
      }
 
      // Add the frequency of
      // arr[l] to val
      if(freq.containsKey(arr[l]))
        val += freq.get(arr[l]);
    }
 
    // Update the frequency of
    // element arr[j]
    if(freq.containsKey(arr[j]))
    {
      freq.put(arr[j], freq.get(arr[j]) + 1);
    }
    else
    {
      freq.put(arr[j], 1);
    }
  }
 
  // Return the answer
  return ans;
}
 
// Driver code
public static void main(String[] args)
{
  // Given array arr[]
  int arr[] = {1, 2, 1, 2, 2, 2};
  int N = arr.length;
 
  // Function Call
  System.out.print(countTuples(arr, N));
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python3 program for the above approach
 
# Function to count total number
# of required tuples
def countTuples(arr, N):
     
    ans = 0
    val = 0
 
    # Initialize unordered map
    freq = {}
 
    for j in range(N - 2):
        val = 0
 
        # Find the pairs (j, l) such
        # that arr[j] = arr[l] and j < l
        for l in range(j + 1, N):
 
            # Elements are equal
            if (arr[j] == arr[l]):
 
                # Update the count
                ans += val
 
            # Add the frequency of
            # arr[l] to val
            if arr[l] in freq:
                val += freq[arr[l]]
 
        # Update the frequency of
        # element arr[j]
        freq[arr[j]] = freq.get(arr[j], 0) + 1
 
    # Return the answer
    return ans
 
# Driver code
if __name__ == '__main__':
     
    # Given array arr[]
    arr = [ 1, 2, 1, 2, 2, 2 ]
 
    N = len(arr)
 
    # Function call
    print(countTuples(arr, N))
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to count total number
// of required tuples
static int countTuples(int []arr, 
                       int N)
{
    int ans = 0, val = 0;
     
    // Initialize unordered map
    Dictionary<int,
               int> freq = new Dictionary<int,
                                          int>();
     
    for(int j = 0; j < N - 2; j++) 
    {
        val = 0;
         
        // Find the pairs (j, l) such
        // that arr[j] = arr[l] and j < l
        for(int l = j + 1; l < N; l++) 
        {
             
            // Elements are equal
            if (arr[j] == arr[l]) 
            {
                 
                // Update the count
                ans += val;
            }
             
            // Add the frequency of
            // arr[l] to val
            if (freq.ContainsKey(arr[l]))
                val += freq[arr[l]];
        }
         
        // Update the frequency of
        // element arr[j]
        if (freq.ContainsKey(arr[j]))
        {
            freq[arr[j]] = freq[arr[j]] + 1;
        }
        else
        {
            freq.Add(arr[j], 1);
        }
    }
     
    // Return the answer
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
     
    // Given array []arr
    int []arr = { 1, 2, 1, 2, 2, 2 };
    int N = arr.Length;
     
    // Function call
    Console.Write(countTuples(arr, N));
}
}
 
// This code is contributed by Amit Katiyar

Javascript

<script>
 
// Javascript program for the above approach
 
// Function to count total number
// of required tuples
function countTuples(arr, N)
{
    var ans = 0, val = 0;
 
    // Initialize unordered map
    var freq = new Map();
 
    for(var j = 0; j < N - 2; j++) 
    {
        val = 0;
 
        // Find the pairs (j, l) such
        // that arr[j] = arr[l] and j < l
        for(var l = j + 1; l < N; l++) 
        {
             
            // Elements are equal
            if (arr[j] == arr[l])
            {
                 
                // Update the count
                ans += val;
            }
 
            // Add the frequency of
            // arr[l] to val
            if (freq.has(arr[l]))
            {
                val += freq.get(arr[l]);
            }
        }
 
        // Update the frequency of
        // element arr[j]
        if (freq.has(arr[j]))
        {
            freq.set(arr[j], freq.get(arr[j]) + 1);
        }
        else
        {
            freq.set(arr[j], 1);
        }
    }
 
    // Return the answer
    return ans;
}
 
// Driver code
 
// Given array arr[]
var arr = [ 1, 2, 1, 2, 2, 2 ];
var N = arr.length;
 
// Function Call
document.write(countTuples(arr, N));
 
// This code is contributed by rutvik_56
 
</script>

Output:

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

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!