Print all numbers whose set of prime factors is a subset of the set of the prime factors of X

Given a number X and an array of N numbers. The task is to print all the numbers in the array whose set of prime factors is a subset of the set of the prime factors of X. 
Examples:

Input: X = 60, a[] = {2, 5, 10, 7, 17} 
Output: 2 5 10 
Set of prime factors of 60: {2, 3, 5} 
Set of prime factors of 2: {2} 
Set of prime factors of 5: {5} 
Set of prime factors of 10: {2, 5} 
Set of prime factors of 7: {7} 
Set of prime factors of 17: {17} 
Hence only 2, 5 and 10’s set of prime factors is a subset of set of prime 
factors of 60. 

Input: X = 15, a[] = {2, 8} 
Output: There are no such numbers 

Approach: Iterate for every element in the array, and keep dividing the number by the gcd of the number and X till gcd becomes 1 for the number and X. If at the end the number becomes 1 after continuous division, then print that number. 
Below is the implementation of the above approach: 

C++

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to print all the numbers
void printNumbers(int a[], int n, int x)
{

    bool flag = false;

    // Iterate for every element in the array
    for (int i = 0; i < n; i++) {

        int num = a[i];

        // Find the gcd
        int g = __gcd(num, x);

        // Iterate till gcd is 1
        // of number and x
        while (g != 1) {

            // Divide the number by gcd
            num /= g;

            // Find the new gcdg
            g = __gcd(num, x);
        }

        // If the number is 1 at the end
        // then print the number
        if (num == 1) {
            flag = true;
            cout << a[i] << " ";
        }
    }

    // If no numbers have been there
    if (!flag)
        cout << "There are no such numbers";
}

// Drivers code
int main()
{
    int x = 60;
    int a[] = { 2, 5, 10, 7, 17 };
    int n = sizeof(a) / sizeof(a[0]);

    printNumbers(a, n, x);
    return 0;
}

Java

// Java program to implement
// the above approach
import java.io.*;
public class GFG
{

// Function to print all the numbers
static void printNumbers(int a[], int n, int x)
{

    boolean flag = false;

    // Iterate for every element in the array
    for (int i = 0; i < n; i++)
    {

        int num = a[i];

        // Find the gcd
        int g = __gcd(num, x);

        // Iterate till gcd is 1
        // of number and x
        while (g != 1)
        {

            // Divide the number by gcd
            num /= g;

            // Find the new gcdg
            g = __gcd(num, x);
        }

        // If the number is 1 at the end
        // then print the number
        if (num == 1)
        {
            flag = true;
            System.out.print(a[i] + " ");
        }
    }

    // If no numbers have been there
    if (!flag)
        System.out.println("There are no such numbers");
}

static int __gcd(int a, int b)
{
    if (b == 0)
        return a;
    return __gcd(b, a % b);

}

// Drivers code
public static void main(String[] args)
{
    int x = 60;
    int a[] = { 2, 5, 10, 7, 17 };
    int n = a.length;

    printNumbers(a, n, x);
}
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python3 program to implement
# the above approach
from math import gcd

# Function to print all the numbers
def printNumbers(a, n, x) :

    flag = False

    # Iterate for every element in the array
    for i in range(n) :

        num = a[i]

        # Find the gcd
        g = gcd(num, x)

        # Iterate till gcd is 1
        # of number and x
        while (g != 1) :

            # Divide the number by gcd
            num //= g

            # Find the new gcdg
            g = gcd(num, x)

        # If the number is 1 at the end
        # then print the number
        if (num == 1) :
            flag = True;
            print(a[i], end = " ");

    # If no numbers have been there
    if (not flag) :
        print("There are no such numbers")

# Driver Code
if __name__ == "__main__" :

    x = 60
    a = [ 2, 5, 10, 7, 17 ]
    n = len(a)

    printNumbers(a, n, x)

# This code is contributed by Ryuga

C#

// C# program to implement
// the above approach
using System;

class GFG
{

// Function to print all the numbers
static void printNumbers(int []a, int n, int x)
{

    bool flag = false;

    // Iterate for every element in the array
    for (int i = 0; i < n; i++)
    {

        int num = a[i];

        // Find the gcd
        int g = __gcd(num, x);

        // Iterate till gcd is 1
        // of number and x
        while (g != 1)
        {

            // Divide the number by gcd
            num /= g;

            // Find the new gcdg
            g = __gcd(num, x);
        }

        // If the number is 1 at the end
        // then print the number
        if (num == 1)
        {
            flag = true;
            Console.Write(a[i] + " ");
        }
    }

    // If no numbers have been there
    if (!flag)
        Console.WriteLine("There are no such numbers");
}

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 x = 60;
    int []a = { 2, 5, 10, 7, 17 };
    int n = a.Length;

