# Minimum steps to reduce N to 0 by given operations

• Difficulty Level : Medium
• Last Updated : 09 Jun, 2022

Give an integer N, the task is to find the minimum number of moves to reduce N to 0 by one of the following operations:

• Reduce N by 1.
• Reduce N to (N/2), if N is divisible by 2.
• Reduce N to (N/3), if N is divisible by 3.

Examples:

Input: N = 10
Output: 4
Explanation:
Here N = 10
Step 1: Reducing N by 1 i.e., 10 – 1 = 9.
Step 2: Since 9 is divisible by 3, reduce it to N/3 = 9/3 = 3
Step 3: Since again 3 is divisible by 3 again repeating step 2, i.e., 3/3 = 1.
Step 4: 1 can be reduced by the step 1, i.e., 1-1 = 0
Hence, 4 steps are needed to reduce N to 0.

Input: N = 6
Output: 3
Explanation:
Here N = 6
Step 1: Since 6 is divisible by 2, then 6/2 =3
Step 2: since 3 is divisible by 3, then 3/3 = 1.
Step 3: Reduce N to N-1 by 1, 1-1 = 0.
Hence, 3 steps are needed to reduce N to 0.

Naive Approach: The idea is to use recursion for all the possible moves. Below are the steps:

1. Observe that base case for the problem, if N < 2 then for all the cases the answer will be N itself.
2. At every value of N, choose between 2 possible cases:
• Reduce n till n % 2 == 0 and then update n /= 2 with count = 1 + n%2 + f(n/2)
• Reduce n till n % 3 == 0 and then update n /= 3 with count = 1 + n%3 + f(n/3)
3. Both the computation results in the recurrence relation as:

count = 1 + min(n%2 + f(n/2), n%3 + f(n/3))
where, f(n) is the minimum  of moves to reduce N to 0.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std;   // Function to find the minimum // number to steps to reduce N to 0 int minDays(int n) {           // Base case     if (n < 1)         return n;               // Recursive call to count the     // minimum steps needed     int cnt = 1 + min(n % 2 + minDays(n / 2),                       n % 3 + minDays(n / 3));       // Return the answer     return cnt; }   // Driver Code int main() {           // Given number N     int N = 6;           // Function call     cout << minDays(N);           return 0; }   // This code is contributed by 29AjayKumar

## Java

 // Java program for the above approach class GFG{         // Function to find the minimum     // number to steps to reduce N to 0     static int minDays(int n)     {           // Base case         if (n < 1)             return n;           // Recursive Call to count the         // minimum steps needed         int cnt = 1 + Math.min(n % 2 + minDays(n / 2),                                n % 3 + minDays(n / 3));           // Return the answer         return cnt;     }       // Driver Code     public static void main(String[] args)     {         // Given Number N         int N = 6;           // Function Call         System.out.print(minDays(N));     } }   // This code is contributed by PrinciRaj1992

## Python3

 # Python3 program for the above approach   # Function to find the minimum # number to steps to reduce N to 0 def minDays(n):       # Base case     if n < 1:         return n             # Recursive Call to count the     # minimum steps needed     cnt = 1 + min(n % 2 + minDays(n // 2),                   n % 3 + minDays(n // 3))       # Return the answer     return cnt   # Driver Code   # Given Number N N = 6   # Function Call print(str(minDays(N)))

## C#

 // C# program for the above approach using System; class GFG{   // Function to find the minimum // number to steps to reduce N to 0 static int minDays(int n) {        // Base case     if (n < 1)         return n;       // Recursive call to count the     // minimum steps needed     int cnt = 1 + Math.Min(n % 2 + minDays(n / 2),                            n % 3 + minDays(n / 3));       // Return the answer     return cnt; }   // Driver Code public static void Main(String[] args) {        // Given number N     int N = 6;       // Function call     Console.Write(minDays(N)); } }   // This code is contributed by Rajput-Ji

## Javascript



Output:

4

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

Efficient Approach: The idea is to use Dynamic Programming. The above recursive approach results in TLE because of the number of repeated subproblems. To optimize the above method using a dictionary to keep track of values whose recursive call is already performed to reduce the further computation such that value can be accessed faster.

Below is the implementation of the above approach:

## C++

 // C++ program for // the above approach #include using namespace std;   // Function to find the minimum // number to steps to reduce N to 0 int count(int n) {   // Dictionary for storing   // the precomputed sum   map dp;     // Bases Cases   dp[0] = 0;   dp[1] = 1;     // Check if n is not in dp then   // only call the function so as   // to reduce no of recursive calls   if ((dp.find(n) == dp.end()))     dp[n] = 1 + min(n % 2 +                     count(n / 2), n % 3 +                     count(n / 3));     // Return the answer   return dp[n]; }   // Driver Code int main() {      // Given number N   int N = 6;     // Function call   cout << count(N); }   // This code is contributed by gauravrajput1

## Java

 // Java program for the above approach import java.util.HashMap;   class GFG{       // Function to find the minimum // number to steps to reduce N to 0 static int count(int n) {           // Dictionary for storing     // the precomputed sum     HashMap dp = new HashMap();       // Bases Cases     dp.put(0, 0);     dp.put(1, 1);       // Check if n is not in dp then     // only call the function so as     // to reduce no of recursive calls     if (!dp.containsKey(n))         dp.put(n, 1 + Math.min(n % 2 +                  count(n / 2), n % 3 +                  count(n / 3)));       // Return the answer     return dp.get(n); }   // Driver Code public static void main(String[] args) {           // Given number N     int N = 6;       // Function call     System.out.println(String.valueOf((count(N)))); } }   // This code is contributed by Amit Katiyar

## Python3

 # Python3 program for the above approach   # Function to find the minimum # number to steps to reduce N to 0 def count(n):         # Dictionary for storing     # the precomputed sum     dp = dict()       # Bases Cases     dp[0] = 0     dp[1] = 1       # Check if n is not in dp then     # only call the function so as     # to reduce no of recursive calls     if n not in dp:         dp[n] = 1 + min(n % 2 + count(n//2), n % 3 + count(n//3))       # Return the answer     return dp[n]     # Driver Code   # Given Number N N = 6   # Function Call print(str(count(N)))

## C#

 // C# program for the above approach using System; using System.Collections.Generic; public class GFG{       // Function to find the minimum // number to steps to reduce N to 0 static int count(int n) {        // Dictionary for storing     // the precomputed sum     Dictionary dp = new Dictionary();       // Bases Cases     dp.Add(0, 0);     dp.Add(1, 1);       // Check if n is not in dp then     // only call the function so as     // to reduce no of recursive calls     if (!dp.ContainsKey(n))         dp.Add(n, 1 + Math.Min(n % 2 + count(n / 2),                                n % 3 + count(n / 3)));       // Return the answer     return dp[n]; }   // Driver Code public static void Main(String[] args) {        // Given number N     int N = 6;       // Function call     Console.WriteLine(String.Join("",                                   (count(N)))); } }   // This code is contributed by Rajput-Ji

## Javascript



Output:

3

Time Complexity: O(log N), where N represents the given integer.
Auxiliary Space: O(N), where N represents the given integer.

My Personal Notes arrow_drop_up
Recommended Articles
Page :