Related Articles
Max occurring divisor in an interval
• Last Updated : 29 Nov, 2019

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 `// Simple CPP program to find maximum occurring``// factor in an interval``#include ``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 m = ``new` `HashMap();`` ` `    ``// 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 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 ``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

 ``

Output :
```2
```

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up