修改数组，使数组不包含除 1 以外的任何公约数

给定的阵列ARR []由N个整数和整数的X，该任务是这样的阵列不包含其他任何公约数大于1时，通过重复地分割的任何阵列元素，以检查是否有可能修改数组数组按其任何除数d (d ≤ X )。如果可以修改数组使其满足给定条件，则打印“Yes” 。否则，打印“否” 。

例子：

Input: arr[] = {6, 15, 6}, X = 6
Output:
Yes 
2 5 2
Explanation:
Operation 1: Dividing arr[0] by 3 (Since 3 ≤ 6) modifies arr[] to { 2, 15, 6 }.
Operation 2: Dividing arr[1] by 5 (Since 5 ≤ 6) modifies arr[] to { 2, 3, 6 }. 
Therefore, GCD of the array = GCD({2, 3, 6}) = 1, which means that the array has no common divisor other than 1, which is the required condition.

Input: arr[] = {10, 20, 30}, X = 4
Output: No

方法：想法是使用欧几里得的 GCD 来找到给定数组的 GCD。这给出了数组元素的所有公因子。通过去除所有这些因素，没有公因数存在。因此，可以生成这样的数组。否则，不可能生成这样的数组。

请按照以下步骤解决问题：

1. 初始化一个变量，比如G，来存储给定数组的 GCD。
2. 遍历数组arr[]并计算 GCD 并将其存储在一个变量中，比如G 。
3. 迭代范围[2, X]并检查G的除数是否大于X。
4. 如果发现是真的，则打印“否” 。否则，打印“是”。
5. 否则，通过将所有元素除以G修改数组后打印数组元素。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to check if it is possible
// to modify the array such that
// there is no common factor between
// array elements except 1
void checkCommonDivisor(int arr[],
                        int N, int X)
{
    // Stores GCD of the array
    int G = 0;
 
    // Calculate GCD of the array
    for (int i = 0; i < N; i++) {
        G = __gcd(G, arr[i]);
    }
 
    int copy_G = G;
 
    for (int divisor = 2;
         divisor <= X; divisor++) {
 
        // If the current divisor
        // is smaller than X
        while (G % divisor == 0) {
 
            // Divide GCD by the
            // current divisor
            G = G / divisor;
        }
    }
 
    // If possible
    if (G <= X) {
        cout << "Yes\n";
 
        // Print the modified array
        for (int i = 0; i < N; i++)
            cout << arr[i] / copy_G << " ";
        cout << endl;
    }
 
    // Otherwise
    else
        cout << "No";
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 6, 15, 6 }, X = 6;
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    checkCommonDivisor(arr, N, X);
}

Java

// Java program for the above approach
class GFG{
 
// Function to check if it is possible
// to modify the array such that
// there is no common factor between
// array elements except 1
static void checkCommonDivisor(int[] arr,
                               int N, int X)
{
     
    // Stores GCD of the array
    int G = 0;
 
    // Calculate GCD of the array
    for(int i = 0; i < N; i++)
    {
        G = gcd(G, arr[i]);
    }
 
    int copy_G = G;
 
    for(int divisor = 2;
            divisor <= X;
            divisor++)
    {
 
        // If the current divisor
        // is smaller than X
        while (G % divisor == 0)
        {
             
            // Divide GCD by the
            // current divisor
            G = G / divisor;
        }
    }
 
    // If possible
    if (G <= X)
    {
        System.out.println("Yes");
 
        // Print the modified array
        for(int i = 0; i < N; i++)
            System.out.print((arr[i] / copy_G) + " ");
             
        System.out.println();
    }
 
    // Otherwise
    else
        System.out.println("No");
}
 
// Calculating gcd
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
         
    return gcd(b, a % b);
}
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 6, 15, 6 };
    int X = 6;
 
    // Size of the array
    int N = arr.length;
 
    checkCommonDivisor(arr, N, X);
}
}
 
