Check for an array element that is co-prime with all others

Given an array arr[] of positive integers where 2 ≤ arr[i] ≤ 106 for all possible values of i. The task is to check whether there exists at least one element in the given array that forms co-prime pair with all other elements of the array. If no such element exists then print No else print Yes.

Examples:

Input: arr[] = {2, 8, 4, 10, 6, 7}
Output: Yes
7 is co-prime with all the other elements of the array

Input: arr[] = {3, 6, 9, 12}
Output: No

Naive approach: A simple solution is to check whether the gcd of every element with all other elements is equal to 1. Time complexity of this solution is O(n2).



Efficient approach: An efficient solution is to generate all the prime factors of integers in the given array. Using hash, store the count of every element which is a prime factor of any of the number in the array. If the element does not contain any common prime factor with other elements, it always forms a co-prime pair with other elements.
For generating prime factors please go through the article Prime Factorization using Sieve in O(log n)

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;
  
#define MAXN 1000001
  
// Stores smallest prime factor for every number
int spf[MAXN];
  
// Hash to store prime factors count
int hash1[MAXN] = { 0 };
  
// Function to calculate SPF (Smallest Prime Factor)
// for every number till MAXN
void sieve()
{
    spf[1] = 1;
    for (int i = 2; i < MAXN; i++)
  
        // Marking smallest prime factor for every
        // number to be itself
        spf[i] = i;
  
    // Separately marking spf for every even
    // number as 2
    for (int i = 4; i < MAXN; i += 2)
        spf[i] = 2;
  
    // Checking if i is prime
    for (int i = 3; i * i < MAXN; i++) {
  
        // Marking SPF for all numbers divisible by i
        if (spf[i] == i) {
            for (int j = i * i; j < MAXN; j += i)
  
                // Marking spf[j] if it is not
                // previously marked
                if (spf[j] == j)
                    spf[j] = i;
        }
    }
}
  
// Function to store the prime factors after dividing
// by the smallest prime factor at every step
void getFactorization(int x)
{
    int temp;
    while (x != 1) {
        temp = spf[x];
        if (x % temp == 0) {
  
            // Storing the count of
            // prime factors in hash
            hash1[spf[x]]++;
            x = x / spf[x];
        }
        while (x % temp == 0)
            x = x / temp;
    }
}
  
// Function that returns true if there are
// no common prime factors between x
// and other numbers of the array
bool check(int x)
{
    int temp;
    while (x != 1) {
        temp = spf[x];
  
        // Checking whether it common
        // prime factor with other numbers
        if (x % temp == 0 && hash1[temp] > 1)
            return false;
        while (x % temp == 0)
            x = x / temp;
    }
    return true;
}
  
// Function that returns true if there is
// an element in the array which is coprime
// with all the other elements of the array
bool hasValidNum(int arr[], int n)
{
  
    // Using sieve for generating prime factors
    sieve();
  
    for (int i = 0; i < n; i++)
        getFactorization(arr[i]);
  
    // Checking the common prime factors
    // with other numbers
    for (int i = 0; i < n; i++)
        if (check(arr[i]))
            return true;
  
    return false;
}
  
