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

• Difficulty Level : Easy
• Last Updated : 25 May, 2021

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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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)

My Personal Notes arrow_drop_up