GCD等于K的范围[L，R]中的四元组计数

给定整数K和范围[L，R] ，任务是从gcd等于K的给定范围对四胞胎对进行计数。
例子：

Input: L = 1, R = 5, K = 3 
Output: 1 
(3, 3, 3, 3) is the only valid quadruplet with gcd = 3
Input: L = 2, R = 24, K = 5 
Output: 239 
 

幼稚的方法：我们可以使用四个循环遍历所有数字，并针对每对四联体检查其gcd是否等于K。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
 
 
// Function to return the count
// of quadruplets having gcd = k
int countQuadruplets(int l, int r, int k)
{
 
    // To store the required count
    int count = 0;
 
    // Check every quadruplet pair
    // whether its gcd is k
    for (int u = l; u <= r; u++) {
        for (int v = l; v <= r; v++) {
            for (int w = l; w <= r; w++) {
                for (int x = l; x <= r; x++) {
                    if (__gcd(__gcd(u, v), __gcd(w, x)) == k)
                        count++;
                }
            }
        }
    }
 
    // Return the required count
    return count;
}
 
// Driver code
int main()
{
    int l = 1, r = 10, k = 2;
 
    cout << countQuadruplets(l, r, k);
 
    return 0;
}

Java

// Java implementation of the approach
import java.io.*;
 
class GFG {
 
    // Function to return
    // the gcd of a and b
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to return the count
    // of quadruplets having gcd = k
    static int countQuadruplets(int l, int r, int k)
    {
 
        // To store the required count
        int count = 0;
 
        // Check every quadruplet pair
        // whether its gcd is k
        for (int u = l; u <= r; u++) {
            for (int v = l; v <= r; v++) {
                for (int w = l; w <= r; w++) {
                    for (int x = l; x <= r; x++) {
                        if (gcd(gcd(u, v), gcd(w, x)) == k)
                            count++;
                    }
                }
            }
        }
 
        // Return the required count
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        int l = 1, r = 10, k = 2;
 
        System.out.println(countQuadruplets(l, r, k));
    }
}
 
// This code is contributed by jit_t.

Python 3

# Python 3 implementation of the approach
from math import gcd
 
# Function to return the count
# of quadruplets having gcd = k
def countQuadruplets(l, r, k):
     
    # To store the required count
    count = 0
 
    # Check every quadruplet pair
    # whether its gcd is k
    for u in range(l, r + 1 ,1):
        for v in range(l, r + 1, 1):
            for w in range(l, r + 1, 1):
                for x in range(l, r + 1, 1):
                    if (gcd(gcd(u, v), gcd(w, x)) == k):
                        count += 1
 
    # Return the required count
    return count
 
# Driver code
if __name__ == '__main__':
    l = 1
    r = 10
    k = 2
 
    print(countQuadruplets(l, r, k))
     
# This code is contributed
# by Surendra_Gangwar

C#

// C# implementation of the approach
using System;
 
class GFG {
 
    // Function to return
    // the gcd of a and b
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to return the count
    // of quadruplets having gcd = k
    static int countQuadruplets(int l, int r, int k)
    {
 
        // To store the required count
        int count = 0;
 
        // Check every quadruplet pair
        // whether its gcd is k
        for (int u = l; u <= r; u++) {
            for (int v = l; v <= r; v++) {
                for (int w = l; w <= r; w++) {
                    for (int x = l; x <= r; x++) {
                        if (gcd(gcd(u, v), gcd(w, x)) == k)
                            count++;
                    }
                }
            }
        }
 
        // Return the required count
        return count;
    }
 
    // Driver code
    static public void Main()
    {
        int l = 1, r = 10, k = 2;
        Console.WriteLine(countQuadruplets(l, r, k));
    }
}
 
// This code is contributed by ajit.

Javascript

 
// javascript implementation of the approach
 
    // Function to return
    // the gcd of a and b
    function gcd(a , b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to return the count
    // of quadruplets having gcd = k
    function countQuadruplets(l , r , k) {
 
        // To store the required count
        var count = 0;
 
        // Check every quadruplet pair
        // whether its gcd is k
        for (u = l; u <= r; u++) {
            for (v = l; v <= r; v++) {
                for (w = l; w <= r; w++) {
                    for (x = l; x <= r; x++) {
                        if (gcd(gcd(u, v), gcd(w, x)) == k)
                            count++;
                    }
                }
            }
        }
 
        // Return the required count
        return count;
    }
 
    // Driver code
     
 
        var l = 1, r = 10, k = 2;
 
        document.write(countQuadruplets(l, r, k));
 
// This code is contributed by todaysgaurav
 

输出：

607

时间复杂度： O((r – l) ⁴ )
高效的方法：

1. 在给定范围内找到每个可能的对(x，y)的GCD。
2. 计算每个可能的GCD值的频率。
3. 此后，如果两个数字的GCD值为k，则按频率[i] *频率[j]递增计数。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return
// the gcd of a and b
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to return the count
// of quadruplets having gcd = k
int countQuadruplets(int l, int r, int k)
{
 
    int frequency[r + 1] = { 0 };
 
    // Count the frequency of every possible gcd
    // value in the range
    for (int i = l; i <= r; i++) {
        for (int j = l; j <= r; j++) {
            frequency[gcd(i, j)]++;
        }
    }
 
    // To store the required count
    long long answer = 0;
 
    // Calculate the answer using frequency values
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= r; j++) {
            if (gcd(i, j) == k) {
                answer += (frequency[i] * frequency[j]);
            }
        }
    }
 
    // Return the required count
    return answer;
}
 
