# Binary Countdown Length

inspired by Count down from infinity

Given a non-negative integer N, output the number of repetitions of the following steps it takes to reach 0:

1. Convert N to binary (4812390 -> 10010010110111001100110)
2. Flip each bit (10010010110111001100110 -> 01101101001000110011001)
3. Trim leading zeroes (01101101001000110011001 -> 1101101001000110011001)
4. Convert back to decimal (1101101001000110011001 -> 3576217)

## Rules

• Input and output may be in any unambiguous, consistent format
• The input will be within the native representable integer range for your language (if your language supports arbitrarily-large integers, there is no bound)

## Test Cases

0 -> 0
1 -> 1
42 -> 6
97 -> 3
170 -> 8
255 -> 1
682 -> 10
8675309 -> 11
4812390 -> 14
178956970 -> 28
2863311530 -> 32


This sequence is A005811 in the OEIS.

• Step 3 is of no use at all – edc65 Nov 3 '16 at 7:29
• @edc65 Seems like you could do either step 3 or step 4, depending on how your algorithm is laid out – Brian J Nov 3 '16 at 13:42
• @edc65 Maybe for you it is of no use. A simple inverse operator doesn't trim leading zeros for you. ~(~a) == a – Poke Nov 3 '16 at 13:42
• @Poke Bitwise NOT inverts all bits of the binary representation, including leading zeroes (and an infinite amount of them in languages with arbitrary precision integers). This is not equivalent to step 2. – Dennis Nov 3 '16 at 15:26
• @Poke A simple inverse operation is different from applying the steps 1..4. If you want to apply these steps, the step 3 is of no use, because the flip in step 2 (as it is shown) does not change the leading 0s. If the step 2 does change the leading 0s to leading 1s, then obviuosly you have to remove the leading 1s in step 3, not the leading 0s – edc65 Nov 3 '16 at 16:20

# Jelly, 6 4 bytes

^HBS


### Background

Let n be a non-negative integer.

Steps 2 and 3 of the process described in the spec can alternatively be stated as removing all leading 1's and toggling the remaining bits.

This means that we'll remove exactly one group of adjacent and equal binary digits in each iteration, so the Binary Countdown Length of n is just the number of these groups in the binary representation of n. For the purposes of this challenge, think of 0 as having no digits.

For n = 8675309, the process looks as follows in binary.

100001000101111111101101
11110111010000000010010
1000101111111101101
111010000000010010
101111111101101
10000000010010
1111111101101
10010
1101
10
1
0


Instead of counting these groups (which would fail for edge case 0), we do the following.

n and n:2 have the following binary representations.

n   = 8675309 = 100001000101111111101101_2
n:2 = 4337654 =  10000100010111111110110_2


Note that n:2's binary representation is simply n's, shifted one bit to the left.

If we XOR n and n:2, we'll obtain a 1 (MSB), and an additional 1 for each pair of different adjacent digits. The number of groups is thus equal to the number of set bits in n ⊻ n:2.

### How it works

^HBS  Main link. Argument: n

H    Halve; yield n:2.
^     XOR n with n:2.
B   Convert the result to binary.
S  Compute the sum of the resulting binary digits.

• Amazing! A totally different reasoning – edc65 Nov 3 '16 at 7:53

# Python 2, 30 bytes

lambda n:bin(n^n/2).count('1')


Test it on Ideone.

### Background

Let n be a non-negative integer.

Steps 2 and 3 of the process described in the spec can alternatively be stated as removing all leading 1's and toggling the remaining bits.

This means that we'll remove exactly one group of adjacent and equal binary digits in each iteration, so the Binary Countdown Length of n is just the number of these groups in the binary representation of n. For the purposes of this challenge, think of 0 as having no digits.

For n = 8675309, the process looks as follows in binary.

100001000101111111101101
11110111010000000010010
1000101111111101101
111010000000010010
101111111101101
10000000010010
1111111101101
10010
1101
10
1
0


Instead of counting these groups (which would fail for edge case 0), we do the following.

n and n:2 have the following binary representations.

n   = 8675309 = 100001000101111111101101_2
n:2 = 4337654 =  10000100010111111110110_2


Note that n:2's binary representation is simply n's, shifted one bit to the left.

