Number of Quadruples with GCD equal to K

Given two integers N and K, the task is to find the count of quadruples of (i, j, k, l) such that 1 ≤ i < j < k < l ≤ N and gcd(i, j, k, l) = K.

Examples:

Input: N = 10, K = 2
Output: 5
Valid quadruples are (2, 4, 6, 8), (2, 4, 6, 10),
(2, 4, 8, 10), (2, 6, 8, 10) and (4, 6, 8, 10)

Input: N = 8, K = 1
Output: 69

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• If gcd of a sequence is K then when we divide all these numbers by K, the gcd of the left-over numbers will be 1.
• Now in order to fulfil this constraint of quadruples having maximum number N, if we find out the count of all quadruples having maximum number less than or equal to N / K and having gcd 1 then we can simply multiply all the quadruples with K to get the answer.
• To find quadruples count with gcd 1, we must use inclusion and exclusion principle. Take N / K = M.
• MC4 quadruples are possible total. (M/2)C4 quadruples have gcd which is a multiple of 2. (M/2 multiples of 2 are used). Similarly, (M/3)C4 quadruples have gcd which is a multiple of 3. But if we subtract both the quantities then, gcd which are multiple of 6 are subtracted twice so we must include (M/6)C4 to add them once.
• So iterate from 2 to M, and if a number has an odd number of distinct prime divisors (like 2, 3, 5, 11 ) then subtract count of quadruples with gcd multiple of that number, and if it has even number of distinct prime divisors (like 6, 10, 33) then add count of quadruples with gcd multiple of that number. (Number must not have a repetition of prime divisors like 4).

Below is the implementation of the above approach:

