Skip to content
Related Articles
Open in App
Not now

Related Articles

Max occurring divisor in an interval

Improve Article
Save Article
  • Last Updated : 19 Jun, 2022
Improve Article
Save Article

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
Javascript



// JavaScript program to find maximum occurring
// factor in an interval
 
// function to find max occurring
// divisor in interval [x, y]
function findDivisor(x, y)
{
    // map to store count of divisors
    let m = new Map();
 
    // iterate for every number in the
    // interval
    for (let num = x; num <= y; num++) {
        // find all divisors of num
        for (let i = 2; i <= Math.sqrt(num) + 1; i++) {
            if (num % i == 0) {
 
                // If divisors are equal, print only one
                if (Math.floor(num / i) == i) {
                    if (!m.has(i)){
                        m.set(i, 1);
                    }
                    else{
                        m.set(i, m.get(i) + 1);
                    }
                }
                else {
                     
                    // insert first one to map
                    if (!m.has(i))
                        m.set(i, 1);
                    else
                        m.set(i, m.get(i) + 1);
 
                    // insert second to map
                    if (!m.has(Math.floor(num / i)))
                        m.set(Math.floor(num / i), 1);
                    else
                        m.set(Math.floor(num/i), m.get(Math.floor(num/i)) + 1);
                }
            }
        }
    }
 
    let divisor = 0;
    let divisorCount = -999999;
 
    // iterate on map
    for(const [key,value] of m){
        if (value> divisorCount) {
            divisorCount = value;
            divisor = key;
        }       
    }
 
    return divisor;
}
 
// Driver code
let x = 3;
let y = 16;
console.log(findDivisor(x, y));
 
// The code is contributed by Gautam goel (gautamgoel962)
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
Previous
Tango Tree Data Structure
Next

Maximum absolute difference of value and index sums
Related Articles
1.
Find GCD of most occurring and least occurring elements of given Array
2.
Check if max occurring character of one string appears same no. of times in other
3.
Find min and max values among all maximum leaf nodes from all possible Binary Max Heap
4.
Queries on XOR of greatest odd divisor of the range
5.
Greatest divisor which divides all natural number in range [L, R]
6.
Smallest divisor D of N such that gcd(D, M) is greater than 1
7.
Generating numbers that are divisor of their right-rotations
8.
Find the k-th smallest divisor of a natural number N
9.
Sum of greatest odd divisor of numbers in given range
10.
Smallest prime divisor of a number
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
harsh.agarwal0
@harsh.agarwal0
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!