Open In App

Number with maximum number of prime factors

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Given an integer N. The task is to find a number that is smaller than or equal to N and has maximum prime factors. In case there are two or more numbers with the same maximum number of prime factors, find the smallest of all.
Examples: 

Input : N = 10
Output : 6
Number of prime factor of:
1 : 0
2 : 1
3 : 1
4 : 1
5 : 1
6 : 2
7 : 1
8 : 1
9 : 1
10 : 2
6 and 10 have maximum (2) prime factor
but 6 is smaller.
Input : N = 40
Output : 30

Method 1 (brute force): 
For each integer from 1 to N, find the number of prime factors of each integer and find the smallest number having a maximum number of prime factors.
Method 2 (Better Approach): 
Use sieve method to count a number of prime factors of each number less than N. And find the minimum number having maximum count.
Below is the implementation of this approach: 

C++




// C++ program to find integer having maximum number
// of prime factor in first N natural numbers.
#include<bits/stdc++.h>
 
using namespace std;
 
// Return smallest number having maximum
// prime factors.
int maxPrimefactorNum(int N)
{
    int arr[N + 5];
    memset(arr, 0, sizeof(arr));
 
    // Sieve of eratosthenes method to count
    // number of prime factors.
    for (int i = 2; i*i <= N; i++)
    {
        if (!arr[i])
            for (int j = 2*i; j <= N; j+=i)
                arr[j]++;
 
        arr[i] = 1;
    }
 
    int maxval = 0, maxint = 1;
 
    // Finding number having maximum number
    // of prime factor.
    for (int i = 1; i <= N; i++)
    {
        if (arr[i] > maxval)
        {
            maxval = arr[i];
            maxint = i;
        }
    }
 
    return maxint;
}
 
// Driven Program
int main()
{
    int N = 40;
    cout << maxPrimefactorNum(N) << endl;
    return 0;
}


Java




// Java program to find integer having maximum number
// of prime factor in first N natural numbers.
import java.util.Arrays;
public class GFG {
 
// Return smallest number having maximum
// prime factors.
    static int maxPrimefactorNum(int N) {
        int arr[] = new int[N + 5];
        Arrays.fill(arr, 0);
         
        // Sieve of eratosthenes method to count
        // number of prime factors.
        for (int i = 2; i * i <= N; i++) {
            if (arr[i] == 0) {
                for (int j = 2 * i; j <= N; j += i) {
                    arr[j]++;
                }
            }
 
            arr[i] = 1;
        }
 
        int maxval = 0, maxint = 1;
 
        // Finding number having maximum number
        // of prime factor.
        for (int i = 1; i <= N; i++) {
            if (arr[i] > maxval) {
                maxval = arr[i];
                maxint = i;
            }
        }
 
        return maxint;
    }
// Driver program
 
    public static void main(String[] args) {
        int N = 40;
        System.out.println(maxPrimefactorNum(N));
    }
}


Python3




# Python 3 program to find integer having
# maximum number of prime factor in first
# N natural numbers.
from math import sqrt
 
# Return smallest number having maximum
# prime factors.
def maxPrimefactorNum(N):
    arr = [0 for i in range(N + 5)]
 
    # Sieve of eratosthenes method to
    # count number of prime factors.
    for i in range(2, int(sqrt(N)) + 1, 1):
        if (arr[i] == 0):
            for j in range(2 * i, N + 1, i):
                arr[j] += 1
 
        arr[i] = 1
 
    maxval = 0
    maxint = 1
 
    # Finding number having maximum
    # number of prime factor.
    for i in range(1, N + 1, 1):
        if (arr[i] > maxval):
            maxval = arr[i]
            maxint = i
     
    return maxint
 
# Driver Code
if __name__ == '__main__':
    N = 40
    print(maxPrimefactorNum(N))
 
# This code is contributed by
# Sahil_Shelangia


C#




// C# program to find integer having
// maximum number of prime factor in
// first N natural numbers.
using System;
 
