Binary to decimal converter

As far as I can see, we don't have a simple binary to decimal conversion challenge.

Write a program or function that takes a positive binary integer and outputs its decimal value.

You are not allowed to use any builtin base conversion functions. Integer-to-decimal functions (e.g., a function that turns 101010 into [1, 0, 1, 0, 1, 0] or "101010") are exempt from this rule and thus allowed.


  • The code must support binary numbers up to the highest numeric value your language supports (by default)
  • You may choose to have leading zeros in the binary representation
  • The decimal output may not have leading zeros.
  • Input and output formats are optional, but there can't be any separators between digits. (1,0,1,0,1,0,1,0) is not a valid input format, but both 10101010 and (["10101010"]) are.
    • You must take the input in the "normal" direction. 1110 is 14 not 7.

Test cases:





This challenge is related to a few other challenges, for instance this, this and this.

  • \$\begingroup\$ Related \$\endgroup\$
    – mbomb007
    Dec 5, 2016 at 19:43
  • \$\begingroup\$ Does the output have to be unsigned or can it be signed? Also, if my language happens to automatically switch between 32-bit and 64-bit integers depending on the length of the value, can the output be signed in both ranges? Eg- There's two binary values that will convert to decimal -1 (32 1's and 64 1's) \$\endgroup\$
    – milk
    Dec 5, 2016 at 20:47
  • \$\begingroup\$ Also, can the output be floating, do does it need to be an integer? \$\endgroup\$ Dec 5, 2016 at 21:17
  • \$\begingroup\$ @Carcigenicate It must be an integer, but it can be of any data type. As long as round(x)==x you're fine :) 2.000 is accepted output for 10. \$\endgroup\$ Dec 5, 2016 at 21:31
  • \$\begingroup\$ Oh sweet. Thanks. \$\endgroup\$ Dec 5, 2016 at 21:33

69 Answers 69


Jelly, 5 bytes


Try it online!


enter image description here

The cast

  • D is a monad (single argument function): digits, turning 1234 into [1, 2, 3, 4].

  • is a monad that doubles its single argument.

  • + is a dyad (two argument function) that adds its left and right arguments.

From there, it gets a little tricky.

Here’s what happens at parse time

  • D, , and + are read. The chain looks like [D, Ḥ, +].

  • The next two characters are quicks, which act like parse-time postfix operators on the links (functions) we've read so far.

  • When ¥ is read, the last two links get popped and replaced by a link that acts like the dyad formed by composing them. So now the chain looks like [D, dyad(Ḥ+)].

  • When / is read, the last link (which ought to be a dyad) gets popped and replaced by a monad that folds using this dyad (intuitively: f/ takes a list, replaces the commas in it with f, and evaluates the result.)

  • The final chain looks like [D, fold(dyad(Ḥ+))], two monads.

Here's what happens at run time

  • Input (a number) is implicitly read into the working value (say, 101010).

  • D is executed, replacing the working value with its digits ([1,0,1,0,1,0]).

  • fold(dyad(Ḥ+)) is executed, replacing the working value with 1∗0∗1∗0∗1∗0, where is the dyad Ḥ+.

So what does x∗y evaluate to?

  • In a dyadic definition, the working value is initially the left argument, x.

  • , the double monad, doubles this value. The working value is now 2x.

  • +, the plus dyad, lacks a right argument, so this is a hook: a special syntactical pattern where the right argument of this dyad gets injected into +. This yields 2x + y as the final working value, which is returned.

So the whole expression evaluates to:

1∗0∗1∗0∗1∗0 = 2×(2×(2×(2×(2×1+0)+1)+0)+1)+0
            = 32×1 + 16×0 + 8×1 + 4×0 + 2×1 + 1×0
            = 42
  • 10
    \$\begingroup\$ Your explanations are getting better and better :-) \$\endgroup\$
    – Luis Mendo
    Dec 6, 2016 at 1:22
  • 2
    \$\begingroup\$ Heh, I guess you do it from now on? That's awesome, +1. \$\endgroup\$ Dec 6, 2016 at 12:57
  • 4
    \$\begingroup\$ I think this is the first piece of Jelly I've ever understood. +1! \$\endgroup\$
    – Blue
    Dec 7, 2016 at 19:59
  • \$\begingroup\$ Bravo. I actually understand what I initially thought was just a mess of seemingly random characters. Wonderful explanation. \$\endgroup\$
    – swinefish
    Dec 8, 2016 at 7:18
  • 1
    \$\begingroup\$ @Mark Jelly has its own codepage to make the programs look, ahem, readable, but the programs could as well just be bytestrings. \$\endgroup\$
    – Lynn
    Dec 10, 2016 at 13:10

