Reduce a number to 1 by performing given operations

Given a number N. The task is to reduce the given number N to 1 in the minimum number of steps. You can perform any one of the below operations in each step.

• Operation 1: If the number is even then you can divide the number by 2.
• Operation 2: If the number is odd then you are allowed to perform either (n+1) or (n-1).

You need to print the minimum number of steps required to reduce the number N to 1 by performing the above operations.

Examples:  

Input : n = 15
Output : 5
 15 is odd 15+1=16    
 16 is even 16/2=8     
 8  is even 8/2=4 
 4  is even 4/2=2     
 2  is even 2/2=1     

Input : n = 7
Output : 4
    7->6    
    6->3 
    3->2    
    2->1
There is one more way to get in 4 steps :
7->8,  8->4,  4->2,  2->1

Simple Recursive Solution:

The idea is to recursively compute the minimum number of steps required.  

• If the number is even, then we are allowed to only divide the number by 2.
• But, when the number is Odd, we can either increment or decrement it by 1. So, we will use recursion for both n-1 and n+1 and return the one with the minimum number of operations.

Below is the implementation of the above approach:

// C++ program to count minimum
// steps to reduce a number
#include <cmath>
#include <iostream>

using namespace std;

int countways(int n)
{
    if (n == 1)
        return 0;
    else if (n % 2 == 0)
        return 1 + countways(n / 2);
    else
        return 1 + min(countways(n - 1),
                       countways(n + 1));
}

// Driver code
int main()
{
    int n = 15;

    cout << countways(n) << "\n";

    return 0;
}

// Java program to count minimum
// steps to reduce a number
class Geeks {

    static int countways(int n)
    {
        if (n == 1)
            return 0;
        else if (n % 2 == 0)
            return 1 + countways(n / 2);
        else
            return 1 + Math.min(countways(n - 1), countways(n + 1));
    }

    // Driver code
    public static void main(String args[])
    {
        int n = 15;

        System.out.println(countways(n));
    }
}

// This code is contributed by ankita_saini

# Python3 program to count minimum 
# steps to reduce a number


def countways(n):
    if (n == 1):
        return 0;
    elif (n % 2 == 0):
        return 1 + countways(n / 2);
    else:
        return 1 + min(countways(n - 1), 
                    countways(n + 1));

# Driver code
n = 15;
print(countways(n));

# This code is contributed by PrinciRaj1992

// C# program to count minimum
// steps to reduce a number
using System;

class GFG {
    static int countways(int n)
    {
        if (n == 1)
            return 0;
        else if (n % 2 == 0)
            return 1 + countways(n / 2);
        else
            return 1 + Math.Min(countways(n - 1), countways(n + 1));
    }

    // Driver code
    static public void Main()
    {
        int n = 15;
        Console.Write(countways(n));
    }
}

// This code is contributed by Raj

<script>

// Javascript program to count minimum
// steps to reduce a number
    
    function countways(n)
    {
        if (n == 1)
            return 0;
        else if (n % 2 == 0)
            return 1 + countways(n / 2);
        else
            return 1 + Math.min(countways(n - 1), 
            countways(n + 1));
    }
    
    // Driver code
    let n = 15;
    document.write(countways(n));
    
    
// This code is contributed by unknown2108

</script>

5

The above-mentioned approach has a time complexity of O(2^n). It is possible to reduce this complexity to O(log n). 
Auxiliary Space: O(n), for recursive stack space.

We can optimize this solution using Dynamic Programming. But there is even a more efficient solution described below.

Using a Mathematical Fact

The idea is based on the observation that observation that performing an increment of 1 or a decrement of 1 on an odd number can result in an even number, one of it divisible by 4 (Note that every alternate even number is divisible by 4).

Algorithm : 
1. Initialize count = 0
2. While number is greater than one perform following steps - 
         Perform count++ for each iteration
         if num % 2 == 0, perform division
         else if num % 4 == 3, perform increment
         else perform decrement (as odd % 4 is either 1 or 3)
3. return count;

// C++ program for the above approach
#include <iostream>
using namespace std;

int countSteps(int n)
{
    int count = 0;
    while (n > 1) {
        count++;

        // num even, divide by 2
        if (n % 2 == 0)
            n /= 2;

        // num odd, n%4 == 1
        // or n==3(special edge case),
        // decrement by 1
        else if (n % 4 == 1 || n == 3)
            n -= 1;

        // num odd, n%4 == 3, increment by 1
        else
            n += 1;
    }

    return count;
}

// driver code

int main()
{
    int n = 15;

    // Function call
    cout << countSteps(n) << "\n";

    return 0;
}

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

class GFG {

    public static int countSteps(int n)
    {
        int count = 0;

        while (n > 1) {
            count++;

            // num even, divide by 2
            if (n % 2 == 0)
                n /= 2;

            // num odd, n%4 == 1
            // or n==3(special edge case),
            // decrement by 1
            else if (n % 4 == 1 || n == 3)
                n -= 1;

            // num odd, n%4 == 3, increment by 1
            else
                n += 1;
        }
        return count;
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 15;

        // Function call
        System.out.print(countSteps(n));
    }
}

// This code is contributed by paragpallavsingh

# Python3 program for the above approach
def countSteps(n):
    
    count = 0
    while (n > 1):
        count += 1

        # num even, divide by 2
        if (n % 2 == 0):
            n //= 2

        # num odd, n%4 == 1 
        # or n==3(special edge case), 
        # decrement by 1
        elif (n % 4 == 1 or n == 3):
            n -= 1

        # num odd, n%4 == 3, increment by 1
        else:
            n += 1

    return count

# Driver code
if __name__ == "__main__":
    
    n = 15

    # Function call
    print(countSteps(n))

# This code is contributed by chitranayal

// C# program for the above approach
using System;

class GFG {

    public static int countSteps(int n)
    {
        int count = 0;

        while (n > 1) {
            count++;

            // num even, divide by 2
            if (n % 2 == 0)
                n /= 2;

            // num odd, n%4 == 1
            // or n==3(special edge case),
            // decrement by 1
            else if (n % 4 == 1 || n == 3)
                n -= 1;

            // num odd, n%4 == 3, increment by 1
            else
                n += 1;
        }
        return count;
    }

    // Driver code
    static public void Main()
    {
        int n = 15;

        // Function call
        Console.WriteLine(countSteps(n));
    }
}

// This code is contributed by avanitrachhadiya2155

// Javascript program for the above approach

function countSteps(n)
{
    let count = 0;

    while (n > 1) {
        count++;

        // num even, divide by 2
        if (n % 2 == 0)
            n = Math.floor(n / 2);

        // num odd, n%4 == 1
        // or n==3(special edge case),
        // decrement by 1
        else if (n % 4 == 1 || n == 3)
            n -= 1;

        // num odd, n%4 == 3, increment by 1
        else
            n += 1;
    }
    return count;
}

// Driver code
let n = 15;
console.log(countSteps(n));

5

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