# Largest Divisor for each element in an array other than 1 and the number itself

Given an array arr[] of N integers, the task is to find the largest divisor for each element in an array other than 1 and the number itself. If there is no such divisor, print -1.

Examples:

Input: arr[] = {5, 6, 7, 8, 9, 10}
Output: -1 3 -1 4 3 5
Divisors(5) = {1, 5}
-> Since there is no divisor other than 1 and the number itself, therefore largest divisor = -1
Divisors(6) = [1, 2, 3, 6]
-> largest divisor other than 1 and the number itself = 3
Divisors(7) = [1, 7]
-> Since there is no divisor other than 1 and the number itself, therefore largest divisor = -1
Divisors(8) = [1, 2, 4, 8]
-> largest divisor other than 1 and the number itself = 4
Divisors(9) = [1, 3, 9]
-> largest divisor other than 1 and the number itself = 3
Divisors(10) = [1, 2, 5, 10]
-> largest divisor other than 1 and the number itself = 5

Input: arr[] = {15, 16, 17, 18, 19, 20, 21}
Output: 5 8 -1 9 -1 10 7

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

Naive approach: The idea is to iterate over all the array elements and find the largest divisor for each of the element using the approach discussed in this article.

Time Complexity: O(N * √N)

Efficient approach: A better solution is to precompute the maximum divisor of the numbers from 2 to 105 and then just run a loop for array and print precomputed answer.

