Skip to content
Related Articles

Related Articles

Number of steps required to convert a binary number to one
  • Difficulty Level : Hard
  • Last Updated : 04 May, 2021

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

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up
Recommended Articles
Page :