# Count elements in the given range which have maximum number of divisors

Given two numbers X and Y. The task is to find the number of elements in the range [X,Y] both inclusive, that have the maximum number of divisors.

Examples:

Input: X = 2, Y = 9
Output: 2
6, 8 are numbers with the maximum number of divisors.

Input: X = 1, Y = 10
Output: 3
6, 8, 10 are numbers with the maximum number of divisors.

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

Method 1:

• Traverse all the elements from X to Y one by one.
• Find the number of divisors of each element.
• Store the number of divisors in an array and update the maximum number of Divisors(maxDivisors).
• Traverse the array that contains divisors and counts the number of elements equal to maxDivisors.
• Return the count.

Below is the implementation of above method:

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the divisors ` `int` `countDivisors(``int` `n) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// Note that this loop runs till square root ` `    ``for` `(``int` `i = 1; i <= ``sqrt``(n); i++) { ` `        ``if` `(n % i == 0) { ` ` `  `            ``// If divisors are equal, print only one ` `            ``if` `(n / i == i) ` `                ``count++; ` ` `  `            ``else` `// Otherwise print both ` `                ``count += 2; ` `        ``} ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Function to count the number with ` `// maximum divisors ` `int` `MaximumDivisors(``int` `X, ``int` `Y) ` `{ ` `    ``int` `maxDivisors = INT_MIN, result = 0; ` ` `  `    ``// to store number of divisors ` `    ``int` `arr[Y - X + 1]; ` ` `  `    ``// Traverse from X to Y ` `    ``for` `(``int` `i = X; i <= Y; i++) { ` ` `  `            ``// Count the number of divisors of i ` `             ``int` `Div = countDivisors(i); ` ` `  `            ``// Store the value of div in an array ` `             ``arr[i - X] = Div; ` ` `  `            ``// Update the value of maxDivisors ` `             ``maxDivisors = max(Div, maxDivisors); ` ` `  `    ``} ` ` `  `    ``// Traverse the array  ` `    ``for` `(``int` `i = 0; i < (Y - X + 1); i++) ` ` `  `        ``// Count the value equals to maxDivisors ` `        ``if` `(arr[i] == maxDivisors) ` `            ``result++; ` ` `  `    ``return` `result; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `X = 1, Y = 10; ` ` `  `    ``// function call ` `    ``cout << MaximumDivisors(X, Y) << endl; ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of above approach ` `class` `GFG  ` `{ ` ` `  `// Function to count the divisors ` `static` `int` `countDivisors(``int` `n) ` `{ ` `int` `count = ``0``; ` ` `  `// Note that this loop  ` `// runs till square root ` `for` `(``int` `i = ``1``; i <= Math.sqrt(n); i++)  ` `{ ` `    ``if` `(n % i == ``0``)  ` `    ``{ ` ` `  `        ``// If divisors are equal, ` `        ``// print only one ` `        ``if` `(n / i == i) ` `            ``count++; ` ` `  `        ``else` `// Otherwise print both ` `            ``count += ``2``; ` `    ``} ` `} ` ` `  `return` `count; ` `} ` ` `  `// Function to count the number  ` `// with maximum divisors ` `static` `int` `MaximumDivisors(``int` `X, ``int` `Y) ` `{ ` `int` `maxDivisors = ``0``, result = ``0``; ` ` `  `// to store number of divisors ` `int``[] arr = ``new` `int``[Y - X + ``1``]; ` ` `  `// Traverse from X to Y ` `for` `(``int` `i = X; i <= Y; i++)  ` `{ ` ` `  `    ``// Count the number of divisors of i ` `    ``int` `Div = countDivisors(i); ` ` `  `    ``// Store the value of div in an array ` `    ``arr[i - X] = Div; ` ` `  `    ``// Update the value of maxDivisors ` `    ``maxDivisors = Math.max(Div, maxDivisors); ` ` `  `} ` ` `  `// Traverse the array  ` `for` `(``int` `i = ``0``; i < (Y - X + ``1``); i++) ` ` `  `    ``// Count the value equals  ` `    ``// to maxDivisors ` `    ``if` `(arr[i] == maxDivisors) ` `        ``result++; ` ` `  `return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `X = ``1``, Y = ``10``; ` ` `  `    ``// function call ` `    ``System.out.println(MaximumDivisors(X, Y)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

 `# from math module import everything ` `from` `math ``import` `*` ` `  `# Python 3 implementation of above approach ` ` `  `# Function to count the divisors  ` `def` `countDivisors(n) : ` `    ``count ``=` `0` `     `  `    ``# Note that this loop runs till square root  ` `    ``for` `i ``in` `range``(``1``,``int``(sqrt(n)``+``1``)) : ` `        ``if` `n ``%` `i ``=``=` `0` `: ` ` `  `            ``# If divisors are equal, print only one  ` `            ``if` `n ``/` `i ``=``=` `i : ` `                ``count ``+``=` `1` `                 `  `            ``# Otherwise print both ` `            ``else` `: ` `                ``count ``+``=` `2` ` `  `    ``return` `count ` ` `  `# Function to count the number with  ` `# maximum divisors  ` `def` `MaximumDivisors(X,Y) : ` `    ``result ``=` `0` `    ``maxDivisors ``=` `0` ` `  `    ``# create list to store number of divisors  ` `    ``arr ``=` `[] ` `     `  `    ``# initialize with 0 upto length Y-X+1 ` `    ``for` `i ``in` `range``(Y ``-` `X ``+` `1``) : ` `        ``arr.append(``0``) ` ` `  `    ``# Traverse from X to Y    ` `    ``for` `i ``in` `range``(X,Y``+``1``) : ` ` `  `        ``# Count the number of divisors of i  ` `        ``Div ``=` `countDivisors(i) ` ` `  `        ``# Store the value of div in an array  ` `        ``arr[i ``-` `X] ``=` `Div ` `         `  `        ``# Update the value of maxDivisors  ` `        ``maxDivisors ``=` `max``(Div,maxDivisors) ` `         `  `    ``# Traverse the array   ` `    ``for` `i ``in` `range` `(Y ``-` `X ``+` `1``) : ` ` `  `        ``# Count the value equals to maxDivisors ` `        ``if` `arr[i] ``=``=` `maxDivisors : ` `            ``result ``+``=` `1` ` `  `    ``return` `result ` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``X, Y ``=` `1``, ``10` ` `  `    ``# function call  ` `    ``print``(MaximumDivisors(X,Y)) `

 `// C# implementation of above approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to count the divisors ` `static` `int` `countDivisors(``int` `n) ` `{ ` `int` `count = 0; ` ` `  `// Note that this loop  ` `// runs till square root ` `for` `(``int` `i = 1; i <= Math.Sqrt(n); i++) ` `{ ` `    ``if` `(n % i == 0)  ` `    ``{ ` ` `  `        ``// If divisors are equal, ` `        ``// print only one ` `        ``if` `(n / i == i) ` `            ``count++; ` ` `  `        ``else` `// Otherwise print both ` `            ``count += 2; ` `    ``} ` `} ` ` `  `return` `count; ` `} ` ` `  `// Function to count the number  ` `// with maximum divisors ` `static` `int` `MaximumDivisors(``int` `X, ``int` `Y) ` `{ ` `int` `maxDivisors = 0, result = 0; ` ` `  `// to store number of divisors ` `int``[] arr = ``new` `int``[Y - X + 1]; ` ` `  `// Traverse from X to Y ` `for` `(``int` `i = X; i <= Y; i++) ` `{ ` ` `  `    ``// Count the number of divisors of i ` `    ``int` `Div = countDivisors(i); ` ` `  `    ``// Store the value of div in an array ` `    ``arr[i - X] = Div; ` ` `  `    ``// Update the value of maxDivisors ` `    ``maxDivisors = Math.Max(Div, maxDivisors); ` ` `  `} ` ` `  `// Traverse the array  ` `for` `(``int` `i = 0; i < (Y - X + 1); i++) ` ` `  `    ``// Count the value equals  ` `    ``// to maxDivisors ` `    ``if` `(arr[i] == maxDivisors) ` `        ``result++; ` ` `  `return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `X = 1, Y = 10; ` ` `  `    ``// function call ` `    ``Console.Write(MaximumDivisors(X, Y)); ` `} ` `} ` ` `  `// This code is contributed ` `// by ChitraNayal `

 ` `