Python 2, 49 37 31 30 Bytes

Now this will take a binary number in a decimal representation, since Python can handle arbitrarily large integers.

b=lambda n:n and n%2+2*b(n/10)

thanks to xnor for saving a byte :)

The easiest way to see how this works is by seeing a basic formula for converting binary to decimal:

= 101010 
= 1*(2^5) + 0*(2^4) + 1*(2^3) + 0*(2^2) + 1*(2^1) + 0*(2^0)
= 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1
= 42

This is a 'standard' way of converting. You can expand the third line like so:

= ((((1*2 + 0)*2 + 1)*2 + 0)*2 + 1)*2 + 0

And this is essentially what the recursive method I've made is doing.

Alternate solutions I had:

b=lambda n:n and n%10+2*b(n/10)
b=lambda n:n%10+2*(n and b(n/10))
b=lambda n:0if n<1else n%10+2*b(n/10)
b=lambda n:0**(n/10)or n%10+2*b(n/10)
b=lambda n,o=0:o*(n<'0')or b(n[1:],2*o+int(n[0]))
lambda j:sum(int(b)*2**a for a,b in enumerate(j,1))
  • 7
    \$\begingroup\$ You can do n%5 or n%2 instead of n%10. \$\endgroup\$
    – xnor
    Dec 5, 2016 at 22:02
  • \$\begingroup\$ @xnor Ah, not sure how I missed that! Thanks :) \$\endgroup\$
    – Kade
    Dec 6, 2016 at 1:37

05AB1E, 6 bytes



For the explantion, let's take the example 101010. We start with the number 1 (which is represented by the first digit). After that, we have two cases:

  • If the digit is a 0, multiply the number by 2.
  • If the digit is a 1, multiply the number by 2 and add 1.

So for the 101010 case, the following is calculated:

  • 101010, start with the number 1.
  • 101010, multiply by two, resulting into 2.
  • 101010, multiply by two and add one, resulting into 5.
  • 101010, multiply by two, resulting into 10.
  • 101010, multiply by two and add one, resulting into 21.
  • 101010, multiply by two, resulting into 42, which is the desired result.

Code explanation:

$         # Push 1 and input
 ¦        # Remove the first character
  v       # For each character (starting with the first)
   ·      #   Multiply the carry number by two
    y+    #   Add the current character (converted automatically to a number)

