Skip to content
Related Articles
Nearest element with at-least one common prime factor
• Difficulty Level : Medium
• Last Updated : 14 May, 2021

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.```

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);``    ``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``?>`

## Javascript

 ``
`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 the closest element with a 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);` `    ``// function to calculate nearest distance``    ``// of every array elements``    ``nearestGCD(arr, n);` `    ``// Print the nearest distance having GDC>1``    ``for` `(``int` `i=0; i

## Java

 `// Java program to print nearest element with at least``// one common prime factor.``import` `java.io.*;``import` `java.util.*;``class` `GFG``{``  ``static` `int` `MAX = ``100001``;``  ``static` `int` `INF = Integer.MAX_VALUE;``  ``static` `int``[] primedivisor = ``new` `int` `[MAX];``  ``static` `int``[] dist = ``new` `int` `[MAX];``  ``static` `int``[] pos = ``new` `int` `[MAX];``  ``static` `int``[] divInd = ``new` `int` `[MAX];` `  ``static` `ArrayList> divisors =``    ``new` `ArrayList>();` `  ``// Pre-computation of smallest prime divisor``  ``// of all numbers``  ``static` `void` `sieveOfEratosthenes()``  ``{``    ``for` `(``int` `i = ``2``; i * i < MAX; ++i)``    ``{``      ``if` `(primedivisor[i] == ``0``)``      ``{``        ``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] == ``0``)``      ``{``        ``primedivisor[i] = i;``      ``}``    ``}` `  ``}` `  ``// Function to calculate all divisors of``  ``// input array``  ``static` `void` `findDivisors(``int` `arr[], ``int` `n)``  ``{``    ``for` `(``int` `i=``0``; i ``1``)``      ``{``        ``int` `div = primedivisor[num];``        ``divisors.get(i).add(div);``        ``while` `(num % div == ``0``)``        ``{``          ``num /= div;``        ``}``      ``}``    ``}` `  ``}` `  ``static` `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 < n; ++i)``    ``{` `      ``// For every divisor of current element,``      ``// find closest element.``      ``for``(``int` `div : divisors.get(i))``      ``{` `        ``// Visit divisor if not visited``        ``if` `(divInd[div] == -``1``)``        ``{``          ``divInd[div] = i;``        ``}``        ``else``        ``{` `          ``// Fetch the index of visited divisor``          ``int` `ind = divInd[div];` `          ``// Update the divisor index to current index``          ``divInd[div] = i;` `          ``// Set the minimum distance``          ``if` `(dist[i] > Math.abs(ind-i))``          ``{` `            ``// Set the min distance of current``            ``// index 'i' to nearest one``            ``dist[i] = Math.abs(ind-i);` `            ``// Add 1 as indexing starts from 0``            ``pos[i] = ind + ``1``;``          ``}` `          ``if` `(dist[ind] > Math.abs(ind-i))``          ``{` `            ``// Set the min distance of found index 'ind'``            ``dist[ind] = Math.abs(ind-i);` `            ``// Add 1 as indexing starts from 0``            ``pos[ind] = i + ``1``;``          ``}``        ``}``      ``}``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``for``(``int` `i = ``0``; i < MAX; i++)``    ``{``      ``divisors.add(``new` `ArrayList());``    ``}` `    ``// Simple sieve to find smallest prime``    ``// divisor of number from 2 to MAX``    ``sieveOfEratosthenes();    ``    ``int` `arr[] = {``2``, ``9``, ``4``, ``3``, ``13``};``    ``int` `n = arr.length;` `    ``// function to calculate nearest distance``    ``// of every array elements``    ``nearestGCD(arr, n);` `    ``// Print the nearest distance having GDC>1``    ``for` `(``int` `i = ``0``; i < n; ++i)``    ``{``      ``System.out.print(pos[i]+``" "``);   ``    ``}``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

## 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`

## C#

 `// C# program to print nearest element with at least``// one common prime factor.``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `  ``static` `int` `MAX = 100001;``  ``static` `int` `INF = Int32.MaxValue;``  ``static` `int``[] primedivisor = ``new` `int` `[MAX];``  ``static` `int``[] dist = ``new` `int` `[MAX];``  ``static` `int``[] pos = ``new` `int` `[MAX];``  ``static` `int``[] divInd = ``new` `int` `[MAX];` `  ``static` `List> divisors = ``new` `List>();` `  ``// Pre-computation of smallest prime divisor``  ``// of all numbers``  ``static` `void` `sieveOfEratosthenes()``  ``{``    ``for` `(``int` `i = 2; i * i < MAX; ++i)``    ``{``      ``if` `(primedivisor[i] == 0)``      ``{``        ``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] == 0)``      ``{``        ``primedivisor[i] = i;``      ``}``    ``}` `  ``}` `  ``// Function to calculate all divisors of``  ``// input array``  ``static` `void` `findDivisors(``int``[] arr, ``int` `n)``  ``{``    ``for` `(``int` `i=0; i 1)``      ``{``        ``int` `div = primedivisor[num];``        ``divisors[i].Add(div);``        ``while` `(num % div == 0)``        ``{``          ``num /= div;``        ``}``      ``}``    ``}` `  ``}` `  ``static` `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 < n; ++i)``    ``{` `      ``// For every divisor of current element,``      ``// find closest element.``      ``foreach``(``int` `div ``in` `divisors[i])``      ``{` `        ``// Visit divisor if not visited``        ``if` `(divInd[div] == -1)``        ``{``          ``divInd[div] = i;``        ``}``        ``else``        ``{` `          ``// Fetch the index of visited divisor``          ``int` `ind = divInd[div];` `          ``// Update the divisor index to current index``          ``divInd[div] = i;` `          ``// Set the minimum distance``          ``if` `(dist[i] > Math.Abs(ind-i))``          ``{` `            ``// Set the min distance of current``            ``// index 'i' to nearest one``            ``dist[i] = Math.Abs(ind-i);` `            ``// Add 1 as indexing starts from 0``            ``pos[i] = ind + 1;``          ``}` `          ``if` `(dist[ind] > Math.Abs(ind-i))``          ``{` `            ``// Set the min distance of found index 'ind'``            ``dist[ind] = Math.Abs(ind-i);` `            ``// Add 1 as indexing starts from 0``            ``pos[ind] = i + 1;``          ``}``        ``}``      ``}``    ``}``  ``}` `  ``// Driver code ``  ``static` `public` `void` `Main ()``  ``{``    ``for``(``int` `i = 0; i < MAX; i++)``    ``{``      ``divisors.Add(``new` `List<``int``>());``    ``}``    ``// Simple sieve to find smallest prime``    ``// divisor of number from 2 to MAX``    ``sieveOfEratosthenes();    ``    ``int``[] arr = {2, 9, 4, 3, 13};``    ``int` `n = arr.Length;` `    ``// function to calculate nearest distance``    ``// of every array elements``    ``nearestGCD(arr, n);` `    ``// Print the nearest distance having GDC>1``    ``for` `(``int` `i = 0; i < n; ++i)``    ``{``      ``Console.Write(pos[i]+``" "``);   ``    ``}``  ``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

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 write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up