间隔中出现的最大除数

给定间隔[x，y]。在[x，y]范围内(包括两个端点)的数字除数中找到除’1’以外出现次数最多的除数。

例子 ：

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

蛮力法：最简单的方法是遍历从x到y的所有数字，并计算所有除数，并将除数及其计数存储在地图中。最后，遍历地图以查找除数出现的最大次数。您可以参考本文，了解如何有效地打印自然数的所有除数。

下面是上述方法的实现：

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 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 m = new Dictionary();
  
    // 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 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

时间复杂度：O(n * sqrt(n))，其中n是间隔[x，y]之间的总数。

有效的方法：一种有效的方法是仔细观察每个偶数都将2作为除数。并且在间隔[x，y]中，至少有floor((yx)/ 2)+ 1个2。即，间隔中总数的一半将被除数为2。显然，这是最大数。在间隔中出现除数。如果(x == y)，则答案将是x或y。

以下是上述想法的实现：

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.

输出 ：

2

时间复杂度：O(1)
辅助空间：O(1)