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
  • 1
    \$\begingroup\$ The last number is the date the challenge was posted? The hours and seconds don't correspond with SE's UTC+0 time, it should be 20161205193745***** :) \$\endgroup\$
    – user60199
    Dec 7, 2016 at 19:52

84 Answers 84


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.


Dyalog APL, 12 bytes


get string input

⍎¨ convert each character to number


(...)/ insert the following function between the numbers

++⊢ the sum of the arguments plus the right argument

ngn shaved 2 bytes.


7, 25 bytes (65 characters)


Try it online!


077                             Initialize counter to 0 (an empty section)
   17134200..77546635           Push the main loop onto the frame

Once the original code has finished executing, the frame is


The last section of this is the main loop, which will run repeatedly until it gets deleted. All of it except the last two commands is data and section separators, which push commands onto the frame to leave it as:

||6|| (main loop) |73426644|6734216644|6667553663||00137||54

3 outputs the last section (54) and discards the last two bars. On the first iteration, 5 is interpreted as a switch to output format 5 ("US-TTY"), which converts each pair of commands to a character. The 4 following it does not form a group, so it is ignored. On future iterations, we are already in output format 5, so 54 is interpreted as a group meaning "input character". To do this, the character from STDIN is converted into its character code (or, on EOF, -1), and 1 is added. Then, the last section (which is now the 00137) is repeated that many times. In summary:

  • If the character is 0, 00137 is repeated 49 times.
  • If the character is 1, 00137 is repeated 50 times.
  • If there are no more characters, 00137 is repeated 0 times (i.e. deleted).
  • If this was the first iteration, 00137 is left alone (i.e. repeated 1 time).

5 removes the last section (00137 repeated some number of times) from the frame and executes it, resulting in this many sections containing 6673.