Uses the CP-1252 encoding. Try it online!

  • \$\begingroup\$ Nice one! (doesn't work for 0 though I just noticed) \$\endgroup\$
    – Emigna
    Dec 5, 2016 at 20:07
  • \$\begingroup\$ @Emigna Yep, luckily your code only needs to work for positive binary numbers. \$\endgroup\$
    – Adnan
    Dec 5, 2016 at 20:08
  • \$\begingroup\$ Didn't even see that part. Very nice then :) \$\endgroup\$
    – Emigna
    Dec 5, 2016 at 20:09

Haskell, 16 111 + 57 = 168 bytes

import Data.String
instance IsString[Int]where fromString=map((-48+).fromEnum)

+57 bytes for the compile flags -XOverloadedStrings, -XOverlappingInstances and -XFlexibleInstances.

The challenge has some cumbersome IO format, because it heavily depends on how data types are expressed in the source code. My first version (16 bytes), namely


takes a list of integers, e.g. [1,0,1,0,1,0] and was declared invalid because literal Haskell lists happen to have , between the elements. Lists per se are not forbidden. In my new version I use the very same function, now named f, but I overload "Quote enclosed character sequences". The function still takes a list of integers as you can see in the type annotation [Int] -> Int, but lists with single digit integers can now be written like "1234", e.g.

f "101010"

which evaluates to 42. Unlucky Haskell, because the native list format doesn't fit the challenge rules. Btw, f [1,0,1,0,1,0] still works.

  • 2
    \$\begingroup\$ Unfortunately a list is not a valid input. \$\endgroup\$ Dec 5, 2016 at 20:43
  • \$\begingroup\$ @JonathanAllan: Why? And if so, how should it take input at all? In Haskell a string is just a list of characters. \$\endgroup\$
    – nimi
    Dec 5, 2016 at 21:04
  • \$\begingroup\$ I don't know why ...but I enquired about this early on and an edit was made to add "(1,0,1,0,1,0,1,0) is not a valid input format, but both 10101010 and (["10101010"]) are." furthermore a comment suggests the array of characters is acceptable if that is how a string input is interpreted. \$\endgroup\$ Dec 5, 2016 at 21:10
  • 1
    \$\begingroup\$ @JonathanAllan: any "binary integer" (the input we have to take) is inherently separated, it's a sequence of powers of 2. The restriction is about explicit separators (between the digits) and not about separation. Somehow I have to take separated digits. \$\endgroup\$
    – nimi
    Dec 5, 2016 at 22:56
  • 2
    \$\begingroup\$ Op here: if it's possible to input 10101010 , "10101010" or something similar and make it work then the submission is valid. You may call it a string, list, integer or whatever. Inputting [1][0][1][0] or [1,0,1,0] is not ok. Basically, it should be possible to just hit a bunch of ones and zeros in a row somewhere. Is this clear? \$\endgroup\$ Dec 6, 2016 at 9:55

Retina, 15 bytes

Converts from binary to unary, then unary to decimal.


Try it online

  • \$\begingroup\$ You are not allowed to use any builtin base conversion functions. ~OP \$\endgroup\$ Dec 5, 2016 at 20:15
  • 11
    \$\begingroup\$ @RomanGräf There aren't any. I was simply describing the process of my solution. \$\endgroup\$
    – mbomb007
    Dec 5, 2016 at 20:25

PHP, 44 bytes


I could have sworn that I´ve seen that question before. But well.

Reads the number from left to right, shifts left and adds the current bit.


JavaScript (ES6), 33 31 bytes


Edit: Shorter but less sweet: 2 bytes saved thanks to @ETHproductions.

  • \$\begingroup\$ As is often the case, .map is shorter: s=>[...s].map(c=>+c+r+r,r=0)|r \$\endgroup\$ Dec 6, 2016 at 23:10
  • \$\begingroup\$ @ETHproductions How does your function return anything other than 0? \$\endgroup\$
    – Neil
    Dec 7, 2016 at 0:43
  • \$\begingroup\$ Sorry, it should be s=>[...s].map(c=>r+=+c+r,r=0)|r \$\endgroup\$ Dec 7, 2016 at 0:52

Labyrinth, 17 15 bytes

8 +

Try it online!

Image of the code

Labyrinth is a two-dimensional, stack-based language. In labyrinth, code execution follows the path of the code like a maze with spaces acting as walls and beginning at the top-left-most non-space character. The code flow is determined by the sign of the top of the stack. Since the stack has implicit zeroes at the bottom, the first four instructions (-+:+) have no effect.

Loop starting at the ,

  • , Push the ascii code value of the next input character to the stop of the stack, or push -1 if EOF.
  • _48 pushes 48 to the top of the stack
  • - Pop y, pop x, push x-y. The previous instructions have the effect of subtracting 48 from the input yielding 0 for "0" and 1 for "1".
  • + Pop y, pop x, push x+y.
  • : Duplicate the top of the stack
  • + This and the previous instruction have the effect of multiplying the current value by 2

So the circular part of the code, in effect, multiples the current number by 2 and adds either a 1 or a 0 depending on if the character 1 or 0 was input.


If the top of the stack is negative (meaning EOF was found), the code will turn left at the junction (going towards the semicolon).

  • ``` Negate the top of the stack to get 1
  • ) Icrement the top of the stack to get 2
  • / Pop y, pop x, push x/y (integer division). This has the effect of undoing the last *2 from the loop.
  • ! Output the integer representation of the top of the stack. At this point the program turns around because it hit a dead end and then exits with an error because it tries to divide by zero.

Thanks to @Martin Ender for saving me 2 bytes (and teaching me how to better think in Labyrinth).

  • \$\begingroup\$ Instead of _48- you can simply do #% but unfortunately I don't see how it might help with the byte count. \$\endgroup\$ Dec 7, 2016 at 20:51
  • \$\begingroup\$ You can save a byte with `) instead of ;_2 though. \$\endgroup\$ Dec 7, 2016 at 20:52
  • \$\begingroup\$ @MartinEnder, I don't understand your comment about #%. Can you explain how that works as a replacement for _48- to convert from ascii to int. Thanks for the ) tip. I'll make that change. \$\endgroup\$ Dec 7, 2016 at 21:22
  • \$\begingroup\$ At that point in your program there are always two values on the stack so # is just short for _2. While _2% isn't a general conversion method for ASCII to integer, it works here because you're only interested in the first two digits as possible input. An alternative would be _1& (since modulo 2 simply extracts the least significant bit). \$\endgroup\$ Dec 7, 2016 at 21:28
  • \$\begingroup\$ Oh. That's brilliant. But yeah I'm not sure how to use that substitution (#%) to shorten the code overall. \$\endgroup\$ Dec 7, 2016 at 21:33

Brain-Flak, 46, 28 bytes


Try it online!

Many many bytes saved thanks to @Riley!

Since brain-flak can't take binary input, input is a list of '0's and '1's.


#Push the height of the stack

#While true:

 #Pop the height of the stack

 #Push this top number to (the other stack * 2)

 #Toggle back on to the main stack

 #Push the new height of the stack


#Toggle back to the other stack, implicitly display.
  • \$\begingroup\$ Love the explanation! So hard to read brain-flak without it :) \$\endgroup\$
    – Emigna
    Dec 5, 2016 at 20:08
  • 2
    \$\begingroup\$ ^. I can't even read my own programs if I don't leave myself a few comments. \$\endgroup\$
    – Riley
    Dec 5, 2016 at 20:10
  • \$\begingroup\$ You can get it down to 32 bytes by getting rid of the whole if part,and for the step "add number to other stack" just add it to the (other stack)*2. ([]){({}[()]<({}<>({}){})><>)}<> \$\endgroup\$
    – Riley
    Dec 5, 2016 at 20:16
  • \$\begingroup\$ And you can save another 4 by just popping at the start of the while and pushing the height again at the end. ([]){{}({}<>({}){})<>([])}<> \$\endgroup\$
    – Riley
    Dec 5, 2016 at 20:18
  • \$\begingroup\$ @Riley Oh my gosh, that's genius. Thankyou very much! \$\endgroup\$
    – DJMcMayhem
    Dec 5, 2016 at 20:20