If we XOR n and n:2, we'll obtain a 1 (MSB), and an additional 1 for each pair of different adjacent digits. The number of groups is thus equal to the number of set bits in n ⊻ n:2.

## Python 2, 29 bytes

f=lambda n:n and-n%4/2+f(n/2)


Counts the number of alternations between 0 and 1 in the binary expansion, counting the leading 1 as an alternation. Does so by checking whether the last two binary digits are different, then recursing onto the number with the last digit removed. The last two digits are different exactly if n%4 is 1 or 2, which can be checked as -n%4/2.

b 0=0
b n|x<-b$div n 2=x+mod(x+n)2  • I like how it says "0=0" :) – AlexR Nov 3 '16 at 14:42 ## JavaScript (ES6), 26 bytes f=n=>n&&(n^(n>>=1))%2+f(n)  Works by counting the transitions between 0 and 1. Only works up to 31 bits. 29 bytes to support 53 bits: f=n=>1<=n&&(n%2^n/2%2)+f(n/2)  # 05AB1E, 7 5 bytes Saved 2 bytes thanks to Dennis. b0ÛÔg  Without the edge case of 0 this could be 3 bytes bÔg. Try it online! or as a Test suite Explanation b # convert to binary 0Û # trim off leading zeroes Ô # remove adjacent duplicates g # length  # CJam, 14 bytes ri0{2b:!2bj)}j  Try it online! ri e# read integer 0 e# value for terminal case { e# recursive function 2b e# create binary representation with no leading zeros :! e# flip bits 2b e# convert binary back to integer j e# recursive call ) e# increment from 0 on the way up }j e# end  Basically a knock off of my answer to the other question. # Java 7,112 108 100 90 73 bytes int c(int i){int l=1,j=i;for(;(j=j/2)>0;l*=2);return i<1?0:1+c(2*l-1-i);}  ### Basic idea  Lets take an no 10110(21) then you do set all bits in no 21 and you will get 11111 and after that you would subtract the original number from 11111. You will get 01001 and loop it until you will get 0  • j=j/2 can be shortened to j/=2. Apart from that a great answer! – Kevin Cruijssen Nov 3 '16 at 10:10 • Hmm.. a port from @Neil's JavaScript answer is shorter though: int c(int i){return i>0?((i^(i>>=1))%2+c(i):0;} (47 bytes). I would still leave your current answer as well though, since it's more original, and ports from other users are the complete opposite of original. :) – Kevin Cruijssen Nov 3 '16 at 10:18 # J, 14 bytes **1+/@,2~:/\#:  Counts the number of runs in the binary digits of n with the special case returning 0 for n = 0. ## Usage  f =: **1+/@,2~:/\#: (,.f"0) 0 1 42 97 170 255 682 8675309 4812390 178956970 2863311530 0 0 1 1 42 6 97 3 170 8 255 1 682 10 8675309 11 4812390 14 178956970 28 2863311530 32  ## Explanation **1+/@,2~:/\#: Input: integer n #: Get the binary digits of n 2 \ For each overlapping sublist of size 2 ~:/ Reduce by not-equals 1 , Prepend a 1 +/@ Reduce by addition * Sign(n), returns 0 for n = 0 else 1 * Multiply with the previous sum and return  # CJam, 11 10 bytes Thanks to @Dennis for saving one byte! ri_2be,e&  Try it online! ### Explanation ri #e Read as integer #e STACK: 97 _ #e Duplicate #e STACK: 97, 97 2b #e Convert to binary #e STACK: 97, [1 1 0 0 0 0 1] e #e Run-length encoding #e STACK: 97, [[2 1] [4 0] [1 1]] , #e Length #e STACK: 97, 3 e& #e Return first value if 0, or else the second value #e STACK: 3  • e& (logical AND) saves a byte over \g*. – Dennis Nov 3 '16 at 14:03 • @Dennis Thanks! It's handy how CJam's logical AND works, I had no idea – Luis Mendo Nov 3 '16 at 14:56 ## Racket 349 bytes (define(h s)(apply string(map(λ(x)(if(eq? x #\0)#\1 #\0))(string->list s))))(define(g s)(let* ((l(string-length s))(k(for/list((i s)(n l)#:final(not(equal? i #\0)))n)))(substring s(last k)))) (define(f n)(if(= 0 n)0(begin(let loop((n n)(c 1))(define m(string->number(string-append "#b" (g(h(number->string n 2))))))(if(> m 0)(loop m(add1 c))c))))  Ungolfed: (define (invertBinary s) (apply string (map (λ(x)(if(eq? x #\0)#\1 #\0)) (string->list s)))) (define (trimLeading0s s) (let* ((l (string-length s)) (k (for/list ((i s) (n l) #:final (not(equal? i #\0))) n))) (substring s (last k)))) (define (f n) (if (= 0 n) 0 (begin (let loop ((n n) (c 1)) (define m (string->number (string-append "#b" (trimLeading0s (invertBinary (number->string n 2)))))) (if (> m 0) (loop m (add1 c)) c)))))  Testing: (f 0) (f 1) (f 42) (f 97) (f 170) (f 255) (f 682) (f 8675309) (f 4812390) (f 178956970) (f 2863311530)  Output: 0 1 6 3 8 1 10 11 14 28 32  • You can save 2 bytes by changing tl and ib to 1-byte names. – Mego Nov 3 '16 at 6:40 • Done. Thanks for the suggestion. – rnso Nov 3 '16 at 6:47 # MATL, 7 bytes BY'nwa*  Try it online! ### Explanation  % Implicit input, for example 97 % STACK: 97 B % Convert to binary % STACK: [1 1 0 0 0 0 1] Y' % Run-length encoding % STACK: [1 0 1], [2 4 1] n % Number of elements % STACK: [1 0 1], 3 w % Swap % STACK: 3, [1 0 1] a % Any: gives 1 if any element is nonzero % STACK: 3, 1 * % Multiply % STACK: 3 % Implicit display  # Vim, 62 59 bytes -3 bytes thanks to DJMcMayhem C0 <C-r>=pri<Tab>'%b',<C-r>") <Esc>0qqC<C-r>=tr(@",'01','10') <Esc>:s/^0\+ k<C-a>j@qq@q  Here is the xxd output with the unprintable characters intact: 0000000: 4330 0d12 3d70 7269 0927 2562 272c 1222 C0..=pri.'%b',." 0000010: 290d 1b30 7171 4312 3d74 7228 4022 2c27 )..0qqC.=tr(@",' 0000020: 3031 272c 2731 3027 290d 1b3a 732f 5e30 01','10')..:s/^0 0000030: 5c2b 0d6b 016a 4071 7140 71 \+.k.j@qq@q  Try it online! ## Explanation C " Delete the number (it goes in @") 0<CR> " Print 0 (our counter) and a carriage return <C-r>=pri<Tab>'%b',<C-r>")<CR><Esc> " Use printf() to insert the number as base 2 0qq " Return to column 0, start recording a macro C<C-r>=tr(@",'01','10')<CR><Esc> " Replace 0s with 1s and vice versa :s/^0\+<CR> " Delete leading 0s k<C-a> " Increment the number on the line above j " Return to the previous line @q " Invoke macro recursively q@q " Stop recording and invoke macro  • Nice! Some tips: :s/^0* is one byte shorter than :s/^0\+, and while you are in the "eval" register, you can just do pr<S-tab>'%b',<C-r>") for autocomplete. (Saves 4 bytes) – James Nov 3 '16 at 16:33 • Oh, thanks for the autocomplete tip! I can't use :s/^0* because it matches an empty line, and I need it to fail for empty an empty line to escape the recursive macro. – Jordan Nov 3 '16 at 16:50 # Burlesque, 8 bytes rib2gnL[  Try it online! ri # Read as integer b2 # Convert to binary gn # Collapse like bits L[ # Find length  # 29 bytes ri0j{j+.j2dg)n!2ug}{^^nz}w!vv  Try it online! Actually doing the calculation ri #Read val as int 0j #Push a 0 (counter) to the bottom of the stack { j+.j # Increment counter and put back 2dg # Get the digits of binary val )n! # Not each digit 2ug # Convert back to decimal } {^^nz}w! # While not zero vv # Drop final zero leaving counter  # Ruby, 26 bytes f=->n{n<1?0:-n%4/2+f[n/2]}  Inspired by xnor's Python answer. # PHP, 64 bytes based on my countdown solution for($n=$argv[1];$n;print 1)$n=bindec(strtr(decbin($n),"01",10));


prints 1 character k times, where k is the number of iterations.

+4 bytes for integer output: (empty output for 0)

for($n=$argv[1];$n;$i++)$n=bindec(strtr(decbin($n),"01",10));echo$i;  # JavaScript (ES6), 44 Recursive function Limited to javascript positive integer, 31 bits: f=(a,s=0)=>a?f((-1>>>Math.clz32(a))-a,s+1):s  Managing double precision number up to 53 significant bits - 59 bytes: F=(a,s=0)=>a?F('0b'+a.toString(2).replace(/./g,1)-a,s+1):s  In another way: using the amazing algorithm by @Dennis, non recursive function managing up 53 bits, 43 bytes: a=>a&&a.toString(2).match(/(.)\1*/g).length  # PHP, 51 bytes <?=preg_match_all('/(1+|0+)/',decbin($argv[1])?:o);


Uses a regex to count the number of runs of 1 or 0. Unfortunately this needs a special case for input of 0 that requires 3 additional bytes (and gives a notice).

• a) Use a digit >1 instead of o to avoid the notice. b) You can save 3 bytes with the -F flag and $argn instead of $argv[1]. c) /1+|0+/ should suffice for the regex. – Titus Apr 24 '18 at 17:51

# Java 7, 71 bytes

int b(Long a){return a==0?0:1+b(~a&-1L>>>64-a.toString(a,2).length());}

I know this is beaten by Geobits' split solution (which will eventually be posted) but this was still fun to write

# Octave, 47 bytes

@(x)(sum(dec2bin(bitxor(x,idivide(x,2)))=='1'))


According to the OEIS entry, the value we are looking for as the solution to this challenge is also equal to the number of 1s in the Gray code for the given integer.

Wikipedia tells me the Gray code can be calculated as x ^ (x >> 1), so in the above function I calculate the Gray code as such, convert it to a binary string, and count how many digits of that string are 1.

## Java 7, 64 bytes

long g(Long n){return n.toString(n,2).split("0+").length*2-n%2;}


I know this could be beaten by a port of one of the better answers, but I came up with it in chat, and I can't not post it after Poke said something about it :)

# C, 76 Bytes

unsigned n,m,i;f(x){for(i=0;x;x^=m-1,i++)for(n=x,m=2;n>>=1;m<<=1);return i;}


Works for all the test cases (as much as I don't want to include the word unsigned or last test case)...

# Bash, 57 bytes

Packages: Core Utililities, grep, sed, vim (for xxd)

Assume the number is given in binary format. Any length is acceptable :)

xxd -b -c1|cut -d" " -f2|sed s/^0*//|grep -o .|uniq|wc -l


$_=(sprintf'%b',$_^$_/2)=~y/1//  Try it online! Using @Dennis's method. # Tcl, 119 bytes proc D n i\ 0 { while \$n {set n [regsub ^0+(?=.) [string map {0 1 1 0} [format %b $n]] ""] incr i scan$n %b n}
set i}


Try it online!

Still very ungolfed for my taste

for($i=$argn;$i;$c++,$i^=(1<<log($i,2)+1)-1);echo$c;  Try it online! All done arithmetically/bitwise (no strings). Am stuck getting it smaller than the 51 byte answer though... # APL, 13 characters/bytes +/2≠/0,2⊥⍣¯1⊢  base 10 to base 2 conversion with all necessary digits 2⊥⍣¯1⊢ 2⊥⍣¯1⊢4812390 ---> 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 0 1 1 0 0 1 1 0  add a leading 0 0, 0,1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 0 1 1 0 0 1 1 0 ---> 0 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 0 1 1 0 0 1 1 0  pair-wise reduction that gives 1 if consecutive elements are not equal 2≠/ 2≠/0 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 0 1 1 0 0 1 1 0 ---> 1 1 0 1 1 0 1 1 1 0 1 1 0 0 1 0 1 0 1 0 1 0 1  sum +/ +/1 1 0 1 1 0 1 1 1 0 1 1 0 0 1 0 1 0 1 0 1 0 1 ---> 14  # PHP, 50 bytes <?=array_sum(str_split(decbin($argn&-2^\$argn*2)));


Try it online!

Unfortunately, really don't think I can get it any more golfed than this!

The idea is to count transitions 1->0 or 0->1.