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

• Difficulty Level : Easy
• Last Updated : 30 Jan, 2022

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

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`

## Javascript

 ``

Output:

`-1 3 -1 4 3 5`

Time Complexity: O(N)

Auxiliary Space: O(100001)

My Personal Notes arrow_drop_up