Given a number N. Find the minimum number of operations required to reach N starting from 0. You have 2 operations available:
- Double the number
- Add one to the number
Examples:
Input: N = 8
Output: 4
Explanation: 0 + 1 = 1 –> 1 + 1 = 2 –> 2 * 2 = 4 –> 4 * 2 = 8.Input: N = 7
Output: 5
Explanation: 0 + 1 = 1 –> 1 + 1 = 2 –> 1 + 2 = 3 –> 3 * 2 = 6 –> 6 + 1 = 7.
Approach: To solve the problem follow the below idea:
The idea is to use greedy algorithm. Think this problem in reverse order like, if we have to reduce given number n to 0. Now, we’ll approach in a way that if n is even then divided it by 2 otherwise, decrement it by 1 and keep a count variable to keep track of operation required to do.
Step-by-step approach:
- Keep a variable count for tracking number of operations.
-
Loop until given number is positive number.
- Check if number is even, then divide it by 2.
- Otherwise, decrement it by 1.
- Increment the count by 1.
- Return count.
Below is implementation of the above approach:
C++
#include <bits/stdc++.h> using namespace std;
// Function to calculate the minimum number // of operations required to make the given // number n equal to 0. The operations allowed // are either dividing n by 2 (if it's // even) or subtracting 1 from n. int minOperation( int n)
{ int count = 0;
while (n > 0) {
// If n is even, divide it by 2.
if (n % 2 == 0) {
n /= 2;
}
// If n is odd, subtract 1 from it.
else {
n -= 1;
}
count++;
}
return count;
} // Drivers code int main()
{ int n;
// Test cases
n = 8; // 8 -> 4 -> 2 -> 1 -> 0, so it takes 4
// operations.
cout << "Minimum operations for n = " << n << ": "
<< minOperation(n) << endl;
n = 15; // 15 -> 14 -> 7 -> 6 -> 3 -> 2 -> 1 -> 0, so it
// takes 7 operations.
cout << "Minimum operations for n = " << n << ": "
<< minOperation(n) << endl;
n = 1; // 1 -> 0, so it takes 1 operation.
cout << "Minimum operations for n = " << n << ": "
<< minOperation(n) << std::endl;
return 0;
} |
public class MinimumOperations {
public static int minOperation( int n) {
int count = 0 ;
while (n > 0 ) {
// If n is even, divide it by 2.
if (n % 2 == 0 ) {
n /= 2 ;
}
// If n is odd, subtract 1 from it.
else {
n -= 1 ;
}
count++;
}
return count;
}
public static void main(String[] args) {
int n;
// Test cases
n = 8 ; // 8 -> 4 -> 2 -> 1 -> 0, so it takes 4 operations.
System.out.println( "Minimum operations for n = " + n + ": " + minOperation(n));
n = 15 ; // 15 -> 14 -> 7 -> 6 -> 3 -> 2 -> 1 -> 0, so it takes 7 operations.
System.out.println( "Minimum operations for n = " + n + ": " + minOperation(n));
n = 1 ; // 1 -> 0, so it takes 1 operation.
System.out.println( "Minimum operations for n = " + n + ": " + minOperation(n));
}
} |
def min_operation(n):
count = 0
while n > 0 :
# If n is even, divide it by 2.
if n % 2 = = 0 :
n / / = 2
# If n is odd, subtract 1 from it.
else :
n - = 1
count + = 1
return count
# Test cases n = 8
print ( "Minimum operations for n =" , n, ":" , min_operation(n))
n = 15
print ( "Minimum operations for n =" , n, ":" , min_operation(n))
n = 1
print ( "Minimum operations for n =" , n, ":" , min_operation(n))
|
// C# Code using System;
public class MinimumOperations
{ public static int MinOperation( int n)
{
int count = 0;
while (n > 0)
{
// If n is even, divide it by 2.
if (n % 2 == 0)
{
n /= 2;
}
// If n is odd, subtract 1 from it.
else
{
n -= 1;
}
count++;
}
return count;
}
public static void Main( string [] args)
{
int n;
// Test cases
n = 8; // 8 -> 4 -> 2 -> 1 -> 0, so it takes 4 operations.
Console.WriteLine( "Minimum operations for n = " + n + ": " + MinOperation(n));
n = 15; // 15 -> 14 -> 7 -> 6 -> 3 -> 2 -> 1 -> 0, so it takes 7 operations.
Console.WriteLine( "Minimum operations for n = " + n + ": " + MinOperation(n));
n = 1; // 1 -> 0, so it takes 1 operation.
Console.WriteLine( "Minimum operations for n = " + n + ": " + MinOperation(n));
}
} |
// Javascript code class MinimumOperations { static minOperation(n) {
let count = 0;
while (n > 0) {
// If n is even, divide it by 2.
if (n % 2 === 0) {
n /= 2;
}
// If n is odd, subtract 1 from it.
else {
n -= 1;
}
count++;
}
return count;
}
static main() {
let n;
// Test cases
n = 8; // 8 -> 4 -> 2 -> 1 -> 0, so it takes 4 operations.
console.log(`Minimum operations for n = ${n}: ${MinimumOperations.minOperation(n)}`);
n = 15; // 15 -> 14 -> 7 -> 6 -> 3 -> 2 -> 1 -> 0, so it takes 7 operations.
console.log(`Minimum operations for n = ${n}: ${MinimumOperations.minOperation(n)}`);
n = 1; // 1 -> 0, so it takes 1 operation.
console.log(`Minimum operations for n = ${n}: ${MinimumOperations.minOperation(n)}`);
}
} // Call the main method MinimumOperations.main(); |
Minimum operations for n = 8: 4 Minimum operations for n = 15: 7 Minimum operations for n = 1: 1
Time Complexity: O(log(n))
Auxiliary Space: O(1)