小于等于N的最大素数乘积

给定数字N ，任务是找到小于或等于其主要因子乘积最大的N的数字。
注意：如果有多个数字，其最大积相等，则打印最小的数字。
例子：

Input: N = 12 
Output: 11 
Explanation: 
Product of prime factor of all numbers before N: 
2 = 2 
3 = 3 
4 = 2 
5 = 5 
6 = 2 * 3 = 6 
7 = 7 
8 = 2 
9 = 3 
10 = 2 * 5 = 10 
11 = 11 
12 = 2*3 = 6 
The maximum of all the above is 11.
Input: N = 20 
Output: 19 
 

方法：这个想法是使用Eratosthenes的Seive概念找到N个数的所有素数的乘积，然后找到素数乘积最大的最小数。步骤如下：

1. 创建一个从1到N的数字列表，并用1初始化每个值。
2. 令p = 2 ，这是第一个素数。从对迭代，列表中的每个指标在P的增量计数，并乘以页。这些索引将是p(p + 1)，p(p + 2)，p(p + 3)等。
   例如：

If p is a prime number, then multiply with p
at every index which is multiple of p.
For p = 2,
Multiply with 2 at index 2, 4, 6, 8, 10,..., till N.

1. 对所有素数重复上述步骤，直到N为止。
2. 找到所有素数直到N的乘积后，遍历数字列表，找到乘积最大的最小数。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the smallest number
// having a maximum product of prime factors
int maxPrimefactorNum(int N)
{
 
    // Declare the array arr[]
    int arr[N + 1];
 
    // Initialise array with 1
    for (int i = 0; i < N + 1; i++)
        arr[i] = 1;
 
    // Iterate from [2, N]
    for (int i = 2; i <= N; i++) {
 
        // If value at index i is 1,
        // then i is prime and make
        // update array at index for
        // all multiples of i
        if (arr[i] == 1) {
            for (int j = i; j <= N; j += i) {
                arr[j] *= i;
            }
        }
    }
 
    // Initialise maxValue
    int maxValue = 1;
 
    // Find number having maximum product
    // of prime factor <= N
    for (int i = 2; i <= N; i++) {
        if (arr[i] > maxValue) {
            maxValue = i;
        }
    }
 
    // Find the maximum value
    return maxValue;
}
 
// Driven Code
int main()
{
    // Given Number
    int N = 20;
 
    // Function call
    cout << maxPrimefactorNum(N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the smallest number
// having a maximum product of prime factors
static int maxPrimefactorNum(int N)
{
     
    // Declare the array arr[]
    int []arr = new int[N + 1];
 
    // Initialise array with 1
    for(int i = 0; i < N + 1; i++)
        arr[i] = 1;
 
    // Iterate from [2, N]
    for(int i = 2; i <= N; i++)
    {
 
        // If value at index i is 1,
        // then i is prime and make
        // update array at index for
        // all multiples of i
        if (arr[i] == 1)
        {
            for(int j = i; j <= N; j += i)
            {
                arr[j] *= i;
            }
        }
    }
 
    // Initialise maxValue
    int maxValue = 1;
 
    // Find number having maximum product
    // of prime factor <= N
    for(int i = 2; i<= N; i++)
    {
        if (arr[i] > maxValue)
        {
            maxValue = i;
        }
    }
 
    // Find the maximum value
    return maxValue;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given number
    int N = 20;
 
    // Function call
    System.out.print(maxPrimefactorNum(N));
}
}
 
// This code is contributed by Rohit_ranjan

Python3

# Python3 program for the above approach
 
# Function to find the smallest number
# having a maximum product of prime factors
def maxPrimefactorNum(N):
     
    # Declare the list arr
    arr = []
 
    # Initialise list with 1
    for i in range(N + 1):
        arr.append(1)
 
    # Iterate from [2, N]
    for i in range(2, N + 1):
         
        # If value at index i is 1,
        # then i is prime and make
        # update list at index for
        # all multiples of i
        if (arr[i] == 1) :
            for j in range(i, N + 1, i):
                arr[j] *= i
 
    # Initialise maxValue
    maxValue = 1
 
    # Find number having maximum product
    # of prime factor <= N
    for i in range(2, N + 1):
        if (arr[i] > maxValue):
            maxValue = i
 
    # Find the maximum value
    return maxValue
 
# Driver Code
 
# Given number
N = 20;
 
# Function call
print(maxPrimefactorNum(N))
 
# This code is contributed by yatinagg

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the smallest number
// having a maximum product of prime factors
static int maxPrimefactorNum(int N)
{
     
    // Declare the array []arr
    int []arr = new int[N + 1];
 
    // Initialise array with 1
    for(int i = 0; i < N + 1; i++)
        arr[i] = 1;
 
    // Iterate from [2, N]
    for(int i = 2; i <= N; i++)
    {
 
        // If value at index i is 1,
        // then i is prime and make
        // update array at index for
        // all multiples of i
        if (arr[i] == 1)
        {
            for(int j = i; j <= N; j += i)
            {
                arr[j] *= i;
            }
        }
    }
 
    // Initialise maxValue
    int maxValue = 1;
 
    // Find number having maximum product
    // of prime factor <= N
    for(int i = 2; i<= N; i++)
    {
        if (arr[i] > maxValue)
        {
            maxValue = i;
        }
    }
 
    // Find the maximum value
    return maxValue;
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given number
    int N = 20;
 
    // Function call
    Console.Write(maxPrimefactorNum(N));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// javascript program for the above approach
 
 
// Function to find the smallest number
// having a maximum product of prime factors
function maxPrimefactorNum( N)
{
 
    // Declare the array arr[]
    let arr=Array(N + 1).fill(1);
 
    // Initialise array with 1
    //for (int i = 0; i < N + 1; i++)
      //  arr[i] = 1;
 
    // Iterate from [2, N]
    for (let i = 2; i <= N; i++) {
 
        // If value at index i is 1,
        // then i is prime and make
        // update array at index for
        // all multiples of i
        if (arr[i] == 1) {
            for (let j = i; j <= N; j += i) {
                arr[j] *= i;
            }
        }
    }
 
    // Initialise maxValue
    let maxValue = 1;
 
    // Find number having maximum product
    // of prime factor <= N
    for (let i = 2; i <= N; i++) {
        if (arr[i] > maxValue) {
            maxValue = i;
        }
    }
 
    // Find the maximum value
    return maxValue;
}
 
// Driven Code
 
    // Given Number
    let N = 20;
 
    // Function call
        document.write(maxPrimefactorNum(N));
     
 
// This code contributed by Rajput-Ji
 

输出：

19

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