Java, 84 79 46 48 bytes

  • Version 3.1

Changed to long/48 bytes:

s->{long x=0;for(char c:s)x=c-48l+x*2;return x;}
  • Version 3.0

Did some golfing/46 bytes:

s->{int x=0;for(char c:s)x=c-48+x*2;return x;}
  • Version 2.0

Thanks to @Geobits!/79 bytes:

s->{int i=Math.pow(2,s.length-1),j=0;for(char c:s){j+=c>48?i:0;i/=2;}return j;}
  • Version 1.0

84 bytes:

s->{for(int i=-1,j=0;++i<s.length;)if(s[i]>48)j+=Math.pow(2,s.length-i+1);return j;}
  • 1
    \$\begingroup\$ guess i should have done an iterative solution. lulz. good job \$\endgroup\$
    – Poke
    Dec 5, 2016 at 20:46
  • \$\begingroup\$ Is your input type List<Character> or String? If it's the latter, I was unaware Java8 could do that! If it's the former is that allowed by the challenge? \$\endgroup\$
    – Poke
    Dec 5, 2016 at 21:00
  • \$\begingroup\$ s should be char[]. I hope that's allowed... \$\endgroup\$ Dec 5, 2016 at 21:01
  • \$\begingroup\$ What is the return type here? I think it should be long because "The code must support binary numbers up to the highest numeric value your language supports" per the OP but for smaller values I would think it returns an int \$\endgroup\$
    – Poke
    Dec 5, 2016 at 21:02
  • 1
    \$\begingroup\$ Probably fine on input type per this. Might want to take the 2 byte hit for output imo \$\endgroup\$
    – Poke
    Dec 5, 2016 at 21:09

C# 6, 85 37 36 bytes

long b(long n)=>n>0?n%2+2*b(n/10):0;
  • Thanks to Kade for saving 41 bytes!
  • Changing to C# 6 saved another 7 bytes.
  • \$\begingroup\$ Maybe this could provide some inspiration? ;) \$\endgroup\$
    – Kade
    Dec 5, 2016 at 21:43
  • \$\begingroup\$ @Kade It does, thanks! I was looking at the Python answer which uses the same technique at the same moment you linked that :D I can get even shorter with C# 6. \$\endgroup\$
    – Yytsi
    Dec 5, 2016 at 21:47

