Max occurring divisor in an interval

Given an interval [x, y]. Find the divisor that occurs maximum number of times except ‘1’ in the divisors of numbers in the range [x, y], both inclusive.

Examples :

Input : [2, 5]
Output : 2
Explanation : Divisors of 2, 3, 4, 5 except 1 are:
              2 -> 2
              3 -> 3
              4 -> 2, 4
              5 -> 5
              Among all the divisors 2 occurs 
              maximum time, i.e two times.

Input : [3, 3]
Output : 3



Brute Force Approach: The most simple approach is to traverse all of the numbers from x to y and calculate all of their divisors and store the divisors in a map with their counts. Finally traverse the map to find the divisor occurring maximum times. You may refer to this article on how to efficiently print all divisors of a natural number.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// Simple CPP program to find maximum occuring
// factor in an interval
#include <bits/stdc++.h>
using namespace std;
  
// function to find max occurring
// divisor in interval [x, y]
int findDivisor(int x, int y)
{
    // map to store count of divisors
    unordered_map<int, int> m;
  
    // iterate for every number in the
    // interval
    for (int num = x; num <= y; num++) {
        // find all divisors of num
        for (int i = 2; i <= sqrt(num) + 1; i++) {
            if (num % i == 0) {
  
                // If divisors are equal, print only one
                if (num / i == i) {
                    if (m.find(i) == m.end())
                        m.insert(make_pair(i, 1));
                    else
                        m[i]++;
                }
                else {
  
                    // insert first one to map
                    if (m.find(i) == m.end())
                        m.insert(make_pair(i, 1));
                    else
                        m[i]++;
  
                    // insert second to map
                    if (m.find(num / i) == m.end())
                        m.insert(make_pair(num / i, 1));
                    else
                        m[num / i]++;
                }
            }
        }
    }
  
    int divisor = 0;
    int divisorCount = INT_MIN;
  
    // iterate on map
    for (auto itr = m.begin(); itr != m.end(); itr++) {
        if (itr->second > divisorCount) {
            divisorCount = itr->second;
            divisor = itr->first;
        }
    }
  
    return divisor;
}
  