// This code is contributed by user_qa7r

Python3

# Python3 program for the above approach
import math
 
# Function to check if it is possible
# to modify the array such that
# there is no common factor between
# array elements except 1
def checkCommonDivisor(arr, N, X):
 
    # Stores GCD of the array
    G = 0
 
    # Calculate GCD of the array
    for i in range(N):
        G = math.gcd(G, arr[i])
 
    copy_G = G
 
    for divisor in range(2, X + 1):
 
        # If the current divisor
        # is smaller than X
        while (G % divisor == 0):
 
            # Divide GCD by the
            # current divisor
            G = G // divisor
 
    # If possible
    if (G <= X):
        print("Yes")
 
        # Print the modified array
        for i in range(N):
            print(arr[i] // copy_G, end = " ")
             
        print()
 
    # Otherwise
    else:
        print("No")
 
# Driver Code
if __name__ == "__main__":
 
    # Given array
    arr = [6, 15, 6]
    X = 6
 
    # Size of the array
    N = len(arr)
    checkCommonDivisor(arr, N, X)
 
# This code is contributed by ukasp

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
static int GCD(int a, int b)
{
    return b == 0 ? a : GCD(b, a % b);
}
  
// Function to check if it is possible
// to modify the array such that
// there is no common factor between
// array elements except 1
static void checkCommonDivisor(int []arr,
                               int N, int X)
{
     
    // Stores GCD of the array
    int G = 0;
 
    // Calculate GCD of the array
    for(int i = 0; i < N; i++)
    {
        G = GCD(G, arr[i]);
    }
 
    int copy_G = G;
 
    for(int divisor = 2;
            divisor <= X;
            divisor++)
    {
         
        // If the current divisor
        // is smaller than X
        while (G % divisor == 0)
        {
             
            // Divide GCD by the
            // current divisor
            G = G / divisor;
        }
    }
 
    // If possible
    if (G <= X)
    {
        Console.WriteLine("Yes");
 
        // Print the modified array
        for(int i = 0; i < N; i++)
            Console.Write(arr[i] / copy_G + " ");
             
        Console.Write("\n");
    }
 
    // Otherwise
    else
        Console.WriteLine("No");
}
 
// Driver Code
public static void Main()
{
     
    // Given array
    int []arr = { 6, 15, 6 };
    int X = 6;
 
    // Size of the array
    int N = arr.Length;
 
    checkCommonDivisor(arr, N, X);
}
}
 
// This code is contributed by bgangwar59

Javascript

// javascript program for the above approach   
// Function to check if it is possible
    // to modify the array such that
    // there is no common factor between
    // array elements except 1
    function checkCommonDivisor(arr , N , X) {
 
        // Stores GCD of the array
        var G = 0;
 
        // Calculate GCD of the array
        for (i = 0; i < N; i++) {
            G = gcd(G, arr[i]);
        }
 
        var copy_G = G;
 
        for (divisor = 2; divisor <= X; divisor++) {
 
            // If the current divisor
            // is smaller than X
            while (G % divisor == 0) {
 
                // Divide GCD by the
                // current divisor
                G = G / divisor;
            }
        }
 
        // If possible
        if (G <= X) {
            document.write("Yes<br/>");
 
            // Prvar the modified array
            for (i = 0; i < N; i++)
                document.write((arr[i] / copy_G) + " ");
 
            document.write();
        }
 
        // Otherwise
        else
            document.write("No");
    }
 
    // Calculating gcd
    function gcd(a , b) {
        if (b == 0)
            return a;
 
        return gcd(b, a % b);
    }
 
    // Driver Code
     
        var arr = [ 6, 15, 6 ];
        var X = 6;
 
        // Size of the array
        var N = arr.length;
 
        checkCommonDivisor(arr, N, X);
 
// This code is contributed by todaysgaurav

输出：

Yes
2 5 2

时间复杂度： O(N * logN)
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live