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.



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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 = []
      
    # intialize with 0 upto lenght 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))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP implementation of above approach
  
// Function to count the divisors
function countDivisors($n)
{
    $count = 0;
  
    // Note that this loop
    // runs till square root
    for ($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
function MaximumDivisors($X, $Y)
{
    $maxDivisors = PHP_INT_MIN;
    $result = 0;
  
    // to store number of divisors
    $arr = array_fill(0, ($Y - $X + 1), NULL);
  
    // Traverse from X to Y
    for ($i = $X; $i <= $Y; $i++) 
    {
  
        // 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 = 0; $i < ($Y - $X + 1); $i++)
  
        // Count the value equals to maxDivisors
        if ($arr[$i] == $maxDivisors)
            $result++;
  
    return $result;
}
  
// Driver Code
$X = 1;
$Y = 10;
  
// function call
echo MaximumDivisors($X, $Y)." ";
  
// This code is contributed
// by ChitraNayal
?>

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
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 divisble 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 divisble 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

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 divisble 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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP implementation of above approach
  
// Function to count the elements
// with maximum number of divisors
function MaximumDivisors($X, $Y)
{
    // to store number of divisors
    // initialise with zero
    $arr = array_fill(0,($Y - $X + 1), NULL);
   
    // to store the maximum 
    // number of divisors
    $mx = PHP_INT_MIN;
  
    // to store required answer
    $cnt = 0;
  
    for ($i = 1; $i * $i <= $Y; $i++) 
    {
        $sq = $i * $i;
  
        // Find the first divisble number
        if (($X / $i) * $i >= $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
?>

chevron_right


Output:

3


My Personal Notes arrow_drop_up

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.



Improved By : Ryuga, Ita_c