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

- If
**‘S’**is odd add 1 to it. - 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**