Skip to content
Related Articles

Related Articles

Improve Article

Minimize operations to reduce N to 2 by repeatedly reducing by 3 or dividing by 5

  • Difficulty Level : Medium
  • Last Updated : 18 Aug, 2021
Geek Week

Given a positive integer N, the task is to find the minimum number of operations needed to convert N to 2 either by decrementing N by 3 or dividing N by 5 if N is divisible by 5. If it is not possible to reduce N to 2, then print “-1”.

Examples:

Input: N =10
Output: 1
Explanation:
Following are the operations performed to reduce N to 2:

  1. Dividing N by 5, reduces N to 10/5 = 2.

After the above operations, N is reduced to 2. Therefore, the minimum number of operations required is 1.

Input: N = 25
Output: 2



Approach: The given problem can be solved by using Dynamic Programming, the idea is to start iterating from 2 and perform both the operations in a reverse manner i.e., instead of subtracting, perform addition of 3 and instead of dividing, perform multiplication with 5 at every state and store the minimum number of operations for every possible value of N in the array dp[].

If the value of N is reached, then print the value of dp[N] as the minimum number of operations. Otherwise, print -1. Follow the steps below to solve the problem:

  • Initialize an auxiliary array, say dp[] of size (N + 1), and initialize all array elements with INT_MAX.
  • Set the value of dp[2] equal to 0.
  • Iterate over the range [0, N], and update the value of dp[i] as:
    • dp[i * 5] = min(dp[i * 5], dp[i] + 1).
    • dp[i + 3] = min(dp[i + 3], dp[i] + 1).
  • If the value of dp[N] is INT_MAX, then print -1. Otherwise, print dp[N] as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum number
// of operations to reduce N to 2 by
// dividing N by 5 or decrementing by 3
int minimumOperations(int N)
{
    // Initialize the dp array
    int dp[N + 1];
    int i;
 
    // Initialize the array dp[]
    for (int i = 0; i <= N; i++) {
        dp[i] = 1e9;
    }
 
    // For N = 2 number of operations
    // needed is zero
    dp[2] = 0;
 
    // Iterating over the range [1, N]
    for (i = 2; i <= N; i++) {
 
        // If it's not possible to
        // create current N
        if (dp[i] == 1e9)
            continue;
 
        // Multiply with 5
        if (i * 5 <= N) {
            dp[i * 5] = min(dp[i * 5],
                            dp[i] + 1);
        }
 
        // Adding the value 3
        if (i + 3 <= N) {
            dp[i + 3] = min(dp[i + 3],
                            dp[i] + 1);
        }
    }
 
    // Checking if not possible to
    // make the number as 2
    if (dp[N] == 1e9)
        return -1;
 
    // Return the minimum number
    // of operations
    return dp[N];
}
 
// Driver Code
int main()
{
    int N = 25;
    cout << minimumOperations(N);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
class GFG {
 
    // Function to find the minimum number
    // of operations to reduce N to 2 by
    // dividing N by 5 or decrementing by 3
    static int minimumOperations(int N)
    {
       
        // Initialize the dp array
        int[] dp = new int[N + 1];
        int i;
 
        // Initialize the array dp[]
        for (i = 0; i <= N; i++) {
            dp[i] = (int)1e9;
        }
 
        // For N = 2 number of operations
        // needed is zero
        dp[2] = 0;
 
        // Iterating over the range [1, N]
        for (i = 2; i <= N; i++) {
 
            // If it's not possible to
            // create current N
            if (dp[i] == (int)1e9)
                continue;
 
            // Multiply with 5
            if (i * 5 <= N) {
                dp[i * 5] = Math.min(dp[i * 5], dp[i] + 1);
            }
 
            // Adding the value 3
            if (i + 3 <= N) {
                dp[i + 3] = Math.min(dp[i + 3], dp[i] + 1);
            }
        }
 
        // Checking if not possible to
        // make the number as 2
        if (dp[N] == 1e9)
            return -1;
 
        // Return the minimum number
        // of operations
        return dp[N];
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 25;
 
        System.out.println(minimumOperations(N));
    }
}
 
// This code is contributed by Potta Lokesh

C#




// C# program for above approach
using System;
 
class GFG{
 
    // Function to find the minimum number
    // of operations to reduce N to 2 by
    // dividing N by 5 or decrementing by 3
    static int minimumOperations(int N)
    {
       
        // Initialize the dp array
        int[] dp = new int[N + 1];
        int i;
 
        // Initialize the array dp[]
        for (i = 0; i <= N; i++) {
            dp[i] = (int)1e9;
        }
 
        // For N = 2 number of operations
        // needed is zero
        dp[2] = 0;
 
        // Iterating over the range [1, N]
        for (i = 2; i <= N; i++) {
 
            // If it's not possible to
            // create current N
            if (dp[i] == (int)1e9)
                continue;
 
            // Multiply with 5
            if (i * 5 <= N) {
                dp[i * 5] = Math.Min(dp[i * 5], dp[i] + 1);
            }
 
            // Adding the value 3
            if (i + 3 <= N) {
                dp[i + 3] = Math.Min(dp[i + 3], dp[i] + 1);
            }
        }
 
        // Checking if not possible to
        // make the number as 2
        if (dp[N] == 1e9)
            return -1;
 
        // Return the minimum number
        // of operations
        return dp[N];
    }
 
// Driver Code
public static void Main(String[] args)
{
    int N = 25;
 
    Console.Write(minimumOperations(N));
}
}
 
// This code is contributed by sanjoy_62.

Javascript




<script>
    // JavaScript Program for the above approach
 
    // Function to find the minimum number
    // of operations to reduce N to 2 by
    // dividing N by 5 or decrementing by 3
    function minimumOperations(N)
    {
       
        // Initialize the dp array
        let dp = new Array(N + 1);
        let i;
 
        // Initialize the array dp[]
        for (i = 0; i <= N; i++) {
            dp[i] = 1e9;
        }
 
        // For N = 2 number of operations
        // needed is zero
        dp[2] = 0;
 
        // Iterating over the range [1, N]
        for (i = 2; i <= N; i++) {
 
            // If it's not possible to
            // create current N
            if (dp[i] == 1e9)
                continue;
 
            // Multiply with 5
            if (i * 5 <= N) {
                dp[i * 5] = Math.min(dp[i * 5], dp[i] + 1);
            }
 
            // Adding the value 3
            if (i + 3 <= N) {
                dp[i + 3] = Math.min(dp[i + 3], dp[i] + 1);
            }
        }
 
        // Checking if not possible to
        // make the number as 2
        if (dp[N] == 1e9)
            return -1;
 
        // Return the minimum number
        // of operations
        return dp[N];
    }
 
    // Driver Code
 
    let N = 25;
 
    document.write(minimumOperations(N));
 
// This code is contributed by sanjoy_62.
</script>

Python3




# Python 3 program for the above approach
 
# Function to find the minimum number
# of operations to reduce N to 2 by
# dividing N by 5 or decrementing by 3
def minimumOperations(N):
    # Initialize the dp array
    dp = [0 for i in range(N + 1)]
 
    # Initialize the array dp[]
    for i in range(N+1):
        dp[i] = 1000000000
 
    # For N = 2 number of operations
    # needed is zero
    dp[2] = 0
 
    # Iterating over the range [1, N]
    for i in range(2,N+1,1):
        # If it's not possible to
        # create current N
        if (dp[i] == 1000000000):
            continue
 
        # Multiply with 5
        if (i * 5 <= N):
            dp[i * 5] = min(dp[i * 5], dp[i] + 1)
 
        # Adding the value 3
        if (i + 3 <= N):
            dp[i + 3] = min(dp[i + 3], dp[i] + 1)
 
    # Checking if not possible to
    # make the number as 2
    if (dp[N] == 1000000000):
        return -1
 
    # Return the minimum number
    # of operations
    return dp[N]
 
# Driver Code
if __name__ == '__main__':
    N = 25
    print(minimumOperations(N))
Output: 
2

 

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

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
Recommended Articles
Page :