# Minimum operations required to reduce N to 0 by either replacing N with N/M or incrementing M by 1

• Last Updated : 11 Nov, 2021

Given two integers N and M, the task is to calculate the minimum number of operations required to reduce N to 0 using the following operations:

• Replace N with (N/M).
• Increment the value of M by 1.

Example:

Input: N = 9, M = 2
Output: 4
Explanation: The given example can be solved by following the below sequence of operations:

• In 1st operation, replace N with (N/M), i.e, N = 9/2 = 4.
• In 2nd operation, again replace N with N/M, i.e, N = 4/2 = 2.
• In 3rd operation, increment M by 1, i.e, M = M+1 = 2+1 = 3.
• In 4th operation, replace N with N/M, i.e, N = 2/3 = 0.

Hence, the number of required operations is 4 which is the minimum possible.

Input: N = 15, M = 1
Output: 5

Approach: The given problem can be solved by observing the fact that the most optimal choice of operations is to increment the value of M let’s say x times and then reduce the value of N to N / (M+x) until it becomes 0. To find the best case, iterate over all values of x in the range [0, √N] using a variable i and calculate the number of steps required to reduce N to 0 by dividing it by (M+i). Keep track of the minimum number of operations over all possible values of (M+i) in a variable ans, which is the required value.

Below is the implementation of the above approach:

## C++

 `// C++ Program of the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the minimum count of` `// operations to reduce N to 0 using M` `int` `findMinimum(``int` `N, ``int` `M)` `{` `    ``// If N is already 0` `    ``if` `(N == 0) {` `        ``return` `0;` `    ``}`   `    ``// Stores the minimum count of operations` `    ``int` `ans = INT_MAX;`   `    ``// Loop to iterate in the range [0, √N]` `    ``for` `(``int` `i = 0; i * i <= N; i++) {`   `        ``// Edge case to prevent infinite looping` `        ``if` `(M == 1 && i == 0) {` `            ``continue``;` `        ``}`   `        ``// Stores the current count of moves` `        ``int` `count = i;` `        ``int` `tempN = N;`   `        ``// Number of operations required to` `        ``// reduce N to 0 by dividing by M + i` `        ``while` `(tempN != 0) {` `            ``tempN /= (M + i);` `            ``count++;` `        ``}`   `        ``// Update the final count` `        ``ans = min(count, ans);` `    ``}`   `    ``// Return answer` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 9;` `    ``int` `M = 2;`   `    ``cout << findMinimum(N, M);`   `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;`   `class` `GFG {`   `    ``public` `static` `int` `findMinimum(``int` `N, ``int` `M)` `    ``{` `        ``// If N is already 0` `        ``if` `(N == ``0``) {` `            ``return` `0``;` `        ``}`   `        ``// Stores the minimum count of operations` `        ``int` `ans = ``1000000007``;`   `        ``// Loop to iterate in the range [0, √N]` `        ``for` `(``int` `i = ``0``; i * i <= N; i++) {`   `            ``// Edge case to prevent infinite looping` `            ``if` `(M == ``1` `&& i == ``0``) {` `                ``continue``;` `            ``}`   `            ``// Stores the current count of moves` `            ``int` `count = i;` `            ``int` `tempN = N;`   `            ``// Number of operations required to` `            ``// reduce N to 0 by dividing by M + i` `            ``while` `(tempN != ``0``) {` `                ``tempN /= (M + i);` `                ``count++;` `            ``}`   `            ``// Update the final count` `            ``if``(count < ans){` `              ``ans = count;` `            ``}` `        ``}`   `        ``// Return answer` `        ``return` `ans;` `    ``}`   `    ``// Driver code`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``9``;` `        ``int` `M = ``2``;`   `        ``System.out.println(findMinimum(N, M));` `    ``}` `}`   `// This code is contributed by maddler.`

## Python3

 `# Python Program to implement` `# the above approach`   `# Function to find the minimum count of` `# operations to reduce N to 0 using M` `def` `findMinimum(N, M):`   `    ``# If N is already 0` `    ``if` `(N ``=``=` `0``):` `        ``return` `0`   `    ``# Stores the minimum count of operations` `    ``ans ``=` `10``*``*``9`   `    ``# Loop to iterate in the range[0, √N]` `    ``i ``=` `0` `    ``while``(i ``*` `i <``=` `N):` `        ``i ``+``=` `1`   `        ``# Edge case to prevent infinite looping` `        ``if` `(M ``=``=` `1` `and` `i ``=``=` `0``):` `            ``continue`   `        ``# Stores the current count of moves` `        ``count ``=` `i` `        ``tempN ``=` `N`   `        ``# Number of operations required to` `        ``# reduce N to 0 by dividing by M + i` `        ``while` `(tempN !``=` `0``):` `            ``tempN ``=` `tempN ``/``/` `(M ``+` `i)` `            ``count ``+``=` `1`   `        ``# Update the final count` `        ``ans ``=` `min``(count, ans)`   `    ``# Return answer` `    ``return` `ans`   `# Driver code` `N ``=` `9` `M ``=` `2`   `print``(findMinimum(N, M))`   `# This code is contributed by Saurabh Jaiswal`

## C#

 `/*package whatever //do not write package name here */`   `using` `System;`   `class` `GFG` `{`   `    ``public` `static` `int` `findMinimum(``int` `N, ``int` `M)` `    ``{` `        ``// If N is already 0` `        ``if` `(N == 0)` `        ``{` `            ``return` `0;` `        ``}`   `        ``// Stores the minimum count of operations` `        ``int` `ans = 1000000007;`   `        ``// Loop to iterate in the range [0, √N]` `        ``for` `(``int` `i = 0; i * i <= N; i++)` `        ``{`   `            ``// Edge case to prevent infinite looping` `            ``if` `(M == 1 && i == 0)` `            ``{` `                ``continue``;` `            ``}`   `            ``// Stores the current count of moves` `            ``int` `count = i;` `            ``int` `tempN = N;`   `            ``// Number of operations required to` `            ``// reduce N to 0 by dividing by M + i` `            ``while` `(tempN != 0)` `            ``{` `                ``tempN /= (M + i);` `                ``count++;` `            ``}`   `            ``// Update the final count` `            ``if` `(count < ans)` `            ``{` `                ``ans = count;` `            ``}` `        ``}`   `        ``// Return answer` `        ``return` `ans;` `    ``}`   `    ``// Driver code`   `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `N = 9;` `        ``int` `M = 2;`   `        ``Console.WriteLine(findMinimum(N, M));` `    ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

`4`

Time complexity: O(N*log N )
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :