# Count number of triplets with product equal to given number

Given an array of distinct integers(considering only positive numbers) and a number â€˜mâ€™, find the number of triplets with product equal to â€˜mâ€™.

Examples:

Input : arr[] = { 1, 4, 6, 2, 3, 8}
m = 24
Output : 3
{1, 4, 6} {1, 3, 8} {4, 2, 3}

Input : arr[] = { 0, 4, 6, 2, 3, 8}
m = 18
Output : 0

A Naive approach is to consider each and every triplet one by one and count if their product is equal to m.

Implementation:

## C++

 `// C++ program to count triplets with given ``// product m ``#include ``using` `namespace` `std; `` ` `// Function to count such triplets ``int` `countTriplets(``int` `arr[], ``int` `n, ``int` `m) ``{ ``    ``int` `count = 0; `` ` `    ``// Consider all triplets and count if ``    ``// their product is equal to m ``    ``for` `(``int` `i = 0; i < n - 2; i++) ``        ``for` `(``int` `j = i + 1; j < n - 1; j++) ``            ``for` `(``int` `k = j + 1; k < n; k++) ``                ``if` `(arr[i] * arr[j] * arr[k] == m) ``                    ``count++; `` ` `    ``return` `count; ``} `` ` `// Drivers code ``int` `main() ``{ ``    ``int` `arr[] = { 1, 4, 6, 2, 3, 8 }; ``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ``    ``int` `m = 24; `` ` `    ``cout << countTriplets(arr, n, m); `` ` `    ``return` `0; ``}`

## Java

 `// Java program to count triplets with given ``// product m `` ` `class` `GFG { ``    ``// Method to count such triplets ``    ``static` `int` `countTriplets(``int` `arr[], ``int` `n, ``int` `m) ``    ``{ ``        ``int` `count = ``0``; `` ` `        ``// Consider all triplets and count if ``        ``// their product is equal to m ``        ``for` `(``int` `i = ``0``; i < n - ``2``; i++) ``            ``for` `(``int` `j = i + ``1``; j < n - ``1``; j++) ``                ``for` `(``int` `k = j + ``1``; k < n; k++) ``                    ``if` `(arr[i] * arr[j] * arr[k] == m) ``                        ``count++; `` ` `        ``return` `count; ``    ``} `` ` `    ``// Driver method ``    ``public` `static` `void` `main(String[] args) ``    ``{ ``        ``int` `arr[] = { ``1``, ``4``, ``6``, ``2``, ``3``, ``8` `}; ``        ``int` `m = ``24``; `` ` `        ``System.out.println(countTriplets(arr, arr.length, m)); ``    ``} ``} `

## Python3

 `# Python3 program to count  ``# triplets with given product m `` ` `# Method to count such triplets ``def` `countTriplets(arr, n, m): ``     ` `    ``count ``=` `0`` ` `    ``# Consider all triplets and count if ``    ``# their product is equal to m ``    ``for` `i ``in` `range` `(n ``-` `2``): ``        ``for` `j ``in` `range` `(i ``+` `1``, n ``-` `1``): ``            ``for` `k ``in` `range` `(j ``+` `1``, n): ``                ``if` `(arr[i] ``*` `arr[j] ``*` `arr[k] ``=``=` `m): ``                    ``count ``+``=` `1``    ``return` `count `` ` `# Driver code ``if` `__name__ ``=``=` `"__main__"``: ``   ` `    ``arr ``=` `[``1``, ``4``, ``6``, ``2``, ``3``, ``8``] ``    ``m ``=` `24``    ``print``(countTriplets(arr,  ``                        ``len``(arr), m)) `` ` `# This code is contributed by Chitranayal`