// Driver code
int main()
{
    int x = 3, y = 16;
    cout << findDivisor(x, y);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find Max
// occurring divisor in an interval
import java.io.*;
import java.util.*;
  
class GFG {
  
// function to find max occurring
// divisor in interval [x, y]
static int findDivisor(int x, int y)
{
    // map to store count of divisors
    HashMap<Integer, Integer> m = new HashMap<Integer, 
                                            Integer>();
  
    // iterate for every number 
    // in the interval
    for (int num = x; num <= y; num++) {
          
        // find all divisors of num
        for (int i = 2; i <= Math.sqrt(num) + 1; i++) {
            if (num % i == 0) {
  
                // If divisors are equal,
                // print only one
                if (num / i == i) {
                    if (m.containsKey(i) != true)
                        m.put(i, 1);
                    else
                        {
                            int val = m.get(i);
                            m.put(i, ++val);
                        }
                }
                else {
  
                    // insert first one to map
                    if (m.containsKey(i) != true)
                        m.put(i, 1);
                    else
                        {
                            int val=m.get(i);
                            m.put(i,++val);
                        }
  
                    // insert second to map
                    if (m.containsKey(num / i) != true)
                        m.put(num / i, 1);
                    else
                        {
                            int k = num / i;
                            int val = m.get(k);
                            m.put( k, ++val);
                        }
                }
            }
        }
    }
  
    int divisor = 0;
    int divisorCount = Integer.MIN_VALUE;
  
    // iterate on map
    for(Map.Entry<Integer, Integer> entry:m.entrySet()){ 
        int key = entry.getKey(); 
        int value = entry.getValue(); 
          
        if (value > divisorCount) {
            divisorCount = value;
            divisor = key;
        
    
  
    return divisor;
}
  
/* Driver program to test above function */
public static void main(String[] args)
{
    int x = 3, y = 16;
    System.out.println(findDivisor(x, y));
}
}
  
// This code is contributed by Gitanjali

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Simple python program to find maximum
# occuring factor in an interval
import math 
  
# Function to find max occurring
# divisor in interval [x, y]
def findDivisor( x, y):
    # Map to store count of divisors
    m = {}
      
    # Iterate for every number in the interval
    for num in range(x, y + 1):
          
        # Find all divisors of num
        for i in range(2, int(math.sqrt(num)) + 2):
            if (num % i == 0):
                  
                # If divisors are equal, print only one
                if (num / i == i):
                    if i not in m:
                        m[i]= 1
                    else:
                        m[i]+= 1
                  
                else:
                    # Insert first one to map
                    if (i not in m):
                        m[i]= 1
                    else:
                        m[i]= m[i]+1
  
                    # Insert second to map
                    if (num / i not in m ):
                        m[num / i]= 1
                    else:
                        m[num / i]= m[num / i]+1
                  
    divisor = 0
    divisorCount = -999999
  
    # Iterate on map
    for itr in m :
        if m[itr] > divisorCount:
            divisorCount = m[itr]
            divisor = itr
          
    return divisor
  
# Driver method
x = 3
y = 16
print (findDivisor(x, y))
  
# This code is contributed by 'Gitanjali'.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find Max
// occurring divisor in an interval
using System;
using System.Collections.Generic; 
  
class GFG 
{
  
// function to find max occurring
// divisor in interval [x, y]
static int findDivisor(int x, int y)
{
    // map to store count of divisors
    Dictionary<int
               int> m = new Dictionary<int,
                                       int>();
  
    // iterate for every number 
    // in the interval
    for (int num = x; num <= y; num++)
    {
          
        // find all divisors of num
        for (int i = 2; i <= Math.Sqrt(num) + 1; i++) 
        {
            if (num % i == 0)
            {
  
                // If divisors are equal,
                // print only one
                if (num / i == i)
                {
                    if (m.ContainsKey(i) != true)
                        m.Add(i, 1);
                    else
                    {
                        int val = m[i];
                        m[i] = ++val;
                    }
                }
                else
                {
  
                    // insert first one to map
                    if (m.ContainsKey(i) != true)
                        m.Add(i, 1);
                    else
                    {
                        int val = m[i];
                        m[i] = ++val;
                    }
  
                    // insert second to map
                    if (m.ContainsKey(num / i) != true)
                        m.Add(num / i, 1);
                    else
                    {
                        int k = num / i;
                        int val = m[k];
                        m[k] = ++val;
                    }
                }
            }
        }
    }
  
    int divisor = 0;
    int divisorCount = int.MinValue;
  
    // iterate on map
    foreach(KeyValuePair<int, int> entry in m)
    
        int key = entry.Key; 
        int value = entry.Value; 
          
        if (value > divisorCount) 
        {
            divisorCount = value;
            divisor = key;
        
    
  
    return divisor;
}
  
// Driver Code
public static void Main(String[] args)
{
    int x = 3, y = 16;
    Console.WriteLine(findDivisor(x, y));
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Time Complexity: O(n*sqrt(n)), where n is total number of numbers between interval [x, y].

Efficient Approach: An efficient approach will be to observe carefully that every even number will have 2 as a divisor. And in the interval [x, y] there is atleast floor((y-x)/2) + 1 numbers of 2. That is, half of the total numbers in the interval will have divisor as 2. Clearly this is the maximum number of occurrences of a divisor in the interval. If (x == y), then answer will be x or y.

Below is implementation of above idea:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// Efficient C++ program to
// find maximum occuring
// factor in an interval
#include <iostream>
using namespace std;
  
// function to find max
// occurring divisor
// interval [x, y]
int findDivisor(int x, int y)
{
    // if there is only 
    // one number in the
    // in the interval, 
    // return that number
    if (x == y)
        return y;
  
    // otherwise, 2 is the
    // max occurring 
    // divisor
    return 2;
}
  
// Driver code
int main()
{
    int x = 3, y = 16;
    cout << findDivisor(x, y);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Efficient Java program to
// find maximum occuring
// factor in an interval
import java.io.*;
  
class GFG {
          
    // function to find max
    // occurring divisor
    // interval [x, y]
    static int findDivisor(int x, int y)
    {
        // if there is only 
        // one number in the
        // in the interval, 
        // return that number
        if (x == y)
            return y;
      
        // otherwise, 2 is the max 
        // occurring divisor
        return 2;
    }
      
    /* Driver program  */
    public static void main(String[] args)
    {
        int x = 3, y = 16;
        System.out.println(findDivisor(x, y));
    }
}
  
// This code is contributed by Gitanjali.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Efficient python 3 program 
# to find maximum occuring
# factor in an interval
  
# function to find max
# occurring divisor
# interval [x, y]
def findDivisor(x, y):
  
    # if there is only 
    # one number in the
    # in the interval, 
    # return that number
    if (x == y):
        return y
  
    # otherwise, 2 is 
    # max occurring 
    # divisor
    return 2
  
# Driver code
x = 3
y = 16
print(findDivisor(x, y))
  
# This code is contributed by
# Smitha Dinesh Semwal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// Efficient C# program to
// find maximum occuring
// factor in an interval
using System;
  
class GFG {
          
    // function to find max
    // occurring divisor
    // interval [x, y]
    static int findDivisor(int x, int y)
    {
          
        // if there is only 
        // one number in the
        // in the interval, 
        // return that number
        if (x == y)
            return y;
      
        // otherwise, 2 is the max 
        // occurring divisor
        return 2;
    }
      
    // Driver Code
    public static void Main()
    {
        int x = 3, y = 16;
        Console.Write(findDivisor(x, y));
    }
}
  
// This code is contributed by nitin mittal.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// Efficient PHP program to
// find maximum occuring
// factor in an interval
  
// function to find max
// occurring divisor
// interval [x, y]
function findDivisor($x, $y)
{
    // if there is only 
    // one number in the
    // in the interval, 
    // return that number
    if ($x == $y)
        return $y;
  
    // otherwise, 2 is the
    // max occurring 
    // divisor
    return 2;
}
  
// Driver code
$x = 3;
$y = 16;
echo findDivisor($x, $y);
  
// This code is contributed by mits.
?>

chevron_right



Output :

2

Time Complexity: O(1)
Auxiliary Space: O(1)



My Personal Notes arrow_drop_up

Senior Technical Content Engineer | GeeksforGeeks

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.