Befunge-98, 12 bytes


Try it online!

Reads one char at a time from input, converts it to 0 or 1 by taking its value modulo 2 (0 is char(48), 1 is char(49)), then uses the usual algorithm of doubling the current value and adding the new digit each time.

Bonus: This works with any kind of input string, I've been trying for a while now to find any funny input->output combination, but I wasn't able to produce anything (sadly, "answer"=46). Can you?

  • \$\begingroup\$ LOL. I was playing the same game with my answer. Most interesting number I could generate was 666. \$\endgroup\$ Dec 6, 2016 at 12:27
  • \$\begingroup\$ Nice one! I hadn't managed to find anything fitting for 666 :D It would be a lot easier if capitalization had an effect on values... \$\endgroup\$
    – Leo
    Dec 6, 2016 at 14:01
  • \$\begingroup\$ @James Holderness - I've been doing the same and I've only found 'theleapyear' to bring back 366, yours is really good. \$\endgroup\$ Dec 6, 2016 at 14:19

Perl, 25 bytes

-3 bytes thanks to @Dom Hastings.

24 bytes of code + 1 byte for -p flag.

$\|=$&<<$v++while s/.$//

To run it:

perl -pe '$\|=$&<<$v++while s/.$//' <<< 101010


$\|=$&<<$v++  # Note that: we use $\ to store the result
              # at first $v=0, and each time it's incremented by one
              # $& contains the current bit (matched with the regex, see bellow)
              # So this operation sets a $v-th bit of $\ to the value of the $v-th bit of the input
while         # keep doing this while...
s/.$//        #  ... there is a character at the end of the string, which we remove.
         # $\ is implicitly printed thanks to -p flag

Javascript (ES7) 41 40 36 bytes


takes a string as input

Shaved a byte thanks to ETHproductions


  • 1
    \$\begingroup\$ The right-to-left associativity of ** is weird, but nice job using it here. 1<<b.length would do the same thing, but it would require parentheses to keep from being parsed as (c*1)<<(b.length+...). I think you can save a byte by replacing b[0] with b+b (see here). \$\endgroup\$ Dec 6, 2016 at 15:09

05AB1E, 7 bytes


Try it online!


R         # reverse input
 v     O  # sum of
  No      # 2^index
     *    # times
    y     # digit

Bash + GNU utilities, 29 bytes

sed 's/./2*&+/g;s/.*/K&p/'|dc

I/O via stdin/stdout.

The sed expression splits the binary up into each digit and builds a RPN expression for dc to evaluate.


C, 53

v(char*s){int v=0,c;while(c=*s++)v+=v+c-48;return v;}

Same as my javascript answer

Test Ideone

  • \$\begingroup\$ You can save 4 bytes by declaring v and c as global variables (though you need to change the name of v, since it's already the name of the function) like this: w=0;c;v(char*s){while(c=*s++)w+=w+c-48;return w;} \$\endgroup\$
    – Steadybox
    Dec 6, 2016 at 19:55
  • \$\begingroup\$ @Steadybox it could be w,c; but I don't want use globals when the answer is a function (even in code-golf) \$\endgroup\$
    – edc65
    Dec 6, 2016 at 20:24
  • \$\begingroup\$ @Steadybox Globals defaults to 0 as well, so you can drop the =0. \$\endgroup\$
    – algmyr
    Dec 8, 2016 at 1:22

Mathematica, 27 13 11 bytes


Accepts a List of bits as input (e.g. {1, 0, 1, 1, 0} -- Mathematica's binary representation of the number 22)

  • \$\begingroup\$ Following up from the comment on Greg's answer, how is "splitting all the digits in the input" not a base conversion function? \$\endgroup\$ Dec 6, 2016 at 5:33
  • \$\begingroup\$ @MartinEnder I'm using it like the Characters function. \$\endgroup\$ Dec 6, 2016 at 5:48
  • \$\begingroup\$ @MartinEnder Actually, as seen in @nimi's answer, I could just accept a list of 1s and 0s because that is the only way to represent a binary number in Mathematica, meaning I don't need IntegerDigits in the first place. \$\endgroup\$ Dec 6, 2016 at 5:52
  • \$\begingroup\$ That assumes that base 10 is the "natural" representation of an integer. An actual integer value has no preferred base attached to it (I guess you could say the way it's stored is probably base 256 or maybe even base 2 but that's an implementation detail). Just because we (normally) use base 10 to write integer literals there doesn't mean integer values are already in base 10. \$\endgroup\$ Dec 6, 2016 at 5:52
  • \$\begingroup\$ @MartinEnder @Lynn's Jelly code uses D, which does the same thing as IntegerDigits \$\endgroup\$ Dec 6, 2016 at 5:53

Pushy, 10 bytes

Takes input as a list of 0/1 on the command line: $ pushy binary.pshy 1,0,1,0,1,0.


The algorithm really shows the beauty of having a second stack:

            \ Implicit: Input on stack
L:    ;     \ len(input) times do:
  v         \   Push last number to auxiliary stack
   K2*      \   Double all items
       OS#  \ Output sum of auxiliary stack

This method works because the stack will be doubled stack length - n times before reaching number n, which is then dumped into the second stack for later. Here's what the process looks like for input 101010:

1: [1,0,1,0,1,0]
2: []

1: [2,0,2,0,2]
2: [0]

1: [4,0,4,0]
2: [2]

1: [8,0,8]
2: [2,0]

1: [16,0]
2: [2,0,8]

1: [32]
2: [2,0,8,0]

1: []
2: [2,0,8,0,32]

2 + 8 + 32 -> 42

R (32-bit), 64 Bytes

Input for the function should be given as character. The base functions of R support 32-bit integers.


# 32-bit version (base)


> f("1")
[1] 1
> f("10")
[1] 2
> f("101010")
[1] 42
> f("1101111111010101100101110111001110001000110100110011100000111")
[1] 2.016121e+18

R (64-bit), 74 Bytes

Input for the function should be given as character. The package bit64 has to be used for 64-bit integers.


# 64-bit version (bit64)


> g("1")
[1] 1
> g("10")
[1] 2
> g("101010")
[1] 42
> g("1101111111010101100101110111001110001000110100110011100000111")
[1] 2016120520371234567
  • 2
    \$\begingroup\$ You can do: el(strsplit(x,"")) instead of strsplit(x,split="")[[1]] to save a couple of bytes. \$\endgroup\$
    – Billywob
    Dec 7, 2016 at 10:14
  • \$\begingroup\$ Thanks a lot! Especially for the el function - I was not aware of it. \$\endgroup\$
    – djhurio
    Dec 7, 2016 at 20:47

Matlab, 30 Bytes


The last test case has rounding errors (because of double), so if you need full precision:


with 47 Bytes.

  • \$\begingroup\$ I can't test this, but I believe @(x)sum(2.^(find(flip(x)-48)-1)) will give the correct result for all cases for 32 bytes. flip works like fliplr if x is one dimensional. \$\endgroup\$ Dec 6, 2016 at 16:51
  • \$\begingroup\$ Nice solution! I also ran into the rounding error, thanks for the fix. What is the format of x? Calling flip or fliplr on a number just returns that number. \$\endgroup\$
    – hwm
    Dec 10, 2016 at 1:35
  • \$\begingroup\$ x is the binary string, so call it with f=@(x)..; f('1111001010'). \$\endgroup\$
    – Jonas
    Dec 10, 2016 at 13:38

Retina, 12 bytes

Byte count assumes ISO 8859-1 encoding.


Try it online!

Alternative solution:



This will probably be easier to explain based on my old, less golfed, version and then showing how I shortened it. I used to convert binary to decimal like this:


The only sensible way to construct a decimal number in Retina is by counting things (because Retina has a couple of features that let it print a decimal number representing an amount). So really the only possible approach is to convert the binary to unary, and then to count the number of unary digits. The last line does the counting, so the first four convert binary to unary.

How do we do that? In general, to convert from a list of bits to an integer, we initialise the result to 0 and then go through the bits from most to least significant, double the value we already have and add the current bit. E.g. if the binary number is 1011, we'd really compute:

(((0 * 2 + 1) * 2 + 0) * 2 + 1) * 2 + 1 = 11
           ^        ^        ^        ^

Where I've marked the individual bits for clarity.

The trick to doing this in unary is a) that doubling simply means repeating the number and b) since we're counting the 1s at the end, we don't even need to distinguish between 0s and 1s in the process. This will become clearer in a second.

What the program does is that it first adds a comma to the beginning as marker for how much of the input we've already processed:


Left of the marker, we'll have the value we're accumulating (which is correctly initialised to the unary representation of zero), and right of the value will be the next bit to process. Now we apply the following substitution in a loop:


Just looking at ,(.) and $1,, this moves the marker one bit to the right each time. But we also insert $`, which is everything in front of the marker, i.e. the current value, which we're doubling. Here are the individual steps when processing input 1011, where I've marked the result of inserting $` above each line (it's empty for the first step):



You'll see that we've retained and doubled the zero along with everything else, but since we're disregarding them at the end, it doesn't matter how often we've doubled them, as long as the number of 1s is correct. If you count them, there are 11 of them, just what we need.

So that leaves the question of how to golf this down to 12 bytes. The most expensive part of the 18-byte version is having to use the marker. The goal is to get rid of that. We really want to double the prefix of every bit, so a first idea might be this:


The problem is that these substitutions happen simultaneously, so first bit doesn't get doubled for each bit, but it just gets copied once each time. For input 1011 we'd get (marking the inserted $`):

 _ __ ___

We do still need to process the input recursively so that the doubled first prefix is doubled again by the second and so on. One idea is to insert markers everywhere and repeatedly replace them with the prefix:


After replacing each marker with the prefix for the first time, we need to remember where the beginning of the input was, so we insert linefeeds as well and use the % option to make sure that the next $` only picks up things up the closest linefeed.

This does work, but it's still too long (16 bytes when counting 1s at the end). How about we turn things around? The places where we want to insert markers are identified by \B (a position between two digits). Why don't we simply insert prefixes into those positions? This almost works, but the difference is that in the previous solution, we actually removed one marker in each substitution, and that's important to make the process terminate. However, the \B aren't character but just positions, so nothing gets removed. We can however stop the \B from matching by instead inserting a non-digit character into this place. That turns the non-word boundary into a word boundary, which is the equivalent of removing the marker character earlier. And that's what the 12-byte solution does:


Just for completeness, here are the individual steps of processing 1011, with an empty line after each step:




Again, you'll find that the last result contains exactly 11 1s.

As an exercise for the reader, can you see how this generalises quite easily to other bases (for a few additional bytes per increment in the base)?


T-SQL, 202 Bytes

DECLARE @b varchar(max)='1',@ int=1 declare @l int=LEN(@b)declare @o bigint=CAST(SUBSTRING(@b,@l,1)AS bigint)WHILE @<@l BEGIN SET @o=@o+POWER(CAST(SUBSTRING(@b,@l-@,1)*2AS bigint),@)SET @=@+1 END PRINT @o

PHP, 64 bytes


We reverse our binary number, split it into its component digits, and sum them based on position.


PowerShell v2+, 55 bytes


Feels too long ... Can't seem to golf it down any -- tips appreciated.


param($n)$j=1;                                          # Take input $n as string, set $j=1
              $n[$n.length..0]                          # Reverses, also converts to char-array
                              |%{                  };   # Loop over that array
                                 $i+=+"$_"*$j;          # Increment by current value of $j times current digit
                                              $j*=2     # Increase $j for next loop iteration
                                                     $i # Leave $i on pipeline
                                                        # Implicit output

MATL, 7 bytes


Try it online!

P   % Implicitly input string. Reverse
o   % Convert to array of ASCII codes
o   % Modulo 2: '1' becomes 1, '0' becomes 0
f   % Find: push array of 1-based indices of nonzeros
q   % Subtract 1 from each entry
W   % 2 raised to each entry
s   % Sum of array. Implicitly display
  • 2
    \$\begingroup\$ My mind went Poof! \$\endgroup\$
    – Adám
    Dec 12, 2016 at 14:54

JavaScript (ES6), 32 bytes


Recursion saves the day again! Though the parameterization seems a little long...

  • \$\begingroup\$ Since it's a single "argument", does [...n] need to be surrounded in parentheses? \$\endgroup\$
    – Cyoce
    Dec 11, 2016 at 18:38
  • \$\begingroup\$ @Cyoce Unfortunately, yes, or JS throws a SyntaxError. \$\endgroup\$ Dec 11, 2016 at 21:18

Clojure, 114 105 63 41 bytes

V4: 41 bytes

-22 bytes thanks to @cliffroot. Since digit is a character, it can be converted to it's code via int, then have 48 subtracted from it to get the actual number. The map was also factored out. I don't know why it seemed necessary.

#(reduce(fn[a d](+(* a 2)(-(int d)48)))%)

V3: 63 bytes

(fn[s](reduce #(+(* %1 2)%2)(map #(Integer/parseInt(str %))s)))

-42 bytes (!) by peeking at other answers. My "zipping" was evidently very naïve. Instead of raising 2 to the current place's power, then multiplying it by the current digit and adding the result to the accumulator, it just multiplies the accumulator by 2, adds on the current digit, then adds it to the accumulator. Also converted the reducing function to a macro to shave off a bit.

Thanks to @nimi, and @Adnan!


(defn to-dec [binary-str]
  (reduce (fn [acc digit]
            (+ (* acc 2) digit))
          (map #(Integer/parseInt (str %)) binary-str)))

V2: 105 bytes

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range)(reverse %)))

-9 bytes by reversing the string so I don't need to create an awkward descending range.

V1: 114 bytes

Well, I'm certainly not winning! In my defense, this is the first program I've ever written that converts between bases, so I had to learn how to do it. It also doesn't help that Math/pow returns a double that requires converting from, and Integer/parseInt doesn't accept a character, so the digit needs to be wrapped prior to passing.

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range(dec(count %))-1 -1)%))

Zips the string with a descending index representing the place number. Reduces over the resulting list.


(defn to-dec [binary-str]
  (reduce (fn [acc [place digit]]
            (let [parsed-digit (Integer/parseInt (str digit))
                  place-value (long (Math/pow 2 place))]
              (+ acc (* parsed-digit place-value))))
          (map vector (range (dec (count binary-str)) -1 -1) binary-str)))
  • \$\begingroup\$ #(reduce(fn[a b](+(* a 2)(-(int b)48)))0 %) improved version. Moved map part of code directly into reduce, changed integer parsing method, make external function with shorthand lambda syntax. \$\endgroup\$
    – cliffroot
    Dec 6, 2016 at 14:46
  • \$\begingroup\$ @cliffroot int can be used to parse!? That'll knock off like 10 bytes in every challenge I've done here lol. \$\endgroup\$ Dec 6, 2016 at 18:40
  • \$\begingroup\$ Oh, I see what you're doing. Taking the ascii code, then subtracting to get the value. I guess this would only work in select circumstances only. Oh well, thanks for the tip. \$\endgroup\$ Dec 6, 2016 at 18:42

Perl, 21 19 16 + 4 = 20 bytes

-4 bytes thanks to @Dada

Run with -F -p (including the extra space after the F). Pipe values to the function using echo -n


Run as echo -n "101010" | perl -F -pE '$\+=$_+$\for@F}{'

I feel this is sufficiently different from @Dada's answer that it merits its own entry.


-F                              #Splits the input character by character into the @F array
-p                              #Wraps the entire program in while(<>){ ... print} turning it into
                   for@F        #Loops through the @F array in order ($_ as alias), and...
          $\+=$_+$\             #...doubles $\, and then adds $_ to it (0 or 1)...
while(<>){              }       #...as long as there is input.
                         {print}#Prints the contents of $_ (empty outside of its scope), followed by the output record separator $\

This uses my personal algorithm of choice for binary-to-decimal conversion. Given a binary number, start your accumulator at 0, and go through its bits one by one. Double the accumulator each bit, then add the bit itself to your accumulator, and you end up with the decimal value. It works because each bit ends up being doubled the appropriate number of times for its position based on how many more bits are left in the original binary number.

  • \$\begingroup\$ Even shorter : perl -F -pE '$\+=$_+$\for@F}{' \$\endgroup\$
    – Dada
    Dec 6, 2016 at 19:51
  • \$\begingroup\$ I honestly laughed at how short this is now. Thank you. \$\endgroup\$ Dec 6, 2016 at 19:56
  • \$\begingroup\$ Yea, it's pretty neat, well done! \$\endgroup\$
    – Dada
    Dec 6, 2016 at 20:04

Haskell, 31 bytes

f=foldl(\a b->2*a+(read$b:[]))0

Takes input in string format (e.g. "1111"). Produces output in integer format (e.g. 15).

:[] Converts from an element to an array -- in this chase from Char to [Char] (String). read Converts from string to whatever context it's in (in this case the context is addition, so converts to Num)

so (read$b:[]) converts b from Char to Num. a is the accumulator, so multiply that by two and add the Num version of b.

If input in the format [1,1,1,1] was allowed, the 18 byte


would work, but since it's not, it doesn't.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.