The main loop has now finished executing, so the last section (which is 6673 unless we reached EOF) runs. 66 concatenates the last three sections into one (and has some other effects that don't affect the number of sections), which 73 deletes. Thus, the last three sections are deleted, and this repeats until the last section is no longer 6673.

  • If we reached EOF, nothing happens.
  • If this is the first iteration or the character was 0, after removing the last three sections 0 or 16 times, there is just one copy left on the frame. This copy deletes itself and the two sections before it, leaving everything up to the main loop and the section after it.
  • If the character was 1, after removing the last three sections 17 times, all 50 copies and the third section after the main loop (the EOF handler) have been deleted.

Now, the last section left on the frame runs. This could, depending on the inputted character, be any of the three sections after the main loop.

If this is the first iteration or the character was 0, the section just after the main loop, 73426644, runs. 73 deletes this section, and 4 swaps the main loop with the counter behind it. This counter keeps track of the number we want to output, stored as the number of 7s and 1s minus the number of 6s and 0s. This metric has the property that it is not changed by pacification (which changes some 6s into 0s, some 7s into 1s, and sometimes inserts 7...6 around code). 2 duplicates the counter and 6 concatenates the two copies (after pacifying the second, which, as we saw, does not change the value it represents), so the value is doubled. If this was the first iteration, the counter was previously empty, and doubling it still results in an empty section. Then, 6 gets rid of the empty section inserted by 4 (and pacifies the counter again, leaving the value unchanged), and 44 swaps the counter back to its original position. This leaves two empty sections on the end of the frame, which are removed automatically, and the main loop runs again.

If the character was 1, the second section after the main loop (6734216644) runs. This is just like the section before it (explained in the last paragraph), except for two extra commands: a 6 at the start, which joins the section with the previous one before 73 deletes it, and a 1 in the middle, which adds a 7 to the counter (increasing its value by 1) after it gets doubled.

If we reached EOF, the third section after the main loop (6667553663) runs. 666 joins the last four sections (everything after the counter) into one section, to be deleted by 3. 7553 exits output format 5 by outputting 55 and deletes the section before it, leaving only ||6| (counter) on the frame. 66 pacifies the two sections and combines them, turning the 6 back into a 0 (and not changing the value of the counter). Finally, the last 3 outputs everything. The 0 at the start enters output format 0 ("Numerical output"), and the rest of the section (i.e. the counter) is converted to a number by taking the number of 7s and 1s minus the number of 6s and 0s. This value, which is the input converted from binary, is output in decimal and the program terminates.


Excel, 74 70 55

Trailing parens already discounted. Tested in Excel Online.


  • A1: Input
  • B1: =LEN(A1) (7)

Main Code (48):

A pretty simple "add all the powers of 2" formula:


Verify with:


R, 48 37 bytes

-11 bytes thanks to Dominic van Essen


Takes input as a string, left-padded with 0s to 32 bits. Try it online!

I copied some good ideas from djhurio's much earlier R answer, so go give that an upvote too. As with the first solution there, this solution won't work for the last test case because it's too large to fit into R's default size of integer.


To get a vector of the bits as integers 0 and 1, we use uft8ToInt to convert to a vector of character codes. This gives us a list of 48s and 49s, which we take mod 2 to get 0s and 1s.

Then, to get the appropriate powers of 2 in descending order, we construct a range from 31 down to 0. Then we convert each of those numbers to the corresponding power of two (2^).

Finally, we multiply the two vectors together and return their sum.

  • \$\begingroup\$ 37 bytes (or 40 bytes as a function) thanks to 'You may choose to have leading zeros in the binary representation'. Accepts input as 32-bit binary string, with leading zeros, but easily modified to double-integer precision for the same length code... \$\endgroup\$ Sep 9, 2020 at 7:19

x86-16 machine code, 10 bytes


00000000: 31d2 acd0 e811 d2e2 f9c3                 1.........


31 D2       XOR  DX, DX         ; clear output value
AC          LODSB               ; load next char into AL
D0 E8       SHR  AL, 1          ; CF = LSb of ASCII char
11 D2       ADC  DX, DX         ; shift CF left into result
E2 F9       LOOP CHRLOOP        ; loop until end of string
C3          RET                 ; return to caller

Callable function, input string in [SI] length in CX. Result in DX.

Example test program I/O:

enter image description here

  • 1
    \$\begingroup\$ Why the downvote? Is there a bug, issue or problem with it? \$\endgroup\$
    – 640KB
    Sep 14, 2020 at 20:05

K (ngn/k), 11 10 bytes

(+/2 1*,)/

Try it online!


C, 48 bytes

i;f(char *s){for(i=0;*++s;i+=i+*s-48);return i;}

Heavily inspired by @edc45 's answer but I made some significant changes. I made 'i' a global variable to save having to typecast. I also used a for loop to save a few bytes. It does now require a single leading 0 in the binary representation.

More readable version

f(char *s){
  int i = 0; // Total decimal counter
  for(;;*++s;i+=i+*s-48); // Shift left and add 0 or 1 depending on charecter
  return i;

k, 8 bytes

Same method as the Haskell answer above.




JavaScript (ES7), 56 47 bytes

Reverses a binary string, then adds each digit's value to the sum.



document.write( f('101010') ) // 42


Java 7, 87 bytes

long c(String b){int a=b.length()-1;return a<0?0:b.charAt(a)-48+2*c(b.substring(0,a));}

For some reason I always go straight to recursion. Looks like an iterative solution works a bit nicer in this case...


JavaScript (ES6), 38

Simple is better




console.log("Test 0 to 99999")
console.log(e+" errors")



Turing Machine Code, 272 bytes

(Using, as usual, the morphett.info rule table syntax)

0 * * l B
B * * l C
C * 0 r D
D * * r E
E * * r A
A _ * l 1
A * * r *
1 0 1 l 1
1 1 0 l 2
1 _ * r Y
Y * * * X
X * _ r X
X _ _ * halt
2 * * l 2
2 _ _ l 3
3 * 1 r 4
3 1 2 r 4
3 2 3 r 4
3 3 4 r 4
3 4 5 r 4
3 5 6 r 4
3 6 7 r 4
3 7 8 r 4
3 8 9 r 4
3 9 0 l 3
4 * * r 4
4 _ _ r A

AKA "Yet another trivial modification of my earlier base converter programs."

Try it online, or you can also use test it using this java implementation.


JavaScript, 18 83 bytes




document.write(f('1011')) // 11

  • \$\begingroup\$ Uses a built-in, which is disallowed. \$\endgroup\$
    – Yytsi
    Dec 5, 2016 at 21:41
  • \$\begingroup\$ @TuukkaX Ah, missed that. Thanks. \$\endgroup\$
    – Oliver
    Dec 5, 2016 at 21:42
  • 1
    \$\begingroup\$ I was just about to do the same thing (in c#), I'm bad at reading. \$\endgroup\$
    – Yodle
    Dec 5, 2016 at 21:42
  • \$\begingroup\$ It's a code golf challenge, try to write short code. (y==='1') could be +y \$\endgroup\$
    – edc65
    Dec 5, 2016 at 22:01

MATL, 8, 7 bytes


Try it online!

One byte saved thanks to @LuisMendo!

Alternate approach: (9 bytes)


Befunge, 20 18 bytes

Input must be terminated with EOF rather than EOL (this lets us save a couple of bytes)


Try it online!


>             The stack is initially empty, the equivalent of all zeros.
 +            So the first pass add just leaves zero as the current total. 
  ~           Read a character from stdin to the top of the stack.
   :0`        Test if greater than 0 (i.e. not EOF)
      _       If true (i.e > 0) go left.
    %2        Modulo 2 is a shortcut for converting the character to a numeric value.
   \          Swap to bring the current total to the top of the stack.
 *2           Multiply the total by 2.
^             Return to the beginning of the loop,
 +            This time around add the new digit to the total.

                ...on EOF we go right...
       $      Drop the EOF character from the stack.
        .     Output the calculated total.
         @    Exit.
  • \$\begingroup\$ I had like a 60-something byte code that was dealing with integers, and wow, this is so much more simple and elegant. Great job, and nice explanation too. \$\endgroup\$ Dec 6, 2016 at 5:14

Ruby, 37 bytes

ruby -e 'o=0;gets.each_byte{|i|o+=o+i%2};p o/2'

This depends on the terminating \n (ASCII decimal 10) being zero modulo 2 (and on ASCII 0 and 1 being 0 and 1 mod two, respectively, which thankfully they are).


아희(Aheui), 40 bytes


Accepts a string composed of 1s and 0s.

To try online

Since the online Aheui interpreter does not allow arbitrary-length strings as inputs, this alternative code must be used (identical code with slight modifications):

Add the character at the end of the first line (after ) length(n)-times.


If the input is 10110, the first line would be 어우벟벟벟벟벟.

When prompted for an input, do NOT type quotation marks. (i.e. type 10110, not "10110")

Try it here! (copy and paste the code)


ClojureScript, 36 bytes

(fn[x](reduce #(+(* 2 %)(int %2))x))


#(reduce(fn[a n](+(* 2 a)(int n)))%)

The straightforward reduction. Takes a string as input.


Minkolang v0.15, 23 19 bytes


Try it online!


n                             gets input in the form of a number
 6Z                           converts to string (so that it is split into an array)
   r                          reverses it
    I                         gets the stack length
     [        ]               for loop with the stack's length as the number of iterations
      2%                       gets the modulo of the ascii value
                               1 =(string conversion)> 49 =(after modulo)> 1
                               0 =(string conversion)> 48 =(after modulo)> 0
        2i;                    raises 2 to the power of the loop counter
           *                   multiplies it by the modulo
            1R                 rotates stack 1 time
              $+              sums everything
                N.            outputs as number and exit

Common Lisp, 99 88 72 bytes

Takes a string as input

(defun f(s)(reduce(lambda(a d)(+ d(* a 2)))(map'list #'digit-char-p s)))


(defun bin-to-dec (bin-str)
  (reduce (lambda (acc digit) (+ digit (* acc 2)))
          (map 'list #'digit-char-p bin-str)))

><> (Fish) 36 28 bytes

/i:1+?!v$2*$2%+!| !
/0| ;n~<

Edit 1: Forgot to put the output in the original. Added output and used MOD 2 instead of minus 48 to convert ascii to decimal to save the extra bytes lost. (no change in bytes)

Edit 2: Changed the algorithm completely. Each loop now does this; times current value by 2, then add the mod of the input. (saving of 8 bytes)

Online version

Try it Online! - This works with bigger numbers than the above link.


C, 44 bytes


Use as follows :

int main(){
  printf("%i\n", d("101010",0));

Remove two bytes and an unused parameter thanks to Steadybox

  • \$\begingroup\$ You have an unused parameter c there. Removing it saves two bytes. \$\endgroup\$
    – Steadybox
    Dec 6, 2016 at 19:49

MATLAB, 49 bytes


Anonymous function that splits the input into an array with int2str(a)-'0', then does a dot product with powers of 2. Has rounding error for the last test case, will update the solution when I figure out a fix.


Forth (gforth 0.7.3), 47 bytes

: x 2 base ! bl parse s>number drop decimal . ;

: x - define new word with name 'x'
2 base ! - set base to binary
bl parse - read line until a space (bl) or EOL
s>number - try to convert the string to number
drop - we only want the converted number and not the success flag
decimal - set base to decimal
. - print value on top of stack
; - end of definition

Test cases:

x 1 1  ok
x 10 2  ok
x 101010 42  ok
x 1101111111010101100101110111001110001000110100110011100000111 2016120520371234567  ok
  • \$\begingroup\$ Sorry, forget my last comment, I thought this answer was to another challenge :/ The answer is perfectly valid :) \$\endgroup\$ Dec 23, 2016 at 12:09

C, 41 37 bytes




SmileBASIC, 47 44 bytes


Another program of the same size:


APL(NARS), 26 chars, 52 bytes



  ⎕fmt f"0"
  ⎕fmt f"101010"
152 4995366924470859583704000893073232977339613183 

152 bits... It should be limited from memory for store string and numbers.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

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