## C#

 `// C# program to count triplets  ``// with given product m ``using` `System; `` ` `public` `class` `GFG { ``     ` `    ``// Method to count such triplets ``    ``static` `int` `countTriplets(``int``[] arr, ``int` `n, ``int` `m) ``    ``{ ``        ``int` `count = 0; `` ` `        ``// Consider all triplets and count if ``        ``// their product is equal to m ``        ``for` `(``int` `i = 0; i < n - 2; i++) ``            ``for` `(``int` `j = i + 1; j < n - 1; j++) ``                ``for` `(``int` `k = j + 1; k < n; k++) ``                    ``if` `(arr[i] * arr[j] * arr[k] == m) ``                        ``count++; `` ` `        ``return` `count; ``    ``} `` ` `    ``// Driver method ``    ``public` `static` `void` `Main() ``    ``{ ``        ``int``[] arr = { 1, 4, 6, 2, 3, 8 }; ``        ``int` `m = 24; `` ` `        ``Console.WriteLine(countTriplets(arr, arr.Length, m)); ``    ``} ``} `` ` `// This code is contributed by Sam007 `

## PHP

 ` `

## Javascript

 ``

Output
`3`

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

An Efficient Method is to use Hashing.

1. Store all the elements in a hash_map with their index.
2. Consider all pairs(i, j) and check the following:
• If (arr[i]*arr[j] !=0 && (m % arr[i]*arr[j]) == 0), If yes, then search for ( m / (arr[i]*arr[j]) in the map.
• Also check m / (arr[i]*arr[j]) is not equal to arr[i] and arr[j].
• Also, check that the current triplet is not counted previously by using the index stored in the map.
• If all the above conditions are satisfied, then increment the count.
3. Return count.

Implementation:

## C++

 `// C++ program to count triplets with given ``// product m ``#include ``using` `namespace` `std; `` ` `// Function to count such triplets ``int` `countTriplets(``int` `arr[], ``int` `n, ``int` `m) ``{ ``    ``// Store all the elements in a set ``    ``unordered_map<``int``, ``int``> occ; ``    ``for` `(``int` `i = 0; i < n; i++) ``        ``occ[arr[i]] = i; `` ` `    ``int` `count = 0; `` ` `    ``// Consider all pairs and check for a ``    ``// third number so their product is equal to m ``    ``for` `(``int` `i = 0; i < n - 1; i++) { ``        ``for` `(``int` `j = i + 1; j < n; j++) { ``            ``// Check if current pair divides m or not ``            ``// If yes, then search for (m / arr[i]*arr[j]) ``            ``if` `((arr[i] * arr[j] <= m) && (arr[i] * arr[j] != 0) && (m % (arr[i] * arr[j]) == 0)) { ``                ``int` `check = m / (arr[i] * arr[j]); ``                ``auto` `it = occ.find(check); `` ` `                ``// Check if the third number is present ``                ``// in the map and it is not equal to any ``                ``// other two elements and also check if ``                ``// this triplet is not counted already ``                ``// using their indexes ``                ``if` `(check != arr[i] && check != arr[j] ``                    ``&& it != occ.end() && it->second > i ``                    ``&& it->second > j) ``                    ``count++; ``            ``} ``        ``} ``    ``} `` ` `    ``// Return number of triplets ``    ``return` `count; ``} `` ` `// Drivers code ``int` `main() ``{ ``    ``int` `arr[] = { 1, 4, 6, 2, 3, 8 }; ``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ``    ``int` `m = 24; `` ` `    ``cout << countTriplets(arr, n, m); `` ` `    ``return` `0; ``} `

## Java

 `// Java program to count triplets with given ``// product m `` ` `import` `java.util.HashMap; `` ` `class` `GFG { ``    ``// Method to count such triplets ``    ``static` `int` `countTriplets(``int` `arr[], ``int` `n, ``int` `m) ``    ``{ ``        ``// Store all the elements in a set ``        ``HashMap occ = ``new` `HashMap(n); ``        ``for` `(``int` `i = ``0``; i < n; i++) ``            ``occ.put(arr[i], i); `` ` `        ``int` `count = ``0``; `` ` `        ``// Consider all pairs and check for a ``        ``// third number so their product is equal to m ``        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) { ``            ``for` `(``int` `j = i + ``1``; j < n; j++) { ``                ``// Check if current pair divides m or not ``                ``// If yes, then search for (m / arr[i]*arr[j]) ``                ``if` `((arr[i] * arr[j] <= m) && (arr[i] * arr[j] != ``0``) && (m % (arr[i] * arr[j]) == ``0``)) { ``                    ``int` `check = m / (arr[i] * arr[j]); `` ` `                    ``occ.containsKey(check); `` ` `                    ``// Check if the third number is present ``                    ``// in the map and it is not equal to any ``                    ``// other two elements and also check if ``                    ``// this triplet is not counted already ``                    ``// using their indexes ``                    ``if` `(check != arr[i] && check != arr[j] ``                        ``&& occ.containsKey(check) && occ.get(check) > i ``                        ``&& occ.get(check) > j) ``                        ``count++; ``                ``} ``            ``} ``        ``} `` ` `        ``// Return number of triplets ``        ``return` `count; ``    ``} `` ` `    ``// Driver method ``    ``public` `static` `void` `main(String[] args) ``    ``{ ``        ``int` `arr[] = { ``1``, ``4``, ``6``, ``2``, ``3``, ``8` `}; ``        ``int` `m = ``24``; `` ` `        ``System.out.println(countTriplets(arr, arr.length, m)); ``    ``} ``} `

## Python3

 `# Python3 program for the above approach `` ` `# Function to find the triplet ``def` `countTriplets(li,product): ``    ``flag ``=` `0``    ``count ``=` `0``     ` `    ``# Consider all pairs and check  ``    ``# for a third number so their  ``    ``# product is equal to product ``    ``for` `i ``in` `range``(``len``(li)): ``         ` `        ``# Check if current pair  ``        ``# divides product or not ``        ``# If yes, then search for ``        ``# (product / li[i]*li[j]) ``        ``if` `li[i]!``=` `0` `and` `product ``%` `li[i] ``=``=` `0``: ``             ` `            ``for` `j ``in` `range``(i``+``1``, ``len``(li)): ``                ` `                ``# Check if the third number is present ``                ``# in the map and it is not equal to any ``                ``# other two elements and also check if ``                ``# this triplet is not counted already ``                ``# using their indexes ``                ``if` `li[j]!``=` `0` `and` `product ``%` `(li[j]``*``li[i]) ``=``=` `0``: ``                    ``if` `product ``/``/` `(li[j]``*``li[i]) ``in` `li: ``                     ` `                        ``n ``=` `li.index(product``/``/``(li[j]``*``li[i])) ``                     ` `                        ``if` `n > i ``and` `n > j: ``                            ``flag ``=` `1``                            ``count``+``=``1``    ``print``(count) ``    ` `# Driver code  ``li ``=` `[  ``1``, ``4``, ``6``, ``2``, ``3``, ``8` `] ``product ``=` `24`` ` `# Function call ``countTriplets(li,product) `

## C#

 `// C# implementation of the above  ``// approach  ``using` `System; ``using` `System.Collections.Generic;  ``class` `GFG{ ``     ` `// Method to count such triplets ``static` `int` `countTriplets(``int``[] arr,  ``                         ``int` `n, ``int` `m) ``{ ``  ``// Store all the elements  ``  ``// in a set ``  ``Dictionary<``int``,  ``             ``int``> occ = ``new` `Dictionary<``int``,  ``                                       ``int``>(n);   `` ` `  ``for` `(``int` `i = 0; i < n; i++) ``    ``occ.Add(arr[i], i); `` ` `  ``int` `count = 0; `` ` `  ``// Consider all pairs and  ``  ``// check for a third number  ``  ``// so their product is equal to m ``  ``for` `(``int` `i = 0; i < n - 1; i++)  ``  ``{ ``    ``for` `(``int` `j = i + 1; j < n; j++)  ``    ``{ ``      ``// Check if current pair divides  ``      ``// m or not If yes, then search  ``      ``// for (m / arr[i]*arr[j]) ``      ``if` `((arr[i] * arr[j] <= m) &&  ``          ``(arr[i] * arr[j] != 0) &&  ``          ``(m % (arr[i] * arr[j]) == 0))  ``      ``{ ``        ``int` `check = m / (arr[i] * arr[j]); `` ` `        ``//occ.containsKey(check); ``        ``// Check if the third number  ``        ``// is present in the map and  ``        ``// it is not equal to any ``        ``// other two elements and also  ``        ``// check if this triplet is not  ``        ``// counted already using their indexes ``        ``if` `(check != arr[i] &&  ``            ``check != arr[j] &&  ``            ``occ.ContainsKey(check) &&  ``            ``occ[check] > i &&  ``            ``occ[check] > j) ``          ``count++; ``      ``} ``    ``} ``  ``} `` ` `  ``// Return number of triplets ``  ``return` `count; ``} `` ` `// Driver code ``static` `void` `Main()  ``{ ``  ``int``[] arr = {1, 4, 6,  ``               ``2, 3, 8}; ``  ``int` `m = 24; ``  ``Console.WriteLine(countTriplets(arr,  ``                                  ``arr.Length, m)); ``} ``} `` ` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output
`3`

Time Complexity : O(n2
Auxiliary Space : O(n)

New Approach:- Another approach to solve this problem is to sort the array and then use two pointers to find the triplets whose product is equal to the given number.

Steps:-

1. Define a function named countTriplets that takes an integer array, the size of the array, and an integer m as arguments.
2. Sort the input array in ascending order using the built-in sort() function of C++.
3. Initialize a variable named count to 0.
4. For each element i in the array from index 0 to n-3:
*Set two pointers, left and right, to the next and last index of the remaining elements, respectively.
*While the left pointer is less than the right pointer:
*If the product of the element i, the element at the left pointer, and the element at the right pointer is equal to m, then increment the count and move the left pointer to the right and the right pointer to the left.
*Else, if the product is less than m, then move the left pointer to the right.
*Else, if the product is greater than m, then move the right pointer to the left.
5. Return the value of count.
6. Define the main function.
7. Declare an integer array named arr and initialize it with some values.
8. Calculate the size of the array and store it in an integer variable named n.
9. Define an integer variable named m and initialize it with a value of 24.
10. Call the countTriplets function with the arguments arr, n, and m and print the returned value.

Here’s the implementation:

## C++

 `// C++ program to count triplets with given ``// product m ``#include ``using` `namespace` `std; `` ` `// Function to count such triplets ``int` `countTriplets(``int` `arr[], ``int` `n, ``int` `m) ``{ ``    ``sort(arr, arr + n); ``// Sort the array ``    ``int` `count = 0; `` ` `    ``// Fix one number and use two pointers to find ``    ``// the other two numbers whose product is equal to m ``    ``for` `(``int` `i = 0; i < n - 2; i++) { ``        ``int` `left = i + 1, right = n - 1; ``        ``while` `(left < right) { ``            ``if` `(arr[i] * arr[left] * arr[right] == m) { ``                ``count++; ``                ``left++; ``                ``right--; ``            ``} ``            ``else` `if` `(arr[i] * arr[left] * arr[right] < m) ``                ``left++; ``            ``else``                ``right--; ``        ``} ``    ``} `` ` `    ``// Return number of triplets ``    ``return` `count; ``} `` ` `// Drivers code ``int` `main() ``{ ``    ``int` `arr[] = { 1, 4, 6, 2, 3, 8 }; ``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ``    ``int` `m = 24; ``    ``cout << countTriplets(arr, n, m); `` ` `    ``return` `0; ``}`

## Java

 `import` `java.util.Arrays; `` ` `public` `class` `CountTriplets { ``    ``// Function to count such triplets ``    ``public` `static` `int` `countTriplets(``int` `arr[], ``int` `n, ``int` `m) { ``        ``Arrays.sort(arr); ``// Sort the array ``        ``int` `count = ``0``; `` ` `        ``// Fix one number and use two pointers to find ``        ``// the other two numbers whose product is equal to m ``        ``for` `(``int` `i = ``0``; i < n - ``2``; i++) { ``            ``int` `left = i + ``1``, right = n - ``1``; ``            ``while` `(left < right) { ``                ``if` `(arr[i] * arr[left] * arr[right] == m) { ``                    ``count++; ``                    ``left++; ``                    ``right--; ``                ``} ``else` `if` `(arr[i] * arr[left] * arr[right] < m) ``                    ``left++; ``                ``else``                    ``right--; ``            ``} ``        ``} `` ` `        ``// Return number of triplets ``        ``return` `count; ``    ``} `` ` `    ``// Drivers code ``    ``public` `static` `void` `main(String[] args) { ``        ``int` `arr[] = { ``1``, ``4``, ``6``, ``2``, ``3``, ``8` `}; ``        ``int` `n = arr.length; ``        ``int` `m = ``24``; ``        ``System.out.println(countTriplets(arr, n, m)); ``    ``} ``} `

## Python3

 `def` `countTriplets(arr, n, m): ``    ``arr.sort()  ``# Sort the array ``    ``count ``=` `0`` ` `    ``# Fix one number and use two pointers to find ``    ``# the other two numbers whose product is equal to m ``    ``for` `i ``in` `range``(n ``-` `2``): ``        ``left ``=` `i ``+` `1``        ``right ``=` `n ``-` `1``        ``while` `left < right: ``            ``if` `arr[i] ``*` `arr[left] ``*` `arr[right] ``=``=` `m: ``                ``count ``+``=` `1``                ``left ``+``=` `1``                ``right ``-``=` `1``            ``elif` `arr[i] ``*` `arr[left] ``*` `arr[right] < m: ``                ``left ``+``=` `1``            ``else``: ``                ``right ``-``=` `1`` ` `    ``# Return number of triplets ``    ``return` `count `` ` `# Drivers code ``arr ``=` `[``1``, ``4``, ``6``, ``2``, ``3``, ``8``] ``n ``=` `len``(arr) ``m ``=` `24``print``(countTriplets(arr, n, m)) `

## C#

 `using` `System; `` ` `public` `class` `Program ``{ ``    ``// Function to count such triplets ``    ``static` `int` `CountTriplets(``int``[] arr, ``int` `n, ``int` `m) ``    ``{ ``        ``Array.Sort(arr); ``// Sort the array ``        ``int` `count = 0; `` ` `        ``// Fix one number and use two pointers to find ``        ``// the other two numbers whose product is equal to m ``        ``for` `(``int` `i = 0; i < n - 2; i++) ``        ``{ ``            ``int` `left = i + 1, right = n - 1; ``            ``while` `(left < right) ``            ``{ ``                ``if` `(arr[i] * arr[left] * arr[right] == m) ``                ``{ ``                    ``count++; ``                    ``left++; ``                    ``right--; ``                ``} ``                ``else` `if` `(arr[i] * arr[left] * arr[right] < m) ``                    ``left++; ``                ``else``                    ``right--; ``            ``} ``        ``} `` ` `        ``// Return number of triplets ``        ``return` `count; ``    ``} `` ` `    ``// Drivers code ``    ``static` `void` `Main() ``    ``{ ``        ``int``[] arr = { 1, 4, 6, 2, 3, 8 }; ``        ``int` `n = arr.Length; ``        ``int` `m = 24; ``        ``Console.WriteLine(CountTriplets(arr, n, m)); ``    ``} ``} `

## Javascript

 `// Function to count such triplets ``function` `countTriplets(arr, n, m) { ``  ``arr.sort((a, b) => a - b); ``// Sort the array ``  ``let count = 0; `` ` `  ``// Fix one number and use two pointers to find ``  ``// the other two numbers whose product is equal to m ``  ``for` `(let i = 0; i < n - 2; i++) { ``    ``let left = i + 1, right = n - 1; ``    ``while` `(left < right) { ``      ``if` `(arr[i] * arr[left] * arr[right] === m) { ``        ``count++; ``        ``left++; ``        ``right--; ``      ``} ``else` `if` `(arr[i] * arr[left] * arr[right] < m) ``        ``left++; ``      ``else``        ``right--; ``    ``} ``  ``} `` ` `  ``// Return number of triplets ``  ``return` `count; ``} `` ` `// Driver code ``const arr = [1, 4, 6, 2, 3, 8]; ``const n = arr.length; ``const m = 24; ``console.log(countTriplets(arr, n, m)); `

Output
`3`

Time Complexity:- The time complexity of this approach is O(n^2), which is better than the naive approach but worse than the hashing approach. However, this approach has the advantage of not requiring any extra space for storing the elements.

Auxiliary Space:- The auxiliary space of this code is O(1) because the space used is constant and does not depend on the size of the input array or the value of m. The only additional space used is for the variables i, left, right, and count, which require a constant amount of space regardless of the input. The sorting is done in-place, so it does not require any additional space. Therefore, the space complexity of this code is O(1).

Previous
Next