 GFG App
Open App Browser
Continue

# Count of triplets having sum of product of any two numbers with the third number equal to N

Given an positive integer N, the task is to find the number of triplets (X, Y, Z) such that the sum of product of any two numbers with the third number is N.

Examples:

Input: N = 2
Output: 1
Explanation:
The only triplets satisfying the given criteria is (1, 1, 1). Therefore, the count is 1.

Input: N = 3
Output: 3

Approach: This given problem can be solved by rearranging the equation as:

Consider a triplet as (X, Y, Z) then

=> => From the above equation the idea is to iterate over all possible value of Z over the range [1, N] and add the count of all possible of X and Y by calculating the prime factor of (N – Z) satisfying the above equation. Follow the below steps to solve the problem:

• Initialize a variable, countTriplets to store the resultant count of triplets satisfying the given criteria.
• Find the smallest prime factor for all the elements over the range [1, 105] using the Sieve Of Eratosthenes.
• Iterate over the range [1, N] using the variable, say K and perform the following steps:
• Find the number of pairs of whose product is (N – K) using the approach discussed in this article and add the count obtained to the variable countTriplets.
• After completing the above steps, print the value of countTriplets as the resultant count of triplets.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include` `using` `namespace` `std;`   `vector<``int``> s(11,0);`   `// Function to find the SPF[i] using the` `// Sieve Of Eratosthenes` `void` `sieveOfEratosthenes(``int` `N){` `     `  `    ``// Stores whether i is prime or not` `    ``bool` `prime[N+1];` `    ``memset``(prime,``false``,``sizeof``(``false``));` `    `  `    ``// Initializing smallest factor as` `    ``// 2 for all even numbers` `    ``for` `(``int` `i=2;i< N + 1; i+=2)` `        ``s[i] = 2;` `    `  `    ``// Iterate for all odd numbers < N` `    ``for``(``int` `i =3;i cnt;` `    ``cnt[s[N]] = 1;` `    `  `    ``// Find all the prime factors and` `    ``// their powers` `    ``while` `(N > 1){` `        ``N /= s[N];` `        ``if` `(N and s[N])` `            ``if``(cnt.find(s[N]) == cnt.end())` `                ``cnt[s[N]] = 1;` `            ``else` `                ``cnt[s[N]] += 1;`   `    ``}` `    `  `    ``if` `(cnt.find(0) != cnt.end())` `        ``cnt.erase(0);` `        `  `    ``int` `totfactor = 1;` `    `  `    ``for` `(``auto` `i: cnt)` `        ``totfactor *= i.second + 1;` `    `  `    ``// Return the total count of factors` `    ``return` `totfactor;  ` `}` `    `  `    `    `// Function to count the number of triplets` `// satisfying the given criteria` `int` `countTriplets(``int` `N){` `  `  `    ``// Stores the count of resultant triplets` `    ``int` `CountTriplet = 0;` `  `  `    ``for` `(``int` `z=1;z 1)` `            ``CountTriplet += p;` `    ``}` `    `  `    ``// Return total count of triplets` `    ``return` `CountTriplet + 1;   ` `  `  `  ``}`   `// Driver Code` `int` `main(){`   `int` `N = 10;`   `// S[i] stores the smallest prime factor` `// for each element i`     `// Find the SPF[i]` `sieveOfEratosthenes(N);`   `// Function Call` `cout<

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG{`   `static` `int``[] s = ``new` `int``[``11``];`   `// Function to find the SPF[i] using the` `// Sieve Of Eratosthenes` `static` `void` `sieveOfEratosthenes(``int` `N){` `     `  `    ``// Stores whether i is prime or not` `    ``boolean` `[]prime = ``new` `boolean``[N+``1``];`   `    `  `    ``// Initializing smallest factor as` `    ``// 2 for all even numbers` `    ``for` `(``int` `i = ``2``; i < N + ``1``; i += ``2``)` `        ``s[i] = ``2``;` `    `  `    ``// Iterate for all odd numbers < N` `    ``for``(``int` `i = ``3``; i < N + ``1``; i += ``2``){` `        ``if` `(prime[i] == ``false``){` `             `  `            ``// SPF of i for a prime is` `            ``// the number itself` `            ``s[i] = i;` `    `  `            ``// Iterate for all the multiples` `            ``// of the current prime number` `            ``for``(``int` `j= i; j < N / i + ``1``; j += ``2``){` `                ``if` `(prime[i * j] == ``false``){` `                    ``prime[i * j] = ``true``;` `                    `  `                    ``// The value i is smallest` `                    ``// prime factor for i * j` `                    ``s[i * j] = i;` `                ``}` `            ``}` `        ``}` `    ``}` `}`   `// Function to generate prime factors` `// and its power` `static` `int` `generatePrimeFactors(``int` `N){` `   ``// Current prime factor of N` `    ``int` `curr = s[N];` `     `  `    ``// Stores the powers of the current` `    ``// prime factor` `    ``HashMap cnt = ``new` `HashMap<>();` `    ``cnt.put(s[N],``1``);` `    `  `    ``// Find all the prime factors and` `    ``// their powers` `    ``while` `(N > ``1``){` `        ``N /= s[N];` `        ``if` `(N != ``0` `&& s[N] != ``0``)` `            ``if``(!cnt.containsKey(s[N]))` `                ``cnt.put(s[N], ``1``);` `            ``else` `                ``cnt.put(s[N], cnt.get(s[N]) + ``1``);`   `    ``}` `    `  `    ``if` `(cnt.containsKey(``0``))` `        ``cnt.remove(``0``);` `        `  `    ``int` `totfactor = ``1``;` `    `  `   `  `        ``for` `(Map.Entry i : cnt.entrySet())` `        ``totfactor *= i.getValue() + ``1``;` `    `  `    ``// Return the total count of factors` `    ``return` `totfactor;  ` `}` `    `  `    `    `// Function to count the number of triplets` `// satisfying the given criteria` `static` `int` `countTriplets(``int` `N){` `  `  `    ``// Stores the count of resultant triplets` `    ``int` `CountTriplet = ``0``;` `  `  `    ``for` `(``int` `z=``1``;z ``1``)` `            ``CountTriplet += p;` `    ``}` `    `  `    ``// Return total count of triplets` `    ``return` `CountTriplet + ``1``;   ` `  `  `  ``}`   `// Driver Code` `public` `static` `void` `main(String[] args){`   `int` `N = ``10``;`   `// S[i] stores the smallest prime factor` `// for each element i`     `// Find the SPF[i]` `sieveOfEratosthenes(N);`   `// Function Call` `System.out.print(countTriplets(N));` `}` `}`   `// This code is contributed by gauravrajput1 `

## Python3

 `# Python program for the above approach`   `# Function to find the SPF[i] using the` `# Sieve Of Eratosthenes` `def` `sieveOfEratosthenes(N, s):` `     `  `    ``# Stores whether i is prime or not` `    ``prime ``=` `[``False``] ``*` `(N ``+` `1``)` `    `  `    ``# Initializing smallest factor as` `    ``# 2 for all even numbers` `    ``for` `i ``in` `range``(``2``, N ``+` `1``, ``2``):` `        ``s[i] ``=` `2` `    `  `    ``# Iterate for all odd numbers < N` `    ``for` `i ``in` `range``(``3``, N ``+` `1``, ``2``):` `        ``if` `(prime[i] ``=``=` `False``):` `             `  `            ``# SPF of i for a prime is` `            ``# the number itself` `            ``s[i] ``=` `i` `    `  `            ``# Iterate for all the multiples` `            ``# of the current prime number` `            ``for` `j ``in` `range``(i, ``int``(N ``/` `i) ``+` `1``, ``2``):` `                ``if` `(prime[i ``*` `j] ``=``=` `False``):` `                    ``prime[i ``*` `j] ``=` `True` `                    `  `                    ``# The value i is smallest` `                    ``# prime factor for i * j` `                    ``s[i ``*` `j] ``=` `i`   `# Function to generate prime factors` `# and its power` `def` `generatePrimeFactors(N):` `    `  `    ``# Current prime factor of N` `    ``curr ``=` `s[N]` `     `  `    ``# Stores the powers of the current` `    ``# prime factor` `    ``cnt ``=` `{s[N]:``1``}` `    `  `    ``# Find all the prime factors and` `    ``# their powers` `    ``while` `(N > ``1``):` `    `  `        ``N ``/``/``=` `s[N]` `        ``if` `N ``and` `s[N]:` `            ``if` `cnt.get(s[N], ``0``) ``=``=` `0``:` `                ``cnt[s[N]] ``=` `1` `            ``else``:` `                ``cnt[s[N]] ``+``=` `1` `    `  `    ``if` `0` `in` `cnt:` `        ``cnt.pop(``0``)` `        `  `    ``totfactor ``=` `1` `    `  `    ``for` `i ``in` `cnt.values():` `        ``totfactor ``*``=` `i ``+` `1` `    `  `    ``# Return the total count of factors` `    ``return` `totfactor  `   `# Function to count the number of triplets` `# satisfying the given criteria` `def` `countTriplets(N):` `  `  `    ``# Stores the count of resultant triplets` `    ``CountTriplet ``=` `0` `  `  `    ``for` `z ``in` `range``(``1``, N ``+` `1``):` `        `  `        ``# Add the count all factors of N-z` `        ``# to the variable CountTriplet` `        ``p ``=` `generatePrimeFactors(N``-``z)` `        ``if` `p > ``1``:` `            ``CountTriplet ``+``=` `p  ` `    `  `    ``# Return total count of triplets` `    ``return` `CountTriplet ``+` `1`    `  `    `# Driver Code` `N ``=` `10`   `# S[i] stores the smallest prime factor` `# for each element i` `s ``=` `[``0``] ``*` `(N ``+` `1``)`   `# Find the SPF[i]` `sieveOfEratosthenes(N, s)`   `# Function Call` `print``(countTriplets(N))`

## C#

 `// C# program for the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `    ``static` `int``[] s = ``new` `int``;`   `    ``// Function to find the SPF[i] using the` `    ``// Sieve Of Eratosthenes` `    ``static` `void` `sieveOfEratosthenes(``int` `N)` `    ``{` `        ``// Stores whether i is prime or not` `        ``bool``[] prime = ``new` `bool``[N + 1];`   `        ``// Initializing smallest factor as` `        ``// 2 for all even numbers` `        ``for` `(``int` `i = 2; i < N + 1; i += 2)` `            ``s[i] = 2;`   `        ``// Iterate for all odd numbers < N` `        ``for` `(``int` `i = 3; i < N + 1; i += 2)` `        ``{` `            ``if` `(prime[i] == ``false``)` `            ``{` `                ``// SPF of i for a prime is` `                ``// the number itself` `                ``s[i] = i;`   `                ``// Iterate for all the multiples` `                ``// of the current prime number` `                ``for` `(``int` `j = i; j < N / i + 1; j += 2)` `                ``{` `                    ``if` `(prime[i * j] == ``false``)` `                    ``{` `                        ``prime[i * j] = ``true``;`   `                        ``// The value i is smallest` `                        ``// prime factor for i * j` `                        ``s[i * j] = i;` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Function to generate prime factors` `    ``// and its power` `    `  `    `  `        ``static` `int` `generatePrimeFactors(``int` `N)` `    ``{` `        ``// Current prime factor of N` `        ``// int curr = s[N];`   `        ``// Stores the powers of the current` `        ``// prime factor` `        ``Dictionary<``int``, ``int``> cnt = ``new` `Dictionary<``int``, ``int``>();` `        ``cnt.Add(s[N], 1);` `    `  `        ``// Find all the prime factors and` `        ``// their powers` `        ``while` `(N > 1)` `        ``{` `            ``N /= s[N];` `            ``if` `(N != 0 && s[N] != 0)` `                ``if` `(!cnt.ContainsKey(s[N]))` `                    ``cnt.Add(s[N], 1);` `                ``else` `                    ``cnt[s[N]]++;`   `        ``}` `        `  `        ``if``(cnt.ContainsKey(0))` `            ``cnt.Remove(0);` `        `  `        `  `        ``int` `totfactor = 1;`   `        ``// get the factor count and multiply them` `        ``foreach` `(``var` `entry ``in` `cnt)` `            ``totfactor *= entry.Value + 1;`   `        `  `        ``// Return the total count of factors` `        ``return` `totfactor;` `    ``}`   `    `  `    ``// Function to count the number of triplets` `    ``// satisfying the given criteria` `    ``static` `int` `countTriplets(``int` `N)` `    ``{` `        ``// Stores the count of resultant triplets` `        ``int` `countTriplet = 0;` `    `  `        ``for` `(``int` `z = 1; z < N + 1; z++)` `        ``{` `            ``// Add the count all factors of N-z` `            ``// to the variable CountTriplet` `            ``int` `p = generatePrimeFactors(N - z);` `            ``if` `(p > 1)` `                ``countTriplet += p;` `        ``}` `    `  `        ``// Return total count of triplets` `        ``return` `countTriplet + 1;` `    ``}` `    `  `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `N = 10;` `        `  `        ``// Find the SPF[i]` `        ``sieveOfEratosthenes(N);` `        `  `        ``// Function Call` `        ``Console.WriteLine(countTriplets(N));` `    ``}` `    `  `}`

## Javascript

 ``

Output:

`23`

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up