# Count triplets such that product of two numbers added with third number is N

• Last Updated : 11 Oct, 2021

Given a positive integer N, the task is to find the number of triplets (A, B, C) where A, B, C are positive integers such that the product of two numbers added with the third number is N i.e., A * B + C = N.

Examples:

Input: N = 3
Output: 3
Explanation:
Following are the possible triplets satisfying the given criteria:

1. (1, 1, 2): The value of 1*1 + 2 = 3.
2. (1, 2, 1): The value of 1*2 + 1 = 3.
3. (2, 1, 1): The value of 2*1 + 1 = 3.

Therefore, the total count of such triplets is 3.

Input: N = 5
Output: 8

Approach: The given problem can be solved by rearranging the equation A * B + C = N as A * B = N – C. Now, the only possible values A and B can have to satisfy the above equation is the divisors of N – C. For Example, if the value of N – C = 18, having 6 divisors that are 1, 2, 3, 6, 9, 18. So, values of A, B satisfying the above equation are: (1, 18), (2, 9), (3, 6), (6, 3), (9, 2), (18, 1). So, for the value of N – C = 18, possible values of A, B are 6, i.e., the number of divisors of N – C(= 18). Follow the steps below to solve the given problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the divisors of` `// the number (N - i)` `int` `countDivisors(``int` `n)` `{` `    ``// Stores the resultant count of` `    ``// divisors of (N - i)` `    ``int` `divisors = 0;` `    ``int` `i;`   `    ``// Iterate over range [1, sqrt(N)]` `    ``for` `(i = 1; i * i < n; i++) {` `        ``if` `(n % i == 0) {` `            ``divisors++;` `        ``}` `    ``}` `    ``if` `(i - (n / i) == 1) {` `        ``i--;` `    ``}` `    ``for` `(; i >= 1; i--) {` `        ``if` `(n % i == 0) {` `            ``divisors++;` `        ``}` `    ``}` `    ``// Return the total divisors` `    ``return` `divisors;` `}`   `// Function to find the number of triplets` `// such that A * B - C = N` `int` `possibleTriplets(``int` `N)` `{` `    ``int` `count = 0;`   `    ``// Loop to fix the value of C` `    ``for` `(``int` `i = 1; i < N; i++) {`   `        ``// Adding the number of` `        ``// divisors in count` `        ``count += countDivisors(N - i);` `    ``}`   `    ``// Return count of triplets` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 10;` `    ``cout << possibleTriplets(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG` `{` `  `  `      ``// Function to find the divisors of` `    ``// the number (N - i)` `    ``static` `int` `countDivisors(``int` `n)` `    ``{` `      `  `        ``// Stores the resultant count of` `        ``// divisors of (N - i)` `        ``int` `divisors = ``0``;` `        ``int` `i;`   `        ``// Iterate over range [1, sqrt(N)]` `        ``for` `(i = ``1``; i * i < n; i++) {` `            ``if` `(n % i == ``0``) {` `                ``divisors++;` `            ``}` `        ``}` `        ``if` `(i - (n / i) == ``1``) {` `            ``i--;` `        ``}` `        ``for` `(; i >= ``1``; i--) {` `            ``if` `(n % i == ``0``) {` `                ``divisors++;` `            ``}` `        ``}`   `        ``// Return the total divisors` `        ``return` `divisors;` `    ``}`   `    ``// Function to find the number of triplets` `    ``// such that A * B - C = N` `    ``static` `int` `possibleTriplets(``int` `N)` `    ``{` `        ``int` `count = ``0``;`   `        ``// Loop to fix the value of C` `        ``for` `(``int` `i = ``1``; i < N; i++) {`   `            ``// Adding the number of` `            ``// divisors in count` `            ``count += countDivisors(N - i);` `        ``}`   `        ``// Return count of triplets` `        ``return` `count;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main (String[] args) {` `      `  `        ``int` `N = ``10``;` `        ``System.out.println(possibleTriplets(N));` `    ``}` `}`   `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python program for the above approach` `import` `math`   `# function to find the divisors of` `# the number (N - i)` `def` `countDivisors(n):`   `    ``# Stores the resultant count of` `    ``# divisors of (N - i)` `    ``divisors ``=` `0`   `    ``# Iterate over range [1, sqrt(N)]` `    ``for` `i ``in` `range``(``1``, math.ceil(math.sqrt(n))``+``1``):` `        ``if` `n ``%` `i ``=``=` `0``:` `            ``divisors ``=` `divisors``+``1`   `        ``if` `(i ``-` `(n ``/` `i) ``=``=` `1``):` `            ``i ``=` `i``-``1`   `    ``for` `i ``in` `range``(math.ceil(math.sqrt(n))``+``1``, ``1``, ``-``1``):` `        ``if` `(n ``%` `i ``=``=` `0``):` `            ``divisors ``=` `divisors``+``1`   `     ``# Return the total divisors` `    ``return` `divisors`   `    ``# def to find the number of triplets` `    ``# such that A * B - C = N`     `def` `possibleTriplets(N):` `    ``count ``=` `0`   `    ``# Loop to fix the value of C` `    ``for` `i ``in` `range``(``1``, N):`   `        ``# Adding the number of` `        ``# divisors in count` `        ``count ``=` `count ``+` `countDivisors(N ``-` `i)`   `        ``# Return count of triplets` `    ``return` `count`   `    ``# Driver Code` `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `10` `    ``print``(possibleTriplets(N))`   `# This code is contributed by Potta Lokesh`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to find the divisors of` `// the number (N - i)` `static` `int` `countDivisors(``int` `n)` `{` `    ``// Stores the resultant count of` `    ``// divisors of (N - i)` `    ``int` `divisors = 0;` `    ``int` `i;`   `    ``// Iterate over range [1, sqrt(N)]` `    ``for` `(i = 1; i * i < n; i++) {` `        ``if` `(n % i == 0) {` `            ``divisors++;` `        ``}` `    ``}` `    ``if` `(i - (n / i) == 1) {` `        ``i--;` `    ``}` `    ``for` `(; i >= 1; i--) {` `        ``if` `(n % i == 0) {` `            ``divisors++;` `        ``}` `    ``}` `    ``// Return the total divisors` `    ``return` `divisors;` `}`   `// Function to find the number of triplets` `// such that A * B - C = N` `static` `int` `possibleTriplets(``int` `N)` `{` `    ``int` `count = 0;`   `    ``// Loop to fix the value of C` `    ``for` `(``int` `i = 1; i < N; i++) {`   `        ``// Adding the number of` `        ``// divisors in count` `        ``count += countDivisors(N - i);` `    ``}`   `    ``// Return count of triplets` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `N = 10;` `    ``Console.Write(possibleTriplets(N));` `}` `}`   `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output:

`23`

Time Complexity: O(N*sqrt(N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :