Skip to content
Related Articles

Related Articles

Improve Article

Find maximum operations to reduce N to 1

  • Last Updated : 11 May, 2021

Given two numbers A and B ( A and B can be up to 106 ) which forms a number N = (A!/B!). The task is to reduce N to 1 by performing maximum number of operations possible. 
In each operation, one can replace N with N/X if N is divisible by X. 
Find the maximum number of operations that can be possible.
Examples: 
 

Input : A = 6, B = 3
Output : 5
Explanation : N is 120 and the divisors are 2, 2, 2, 3, 5

Input : A = 2, B = 1
Output : 1
Explanation : N is 2 and the divisor is 2.

 

Observe that factorization of number A!/B! is this same as factorization of numbers (B + 1)*(B + 2)*…*(A – 1)*A.
Also, the number of operations will be maximum if we divide N with only with it’s prime factors. So, in other words we need to find the count of prime factors of N including duplicates.
Let’s count the number of prime factors in the factorization of every number from 2 to 1000000.
First, use Sieve of Eratosthenes to find a prime divisor of each of these numbers. Then we can calculate the number of prime factors in the factorization of a using the formula: 
 

primefactors[num] = primefactors[num / primediviser[num]] + 1

Now, one can use prefix sum array for prime factors and then answer for the sum on an interval [A, B].
Below is the implementation of the above approach:
 

C++




// CPP program to find maximum
// number moves possible
 
#include <bits/stdc++.h>
using namespace std;
#define N 1000005
 
// To store number of prime
// factors of each number
int primeFactors[N];
 
// Function to find number of prime
// factors of each number
void findPrimeFactors()
{
    for (int i = 2; i < N; i++)
        // if i is a prime number
        if (primeFactors[i] == 0)
            for (int j = i; j < N; j += i)
                // increase value by one from
                // it's preveious multiple
                primeFactors[j] = primeFactors[j / i] + 1;
 
    // make prefix sum
    // this will be helpful for
    // multiple test cases
    for (int i = 1; i < N; i++)
        primeFactors[i] += primeFactors[i - 1];
}
 
// Driver Code
int main()
{
    // Generate primeFactors array
    findPrimeFactors();
 
    int a = 6, b = 3;
 
    // required answer
    cout << primeFactors[a] - primeFactors[b];
 
    return 0;
}
Java



// Java program to find maximum
// number moves possible
import java.io.*;
 
class GFG
{
     
static int N= 1000005;
 
// To store number of prime
// factors of each number
static int primeFactors[] = new int[N];
 
// Function to find number of prime
// factors of each number
static void findPrimeFactors()
{
    for (int i = 2; i < N; i++)
     
        // if i is a prime number
        if (primeFactors[i] == 0)
            for (int j = i; j < N; j += i)
             
                // increase value by one from
                // it's preveious multiple
                primeFactors[j] = primeFactors[j / i] + 1;
 
    // make prefix sum
    // this will be helpful for
    // multiple test cases
    for (int i = 1; i < N; i++)
        primeFactors[i] += primeFactors[i - 1];
}
 
// Driver Code
public static void main (String[] args)
{
 
    // Generate primeFactors array
    findPrimeFactors();
    int a = 6, b = 3;
     
    // required answer
    System.out.println (primeFactors[a] -
                        primeFactors[b]);
}
}
 
// This code is contributed by jit_t.
Python3



# Python3 program to find maximum
# number moves possible
N = 1000005
 
# To store number of prime
# factors of each number
primeFactors = [0] * N;
 
# Function to find number of prime
# factors of each number
def findPrimeFactors() :
     
    for i in range(2, N) :
         
        # if i is a prime number
        if (primeFactors[i] == 0) :
            for j in range(i, N, i) :
                 
                # increase value by one from
                # it's preveious multiple
                primeFactors[j] = primeFactors[j // i] + 1;
 
    # make prefix sum this will be
    # helpful for multiple test cases
    for i in range(1, N) :
        primeFactors[i] += primeFactors[i - 1];
 
# Driver Code
if __name__ == "__main__" :
     
    # Generate primeFactors array
    findPrimeFactors();
 
    a = 6; b = 3;
 
    # required answer
    print(primeFactors[a] - primeFactors[b]);
 
# This code is contributed by Ryuga
C#



// C# program to find maximum
// number moves possible
using System;
 
class GFG
{
    static int N = 1000005;
 
    // To store number of prime
    // factors of each number
    static int []primeFactors = new int[N];
 
    // Function to find number of prime
    // factors of each number
    static void findPrimeFactors()
    {
        for (int i = 2; i < N; i++)
     
        // if i is a prime number
        if (primeFactors[i] == 0)
            for (int j = i; j < N; j += i)
             
                // increase value by one from
                // it's preveious multiple
                primeFactors[j] = primeFactors[j / i] + 1;
 
        // make prefix sum
        // this will be helpful for
        // multiple test cases
        for (int i = 1; i < N; i++)
            primeFactors[i] += primeFactors[i - 1];
    }
 
    // Driver Code
    static public void Main ()
    {
         
    // Generate primeFactors array
    findPrimeFactors();
    int a = 6, b = 3;
     
    // required answer
    Console.WriteLine(primeFactors[a] -
                        primeFactors[b]);
    }
}
 
// This code is contributed by ajit
PHP



<?php
// PHP program to find maximum
// number moves possible
 
$N = 10005;
 
// To store number of prime
// factors of each number
$primeFactors = array_fill(0, $N, 0);
 
// Function to find number of prime
// factors of each number
function findPrimeFactors()
{
    global $N,$primeFactors;
    for ($i = 2; $i < $N; $i++)
     
        // if i is a prime number
        if ($primeFactors[$i] == 0)
            for ($j = $i; $j < $N; $j += $i)
             
                // increase value by one from
                // it's preveious multiple
                $primeFactors[$j] = $primeFactors[(int)($j / $i)] + 1;
 
    // make prefix sum
    // this will be helpful for
    // multiple test cases
    for ($i = 1; $i < $N; $i++)
        $primeFactors[$i] += $primeFactors[$i - 1];
}
 
    // Driver Code
     
    // Generate primeFactors array
    findPrimeFactors();
 
    $a = 6;
    $b = 3;
 
    // required answer
    print(($primeFactors[$a] - $primeFactors[$b]));
 
// This code is contributed by chandan_jnu
?>
Javascript



<script>
    // Javascript program to find maximum number moves possible
     
    let N = 1000005;
   
    // To store number of prime
    // factors of each number
    let primeFactors = new Array(N);
    primeFactors.fill(0);
   
    // Function to find number of prime
    // factors of each number
    function findPrimeFactors()
    {
        for (let i = 2; i < N; i++)
       
        // if i is a prime number
        if (primeFactors[i] == 0)
            for (let j = i; j < N; j += i)
               
                // increase value by one from
                // it's preveious multiple
                primeFactors[j] = primeFactors[parseInt(j / i, 10)] + 1;
   
        // make prefix sum
        // this will be helpful for
        // multiple test cases
        for (let i = 1; i < N; i++)
            primeFactors[i] += primeFactors[i - 1];
    }
     
    // Generate primeFactors array
    findPrimeFactors();
    let a = 6, b = 3;
       
    // required answer
    document.write(primeFactors[a] -
                        primeFactors[b]);
 
</script>
Output: 
5
 



My Personal Notes
arrow_drop_up
Previous
Java ArrayList to print all possible words from phone digits
Next

Find the values of X and Y in the Given Equations
Recommended Articles
Page :
Minimum number of operations required to reduce N to 1
13, Nov 18
Count operations of the given type required to reduce N to 0
24, Jan 19
Count the number of operations required to reduce the given number
29, Mar 19
Minimum number of given operations required to reduce the array to 0 element
07, May 19
Reduce N to 1 with minimum number of given operations
30, Sep 19
Reduce a number to 1 by performing given operations | Set 2
22, Jan 20
Min number of operations to reduce N to 0 by subtracting any digits from N
26, Jun 20
Min operations to reduce N to 1 by multiplying by A or dividing by B
13, Jul 20
Min operations to reduce N by multiplying by any number or taking square root
13, Jul 20
Minimum number of operations required to reduce N to 0
05, Aug 20
Minimum steps to reduce N to 0 by given operations
24, Aug 20
Reduce a given number to form a key by the given operations
17, Sep 20
Reduce N to 0 or less by given X and Y operations
03, Sep 20
Reduce all array elements to zero by performing given operations thrice
22, Feb 21
Reduce a number to 1 by performing given operations | Set 3
15, Jun 21
Minimum number of given operations required to reduce a number to 2
14, Jun 21
Minimize operations to reduce N to 2 by repeatedly reducing by 3 or dividing by 5
29, Jul 21
Minimum number of given operations required to be performed to reduce N to 0
14, Jul 21
Reduce array to a single element by repeatedly replacing adjacent unequal pairs with their maximum
29, Oct 20
Find maximum value of the last element after reducing the array with given operations
19, Jun 19
Minimize cost to reduce array to a single element by replacing K consecutive elements by their sum
10, Dec 20
Steps to reduce N to zero by subtracting its most significant digit at every step
20, Nov 18
Reduce the array to a single element with the given operation
10, Dec 18
Count number of step required to reduce N to 1 by following certain rule
31, Dec 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pawan_asipu
@pawan_asipu
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