// Driver code
int main()
{
    int arr[] = { 2, 8, 4, 10, 6, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    if (hasValidNum(arr, n))
        cout << "Yes";
    else
        cout << "No";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG
{
      
static int MAXN = 1000001;
  
// Stores smallest prime factor for every number
static int[] spf = new int[MAXN];
  
// Hash to store prime factors count
static int[] hash1 = new int[MAXN];
  
// Function to calculate SPF (Smallest Prime Factor)
// for every number till MAXN
static void sieve()
{
    spf[1] = 1;
    for (int i = 2; i < MAXN; i++)
  
        // Marking smallest prime factor for every
        // number to be itself
        spf[i] = i;
  
    // Separately marking spf for every even
    // number as 2
    for (int i = 4; i < MAXN; i += 2)
        spf[i] = 2;
  
    // Checking if i is prime
    for (int i = 3; i * i < MAXN; i++) 
    {
  
        // Marking SPF for all numbers divisible by i
        if (spf[i] == i) 
        {
            for (int j = i * i; j < MAXN; j += i)
  
                // Marking spf[j] if it is not
                // previously marked
                if (spf[j] == j)
                    spf[j] = i;
        }
    }
}
  
// Function to store the prime factors after dividing
// by the smallest prime factor at every step
static void getFactorization(int x)
{
    int temp;
    while (x != 1
    {
        temp = spf[x];
        if (x % temp == 0
        {
  
            // Storing the count of
            // prime factors in hash
            hash1[spf[x]]++;
            x = x / spf[x];
        }
        while (x % temp == 0)
            x = x / temp;
    }
}
  
// Function that returns true if there are
// no common prime factors between x
// and other numbers of the array
static boolean check(int x)
{
    int temp;
    while (x != 1
    {
        temp = spf[x];
  
        // Checking whether it common
        // prime factor with other numbers
        if (x % temp == 0 && hash1[temp] > 1)
            return false;
        while (x % temp == 0)
            x = x / temp;
    }
    return true;
}
  
// Function that returns true if there is
// an element in the array which is coprime
// with all the other elements of the array
static boolean hasValidNum(int []arr, int n)
{
  
    // Using sieve for generating prime factors
    sieve();
  
    for (int i = 0; i < n; i++)
        getFactorization(arr[i]);
  
    // Checking the common prime factors
    // with other numbers
    for (int i = 0; i < n; i++)
        if (check(arr[i]))
            return true;
  
    return false;
}
  
// Driver code
public static void main (String[] args) 
{
  
    int []arr = { 2, 8, 4, 10, 6, 7 };
    int n = arr.length;
  
    if (hasValidNum(arr, n))
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
  
// This code is contributed by chandan_jnu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
MAXN = 1000001
  
# Stores smallest prime factor for 
# every number
spf = [i for i in range(MAXN)]
  
# Hash to store prime factors count
hash1 = [0 for i in range(MAXN)]
  
# Function to calculate SPF (Smallest 
# Prime Factor) for every number till MAXN
def sieve():
  
    # Separately marking spf for 
    # every even number as 2
    for i in range(4, MAXN, 2):
        spf[i] = 2
  
    # Checking if i is prime
    for i in range(3, MAXN):
  
        if i * i < MAXN:
            break
  
        # Marking SPF for all numbers
        # divisible by i
        if (spf[i] == i):
            for j in range(i * i, MAXN, i):
  
                # Marking spf[j] if it is not
                # previously marked
                if (spf[j] == j):
                    spf[j] = i
  
# Function to store the prime factors 
# after dividing by the smallest prime 
# factor at every step
def getFactorization(x):
  
    while (x != 1):
        temp = spf[x]
        if (x % temp == 0):
  
            # Storing the count of
            # prime factors in hash
            hash1[spf[x]] += 1
            x = x // spf[x]
  
        while (x % temp == 0):
            x = x // temp
  
# Function that returns true if there 
# are no common prime factors between x
# and other numbers of the array
def check(x):
  
    while (x != 1):
        temp = spf[x]
  
        # Checking whether it common
        # prime factor with other numbers
        if (x % temp == 0 and hash1[temp] > 1):
            return False
        while (x % temp == 0):
            x = x //temp
      
    return True
  
# Function that returns true if there is
# an element in the array which is coprime
# with all the other elements of the array
def hasValidNum(arr, n):
  
    # Using sieve for generating 
    # prime factors
    sieve()
  
    for i in range(n):
        getFactorization(arr[i])
  
    # Checking the common prime factors
    # with other numbers
    for i in range(n):
        if (check(arr[i])):
            return True
  
    return False
  
# Driver code
arr = [2, 8, 4, 10, 6, 7]
n = len(arr)
  
if (hasValidNum(arr, n)):
    print("Yes")
else:
    print("No")
  
# This code is contributed by mohit kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG
{
      
static int MAXN=1000001;
  
// Stores smallest prime factor for every number
static int[] spf = new int[MAXN];
  
// Hash to store prime factors count
static int[] hash1 = new int[MAXN];
  
// Function to calculate SPF (Smallest Prime Factor)
// for every number till MAXN
static void sieve()
{
    spf[1] = 1;
    for (int i = 2; i < MAXN; i++)
  
        // Marking smallest prime factor for every
        // number to be itself
        spf[i] = i;
  
    // Separately marking spf for every even
    // number as 2
    for (int i = 4; i < MAXN; i += 2)
        spf[i] = 2;
  
    // Checking if i is prime
    for (int i = 3; i * i < MAXN; i++) 
    {
  
        // Marking SPF for all numbers divisible by i
        if (spf[i] == i) 
        {
            for (int j = i * i; j < MAXN; j += i)
  
                // Marking spf[j] if it is not
                // previously marked
                if (spf[j] == j)
                    spf[j] = i;
        }
    }
}
  
// Function to store the prime factors after dividing
// by the smallest prime factor at every step
static void getFactorization(int x)
{
    int temp;
    while (x != 1) 
    {
        temp = spf[x];
        if (x % temp == 0) 
        {
  
            // Storing the count of
            // prime factors in hash
            hash1[spf[x]]++;
            x = x / spf[x];
        }
        while (x % temp == 0)
            x = x / temp;
    }
}
  
// Function that returns true if there are
// no common prime factors between x
// and other numbers of the array
static bool check(int x)
{
    int temp;
    while (x != 1) 
    {
        temp = spf[x];
  
        // Checking whether it common
        // prime factor with other numbers
        if (x % temp == 0 && hash1[temp] > 1)
            return false;
        while (x % temp == 0)
            x = x / temp;
    }
    return true;
}
  
// Function that returns true if there is
// an element in the array which is coprime
// with all the other elements of the array
static bool hasValidNum(int []arr, int n)
{
  
    // Using sieve for generating prime factors
    sieve();
  
    for (int i = 0; i < n; i++)
        getFactorization(arr[i]);
  
    // Checking the common prime factors
    // with other numbers
    for (int i = 0; i < n; i++)
        if (check(arr[i]))
            return true;
  
    return false;
}
  
// Driver code
static void Main()
{
    int []arr = { 2, 8, 4, 10, 6, 7 };
    int n = arr.Length;
  
    if (hasValidNum(arr, n))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
}
  
// This code is contributed by chandan_jnu

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
  
$MAXN = 10001;
  
// Stores smallest prime factor for every number
$spf = array_fill(0, $MAXN, 0);
  
// Hash to store prime factors count
$hash1 = array_fill(0, $MAXN, 0);
  
// Function to calculate SPF (Smallest Prime Factor)
// for every number till MAXN
function sieve()
{
    global $spf, $MAXN, $hash1;
    $spf[1] = 1;
    for ($i = 2; $i < $MAXN; $i++)
  
        // Marking smallest prime factor for every
        // number to be itself
        $spf[$i] = $i;
  
    // Separately marking spf for every even
    // number as 2
    for ($i = 4; $i < $MAXN; $i += 2)
        $spf[$i] = 2;
  
    // Checking if i is prime
    for ($i = 3; $i * $i < $MAXN; $i++) 
    {
  
        // Marking SPF for all numbers divisible by i
        if ($spf[$i] == $i)
        {
            for ($j = $i * $i; $j < $MAXN; $j += $i)
  
                // Marking spf[j] if it is not
                // previously marked
                if ($spf[$j] == $j)
                    $spf[$j] = $i;
        }
    }
}
  
// Function to store the prime factors after dividing
// by the smallest prime factor at every step
function getFactorization($x)
{
    global $spf,$MAXN,$hash1;
    while ($x != 1) 
    {
        $temp = $spf[$x];
        if ($x % $temp == 0) 
        {
  
            // Storing the count of
            // prime factors in hash
            $hash1[$spf[$x]]++;
            $x = (int)($x / $spf[$x]);
        }
        while ($x % $temp == 0)
            $x = (int)($x / $temp);
    }
}
  
// Function that returns true if there are
// no common prime factors between x
// and other numbers of the array
function check($x)
{
    global $spf,$MAXN,$hash1;
    while ($x != 1)
    {
        $temp = $spf[$x];
  
        // Checking whether it common
        // prime factor with other numbers
        if ($x % $temp == 0 && $hash1[$temp] > 1)
            return false;
        while ($x % $temp == 0)
            $x = (int)($x / $temp);
    }
    return true;
}
  
// Function that returns true if there is
// an element in the array which is coprime
// with all the other elements of the array
function hasValidNum($arr, $n)
{
    global $spf,$MAXN,$hash1;
  
    // Using sieve for generating prime factors
    sieve();
  
    for ($i = 0; $i < $n; $i++)
        getFactorization($arr[$i]);
  
    // Checking the common prime factors
    // with other numbers
    for ($i = 0; $i < $n; $i++)
        if (check($arr[$i]))
            return true;
  
    return false;
}
  
// Driver code
    $arr = array( 2, 8, 4, 10, 6, 7 );
    $n = count($arr);
  
    if (hasValidNum($arr, $n))
        echo "Yes";
    else
        echo "No";
  
// This code is contributed by chandan_jnu
?>

chevron_right


Output:

Yes

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

Recommended Posts:


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.