C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate NC4 ` `int` `nCr(``int` `n) ` `{ ` `    ``// Base case to calculate NC4 ` `    ``if` `(n < 4) ` `        ``return` `0; ` ` `  `    ``int` `answer = n * (n - 1) * (n - 2) * (n - 3); ` `    ``answer /= 24; ` `    ``return` `answer; ` `} ` ` `  `// Function to return the count of required ` `// quadruples using Inclusion Exclusion ` `int` `countQuadruples(``int` `N, ``int` `K) ` `{ ` `    ``// Effective N ` `    ``int` `M = N / K; ` ` `  `    ``int` `answer = nCr(M); ` ` `  `    ``// Iterate over 2 to M ` `    ``for` `(``int` `i = 2; i < M; i++) { ` `        ``int` `j = i; ` ` `  `        ``// Number of divisors of i till M ` `        ``int` `temp2 = M / i; ` ` `  `        ``// Count stores the number of prime ` `        ``// divisors occurring exactly once ` `        ``int` `count = 0; ` ` `  `        ``// To prevent repetition of prime divisors ` `        ``int` `check = 0; ` `        ``int` `temp = j; ` ` `  `        ``while` `(j % 2 == 0) { ` `            ``count++; ` `            ``j /= 2; ` `            ``if` `(count >= 2) ` `                ``break``; ` `        ``} ` ` `  `        ``if` `(count >= 2) { ` `            ``check = 1; ` `        ``} ` ` `  `        ``for` `(``int` `k = 3; k <= ``sqrt``(temp); k += 2) { ` `            ``int` `cnt = 0; ` ` `  `            ``while` `(j % k == 0) { ` `                ``cnt++; ` `                ``j /= k; ` `                ``if` `(cnt >= 2) ` `                    ``break``; ` `            ``} ` ` `  `            ``if` `(cnt >= 2) { ` `                ``check = 1; ` `                ``break``; ` `            ``} ` `            ``else` `if` `(cnt == 1) ` `                ``count++; ` `        ``} ` ` `  `        ``if` `(j > 2) { ` `            ``count++; ` `        ``} ` ` `  `        ``// If repetition of prime divisors present ` `        ``// ignore this number ` `        ``if` `(check) ` `            ``continue``; ` `        ``else` `{ ` ` `  `            ``// If prime divisor count is odd ` `            ``// subtract it from answer else add ` `            ``if` `(count % 2 == 1) { ` `                ``answer -= nCr(temp2); ` `            ``} ` `            ``else` `{ ` `                ``answer += nCr(temp2); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `answer; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 10, K = 2; ` ` `  `    ``cout << countQuadruples(N, K); ` ` `  `    ``return` `0; ` `} `

Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to calculate NC4 ` `static` `int` `nCr(``int` `n) ` `{ ` `    ``// Base case to calculate NC4 ` `    ``if` `(n < ``4``) ` `        ``return` `0``; ` ` `  `    ``int` `answer = n * (n - ``1``) * (n - ``2``) * (n - ``3``); ` `    ``answer /= ``24``; ` `    ``return` `answer; ` `} ` ` `  `// Function to return the count of required ` `// quadruples using Inclusion Exclusion ` `static` `int` `countQuadruples(``int` `N, ``int` `K) ` `{ ` `    ``// Effective N ` `    ``int` `M = N / K; ` ` `  `    ``int` `answer = nCr(M); ` ` `  `    ``// Iterate over 2 to M ` `    ``for` `(``int` `i = ``2``; i < M; i++)  ` `    ``{ ` `        ``int` `j = i; ` ` `  `        ``// Number of divisors of i till M ` `        ``int` `temp2 = M / i; ` ` `  `        ``// Count stores the number of prime ` `        ``// divisors occurring exactly once ` `        ``int` `count = ``0``; ` ` `  `        ``// To prevent repetition of prime divisors ` `        ``int` `check = ``0``; ` `        ``int` `temp = j; ` ` `  `        ``while` `(j % ``2` `== ``0``)  ` `        ``{ ` `            ``count++; ` `            ``j /= ``2``; ` `            ``if` `(count >= ``2``) ` `                ``break``; ` `        ``} ` ` `  `        ``if` `(count >= ``2``)  ` `        ``{ ` `            ``check = ``1``; ` `        ``} ` ` `  `        ``for` `(``int` `k = ``3``; k <= Math.sqrt(temp); k += ``2``)  ` `        ``{ ` `            ``int` `cnt = ``0``; ` ` `  `            ``while` `(j % k == ``0``) ` `            ``{ ` `                ``cnt++; ` `                ``j /= k; ` `                ``if` `(cnt >= ``2``) ` `                    ``break``; ` `            ``} ` ` `  `            ``if` `(cnt >= ``2``) ` `            ``{ ` `                ``check = ``1``; ` `                ``break``; ` `            ``} ` `            ``else` `if` `(cnt == ``1``) ` `                ``count++; ` `        ``} ` ` `  `        ``if` `(j > ``2``)  ` `        ``{ ` `            ``count++; ` `        ``} ` ` `  `        ``// If repetition of prime divisors present ` `        ``// ignore this number ` `        ``if` `(check==``1``) ` `            ``continue``; ` `        ``else` `        ``{ ` ` `  `            ``// If prime divisor count is odd ` `            ``// subtract it from answer else add ` `            ``if` `(count % ``2` `== ``1``) ` `            ``{ ` `                ``answer -= nCr(temp2); ` `            ``} ` `            ``else` `            ``{ ` `                ``answer += nCr(temp2); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` `  `    ``int` `N = ``10``, K = ``2``; ` ` `  `    ``System.out.println(countQuadruples(N, K)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Python3

 `# Python3 implementation of the approach  ` `from` `math ``import` `sqrt ` ` `  `# Function to calculate NC4  ` `def` `nCr(n) :  ` ` `  `    ``# Base case to calculate NC4  ` `    ``if` `(n < ``4``) : ` `        ``return` `0``;  ` ` `  `    ``answer ``=` `n ``*` `(n ``-` `1``) ``*` `(n ``-` `2``) ``*` `(n ``-` `3``);  ` `    ``answer ``/``/``=` `24``;  ` `     `  `    ``return` `answer;  ` ` `  `# Function to return the count of required  ` `# quadruples using Inclusion Exclusion  ` `def` `countQuadruples(N, K) : ` ` `  `    ``# Effective N  ` `    ``M ``=` `N ``/``/` `K;  ` ` `  `    ``answer ``=` `nCr(M);  ` ` `  `    ``# Iterate over 2 to M  ` `    ``for` `i ``in` `range``(``2``, M) : ` `        ``j ``=` `i;  ` ` `  `        ``# Number of divisors of i till M  ` `        ``temp2 ``=` `M ``/``/` `i;  ` ` `  `        ``# Count stores the number of prime  ` `        ``# divisors occurring exactly once  ` `        ``count ``=` `0``;  ` ` `  `        ``# To prevent repetition of prime divisors  ` `        ``check ``=` `0``;  ` `        ``temp ``=` `j;  ` ` `  `        ``while` `(j ``%` `2` `=``=` `0``) : ` `            ``count ``+``=` `1``;  ` `            ``j ``/``/``=` `2``;  ` `            ``if` `(count >``=` `2``) : ` `                ``break``;  ` ` `  `        ``if` `(count >``=` `2``) : ` `            ``check ``=` `1``; ` ` `  `        ``for` `k ``in` `range``(``3``, ``int``(sqrt(temp)), ``2``) : ` `            ``cnt ``=` `0``;  ` ` `  `            ``while` `(j ``%` `k ``=``=` `0``) : ` `                ``cnt ``+``=` `1``;  ` `                ``j ``/``/``=` `k;  ` `                ``if` `(cnt >``=` `2``) : ` `                    ``break``;  ` `     `  `            ``if` `(cnt >``=` `2``) : ` `                ``check ``=` `1``;  ` `                ``break``;  ` `            ``elif` `(cnt ``=``=` `1``) : ` `                ``count ``+``=` `1``; ` ` `  `        ``if` `(j > ``2``) : ` `            ``count ``+``=` `1``;  ` ` `  `        ``# If repetition of prime divisors present  ` `        ``# ignore this number  ` `        ``if` `(check) : ` `            ``continue``;  ` `        ``else` `:  ` `             `  `            ``# If prime divisor count is odd  ` `            ``# subtract it from answer else add  ` `            ``if` `(count ``%` `2` `=``=` `1``) : ` `                ``answer ``-``=` `nCr(temp2);  ` `            ``else` `: ` `                ``answer ``+``=` `nCr(temp2);  ` ` `  `    ``return` `answer;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``N ``=` `10``; K ``=` `2``;  ` ` `  `    ``print``(countQuadruples(N, K));  ` ` `  `# This code is contributed by AnkitRai01 `

C#

 `// C# implementation of the approach ` `using` `System; ` `     `  `class` `GFG  ` `{ ` ` `  `// Function to calculate NC4 ` `static` `int` `nCr(``int` `n) ` `{ ` `    ``// Base case to calculate NC4 ` `    ``if` `(n < 4) ` `        ``return` `0; ` ` `  `    ``int` `answer = n * (n - 1) * (n - 2) * (n - 3); ` `    ``answer /= 24; ` `    ``return` `answer; ` `} ` ` `  `// Function to return the count of required ` `// quadruples using Inclusion Exclusion ` `static` `int` `countQuadruples(``int` `N, ``int` `K) ` `{ ` `    ``// Effective N ` `    ``int` `M = N / K; ` ` `  `    ``int` `answer = nCr(M); ` ` `  `    ``// Iterate over 2 to M ` `    ``for` `(``int` `i = 2; i < M; i++)  ` `    ``{ ` `        ``int` `j = i; ` ` `  `        ``// Number of divisors of i till M ` `        ``int` `temp2 = M / i; ` ` `  `        ``// Count stores the number of prime ` `        ``// divisors occurring exactly once ` `        ``int` `count = 0; ` ` `  `        ``// To prevent repetition of prime divisors ` `        ``int` `check = 0; ` `        ``int` `temp = j; ` ` `  `        ``while` `(j % 2 == 0)  ` `        ``{ ` `            ``count++; ` `            ``j /= 2; ` `            ``if` `(count >= 2) ` `                ``break``; ` `        ``} ` ` `  `        ``if` `(count >= 2)  ` `        ``{ ` `            ``check = 1; ` `        ``} ` ` `  `        ``for` `(``int` `k = 3; k <= Math.Sqrt(temp); k += 2)  ` `        ``{ ` `            ``int` `cnt = 0; ` ` `  `            ``while` `(j % k == 0) ` `            ``{ ` `                ``cnt++; ` `                ``j /= k; ` `                ``if` `(cnt >= 2) ` `                    ``break``; ` `            ``} ` ` `  `            ``if` `(cnt >= 2) ` `            ``{ ` `                ``check = 1; ` `                ``break``; ` `            ``} ` `            ``else` `if` `(cnt == 1) ` `                ``count++; ` `        ``} ` ` `  `        ``if` `(j > 2)  ` `        ``{ ` `            ``count++; ` `        ``} ` ` `  `        ``// If repetition of prime divisors present ` `        ``// ignore this number ` `        ``if` `(check==1) ` `            ``continue``; ` `        ``else` `        ``{ ` ` `  `            ``// If prime divisor count is odd ` `            ``// subtract it from answer else add ` `            ``if` `(count % 2 == 1) ` `            ``{ ` `                ``answer -= nCr(temp2); ` `            ``} ` `            ``else` `            ``{ ` `                ``answer += nCr(temp2); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` `  `    ``int` `N = 10, K = 2; ` ` `  `    ``Console.WriteLine(countQuadruples(N, K)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```5
```

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.