    printNumbers(a, n, x);
}
}

// This code has been contributed by 29AjayKumar

PHP

<?php
// PHP program to implement
// the above approach

// Function to print all the numbers
function printNumbers($a, $n, $x)
{

    $flag = false;

    // Iterate for every element in the array
    for ($i = 0; $i < $n; $i++)
    {

        $num = $a[$i];

        // Find the gcd
        $g = __gcd($num, $x);

        // Iterate till gcd is 1
        // of number and x
        while ($g != 1)
        {

            // Divide the number by gcd
            $num /= $g;

            // Find the new gcdg
            $g = __gcd($num, $x);
        }

        // If the number is 1 at the end
        // then print the number
        if ($num == 1)
        {
            $flag = true;
            echo $a[$i] , " ";
        }
    }

    // If no numbers have been there
    if (!$flag)
        echo ("There are no such numbers");
}

function __gcd($a, $b)
{
    if ($b == 0)
        return $a;
    return __gcd($b, $a % $b);

}

// Driver code

$x = 60;
$a = array(2, 5, 10, 7, 17 );
$n = count($a);


printNumbers($a, $n, $x);

// This code has been contributed by ajit.
?>

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to print all the numbers

// Find the gcd
function __gcd(a, b)
{
    if (b == 0)
        return a;
    return __gcd(b, a % b);

}

function printNumbers(a, n, x)
{

    let flag = false;

    // Iterate for every element in the array
    for (let i = 0; i < n; i++) {

        let num = a[i];

        // Find the gcd
        let g = __gcd(num, x);

        // Iterate till gcd is 1
        // of number and x
        while (g != 1) {

            // Divide the number by gcd
            num = parseInt(num/g);

            // Find the new gcdg
            g = __gcd(num, x);
        }

        // If the number is 1 at the end
        // then print the number
        if (num == 1) {
            flag = true;
            document.write(a[i] + " ");
        }
    }

    // If no numbers have been there
    if (!flag)
        document.write("There are no such numbers");
}

// Drivers code

    let x = 60;
    let a = [ 2, 5, 10, 7, 17 ];
    let n = a.length;

    printNumbers(a, n, x);

</script>

Output:

2 5 10

Time Complexity: O(n logn), where n is the time to traverse a given array size and logn operations for gcd function going inside it
Auxiliary Space: O(1), no extra space required

Another Approach Using DP :

To solve this problem using dynamic programming (DP), we can use a boolean table dp[i][j], where dp[i][j] will be true if there is a subset of elements from the first i elements of the array (a[0] to a[i-1]) whose gcd is j.

We can fill this table in a bottom-up manner, starting from dp[0][j] = (j == 1) for all j, because an empty subset will have a gcd of 1. Then, for each i > 0 and j > 0, we can compute dp[i][j] by considering two cases:

1. We don’t include a[i-1] in the subset: In this case, dp[i][j] will be the same as dp[i-1][j], because we are not adding a[i-1] to the subset.
2. We include a[i-1] in the subset: In this case, dp[i][j] will be true if dp[i-1][j] is true (because we can already form a subset whose gcd is j without using a[i-1]), or if dp[i-1][gcd(j, a[i-1])] is true (because we can form a subset whose gcd is j by adding a[i-1] to a subset whose gcd is gcd(j, a[i-1])).

After filling this table, we can simply iterate over the last row (dp[n][j]) and print out all the j such that dp[n][j] is true.

C++

#include <bits/stdc++.h>
using namespace std;

void printNumbers(int a[], int n, int x)
{
    bool flag = false;

    // Iterate for every element in the array
    for (int i = 0; i < n; i++)
    {
        int num = a[i];

        // Find the gcd
        int g = __gcd(num, x);

        // Iterate till gcd is 1 of number and x
        while (g != 1)
        {
            // Divide the number by gcd
            num /= g;

            // Find the new gcd
            g = __gcd(num, x);
        }

        // If the number is 1 at the end, then print the number
        if (num == 1)
        {
            flag = true;
            cout << a[i] << " ";
        }
    }

    // If no numbers have been printed, print "There are no such numbers"
    if (!flag)
        cout << "There are no such numbers";
}

int main()
{
    int x = 60;
    int a[] = { 2, 5, 10, 7, 17 };
    int n = sizeof(a) / sizeof(a[0]);

    printNumbers(a, n, x);
    return 0;
}

Output

2 5 10 

Time Complexity: O(n logn)
Auxiliary Space: O(1)