Number of steps required to convert a binary number to one

Given a binary string str, the task is to print the numbers of steps required to convert it to one by the following operations: 

1. If ‘S’ is odd add 1 to it.
2. If ‘S’ is even divide it by 2.

Examples:

Input: str = “1001001” 
Output: 12

Input: str = “101110” 
Output: 8
Number ‘101110’ is even, after dividing it by 2 we get an odd number ‘10111’ so we will add 1 to it. Then we’ll get ‘11000’ which is even and can be divide three times continuously in a row and get ’11’ which is odd, adding 1 to it will give us ‘100’ which is even and can be divided 2 times in a row. As, a result we get 1. 
So 8 times the above two operations were required in this number.

Below is the step by step algorithm to solve this problem:  

• Initialize the string S as a binary number.
• If the size of the binary is 1, then the required number of actions will be 0.
• If the last digit is 0, then its an even number so one operation is required to divide it by 2.
• After encountering 1, traverse till you get 0, with every digit one operation will take place.
• After encountering 0 after 1 while traversing, replace 0 by 1 and start from step 4 again.

Below is the implementation of above algorithm:  

C++

// C++ program to count the steps
// required to convert a number to 1

#include <bits/stdc++.h>
using namespace std;
#define ll long long

// function to calculate the number of actions
int calculate_(string s)
{
    // if the size of binary is 1
    // then the number of actions will be zero
    if (s.size() == 1)
        return 0;

    // initializing the number of actions as 0 at first
    int count_ = 0;
    for (int i = s.length() - 1; i > 0;) {
        // start traversing from the last digit
        // if its 0 increment the count and decrement i
        if (s[i] == '0') {
            count_++;
            i--;
        }
        // if s[i] == '1'
        else {
            count_++;

            // stop until you get 0 in the binary
            while (s[i] == '1' && i > 0) {
                count_++;
                i--;
            }
            if (i == 0)
                count_++;

            // when encounter a 0 replace it with 1
            s[i] = '1';
        }
    }
    return count_;
}

// Driver code
int main()
{
    string s;
    s = "10000100000";

    cout <<  calculate_(s);
    return 0;
}

Java

//Java program to count the steps
//required to convert a number to 1

public class ACX {

    //function to calculate the number of actions
    static int calculate_(String s)
    {
     // if the size of binary is 1
     // then the number of actions will be zero
     if (s.length() == 1)
         return 0;

     // initializing the number of actions as 0 at first
     int count_ = 0;
     char[] s1=s.toCharArray();
     for (int i = s.length() - 1; i > 0😉 {
         // start traversing from the last digit
         // if its 0 increment the count and decrement i
         if (s1[i] == '0') {
             count_++;
             i--;
         }
         // if s[i] == '1'
         else {
             count_++;

             // stop until you get 0 in the binary
             while (s1[i] == '1' && i > 0) {
                 count_++;
                 i--;
             }
             if (i == 0)
                 count_++;

             // when encounter a 0 replace it with 1
             s1[i] = '1';
         }
     }
     return count_;
    }

    //Driver code
    public static void main(String []args)
    {

         String s;
         s = "10000100000";

         System.out.println(calculate_(s));

    }
}

Python3

# Python3 program to count the steps
# required to convert a number to 1

# Method to calculate the number of actions
def calculate_(s):

    # if the size of binary is 1
    # then the number of actions will be zero
    if len(s) == 1:
        return 0

    # initializing the number of actions as 0 at first
    count_ = 0
    i = len(s) - 1
    while i > 0:

        # start traversing from the last digit
        # if its 0 increment the count and decrement i
        if s[i] == '0':
            count_ += 1
            i -= 1

            # if s[i] == '1'
        else:
            count_ += 1

            # stop until you get 0 in the binary
            while s[i] == '1' and i > 0:
                count_ += 1
                i -= 1
            if i == 0:
                count_ += 1
            # when encounter a 0 replace it with 1
            s = s[:i] + "1" + s[i + 1:]
    return count_

# Driver code
s = "10000100000"
print(calculate_(s))

# This code is contributed by
# Rajnis09

C#

// C# program to count the steps
//required to convert a number to 1
using System;
class GFG
{

    // function to calculate the number of actions
    static int calculate_(String s)
    {
        // if the size of binary is 1
        // then the number of actions will be zero
        if (s.Length == 1)
            return 0;

        // initializing the number of actions as 0 at first
        int count_ = 0;
        char[] s1 = s.ToCharArray();
        for (int i = s.Length - 1; i > 0;)
        {
            // start traversing from the last digit
            // if its 0 increment the count and decrement i
            if (s1[i] == '0')
            {
                count_++;
                i--;
            }

            // if s[i] == '1'
            else
            {
                count_++;

                // stop until you get 0 in the binary
                while (s1[i] == '1' && i > 0)
                {
                    count_++;
                    i--;
                }
                if (i == 0)
                    count_++;

                // when encounter a 0 replace it with 1
                s1[i] = '1';
            }
        }
        return count_;
    }

    // Driver code
    public static void Main(String []args)
    {
        String s;
        s = "10000100000";

        Console.WriteLine(calculate_(s));
    }
}

// This code is contributed by princiraj1992

PHP

<?php
// PHP program to count the steps
// required to convert a number to 1

// function to calculate the
// number of actions
function calculate_($s)
{
    // if the size of binary is 1
    // then the number of actions
    // will be zero
    if (strlen($s) == 1)
        return 0;

    // initializing the number of
    // actions as 0 at first
    $count_ = 0;
    for ($i = strlen($s) - 1; $i > 0;)
    {
        // start traversing from the last
        // digit if its 0 increment the
        // count and decrement i
        if ($s[$i] == '0')
        {
            $count_++;
            $i--;
        }

        // if $s[$i] == '1'
        else
        {
            $count_++;

            // stop until you get 0 in the binary
            while ($s[$i] == '1' && $i > 0)
            {
                $count_++;
                $i--;
            }
            if ($i == 0)
                $count_++;

            // when encounter a 0 replace
            // it with 1
            $s[$i] = '1';
        }
    }
    return $count_;
}

// Driver code

$s = "10000100000";
echo calculate_($s);

// This code is contributed
// by Shivi_Aggarwal
?>

Javascript

<script>

// Javascript program to count the steps
// required to convert a number to 1

// Function to calculate the number of actions
function calculate_(s)
{

    // If the size of binary is 1
    // then the number of actions
    // will be zero
    if (s.length == 1)
        return 0;

    // Initializing the number of
    // actions as 0 at first
    let count_ = 0;
    let s1 = s.split("")

    for(let i = s.length - 1; i > 0;)
    {

        // Start traversing from the last
        // digit if its 0 increment the
        // count and decrement i
        if (s1[i] == '0')
        {
            count_++;
            i--;
        }

        // If s[i] == '1'
        else
        {
            count_++;

            // Stop until you get 0 in the binary
            while (s1[i] == '1' && i > 0)
            {
                count_++;
                i--;
            }
            if (i == 0)
                count_++;

            // When encounter a 0
            // replace it with 1
            s1[i] = '1';
        }
    }
    return count_;
}

// Driver code
let s = "10000100000";

document.write(calculate_(s));

// This code is contributed by avanitrachhadiya2155

</script>

Output:

16

Time complexity: O(n) where n is the length of binary string

Auxiliary Space: O(1)