# 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:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

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