class GFG
{
 
// Return smallest number having
// prime factors.
static int maxPrimefactorNum(int N)
{
    int []arr = new int[N + 5];
     
    // Sieve of eratosthenes method to
    // count number of prime factors.
    for (int i = 2; i * i <= N; i++)
    {
        if (arr[i] == 0)
        {
            for (int j = 2 * i; j <= N; j += i)
            {
                arr[j]++;
            }
        }
 
        arr[i] = 1;
    }
 
    int maxval = 0, maxint = 1;
 
    // Finding number having maximum
    // number of prime factor.
    for (int i = 1; i <= N; i++)
    {
        if (arr[i] > maxval)
        {
            maxval = arr[i];
            maxint = i;
        }
    }
 
    return maxint;
}
 
// Driver Code
public static void Main()
{
    int N = 40;
    Console.WriteLine(maxPrimefactorNum(N));
}
}
 
// This code is contributed
// by 29AjayKumar


Javascript




<script>
// javascript program to find integer having maximum number
// of prime factor in first N natural numbers.
 
// Return smallest number having maximum
// prime factors.
function maxPrimefactorNum(N) {
    var arr = Array.from({length: N + 5}, (_, i) => 0);
     
    // Sieve of eratosthenes method to count
    // number of prime factors.
    for (i = 2; i * i <= N; i++) {
        if (arr[i] == 0) {
            for (j = 2 * i; j <= N; j += i) {
                arr[j]++;
            }
        }
 
        arr[i] = 1;
    }
 
    var maxval = 0, maxvar = 1;
 
    // Finding number having maximum number
    // of prime factor.
    for (i = 1; i <= N; i++) {
        if (arr[i] > maxval) {
            maxval = arr[i];
            maxvar = i;
        }
    }
 
    return maxvar;
}
// Driver program
var N = 40;
document.write(maxPrimefactorNum(N));
 
 
// This code contributed by Princi Singh
</script>


PHP




<?php
// PHP program to find integer having
// maximum number of prime factor in
// first N natural numbers.
 
// Return smallest number having
// maximum prime factors.
function maxPrimefactorNum($N)
{
    $arr[$N + 5] = array();
    $arr = array_fill(0, $N + 1, NULL);
     
    // Sieve of eratosthenes method to count
    // number of prime factors.
    for ($i = 2; ($i * $i) <= $N; $i++)
    {
        if (!$arr[$i])
            for ($j = 2 * $i; $j <= $N; $j += $i)
                $arr[$j]++;
 
        $arr[$i] = 1;
    }
 
    $maxval = 0;
    $maxint = 1;
 
    // Finding number having maximum
    // number of prime factor.
    for ($i = 1; $i <= $N; $i++)
    {
        if ($arr[$i] > $maxval)
        {
            $maxval = $arr[$i];
            $maxint = $i;
        }
    }
 
    return $maxint;
}
 
// Driver Code
$N = 40;
echo maxPrimefactorNum($N), "\n";
 
// This code is contributed by ajit
?>


Output

30






Time complexity: O(n)
Auxiliary space: O(1)

Method 3 (efficient approach): 
Generate all prime numbers before N using Sieve. Now, multiply consecutive prime numbers (starting from the first prime number) one after another until the product is less than N.
Below is the implementation of this approach: 

C++




// C++ program to find integer having maximum number
// of prime factor in first N natural numbers
#include<bits/stdc++.h>
 
using namespace std;
 
// Return smallest number having maximum prime factors.
int maxPrimefactorNum(int N)
{
    bool arr[N + 5];
    memset(arr, true, sizeof(arr));
 
    // Sieve of eratosthenes
    for (int i = 3; i*i <= N; i += 2)
    {
        if (arr[i])
            for (int j = i*i; j <= N; j+=i)
                arr[j] = false;
    }
 
    // Storing prime numbers.
    vector<int> prime;
    prime.push_back(2);
 
    for(int i = 3; i <= N; i += 2)
        if(arr[i])
            prime.push_back(i);
 
    // Generating number having maximum prime factors.
    int i = 0, ans = 1;
    while (ans*prime[i] <= N && i < prime.size())
    {
        ans *= prime[i];
        i++;
    }
 
    return ans;
}
 
