Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Max occurring divisor in an interval

  • Last Updated : 02 Jun, 2021

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

C++




// Simple CPP program to find maximum occurring
// 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;
}

Java




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

Python




# Simple python program to find maximum
# occurring 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'.

C#




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

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




// Efficient C++ program to
// find maximum occurring
// 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;
}

Java




// Efficient Java program to
// find maximum occurring
// 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.

Python3




# Efficient python 3 program
# to find maximum occurring
# 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

C#




// Efficient C# program to
// find maximum occurring
// 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.

PHP




<?php
// Efficient PHP program to
// find maximum occurring
// 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.
?>

Javascript




<script>
 
// Efficient javascript program to
// find maximum occurring
// 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 program  */
var x = 3, y = 16;
document.write(findDivisor(x, y));
 
// This code is contributed by 29AjayKumar
 
</script>

Output:  

2

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!