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


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.



Improved By : nitin mittal, Mithun Kumar