// Driven Program
int main()
{
    int N = 40;
    cout << maxPrimefactorNum(N) << endl;
    return 0;
}


Java




// Java program to find integer having maximum number
// of prime factor in first N natural numbers
import java.util.Vector;
 
public class GFG {
 
// Return smallest number having maximum prime factors.
    static int maxPrimefactorNum(int N) {
        //default value of boolean is false
        boolean arr[] = new boolean[N + 5];
 
        // Sieve of eratosthenes
        for (int i = 3; i * i <= N; i += 2) {
            if (!arr[i]) {
                for (int j = i * i; j <= N; j += i) {
                    arr[j] = true;
                }
            }
        }
 
        // Storing prime numbers.
        Vector<Integer> prime = new Vector<>();
        prime.add(prime.size(), 2);
        for (int i = 3; i <= N; i += 2) {
            if (!arr[i]) {
                prime.add(prime.size(), i);
            }
        }
 
        // Generating number having maximum prime factors.
        int i = 0, ans = 1;
        while (ans * prime.get(i) <= N && i < prime.size()) {
            ans *= prime.get(i);
            i++;
        }
 
        return ans;
    }
// Driver program
 
    public static void main(String[] args) {
        int N = 40;
        System.out.println(maxPrimefactorNum(N));
    }
}


Python3




# Python3 program to find integer having
# maximum number of prime factor in first
# N natural numbers
 
# Return smallest number having
# maximum prime factors.
def maxPrimefactorNum(N):
 
    arr = [True] * (N + 5);
 
    # Sieve of eratosthenes
    i = 3;
    while (i * i <= N):
        if (arr[i]):
            for j in range(i * i, N + 1, i):
                arr[j] = False;
        i += 2;
 
    # Storing prime numbers.
    prime = [];
    prime.append(2);
 
    for i in range(3, N + 1, 2):
        if(arr[i]):
            prime.append(i);
 
    # Generating number having maximum
    # prime factors.
    i = 0;
    ans = 1;
    while (ans * prime[i] <= N and
                    i < len(prime)):
        ans *= prime[i];
        i += 1;
 
    return ans;
 
# Driver Code
N = 40;
print(maxPrimefactorNum(N));
 
# This code is contributed by mits


C#




// C# program to find integer having maximum number
// of prime factor in first N natural numbers
using System;
using System.Collections;
 
class GFG {
 
    // Return smallest number having maximum prime factors.
    static int maxPrimefactorNum(int N)
    {
        //default value of boolean is false
        bool []arr = new bool[N + 5];
        int i ;
         
        // Sieve of eratosthenes
        for (i = 3; i * i <= N; i += 2)
        {
            if (!arr[i])
            {
                for (int j = i * i; j <= N; j += i)
                {
                    arr[j] = true;
                }
            }
        }
 
        // Storing prime numbers.
        ArrayList prime = new ArrayList();
        prime.Add(2);
        for (i = 3; i <= N; i += 2)
        {
            if (!arr[i])
            {
                prime.Add(i);
            }
        }
 
        // Generating number having
        // maximum prime factors.
        int ans = 1;
        i = 0;
        while (ans * (int)prime[i] <= N && i < prime.Count)
        {
            ans *= (int)prime[i];
            i++;
        }
 
        return ans;
    }
 
    // Driver code
    public static void Main()
    {
        int N = 40;
        Console.Write(maxPrimefactorNum(N));
    }
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
 
    // Javascript program to find
    // integer having maximum number
    // of prime factor in first
    // N natural numbers
     
    // Return smallest number having
    // maximum prime factors.
    function maxPrimefactorNum(N)
    {
        // default value of boolean is false
        let arr = new Array(N + 5);
        arr.fill(false);
        let i ;
          
        // Sieve of eratosthenes
        for (i = 3; i * i <= N; i += 2)
        {
            if (!arr[i])
            {
                for (let j = i * i; j <= N; j += i)
                {
                    arr[j] = true;
                }
            }
        }
  
        // Storing prime numbers.
        let prime = [];
        prime.push(2);
        for (i = 3; i <= N; i += 2)
        {
            if (!arr[i])
            {
                prime.push(i);
            }
        }
  
        // Generating number having
        // maximum prime factors.
        let ans = 1;
        i = 0;
        while (ans * prime[i] <= N && i < prime.length)
        {
            ans *= prime[i];
            i++;
        }
  
        return ans;
    }
     