• Use Sieve of Eratosthenes to mark the prime numbers and store the smallest prime divisor of each number.
• Now largest divisor for any number will be number / smallest_prime_divisor.
• Find the Largest divisor for each number using the precomputed answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `#define int long long ` `const` `int` `maxin = 100001; ` ` `  `// Divisors array to keep track ` `// of the maximum divisor ` `int` `divisors[maxin]; ` ` `  `// Function to pre-compute the prime ` `// numbers and largest divisors ` `void` `Calc_Max_Div(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``// Visited array to keep ` `    ``// track of prime numbers ` `    ``bool` `vis[maxin]; ` `    ``memset``(vis, 1, maxin); ` ` `  `    ``// 0 and 1 are not prime numbers ` `    ``vis = vis = 0; ` ` `  `    ``// Initialising divisors[i] = i ` `    ``for` `(``int` `i = 1; i <= maxin; i++) ` `        ``divisors[i] = i; ` ` `  `    ``// For all the numbers divisible by 2 ` `    ``// the maximum divisor will be number / 2 ` `    ``for` `(``int` `i = 4; i <= maxin; i += 2) { ` `        ``vis[i] = 0; ` `        ``divisors[i] = i / 2; ` `    ``} ` `    ``for` `(``int` `i = 3; i <= maxin; i += 2) { ` ` `  `        ``// If divisors[i] is not equal to i then ` `        ``// this means that divisors[i] contains ` `        ``// minimum prime divisor for the number ` `        ``if` `(divisors[i] != i) { ` ` `  `            ``// Update the answer to ` `            ``// i / smallest_prime_divisor[i] ` `            ``divisors[i] = i / divisors[i]; ` `        ``} ` ` `  `        ``// Condition if i is a prime number ` `        ``if` `(vis[i] == 1) { ` `            ``for` `(``int` `j = i * i; j < maxin; j += i) { ` `                ``vis[j] = 0; ` ` `  `                ``// If divisors[j] is equal to j then ` `                ``// this means that i is the first prime ` `                ``// divisor for j so we update divi[j] = i ` `                ``if` `(divisors[j] == j) ` `                    ``divisors[j] = i; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// If the current element is prime ` `        ``// then it has no divisors ` `        ``// other than 1 and itself ` `        ``if` `(divisors[arr[i]] == arr[i]) ` `            ``cout << ``"-1 "``; ` `        ``else` `            ``cout << divisors[arr[i]] << ``" "``; ` `    ``} ` `} ` ` `  `// Driver code ` `int32_t main() ` `{ ` `    ``int` `arr[] = { 5, 6, 7, 8, 9, 10 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``); ` ` `  `    ``Calc_Max_Div(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GFG  ` `{ ` `     `  `    ``final` `static` `int` `maxin = ``10001``;  ` `     `  `    ``// Divisors array to keep track  ` `    ``// of the maximum divisor  ` `    ``static` `int` `divisors[] = ``new` `int``[maxin + ``1``];  ` `     `  `    ``// Function to pre-compute the prime  ` `    ``// numbers and largest divisors  ` `    ``static` `void` `Calc_Max_Div(``int` `arr[], ``int` `n)  ` `    ``{  ` `     `  `        ``// Visited array to keep  ` `        ``// track of prime numbers  ` `        ``int` `vis[] = ``new` `int``[maxin + ``1``]; ` `         `  `        ``for``(``int` `i = ``0``;i

## Python3

 `# Python3 implementation of the approach  ` `maxin ``=` `100001``;  ` ` `  `# Divisors array to keep track  ` `# of the maximum divisor  ` `divisors ``=` `[``0``] ``*` `(maxin ``+` `1``);  ` ` `  `# Function to pre-compute the prime  ` `# numbers and largest divisors  ` `def` `Calc_Max_Div(arr, n) : ` ` `  `    ``# Visited array to keep  ` `    ``# track of prime numbers  ` `    ``vis ``=` `[``1``] ``*` `(maxin ``+` `1``);  ` ` `  `    ``# 0 and 1 are not prime numbers  ` `    ``vis[``0``] ``=` `vis[``1``] ``=` `0``;  ` ` `  `    ``# Initialising divisors[i] = i  ` `    ``for` `i ``in` `range``(``1``, maxin ``+` `1``) : ` `        ``divisors[i] ``=` `i;  ` ` `  `    ``# For all the numbers divisible by 2  ` `    ``# the maximum divisor will be number / 2  ` `    ``for` `i ``in` `range``(``4` `, maxin ``+` `1``, ``2``) : ` `        ``vis[i] ``=` `0``;  ` `        ``divisors[i] ``=` `i ``/``/` `2``;  ` `     `  `    ``for` `i ``in` `range``(``3``, maxin ``+` `1``, ``2``) : ` ` `  `        ``# If divisors[i] is not equal to i then  ` `        ``# this means that divisors[i] contains  ` `        ``# minimum prime divisor for the number  ` `        ``if` `(divisors[i] !``=` `i) : ` ` `  `            ``# Update the answer to  ` `            ``# i / smallest_prime_divisor[i]  ` `            ``divisors[i] ``=` `i ``/``/` `divisors[i];  ` `     `  `        ``# Condition if i is a prime number  ` `        ``if` `(vis[i] ``=``=` `1``) : ` `            ``for` `j ``in` `range``( i ``*` `i, maxin, i) :  ` `                ``vis[j] ``=` `0``;  ` ` `  `                ``# If divisors[j] is equal to j then  ` `                ``# this means that i is the first prime  ` `                ``# divisor for j so we update divi[j] = i  ` `                ``if` `(divisors[j] ``=``=` `j) : ` `                    ``divisors[j] ``=` `i;  ` `         `  `    ``for` `i ``in` `range``(n) : ` ` `  `        ``# If the current element is prime  ` `        ``# then it has no divisors  ` `        ``# other than 1 and itself  ` `        ``if` `(divisors[arr[i]] ``=``=` `arr[i]) : ` `            ``print``(``"-1 "``, end ``=` `"");  ` `        ``else` `: ` `            ``print``(divisors[arr[i]], end ``=` `" "``);  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[ ``5``, ``6``, ``7``, ``8``, ``9``, ``10` `];  ` `    ``n ``=` `len``(arr);  ` ` `  `    ``Calc_Max_Div(arr, n);  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach  ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `     `  `    ``static` `int` `maxin = 10001;  ` `     `  `    ``// Divisors array to keep track  ` `    ``// of the maximum divisor  ` `    ``static` `int` `[]divisors = ``new` `int``[maxin + 1];  ` `     `  `    ``// Function to pre-compute the prime  ` `    ``// numbers and largest divisors  ` `    ``static` `void` `Calc_Max_Div(``int` `[]arr, ``int` `n)  ` `    ``{  ` `     `  `        ``// Visited array to keep  ` `        ``// track of prime numbers  ` `        ``int` `[]vis = ``new` `int``[maxin + 1]; ` `         `  `        ``for``(``int` `i = 0; i < maxin + 1 ; i++) ` `            ``vis[i] = 1; ` ` `  `        ``// 0 and 1 are not prime numbers  ` `        ``vis = vis = 0;  ` `     `  `        ``// Initialising divisors[i] = i  ` `        ``for` `(``int` `i = 1; i <= maxin; i++)  ` `            ``divisors[i] = i;  ` `     `  `        ``// For all the numbers divisible by 2  ` `        ``// the maximum divisor will be number / 2  ` `        ``for` `(``int` `i = 4; i <= maxin; i += 2)  ` `        ``{  ` `            ``vis[i] = 0;  ` `            ``divisors[i] = i / 2;  ` `        ``}  ` `        ``for` `(``int` `i = 3; i <= maxin; i += 2)  ` `        ``{  ` `     `  `            ``// If divisors[i] is not equal to i then  ` `            ``// this means that divisors[i] contains  ` `            ``// minimum prime divisor for the number  ` `            ``if` `(divisors[i] != i) ` `            ``{  ` `     `  `                ``// Update the answer to  ` `                ``// i / smallest_prime_divisor[i]  ` `                ``divisors[i] = i / divisors[i];  ` `            ``}  ` `     `  `            ``// Condition if i is a prime number  ` `            ``if` `(vis[i] == 1)  ` `            ``{  ` `                ``for` `(``int` `j = i * i; j < maxin; j += i) ` `                ``{  ` `                    ``vis[j] = 0;  ` `     `  `                    ``// If divisors[j] is equal to j then  ` `                    ``// this means that i is the first prime  ` `                    ``// divisor for j so we update divi[j] = i  ` `                    ``if` `(divisors[j] == j)  ` `                        ``divisors[j] = i;  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{  ` `     `  `            ``// If the current element is prime  ` `            ``// then it has no divisors  ` `            ``// other than 1 and itself  ` `            ``if` `(divisors[arr[i]] == arr[i])  ` `                    ``Console.Write(``"-1 "``);  ` `            ``else` `                    ``Console.Write(divisors[arr[i]] + ``" "``);  ` `        ``}  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `        ``int` `[]arr = { 5, 6, 7, 8, 9, 10 };  ` `        ``int` `n = arr.Length;  ` `     `  `        ``Calc_Max_Div(arr, n);  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```-1 3 -1 4 3 5
```

Time Complexity: O(N)

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

Improved By : AnkitRai01