Output:
```3
```

Method 2:

• Create an array of size Y-X+1 to store number of divisors of X in arr[0], X+1 in arr[1]… up to Y.
• To get the number of divisors of all numbers from X to Y run two loops(nested).
• Run an outer loop from 1 to sqrt(Y).
• Run an inner loop from first_divisible to Y.
• First_divisible is the number which is the first number to be divisible by I(outer loop) and greater than or equals to X.

Here, first_divisible is calculated by using Find the number closest to n and divisible by m method. Then find divisors of the number.

Below is the implementation of above approach:

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the elements ` `// with maximum number of divisors ` `int` `MaximumDivisors(``int` `X, ``int` `Y) ` `{ ` `    ``// to store number of divisors ` `    ``int` `arr[Y - X + 1]; ` ` `  `    ``// initialise with zero ` `    ``memset``(arr, 0, ``sizeof``(arr)); ` ` `  `    ``// to store the maximum number of divisors ` `    ``int` `mx = INT_MIN; ` ` `  `    ``// to store required answer ` `    ``int` `cnt = 0; ` ` `  `    ``for` `(``int` `i = 1; i * i <= Y; i++) { ` `        ``int` `sq = i * i; ` `        ``int` `first_divisible; ` ` `  `        ``// Find the first divisible number ` `        ``if` `((X / i) * i >= X) ` `            ``first_divisible = (X / i) * i; ` `        ``else` `            ``first_divisible = (X / i + 1) * i; ` ` `  `        ``// Count number of divisors ` `        ``for` `(``int` `j = first_divisible; j <= Y; j += i) { ` `            ``if` `(j < sq) ` `                ``continue``; ` `            ``else` `if` `(j == sq) ` `                ``arr[j - X]++; ` `            ``else` `                ``arr[j - X] += 2; ` `        ``} ` `    ``} ` ` `  `    ``// Find number of elements with ` `    ``// maximum number of divisors ` `    ``for` `(``int` `i = X; i <= Y; i++) { ` `        ``if` `(arr[i - X] > mx) { ` `            ``cnt = 1; ` `            ``mx = arr[i - X]; ` `        ``} ` `        ``else` `if` `(arr[i - X] == mx) ` `            ``cnt++; ` `    ``} ` ` `  `    ``return` `cnt; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `X = 1, Y = 10; ` `    ``cout << MaximumDivisors(X, Y) << endl; ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of above approach ` `class` `GFG  ` `{ ` ` `  `// Function to count the elements ` `// with maximum number of divisors ` `static` `int` `MaximumDivisors(``int` `X, ``int` `Y) ` `{ ` `     `  `// to store number of divisors ` `int``[] arr = ``new` `int``[Y - X + ``1``]; ` ` `  `// initialise with zero ` `for``(``int` `i = ``0``; i < arr.length; i++) ` `    ``arr[i] = ``0``; ` ` `  `// to store the maximum  ` `// number of divisors ` `int` `mx = ``0``; ` ` `  `// to store required answer ` `int` `cnt = ``0``; ` ` `  `for` `(``int` `i = ``1``; i * i <= Y; i++) ` `{ ` `    ``int` `sq = i * i; ` `    ``int` `first_divisible; ` ` `  `    ``// Find the first divisible number ` `    ``if` `((X / i) * i >= X) ` `        ``first_divisible = (X / i) * i; ` `    ``else` `        ``first_divisible = (X / i + ``1``) * i; ` ` `  `    ``// Count number of divisors ` `    ``for` `(``int` `j = first_divisible; ` `             ``j <= Y; j += i)  ` `    ``{ ` `        ``if` `(j < sq) ` `            ``continue``; ` `        ``else` `if` `(j == sq) ` `            ``arr[j - X]++; ` `        ``else` `            ``arr[j - X] += ``2``; ` `    ``} ` `} ` ` `  `// Find number of elements with ` `// maximum number of divisors ` `for` `(``int` `i = X; i <= Y; i++) ` `{ ` `    ``if` `(arr[i - X] > mx)  ` `    ``{ ` `        ``cnt = ``1``; ` `        ``mx = arr[i - X]; ` `    ``} ` `    ``else` `if` `(arr[i - X] == mx) ` `        ``cnt++; ` `} ` ` `  `return` `cnt; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `X = ``1``, Y = ``10``; ` `    ``System.out.println(MaximumDivisors(X, Y)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

 `# Python 3 implementation of above approach ` ` `  `# Function to count the elements ` `# with maximum number of divisors ` `def` `MaximumDivisors(X, Y): ` ` `  `    ``# to store number of divisors ` `    ``# initialise with zero ` `    ``arr ``=` `[``0``] ``*` `(Y ``-` `X ``+` `1``) ` ` `  `    ``# to store the maximum  ` `    ``# number of divisors ` `    ``mx ``=` `0` ` `  `    ``# to store required answer ` `    ``cnt ``=` `0` ` `  `    ``i ``=` `1` `    ``while` `i ``*` `i <``=` `Y : ` `        ``sq ``=` `i ``*` `i ` ` `  `        ``# Find the first divisible number ` `        ``if` `((X ``/``/` `i) ``*` `i >``=` `X) : ` `            ``first_divisible ``=` `(X ``/``/` `i) ``*` `i ` `        ``else``: ` `            ``first_divisible ``=` `(X ``/``/` `i ``+` `1``) ``*` `i ` ` `  `        ``# Count number of divisors ` `        ``for` `j ``in` `range``(first_divisible, Y ``+` `1``, i): ` `            ``if` `j < sq : ` `                ``continue` `            ``elif` `j ``=``=` `sq : ` `                ``arr[j ``-` `X] ``+``=` `1` `            ``else``: ` `                ``arr[j ``-` `X] ``+``=` `2` `        ``i ``+``=` `1` ` `  `    ``# Find number of elements with ` `    ``# maximum number of divisors ` `    ``for` `i ``in` `range``(X, Y ``+` `1``): ` `        ``if` `arr[i ``-` `X] > mx : ` `            ``cnt ``=` `1` `            ``mx ``=` `arr[i ``-` `X] ` ` `  `        ``elif` `arr[i ``-` `X] ``=``=` `mx : ` `            ``cnt ``+``=` `1` ` `  `    ``return` `cnt ` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``X ``=` `1` `    ``Y ``=` `10` `    ``print``(MaximumDivisors(X, Y)) ` ` `  `# This code is contributed  ` `# by ChitraNayal `

 `// C# implementation of above approach ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to count the elements ` `// with maximum number of divisors ` `static` `int` `MaximumDivisors(``int` `X, ``int` `Y) ` `{ ` `     `  `// to store number of divisors ` `int``[] arr = ``new` `int``[Y - X + 1]; ` ` `  `// initialise with zero ` `for``(``int` `i = 0; i < arr.Length; i++) ` `    ``arr[i] = 0; ` ` `  `// to store the maximum  ` `// number of divisors ` `int` `mx = 0; ` ` `  `// to store required answer ` `int` `cnt = 0; ` ` `  `for` `(``int` `i = 1; i * i <= Y; i++)  ` `{ ` `    ``int` `sq = i * i; ` `    ``int` `first_divisible; ` ` `  `    ``// Find the first divisible number ` `    ``if` `((X / i) * i >= X) ` `        ``first_divisible = (X / i) * i; ` `    ``else` `        ``first_divisible = (X / i + 1) * i; ` ` `  `    ``// Count number of divisors ` `    ``for` `(``int` `j = first_divisible;  ` `             ``j <= Y; j += i)  ` `    ``{ ` `        ``if` `(j < sq) ` `            ``continue``; ` `        ``else` `if` `(j == sq) ` `            ``arr[j - X]++; ` `        ``else` `            ``arr[j - X] += 2; ` `    ``} ` `} ` ` `  `// Find number of elements with ` `// maximum number of divisors ` `for` `(``int` `i = X; i <= Y; i++) ` `{ ` `    ``if` `(arr[i - X] > mx)  ` `    ``{ ` `        ``cnt = 1; ` `        ``mx = arr[i - X]; ` `    ``} ` `    ``else` `if` `(arr[i - X] == mx) ` `        ``cnt++; ` `} ` ` `  `return` `cnt; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `X = 1, Y = 10; ` `    ``Console.Write(MaximumDivisors(X, Y)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

 `= ``\$X``) ` `            ``\$first_divisible` `= (``\$X` `/ ``\$i``) * ``\$i``; ` `        ``else` `            ``\$first_divisible` `= (``\$X` `/ ``\$i` `+ 1) * ``\$i``; ` ` `  `        ``// Count number of divisors ` `        ``for` `(``\$j` `= ``\$first_divisible``;  ` `             ``\$j` `< ``\$Y``; ``\$j` `+= ``\$i``) ` `        ``{ ` `            ``if` `(``\$j` `< ``\$sq``) ` `                ``continue``; ` `            ``else` `if` `(``\$j` `== ``\$sq``) ` `                ``\$arr``[``\$j` `- ``\$X``]++; ` `            ``else` `                ``\$arr``[``\$j` `- ``\$X``] += 2; ` `        ``} ` `    ``} ` ` `  `    ``// Find number of elements with ` `    ``// maximum number of divisors ` `    ``for` `(``\$i` `= ``\$X``; ``\$i` `<= ``\$Y``; ``\$i``++)  ` `    ``{ ` `        ``if` `(``\$arr``[``\$i` `- ``\$X``] > ``\$mx``)   ` `        ``{ ` `            ``\$cnt` `= 1; ` `            ``\$mx` `= ``\$arr``[``\$i` `- ``\$X``]; ` `        ``} ` `        ``else` `if` `(``\$arr``[``\$i` `- ``\$X``] == ``\$mx``) ` `            ``\$cnt``++; ` `    ``} ` ` `  `    ``return` `\$cnt``; ` `} ` ` `  `// Driver code ` `\$X` `= 1; ` `\$Y` `= 10; ` `echo` `MaximumDivisors(``\$X``, ``\$Y``).``"\n"``; ` ` `  `// This code is contributed  ` `// by ChitraNayal ` `?> `

Output:
```3
```

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.

pawanasipugmailcom

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.

Article Tags :
Practice Tags :