    let N = 40;
      document.write(maxPrimefactorNum(N));
     
</script>


PHP




<?php
// PHP program to find integer having maximum number
// of prime factor in first N natural numbers
 
// Return smallest number having
// maximum prime factors.
function maxPrimefactorNum($N)
{
    $arr = array_fill(0, $N + 5, true);
 
    // Sieve of eratosthenes
    for ($i = 3; $i * $i <= $N; $i += 2)
    {
        if ($arr[$i])
            for ($j = $i * $i; $j <= $N; $j += $i)
                $arr[$j] = false;
    }
 
    // Storing prime numbers.
    $prime = array();
    array_push($prime, 2);
 
    for($i = 3; $i <= $N; $i += 2)
        if($arr[$i])
            array_push($prime, $i);
 
    // Generating number having maximum
    // prime factors.
    $i = 0;
    $ans = 1;
    while ($ans * $prime[$i] <= $N &&
                  $i < count($prime))
    {
        $ans *= $prime[$i];
        $i++;
    }
 
    return $ans;
}
 
// Driver Code
$N = 40;
print(maxPrimefactorNum($N));
 
// This code is contributed by mits
?>


Output

30






Time complexity: O(nsqrtn)
Auxiliary space: O(n)

 Prime Factorization Method:

Approach:

In this approach, we factorize all numbers from 1 to N and count the number of prime factors for each number. We can use a prime factorization algorithm like trial division or Pollard’s rho algorithm.

  • Define a function prime_factors_trial_division(n) that takes an integer n as input and returns a list of prime factors of n using the trial division method. The trial division method involves dividing n by each integer from 2 to the square root of n, and adding each integer that divides n without a remainder to the list of factors. If no integer from 2 to the square root of n divides n without a remainder, then n itself is a prime factor and is added to the list of factors.
  • Define a function count_prime_factors(n) that takes an integer n as input and returns the count of distinct prime factors of n. The function first calls the prime_factors_trial_division(n) function to get the list of prime factors, and then converts the list to a set to remove duplicates. The length of the set is then returned as the count of distinct prime factors.
  • Define a function max_prime_factors_prime_factorization(n) that takes an integer n as input and returns the number between 1 and n that has the maximum number of distinct prime factors. The function iterates through all integers from 1 to n, calls the count_prime_factors(n) function to get the count of distinct prime factors for each integer, and updates the max_count and max_num variables if the count for the current integer is greater than the current maximum count. The function returns the max_num variable as the output.
  • Use the max_prime_factors_prime_factorization(n) function to find the number between 1 and n that has the maximum number of distinct prime factors. Print the result as the output.

C++




#include <iostream>
#include <set>
#include <vector>
 
using namespace std;
 
// Function to find prime factors of a number using trial
// division
vector<int> prime_factors_trial_division(int n)
{
    vector<int> factors;
    int i = 2;
    while (i * i <= n) {
        if (n % i == 0) {
            factors.push_back(i); // Store the prime factor
            n /= i; // Divide by the prime factor
        }
        else {
            i++;
        }
    }
    if (n > 1) {
        factors.push_back(
            n); // Store the remaining prime factor
    }
    return factors;
}
 
// Function to count the number of unique prime factors of a
// number
int count_prime_factors(int n)
{
    vector<int> factors = prime_factors_trial_division(n);
    set<int> unique_factors(factors.begin(), factors.end());
    int count = unique_factors.size();
    return count;
}
 
// Function to find the number with the maximum prime
// factors among numbers from 1 to n
int max_prime_factors_prime_factorization(int n)
{
    int max_count = 0;
    int max_num = 0;
    for (int i = 1; i <= n; i++) {
        int count = count_prime_factors(
            i); // Count the unique prime factors
        if (count > max_count) {
            max_count = count;
            max_num = i; // Update if the current number has
                         // more prime factors
        }
    }
    return max_num;
}
 
int main()
{
    int n = 10;
    cout << "Input : N = " << n << endl;
    cout << "Number of prime factors of:" << endl;
    for (int i = 1; i <= n; i++) {
        vector<int> factors
            = prime_factors_trial_division(i);
        int count = count_prime_factors(i);
        cout << i << " : " << count << endl;
    }
    int max_num = max_prime_factors_prime_factorization(n);
    cout << max_num
         << " has the maximum number of prime factors "
            "among all numbers from 1 to "
         << n << endl;
 
    n = 40;
    cout << "Input : N = " << n << endl;
    max_num = max_prime_factors_prime_factorization(n);
    cout << max_num
         << " has the maximum number of prime factors "
            "among all numbers from 1 to "
         << n << endl;
 
    return 0;
}


Java




import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
 
public class PrimeFactorization {
 
