# Nearest element with at-least one common prime factor

Given an array arr[], find the nearest element for every element such that there is at least one common prime factor. In the output, we need to print the position of the closest element.

Example:

```Input: arr[] = {2, 9, 4, 3, 13}
Output: 3 4 1 2 -1
Explanation :
Closest element for 1st element is 3rd.
=>Common prime factor of 1st and 3rd elements
is 2.
Closest element for 2nd element is 4th.
=>Common prime factor of 2nd and 4th elements
is 3.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive approach

The common prime factor will only exist if the GCD of these two numbers will greater than 1. Simple brute force is to run the two loops one inside the another and iterate one by one from each index to both the sides simultaneously and find the gcd which is greater than 1. Whenever we found the answer then just break the loop and the print. If we reached the end of an array after traversing both the sides then simply print -1.

## C++

 `// C++ program to print nearest element with at least ` `// one common prime factor. ` `#include ` `using` `namespace` `std; ` ` `  `void` `nearestGcd(``int` `arr[], ``int` `n) ` `{ ` `    ``// Loop covers the every element of arr[] ` `    ``for` `(``int` `i=0; i0 || k<=n; --j, ++k) ` `        ``{ ` `            ``if` `(j>=0 && __gcd(arr[i], arr[j]) > 1) ` `            ``{ ` `                ``closest = j+1; ` `                ``break``; ` `            ``} ` `            ``if` `(k1) ` `            ``{ ` `                ``closest = k+1; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// print position of closest element ` `        ``cout << closest << ``" "``; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {2, 9, 4, 3, 13}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` `    ``nearestGcd(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print nearest element  ` `// with at least one common prime factor. ` `import` `java.util.*; ` `import` `java.lang.*; ` ` `  `class` `GFG  ` `{ ` `static` `void` `nearestGcd(``int` `[]arr, ``int` `n)  ` `{  ` `    ``// Loop covers the every ` `    ``// element of arr[]  ` `    ``for` `(``int` `i = ``0``; i < n; ++i)  ` `    ``{  ` `        ``int` `closest = -``1``;  ` ` `  `        ``// Loop that covers from 0 to  ` `        ``// i-1 and i+1 to n-1 indexes  ` `        ``// simultaneously  ` `        ``for` `(``int` `j = i - ``1``, k = i + ``1``;  ` `                 ``j > ``0` `|| k <= n; --j, ++k)  ` `        ``{  ` `            ``if` `(j >= ``0` `&& __gcd(arr[i], arr[j]) > ``1``)  ` `            ``{  ` `                ``closest = j + ``1``;  ` `                ``break``;  ` `            ``}  ` `            ``if` `(k < n && __gcd(arr[i], arr[k]) > ``1``)  ` `            ``{  ` `                ``closest = k + ``1``;  ` `                ``break``;  ` `            ``}  ` `        ``}  ` ` `  `        ``// print position of closest element  ` `        ``System.out.print(closest + ``" "``);  ` `    ``}  ` `}  ` ` `  `// Recursive function to return  ` `// gcd of a and b  ` `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 = {``2``, ``9``, ``4``, ``3``, ``13``};  ` `    ``int` `n = arr.length;  ` `    ``nearestGcd(arr, n);  ` `}  ` `} ` ` `  `// This code is contributed  ` `// by Akanksha Rai `

## Python 3

 `# Python 3 program to print nearest  ` `# element with at least one common ` `# prime factor. ` `import` `math ` ` `  `def` `nearestGcd(arr, n): ` ` `  `    ``# Loop covers the every element of arr[] ` `    ``for` `i ``in` `range``(n): ` `        ``closest ``=` `-``1` ` `  `        ``# Loop that covers from 0 to i-1 and  ` `        ``# i+1 to n-1 indexes simultaneously ` `        ``j ``=` `i ``-` `1` `        ``k ``=` `i ``+` `1` `        ``while` `j > ``0` `or` `k <``=` `n: ` `            ``if` `(j >``=` `0` `and`  `                ``math.gcd(arr[i], arr[j]) > ``1``): ` `                ``closest ``=` `j ``+` `1` `                ``break` `             `  `            ``if` `(k < n ``and` `                ``math.gcd(arr[i], arr[k]) > ``1``): ` `                ``closest ``=` `k ``+` `1` `                ``break` `            ``k ``+``=` `1` `            ``j ``-``=` `1` ` `  `        ``# print position of closest element ` `        ``print``(closest, end ``=` `" "``) ` ` `  `# Driver code ` `if` `__name__``=``=``"__main__"``: ` `     `  `    ``arr ``=` `[``2``, ``9``, ``4``, ``3``, ``13``] ` `    ``n ``=` `len``(arr) ` `    ``nearestGcd(arr, n) ` ` `  `# This code is contributed by ita_c `

