 GeeksforGeeks App
Open App Browser
Continue

# Minimum steps to reduce N to 0 by given operations

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<``int``, ``int``> dp;` `  ``// Bases Cases``  ``dp = 0;``  ``dp = 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<``int``,``               ``int``> dp = ``new` `Dictionary<``int``,``                                        ``int``>();` `    ``// 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(Nlog N), where N represents the given integer.
Auxiliary Space: O(N), where N represents the given integer.

Efficient approach: Using DP Tabulation method

This method Provided further improves on this by avoiding the use of a map and instead using an array to store the previously computed results. This is more efficient as array access is faster than map access.

Implementation steps :

• Create a vector dp of size n+1 and initialize dp to 0 and dp to 1.
• Loop from i=2 to i=n and for each i, compute the minimum number of steps to reduce i to 0 using the recurrence relation dp[i] = 1 + min(dp[i-1], dp[i/2] (if i is even), dp[i/3] (if i is divisible by 3)).
• Return dp[n] as the result.

Implementation:

## C++

 `// C++ program for above approach``#include``using` `namespace` `std;` `const` `int` `MAXN = 1e6+5;``int` `dp[MAXN];` `int` `count(``int` `n)``{``    ``// Base Cases``    ``if``(n == 0)``        ``return` `0;``    ``if``(n == 1)``        ``return` `1;``    ` `    ``// Check if n is already computed``    ``if``(dp[n] != 0)``        ``return` `dp[n];` `    ``// Compute the answer recursively``    ``int` `ans = 1 + min(n % 2 + count(n / 2), n % 3 + count(n / 3));` `    ``// Store the computed answer``    ``dp[n] = ans;` `    ``// Return the answer``    ``return` `ans;``}` `int` `main()``{``    ``// Given number N``    ``int` `N = 6;` `    ``// Initialize the dp array to 0``    ``memset``(dp, 0, ``sizeof``(dp));` `    ``// Function call``    ``cout << count(N);``}``// this code is contributed by bhardwajji`

## Java

 `// Java program for above approach``import` `java.util.*;` `class` `Main {``    ``static` `int``[] dp = ``new` `int``[(``int``)1e6 + ``5``];` `    ``public` `static` `int` `count(``int` `n)``    ``{``        ``// Base Cases``        ``if` `(n == ``0``)``            ``return` `0``;``        ``if` `(n == ``1``)``            ``return` `1``;` `        ``// Check if n is already computed``        ``if` `(dp[n] != ``0``)``            ``return` `dp[n];` `        ``// Compute the answer recursively``        ``int` `ans = ``1``                  ``+ Math.min(n % ``2` `+ count(n / ``2``),``                             ``n % ``3` `+ count(n / ``3``));` `        ``// Store the computed answer``        ``dp[n] = ans;` `        ``// Return the answer``        ``return` `ans;``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given number N``        ``int` `N = ``6``;` `        ``// Initialize the dp array to 0``        ``Arrays.fill(dp, ``0``);` `        ``// Function call``        ``System.out.println(count(N));``    ``}``}``// This code is contributed by sarojmcy2e`

## Python3

 `MAXN ``=` `1000005``dp ``=` `[``0``] ``*` `MAXN`  `def` `count(n):``    ``# Base Cases``    ``if` `n ``=``=` `0``:``        ``return` `0``    ``if` `n ``=``=` `1``:``        ``return` `1` `    ``# Check if n is already computed``    ``if` `dp[n] !``=` `0``:``        ``return` `dp[n]` `    ``# Compute the answer recursively``    ``ans ``=` `1` `+` `min``(n ``%` `2` `+` `count(n ``/``/` `2``), n ``%` `3` `+` `count(n ``/``/` `3``))` `    ``# Store the computed answer``    ``dp[n] ``=` `ans` `    ``# Return the answer``    ``return` `ans`  `# Given number N``N ``=` `6` `# Initialize the dp array to 0``dp ``=` `[``0``] ``*` `MAXN` `# Function call``print``(count(N))`

## C#

 `using` `System;` `class` `MainClass {``const` `int` `MAXN = 1000005;``static` `int``[] dp = ``new` `int``[MAXN];``  ``static` `int` `count(``int` `n) {``    ``// Base Cases``    ``if` `(n == 0)``        ``return` `0;``    ``if` `(n == 1)``        ``return` `1;` `    ``// Check if n is already computed``    ``if` `(dp[n] != 0)``        ``return` `dp[n];` `    ``// Compute the answer recursively``    ``int` `ans = 1 + Math.Min(n % 2 + count(n / 2), n % 3 + count(n / 3));` `    ``// Store the computed answer``    ``dp[n] = ans;` `    ``// Return the answer``    ``return` `ans;``}` `public` `static` `void` `Main() {``    ``// Given number N``    ``int` `N = 6;` `    ``// Initialize the dp array to 0``    ``Array.Fill(dp, 0);` `    ``// Function call``    ``Console.WriteLine(count(N));``}``}`

## Javascript

 `// Javascript program for above approach``let dp = ``new` `Array(1000005).fill(0);` `function` `count(n) {``    ``// Base Cases``    ``if` `(n == 0)``        ``return` `0;``    ``if` `(n == 1)``        ``return` `1;` `    ``// Check if n is already computed``    ``if` `(dp[n] != 0)``        ``return` `dp[n];` `    ``// Compute the answer recursively``    ``let ans = 1 + Math.min(n % 2 + count(Math.floor(n / 2)),``        ``n % 3 + count(Math.floor(n / 3)));` `    ``// Store the computed answer``    ``dp[n] = ans;` `    ``// Return the answer``    ``return` `ans;``}` `// Given number N``let N = 6;` `// Function call``console.log(count(N));`

Output

`3`

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

My Personal Notes arrow_drop_up