    // Function to find the prime factors of n using trial
    // division
    public static List<Integer>
    primeFactorsTrialDivision(int n)
    {
        List<Integer> factors = new ArrayList<>();
        int i = 2;
        while (i * i <= n) {
            if (n % i == 0) {
                factors.add(i);
                n /= i;
            }
            else {
                i++;
            }
        }
        if (n > 1) {
            factors.add(n);
        }
        return factors;
    }
 
    // Function to count the number of unique prime factors
    public static int countPrimeFactors(int n)
    {
        List<Integer> factors
            = primeFactorsTrialDivision(n);
        Set<Integer> uniqueFactors = new HashSet<>(factors);
        return uniqueFactors.size();
    }
 
    // Function to find the number with the maximum prime
    // factors from 1 to n
    public static int
    maxPrimeFactorsPrimeFactorization(int n)
    {
        int maxCount = 0;
        int maxNum = 0;
        for (int i = 1; i <= n; i++) {
            int count = countPrimeFactors(i);
            if (count > maxCount) {
                maxCount = count;
                maxNum = i;
            }
        }
        return maxNum;
    }
 
    public static void main(String[] args)
    {
        int n = 10;
        System.out.println("Input: N = " + n);
        System.out.println(
            "Number of prime factors of each number:");
 
        // Iterate through numbers from 1 to N
        for (int i = 1; i <= n; i++) {
            List<Integer> factors
                = primeFactorsTrialDivision(i);
            Set<Integer> uniqueFactors
                = new HashSet<>(factors);
            int count = uniqueFactors.size();
            System.out.println(i + " : " + count);
        }
 
        int maxNum = maxPrimeFactorsPrimeFactorization(n);
        System.out.println(
            maxNum
            + " has the maximum number of prime factors among all numbers from 1 to "
            + n);
 
        n = 40;
        System.out.println("Input: N = " + n);
 
        maxNum = maxPrimeFactorsPrimeFactorization(n);
        System.out.println(
            maxNum
            + " has the maximum number of prime factors among all numbers from 1 to "
            + n);
    }
}


Python3




def prime_factors_trial_division(n):
    factors = []
    i = 2
    while i * i <= n:
        if n % i == 0:
            factors.append(i)
            n //= i
        else:
            i += 1
    if n > 1:
        factors.append(n)
    return factors
 
def count_prime_factors(n):
    factors = prime_factors_trial_division(n)
    count = len(set(factors))
    return count
 
def max_prime_factors_prime_factorization(n):
    max_count = 0
    max_num = 0
    for i in range(1, n+1):
        count = count_prime_factors(i)
        if count > max_count:
            max_count = count
            max_num = i
    return max_num
 
# Example usage
n = 10
print("Input : N =", n)
print("Number of prime factors of:")
for i in range(1, n+1):
    factors = prime_factors_trial_division(i)
    count = len(set(factors))
    print(i, ":", count)
max_num = max_prime_factors_prime_factorization(n)
print(max_num, "has maximum number of prime factors among all numbers from 1 to", n)
 
n = 40
print("Input : N =", n)
max_num = max_prime_factors_prime_factorization(n)
print(max_num, "has maximum number of prime factors among all numbers from 1 to", n)


C#




using System;
using System.Collections.Generic;
 
class PrimeFactorUtils {
    // Function to find prime factors using trial division
    static List<int> PrimeFactorsTrialDivision(int n)
    {
        List<int> factors = new List<int>();
        int i = 2;
        while (i * i <= n) {
            if (n % i == 0) {
                factors.Add(i);
                n /= i;
            }
            else {
                i++;
            }
        }
        if (n > 1) {
            factors.Add(n);
        }
        return factors;
    }
 