// Driver code
int main()
{
    int l = 1, r = 10, k = 2;
 
    cout << countQuadruplets(l, r, k);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
     
// Function to return
// the gcd of a and b
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to return the count
// of quadruplets having gcd = k
static int countQuadruplets(int l, int r, int k)
{
 
    int frequency[]= new int[r + 1] ;
 
    // Count the frequency of every possible gcd
    // value in the range
    for (int i = l; i <= r; i++)
    {
        for (int j = l; j <= r; j++)
        {
            frequency[gcd(i, j)]++;
        }
    }
 
    // To store the required count
    long answer = 0;
 
    // Calculate the answer using frequency values
    for (int i = 1; i <= r; i++)
    {
        for (int j = 1; j <= r; j++)
        {
            if (gcd(i, j) == k)
            {
                answer += (frequency[i] * frequency[j]);
            }
        }
    }
 
    // Return the required count
    return (int)answer;
}
 
// Driver code
public static void main(String args[])
{
    int l = 1, r = 10, k = 2;
 
    System.out.println(countQuadruplets(l, r, k));
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 implementation of the approach
 
# Function to return
# the gcd of a and b
def gcd(a, b):
    if (b == 0):
        return a;
    return gcd(b, a % b);
 
# Function to return the count
# of quadruplets having gcd = k
def countQuadruplets(l, r, k):
    frequency = [0] * (r + 1);
 
    # Count the frequency of every possible gcd
    # value in the range
    for i in range(l, r + 1):
        for j in range(l, r + 1):
            frequency[gcd(i, j)] += 1;
 
    # To store the required count
    answer = 0;
 
    # Calculate the answer using frequency values
    for i in range(l, r + 1):
        for j in range(l, r + 1):
            if (gcd(i, j) == k):
                answer += (frequency[i] * frequency[j]);
 
    # Return the required count
    return answer;
 
# Driver code
if __name__ == '__main__':
    l, r, k = 1, 10, 2;
 
    print(countQuadruplets(l, r, k));
 
# This code is contributed by Rajput-Ji

C＃

// C# implementation of the approach
using System;
 
class GFG
{
         
// Function to return
// the gcd of a and b
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
// Function to return the count
// of quadruplets having gcd = k
static int countQuadruplets(int l, int r, int k)
{
 
    int []frequency= new int[r + 1] ;
 
    // Count the frequency of every possible gcd
    // value in the range
    for (int i = l; i <= r; i++)
    {
        for (int j = l; j <= r; j++)
        {
            frequency[gcd(i, j)]++;
        }
    }
 
    // To store the required count
    long answer = 0;
 
    // Calculate the answer using frequency values
    for (int i = 1; i <= r; i++)
    {
        for (int j = 1; j <= r; j++)
        {
            if (gcd(i, j) == k)
            {
                answer += (frequency[i] * frequency[j]);
            }
        }
    }
 
    // Return the required count
    return (int)answer;
}
 
// Driver code
static public void Main ()
{
    int l = 1, r = 10, k = 2;
    Console.WriteLine(countQuadruplets(l, r, k));
}
}
 
// This code is contributed by @ajit_00023

Java脚本

    // Javascript implementation of the approach
     
    // Function to return
    // the gcd of a and b
    function gcd(a, b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Function to return the count
    // of quadruplets having gcd = k
    function countQuadruplets(l, r, k)
    {
 
        let frequency= new Array(r + 1);
        frequency.fill(0);
 
        // Count the frequency of every possible gcd
        // value in the range
        for (let i = l; i <= r; i++)
        {
            for (let j = l; j <= r; j++)
            {
                frequency[gcd(i, j)]++;
            }
        }
 
        // To store the required count
        let answer = 0;
 
        // Calculate the answer using frequency values
        for (let i = 1; i <= r; i++)
        {
            for (let j = 1; j <= r; j++)
            {
                if (gcd(i, j) == k)
                {
                    answer += (frequency[i] * frequency[j]);
                }
            }
        }
 
        // Return the required count
        return answer;
    }
     
    let l = 1, r = 10, k = 2;
    document.write(countQuadruplets(l, r, k));
     

输出：

607

时间复杂度： O((r – l) ² )

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。