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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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 occuring 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 occuring 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 occuring 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

chevron_right


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.