Count number of triplets with product equal to given number with duplicates allowed

<script>

// Javascript program for above implementation 

// The target value for which 
// we have to find the solution 
var target = 93;

var arr = [ 1, 31, 3, 1, 93,
            3, 31, 1, 93 ];
var length = arr.length;

// This variable contains the total 
// count of triplets found 
var totalCount = 0;

// Loop from the first to the third 
// last integer in the list 
for(var i = 0; i < length - 2; i++)
{
    
    // Check if arr[i] is a factor 
    // of target or not. If not, 
    // skip to the next element 
    if (target % arr[i] == 0)
    { 
        for(var j = i + 1; 
                j < length - 1; j++)
        {
            
            // Check if the pair (arr[i], arr[j])
            // can be a part of triplet whose 
            // product is equal to the target 
            if (target % (arr[i] * arr[j]) == 0)
            {
                
                // Find the remaining 
                // element of the triplet 
                var toFind = target / (arr[i] * arr[j]);
            
                for(var k = j + 1; k < length; k++)
                {
                    
                    // If element is found. increment 
                    // the total count of the triplets 
                    if (arr[k] == toFind)
                    { 
                        totalCount ++;
                    }
                }
            } 
        } 
    }
}

document.write("Total number of triplets found : " + 
               totalCount);

// This code is contributed by rutvik_56

</script> 

// JavaScript code to find the number of triplets
// whose product is equal to a given number
// in quadratic time



function getValue(dict, val, defaultVal)
  {
    if (dict.hasOwnProperty(val))
      return dict[val];
    return defaultVal;
  }


// Value for which solution has to be found
let target = 93
let arr = [1, 31, 3, 1, 93, 3, 31, 1, 93]

// Create a list of integers from arr which
// contains only factors of the target
// Using list comprehension
let arr1 = []
for (var i = 0; i < arr.length; i++)
{
    if (arr[i] != 0) 
        if (target % arr[i] == 0)
            arr1.push(arr[i])
        
}

arr = arr1

// Sort the list
arr.sort()
let length = arr.length

// Initialize the dictionary with the default value
let tripletSeen = new Set();
let count = {}

// Count the number of times a value is present in
// the list and store it in a dictionary for further use
for (var key of arr)
    count[key] = getValue(count, key, 0) + 1;

// Used to store the total number of triplets
let totalCount = 0

// This function returns the total number of combinations
// of the triplet (x, y, z) possible in the given list
function Combinations(x, y, z)
{
    let valx = getValue(count, x, 0);
    let valy = getValue(count, y, 0);
    let valz = getValue(count, z, 0);

    if (x == y) {
      if (y == z) {
        return Math.floor((valx * (valy - 1) * (valz - 2)) / 6);
      }
      else {
        return (Math.floor(((valy - 1) * valx) / 2) * valz);
      }
    }
    else if (y == z) {
      return valx * Math.floor(((valz - 1) * valy) / 2);
    }
    else {
      return (valx * valy * valz);
    }
  }


for (var i = 0; i < (length - 2); i++)
{
    for (var j = i + 1; j < length - 1; j++)
    {
        // Check if the pair (arr[i], arr[j]) can be a
        // part of triplet whose product is equal to the target
        if (target % (arr[i] * arr[j]) == 0)
        {
            let toFind = Math.floor(target / (arr[i] * arr[j]))
            
            let str = (arr[i] + "#" + arr[j] + "#" + toFind);
            // This condition makes sure that a solution is not repeated
            if (toFind >= arr[i] && toFind >= arr[j] &&
                !tripletSeen.has(str))
            {    
                tripletSeen.add(str)
                totalCount += Combinations(arr[i], arr[j], toFind)
            }
        }
    }
}

console.log('Total number of triplets found: ', totalCount)


// This code is contributed by phasing17