Binary Countdown Length

Question

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.

• edc65: Step 3 is of no use at all
• Brian J: @edc65 Seems like you could do either step 3 or step 4, depending on how your algorithm is laid out
• Poke: @edc65 Maybe for you it is of no use. A simple inverse operator doesn't trim leading zeros for you. ~(~a) == a
• Dennis: @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.
• edc65: @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

Answer 1

Jelly, (削除) 6 (削除ここまで) 4 bytes

^HBS

Try it online! or verify all test cases.

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.

• edc65: Amazing! A totally different reasoning

Answer 2

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.

Answer 3

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.

Answer 4

Haskell, 34 bytes

b 0=0
b n|x<-b$div n 2=x+mod(x+n)2

• AlexR: I like how it says "0=0" :)

Answer 5

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)

Answer 6

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

• Makonede: Alternatively: ;^bSO

Answer 7

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.

Answer 8

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

• Kevin Cruijssen: j=j/2 can be shortened to j/=2. Apart from that a great answer!
• Kevin Cruijssen: 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. :)

Answer 9

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

Answer 10

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

• Dennis: e& (logical AND) saves a byte over \g*.
• Luis Mendo: @Dennis Thanks! It's handy how CJam's logical AND works, I had no idea

Answer 11

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

• DJMcMayhem: 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)
• Jordan: 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.

Answer 12

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

• user45941: You can save 2 bytes by changing tl and ib to 1-byte names.
• rnso: Done. Thanks for the suggestion.

Answer 13

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

Answer 14

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

Answer 15

Ruby, 26 bytes

f=->n{n<1?0:-n%4/2+f[n/2]}

Inspired by xnor's Python answer.

Answer 16

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

Answer 17

Vyxal 3 s, 3 bytes

1⁄2⊻b

Try it Online!

port of the jelly answer

Answer 18

Go, 172 bytes

import(."fmt";."strings")
func f(n uint)(i int){for;n>0;i++{Sscanf(Map(func(r rune)rune{if r<'1'{return'1'}else{return'0'}},TrimLeft(Sprintf("%b",n),"0")),"%b",&n)}
return}

Attempt This Online!

Implements the algorithm more or less verbatim from the OP.

Answer 19

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;

Answer 20

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

Answer 21

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).

• Titus: 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.

Answer 22

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

Answer 23

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.

Answer 24

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 :)

Answer 25

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

Answer 26

Perl 5, 31 + 1 (p) = 32 bytes

$_=(sprintf'%b',$_^$_/2)=~y/1//

Try it online!

Using @Dennis's method.

Answer 27

PHP, (削除) 55 (削除ここまで) 52 bytes

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...

Answer 28

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.

Answer 29

C (gcc), 76 Bytes, 72 Bytes (thanks to celingcat)

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

Try it online!

Answer 30

Husk, 6 bytes

ΣẊ≠:0ḋ

Try it online!

Algorithm from Popov's APL answer.

Husk, 9 bytes

←LU¡ȯḋm¬ḋ

Try it online!

The approach shown in the question.

Explanation

←LU¡ȯḋm¬ḋ
 ¡ apply function pinfinitely, collecting results
 ȯ composition of three function
 ḋ convert to binary digits
 m¬ negate each bit
 ḋ convert back to base-10
 U split infinite list at first non-unique value
 L get the length of the list
← decrement