## C#

 `// C# program to print nearest element  ` `// with at least one common prime factor. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `static` `void` `nearestGcd(``int` `[]arr, ``int` `n)  ` `{  ` `    ``// Loop covers the every ` `    ``// element of arr[]  ` `    ``for` `(``int` `i = 0; i < n; ++i)  ` `    ``{  ` `        ``int` `closest = -1;  ` ` `  `        ``// Loop that covers from 0 to  ` `        ``// i-1 and i+1 to n-1 indexes  ` `        ``// simultaneously  ` `        ``for` `(``int` `j = i - 1, k = i + 1;  ` `                 ``j > 0 || k <= n; --j, ++k)  ` `        ``{  ` `            ``if` `(j >= 0 && __gcd(arr[i], arr[j]) > 1)  ` `            ``{  ` `                ``closest = j + 1;  ` `                ``break``;  ` `            ``}  ` `            ``if` `(k < n && __gcd(arr[i], arr[k]) > 1)  ` `            ``{  ` `                ``closest = k + 1;  ` `                ``break``;  ` `            ``}  ` `        ``}  ` ` `  `        ``// print position of closest element  ` `        ``Console.Write(closest + ``" "``);  ` `    ``}  ` `}  ` ` `  `// Recursive function to return  ` `// gcd of a and b  ` `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{      ` `    ``if` `(b == 0)  ` `        ``return` `a;  ` `    ``return` `__gcd(b, a % b);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main()  ` `{  ` `    ``int` `[]arr = {2, 9, 4, 3, 13};  ` `    ``int` `n = arr.Length;  ` `    ``nearestGcd(arr, n);  ` `}  ` `} ` ` `  `// This code is contributed  ` `// by 29AjayKumar `

## PHP

 ` 0 || ``\$k` `<= ``\$n``; --``\$j``, ++``\$k``)  ` `        ``{  ` `            ``if` `(``\$j` `>= 0 && __gcd(``\$arr``[``\$i``],  ` `                                 ``\$arr``[``\$j``]) > 1)  ` `            ``{  ` `                ``\$closest` `= ``\$j` `+ 1;  ` `                ``break``;  ` `            ``}  ` `            ``if` `(``\$k` `< ``\$n` `&& __gcd(``\$arr``[``\$i``],  ` `                                 ``\$arr``[``\$k``]) > 1)  ` `            ``{  ` `                ``\$closest` `= ``\$k` `+ 1;  ` `                ``break``;  ` `            ``}  ` `        ``}  ` ` `  `        ``// print position of closest element  ` `        ``echo` `\$closest` `. ``" "``;  ` `    ``}  ` `}  ` ` `  `// Recursive function to return  ` `// gcd of a and b  ` `function` `__gcd(``\$a``, ``\$b``)  ` `{  ` `    ``if` `(``\$b` `== 0)  ` `        ``return` `\$a``;  ` `    ``return` `__gcd(``\$b``, ``\$a` `% ``\$b``);  ` `}  ` ` `  `// Driver Code  ` `\$arr` `= ``array``(2, 9, 4, 3, 13);  ` `\$n` `= sizeof(``\$arr``);  ` `nearestGcd(``\$arr``, ``\$n``);  ` ` `  `// This code is contributed  ` `// by Akanksha Rai ` `?> `

`Output: 3 4 1 2 -1`

Time complexity: O(n2)
Auxiliary space: O(1)

Efficient Approach

We find prime factors of all array elements. To quickly find prime factors, we use Sieve of Eratosthenes. For every element, we consider all prime factors and keep track of closest element with common factor.

## C++

 `// C++ program to print nearest element with at least ` `// one common prime factor. ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `MAX = 100001; ` `const` `int` `INF = INT_MAX; ` ` `  `int` `primedivisor[MAX], dist[MAX], pos[MAX], divInd[MAX]; ` ` `  `vector<``int``> divisors[MAX]; ` ` `  `// Pre-computation of smallest prime divisor ` `// of all numbers ` `void` `sieveOfEratosthenes() ` `{ ` `    ``for` `(``int` `i=2; i*i < MAX; ++i) ` `    ``{ ` `        ``if` `(!primedivisor[i]) ` `            ``for` `(``int` `j = i*i; j < MAX; j += i) ` `                ``primedivisor[j] = i; ` `    ``} ` ` `  `    ``// Prime number will have same divisor ` `    ``for` `(``int` `i = 1; i < MAX; ++i) ` `        ``if` `(!primedivisor[i]) ` `            ``primedivisor[i] = i; ` `} ` ` `  `// Function to calculate all divisors of ` `// input array ` `void` `findDivisors(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i=0; i 1) ` `        ``{ ` `            ``int` `div` `= primedivisor[num]; ` `            ``divisors[i].push_back(``div``); ` `            ``while` `(num % ``div` `== 0) ` `                ``num /= ``div``; ` `        ``} ` `    ``} ` `} ` ` `  `void` `nearestGCD(``int` `arr[], ``int` `n) ` `{ ` `    ``// Pre-compute all the divisors of array ` `    ``// element by using prime factors ` `    ``findDivisors(arr, n); ` ` `  `    ``// Traverse all elements, ` `    ``for` `(``int` `i=0; i ``abs``(ind-i)) ` `                ``{ ` `                    ``// Set the min distance of current ` `                    ``// index 'i' to nearest one ` `                    ``dist[i] = ``abs``(ind-i); ` ` `  `                    ``// Add 1 as indexing starts from 0 ` `                    ``pos[i] = ind + 1; ` `                ``} ` ` `  `                ``if` `(dist[ind] > ``abs``(ind-i)) ` `                ``{ ` `                    ``// Set the min distance of found index 'ind' ` `                    ``dist[ind] = ``abs``(ind-i); ` ` `  `                    ``// Add 1 as indexing starts from 0 ` `                    ``pos[ind] = i + 1; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Simple sieve to find smallest prime ` `    ``// divisor of number from 2 to MAX ` `    ``sieveOfEratosthenes(); ` ` `  `    ``int` `arr[] = {2, 9, 4, 3, 13}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` ` `  `    ``// function to calculate nearest distance ` `    ``// of every array elements ` `    ``nearestGCD(arr, n); ` ` `  `    ``// Print the nearest distance having GDC>1 ` `    ``for` `(``int` `i=0; i

## Python3

 `# Python3 program to print nearest element with at least ` `# one common prime factor. ` ` `  `MAX` `=` `100001` `INF ``=` `10``*``*``9` ` `  `primedivisor ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `dist ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `pos ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `divInd ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` ` `  `divisors ``=` `[[] ``for` `i ``in` `range``(``MAX``)] ` ` `  `# Pre-computation of smallest prime divisor ` `# of all numbers ` `def` `sieveOfEratosthenes(): ` ` `  `    ``for` `i ``in` `range``(``2``,``MAX``): ` `        ``if` `i ``*` `i > ``MAX``: ` `            ``break` ` `  `        ``if` `(primedivisor[i] ``=``=` `0``): ` `            ``for` `j ``in` `range``(``2` `*` `i, ``MAX``, i): ` `                ``primedivisor[j] ``=` `i ` ` `  `    ``# Prime number will have same divisor ` `    ``for` `i ``in` `range``(``1``, ``MAX``): ` `        ``if` `(primedivisor[i] ``=``=` `0``): ` `            ``primedivisor[i] ``=` `i ` ` `  `# Function to calculate all divisors of ` `# input array ` `def` `findDivisors(arr, n): ` ` `  `    ``for` `i ``in` `range``(``MAX``): ` `        ``pos[i] ``=` `divInd[i] ``=` `-``1` `        ``dist[i] ``=` `10``*``*``9` `    ``for` `i ``in` `range``(n): ` `        ``num ``=` `arr[i] ` `        ``while` `(num > ``1``): ` ` `  `            ``div ``=` `primedivisor[num] ` `            ``divisors[i].append(div) ` `            ``while` `(num ``%` `div ``=``=` `0``): ` `                ``num ``/``/``=` `div ` ` `  ` `  `def` `nearestGCD(arr, n): ` `    ``# Pre-compute all the divisors of array ` `    ``# element by using prime factors ` `    ``findDivisors(arr, n) ` ` `  `    ``# Traverse all elements, ` `    ``for` `i ``in` `range``(n): ` `        ``# For every divisor of current element, ` `        ``# find closest element. ` `        ``for` `div ``in` `divisors[i]: ` `            ``# Visit divisor if not visited ` `            ``if` `(divInd[div] ``=``=` `-``1``): ` `                ``divInd[div] ``=` `i ` `            ``else``: ` ` `  `                ``# Fetch the index of visited divisor ` `                ``ind ``=` `divInd[div] ` ` `  `                ``# Update the divisor index to current index ` `                ``divInd[div] ``=` `i ` ` `  `                ``# Set the minimum distance ` `                ``if` `(dist[i] > ``abs``(ind``-``i)): ` ` `  `                    ``# Set the min distance of current ` `                    ``# index 'i' to nearest one ` `                    ``dist[i] ``=` `abs``(ind``-``i) ` ` `  `                    ``# Add 1 as indexing starts from 0 ` `                    ``pos[i] ``=` `ind ``+` `1` ` `  ` `  `                ``if` `(dist[ind] > ``abs``(ind``-``i)): ` ` `  `                    ``# Set the min distance of found index 'ind' ` `                    ``dist[ind] ``=` `abs``(ind``-``i) ` ` `  `                    ``# Add 1 as indexing starts from 0 ` `                    ``pos[ind] ``=` `i ``+` `1` ` `  ` `  `# Driver code ` ` `  `# Simple sieve to find smallest prime ` `# divisor of number from 2 to MAX ` `sieveOfEratosthenes() ` ` `  `arr ``=``[``2``, ``9``, ``4``, ``3``, ``13``] ` `n ``=` `len``(arr) ` ` `  `# function to calculate nearest distance ` `# of every array elements ` `nearestGCD(arr, n) ` ` `  `# Print the nearest distance having GDC>1 ` `for` `i ``in` `range``(n): ` `    ``print``(pos[i],end``=``" "``) ` `     `  `# This code is contributed by mohit kumar 29 `

```Output:
3 4 1 2 -1
```

Time complexity: O(MAX * log(log (MAX) ) )
Auxiliary space: O(MAX)

This article is contributed by Shubham Bansal. 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.