    // Function to count unique prime factors of a number
    static int CountPrimeFactors(int n)
    {
        List<int> factors = PrimeFactorsTrialDivision(n);
        HashSet<int> uniqueFactors
            = new HashSet<int>(factors);
        return uniqueFactors.Count;
    }
 
    // Function to find the number with the maximum unique
    // prime factors
    static int MaxPrimeFactorsPrimeFactorization(int n)
    {
        int maxCount = 0;
        int maxNum = 0;
        for (int i = 1; i <= n; i++) {
            int count = CountPrimeFactors(i);
            if (count > maxCount) {
                maxCount = count;
                maxNum = i;
            }
        }
        return maxNum;
    }
 
    static void Main(string[] args)
    {
        int n = 10;
        Console.WriteLine("Input: N = " + n);
        Console.WriteLine("Number of prime factors of:");
        for (int i = 1; i <= n; i++) {
            List<int> factors
                = PrimeFactorsTrialDivision(i);
            HashSet<int> uniqueFactors
                = new HashSet<int>(factors);
            int count = uniqueFactors.Count;
            Console.WriteLine(i + " : " + count);
        }
        int maxNum = MaxPrimeFactorsPrimeFactorization(n);
        Console.WriteLine(
            maxNum
            + " has the maximum number of prime factors among all numbers from 1 to "
            + n);
 
        n = 40;
        Console.WriteLine("Input: N = " + n);
        maxNum = MaxPrimeFactorsPrimeFactorization(n);
        Console.WriteLine(
            maxNum
            + " has the maximum number of prime factors among all numbers from 1 to "
            + n);
    }
}


Javascript




// Function to find prime factors using trial division
function prime_factors_trial_division(n) {
    const factors = [];
    let i = 2;
    while (i * i <= n) {
        if (n % i === 0) {
            factors.push(i);
            n /= i;
        } else {
            i++;
        }
    }
    if (n > 1) {
        factors.push(n);
    }
    return factors;
}
 
// Function to count the number of distinct prime factors
function count_prime_factors(n) {
    const factors = prime_factors_trial_division(n);
    const unique_factors = [...new Set(factors)];
    return unique_factors.length;
}
 
// Function to find the number with the maximum prime factors
function max_prime_factors_prime_factorization(n) {
    let max_count = 0;
    let max_num = 0;
    for (let i = 1; i <= n; i++) {
        const count = count_prime_factors(i);
        if (count > max_count) {
            max_count = count;
            max_num = i;
        }
    }
    return max_num;
}
 
// Example usage
const n1 = 10;
console.log("Input : N =", n1);
console.log("Number of prime factors of:");
for (let i = 1; i <= n1; i++) {
    const factors = prime_factors_trial_division(i);
    const count = [...new Set(factors)].length;
    console.log(i, ":", count);
}
const maxNum1 = max_prime_factors_prime_factorization(n1);
console.log(maxNum1, "has maximum number of prime factors among all numbers from 1 to", n1);
 
const n2 = 40;
console.log("Input : N =", n2);
const maxNum2 = max_prime_factors_prime_factorization(n2);
console.log(maxNum2, "has maximum number of prime factors among all numbers from 1 to", n2);


Output

Input : N = 10
Number of prime factors of:
1 : 0
2 : 1
3 : 1
4 : 1
5 : 1
6 : 2
7 : 1
8 : 1
9 : 1
10 : 2
6 has maximum number of prime factors among all numbers from 1 to 10
Input : N = 40
30 has maximum number of prime factors among all numbers from 1 to 40






Time Complexity: O(N log log N)
Space Complexity: O(1)

This article is contributed byAnuj Chauhan.



Last Updated : 09 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads