[Question]
  [
# 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.
Rules:
* 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:
```
1
1
10
2
101010
42
1101111111010101100101110111001110001000110100110011100000111
2016120520371234567
```
This challenge is related to a few other challenges, for instance [this](https://codegolf.stackexchange.com/questions/68247/convert-a-number-to-hexadecimal), [this](https://codegolf.stackexchange.com/questions/63564/simplify-binary) and [this](https://codegolf.stackexchange.com/questions/69155/base-conversion-with-strings).
  
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 5 bytes
```
DḤ+¥/
```
[Try it online!](http://jelly.tryitonline.net/#code=ROG4pCvCpS8&input=&args=MTAxMDEw)
## Explanation
[![enter image description here](https://i.stack.imgur.com/rlLYr.png)](https://i.stack.imgur.com/rlLYr.png)
### 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](https://en.wikipedia.org/wiki/Fold_(higher-order_function)) 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
```
[Answer]
# 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))
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 6 bytes
Code:
```
$¦v·y+
```
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:
* **1**01010, start with the number **1**.
* 1**0**1010, multiply by two, resulting into **2**.
* 10**1**010, multiply by two and add one, resulting into **5**.
* 101**0**10, multiply by two, resulting into **10**.
* 1010**1**0, multiply by two and add one, resulting into **21**.
* 10101**0**, 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!](http://05ab1e.tryitonline.net/#code=JMKmdsK3eSs&input=MTEwMTExMTExMTAxMDEwMTEwMDEwMTExMDExMTAwMTExMDAwMTAwMDExMDEwMDExMDAxMTEwMDAwMDExMQ)
[Answer]
# Turing Machine Code, 232 bytes
(Using, as usual, the morphett.info rule table syntax)
While only 40 bytes shorter than the [existing solution](https://codegolf.stackexchange.com/a/102258), that solution uses 12 states whereas this one only uses 4:
```
0 1 0 l 0
0 0 . r 0
0 . 1 l 0
0 _ I r 1
0 I 2 r 0
0 2 3 r 0
0 3 4 r 0
0 4 5 r 0
0 5 6 r 0
0 6 7 r 0
0 7 8 r 0
0 8 9 r 0
0 9 X l 0
0 X O r 0
0 O I r 0
1 _ _ l 2
1 * * * 0
2 * _ l 3
3 O 0 l 3
3 I 1 l 3
3 . _ l 3
3 _ * * halt
3 * * l 3
```
### [Try it online!](http://morphett.info/turing/turing.html?913c655ff9a63a6da93fa5af72de73cc)
The interesting computation (ie. base-conversion) actually just takes place in state 0. This state decrements the binary number one-by-one, each time incrementing a decimal counter.
Due to naming clashes of the number-bases' alphabets, I make use of `O` and `I` during the conversion. State *1,2,3* only take care of cleaning the tape, converting the symbols `O → 0` and `I → 1` and finally halting the machine.
[Answer]
## Haskell, ~~16~~ 111 + 57 = 168 bytes
```
import Data.String
instance IsString[Int]where fromString=map((-48+).fromEnum)
f::[Int]->Int
f=foldl1((+).(2*))
```
+57 bytes for the compile flags `-XOverloadedStrings`, `-XOverlappingInstances` and `-XFlexibleInstances`.
The challenge has some [cumbersome IO format](http://meta.codegolf.stackexchange.com/a/8077/34531), because it heavily depends on how data types are expressed in the source code. My first version (16 bytes), namely
```
foldl1((+).(2*))
```
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.
[Answer]
## JavaScript (ES6), ~~33~~ 31 bytes
```
s=>[...s].map(c=>r+=+c+r,r=0)|r
```
Edit: Shorter but less sweet: 2 bytes saved thanks to @ETHproductions.
[Answer]
# [Labyrinth](http://github.com/mbuettner/labyrinth), 17 15 bytes
```
-+:
8 +
4_,`)/!
```
[Try it online!](http://labyrinth.tryitonline.net/#code=LSs6CjggKwo0XyxgKS8h&input=MTEwMTExMTExMTAxMDEwMTEwMDEwMTExMDExMTAwMTExMDAwMTAwMDExMDEwMDExMDAxMTEwMDAwMDExMQ)
[![Image of the code](https://i.stack.imgur.com/TVlWV.png)](https://i.stack.imgur.com/TVlWV.png)
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.
## Tail
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](https://codegolf.stackexchange.com/users/8478/martin-ender) for saving me 2 bytes (and teaching me how to better think in Labyrinth).
[Answer]
# Retina, 15 bytes
Converts from binary to unary, then unary to decimal.
```
1
01
+`10
011
1
```
[**Try it online**](http://retina.tryitonline.net/#code=MQowMQorYDEwCjAxMQox&input=MTAxMDEw)
[Answer]
# PHP, 44 bytes
```
for(;""<$c=$argv[1][$i++];)$n+=$n+$c;echo$n;
```
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.
[Answer]
# [Brain-Flak](http://github.com/DJMcMayhem/Brain-Flak), ~~46~~, 28 bytes
```
([]){{}({}<>({}){})<>([])}<>
```
[Try it online!](http://brain-flak.tryitonline.net/#code=KFtdKXt7fSh7fTw-KHt9KXt9KTw-KFtdKX08Pg&input=MSAxIDAgMSAxIDEgMSAxIDEgMSAwIDEgMCAxIDAgMSAxIDAgMCAxIDAgMSAxIDEgMCAxIDEgMSAwIDAgMSAxIDEgMCAwIDAgMSAwIDAgMCAxIDEgMCAxIDAgMCAxIDEgMCAwIDEgMSAxIDAgMCAwIDAgMCAxIDEgMSA)
*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.
Explanation:
```
#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
 ([])
#endwhile
}
#Toggle back to the other stack, implicitly display.
<>
```
[Answer]
# 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;}
```
[Answer]
# Befunge-98, 12 bytes
```
2j@.~2%\2*+
```
[Try it online!](http://befunge-98.tryitonline.net/#code=MmpALn4yJVwyKis&input=MTEwMTExMTExMTAxMDEwMTEwMDEwMTExMDExMTAwMTExMDAwMTAwMDExMDEwMDExMDAxMTEwMDAwMDExMQ)
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?
[Answer]
# C# 6, ~~85~~ ~~37~~ 36 bytes
```
long b(long n)=>n>0?n%2+2*b(n/10):0;
```
* Thanks to [Kade](https://codegolf.stackexchange.com/users/38417/kade) for saving 41 bytes!
* Changing to C# 6 saved another 7 bytes.
[Answer]
## 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
```
**Explanations:**
```
$\|=$&<<$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
```
[Answer]
## Javascript (ES7) ~~41~~ ~~40~~ 36 bytes
```
f=([c,...b])=>c?c*2**b.length+f(b):0
```
takes a string as input
Shaved a byte thanks to ETHproductions
```
f=([c,...b])=>c?c*2**b.length+f(b):0
document.write([
    f('101010'),
    f('11010'),
    f('10111111110'),
    f('1011110010110'),
].join("<br>"))
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `s`, 31 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), ~~9~~ ~~7~~ 3.875 bytes
```
fṘTE
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJzPSIsIiIsImbhuZhURSIsIiIsIjEwMSJd)
```
fṘTE
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJzPSIsIiIsImbhuZhURSIsIiIsIjEwMSJd)
* -2 thanks to Steffan
* -3 chars thanks to lyxal
**Explanation:**
```
fṘTE  # Implicit input
f     # Flatten into a list of digits
 Ṙ    # Reverse the list
  T   # Truthy indices
   E  # Two power
      # Implicit output of sum
```
Old:
```
ṘėRvƒ↲∑    # Implicit input
Ṙė         # Reverse and enumerate
  R        # Reverse each
   vƒ      # Vecorised reduce over:
     ↲     # Left bit-shift
      ∑    # Sum
           # Implicit output
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 7 bytes
```
RvNoy*O
```
[Try it online!](http://05ab1e.tryitonline.net/#code=UnZOb3kqTw&input=MTEwMTExMTExMTAxMDEwMTEwMDEwMTExMDExMTAwMTExMDAwMTAwMDExMDEwMDExMDAxMTEwMDAwMDExMQ)
**Explanation**
```
R         # reverse input
 v     O  # sum of
  No      # 2^index
     *    # times
    y     # digit
```
[Answer]
# 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.
[Answer]
# 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](http://ideone.com/eSaKPz)
[Answer]
# Mathematica, ~~27~~ ~~13~~ 11 bytes
```
Fold[#+##&]
```
Accepts a `List` of bits as input (e.g. `{1, 0, 1, 1, 0}` -- *Mathematica*'s binary representation of the number `22`)
[Answer]
# [Pushy](https://github.com/FTcode/Pushy), 10 bytes
Takes input as a list of 0/1 on the command line: `$ pushy binary.pshy 1,0,1,0,1,0`.
```
L:vK2*;OS#
```
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
```
[Answer]
## R (32-bit), 64 Bytes
Input for the function should be given as character. The base functions of R support 32-bit integers.
Input:
```
# 32-bit version (base)
f=function(x)sum(as.double(el(strsplit(x,"")))*2^(nchar(x):1-1))
f("1")
f("10")
f("101010")
f("1101111111010101100101110111001110001000110100110011100000111")
```
Output:
```
> 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.
Input:
```
# 64-bit version (bit64)
g=function(x)sum(bit64::as.integer64(el(strsplit(x,"")))*2^(nchar(x):1-1))
g("1")
g("10")
g("101010")
g("1101111111010101100101110111001110001000110100110011100000111")
```
Output:
```
> g("1")
integer64
[1] 1
> g("10")
integer64
[1] 2
> g("101010")
integer64
[1] 42
> g("1101111111010101100101110111001110001000110100110011100000111")
integer64
[1] 2016120520371234567
```
[Answer]
# Matlab, 30 Bytes
```
@(x)sum(2.^find(flip(x)-48)/2)
```
The last test case has rounding errors (because of `double`), so if you need full precision:
```
@(x)sum(2.^uint64(find(flip(x)-48))/2,'native')
```
with 47 Bytes.
[Answer]
## [Retina](http://github.com/mbuettner/retina), 12 bytes
Byte count assumes ISO 8859-1 encoding.
```
+%`\B
¶$`:
1
```
[Try it online!](http://retina.tryitonline.net/#code=KyVgXEIKwrYkYDoKMQ&input=MTAxMDEw)
Alternative solution:
```
+1`\B
:$`:
1
```
### Explanation
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:
```
^
,
+`,(.)
$`$1,
1
```
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 `1`s at the end, we don't even need to distinguish between `0`s and `1`s 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:
```
,(.)
$`$1,
```
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):
```
,1011
1,011
 _
110,11
   ___
1101101,1
       _______
110110111011011,
```
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 `1`s 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 `$``):
```
 _ __ ___
1101011011
```
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:
```
\B
,
+%`,
¶$`
```
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 `1`s 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:
```
+%`\B
¶$`:
```
Just for completeness, here are the individual steps of processing `1011`, with an empty line after each step:
```
1
1:0
10:1
101:1
1
1:0
1
1:0:1
1
1:0
10:1:1
1
1:0
1
1:0:1
1
1:0
1
1:0:1:1
```
Again, you'll find that the last result contains exactly 11 `1`s.
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)?
[Answer]
# Elm, ~~60~~ 41 bytes
```
String.foldl(\b a->2*a+Char.toCode b-48)0
```
-19 bytes thanks to Wheat Wizard and alephalpha
You can try it [here](https://elm-lang.org/try). Here's a full test snippet:
```
import Html exposing (text)
f : String -> Int
f=String.foldl(\b a->2*a+Char.toCode b-48)0
main = text (String.fromInt (f "101010"))
```
[Answer]
## 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
```
[Answer]
# PHP, 64 bytes
```
foreach(str_split(strrev($argv[1]))as$k=>$v)$t+=$v*2**$k;echo$t;
```
We reverse our binary number, split it into its component digits, and sum them based on position.
[Answer]
## PowerShell v2+, 55 bytes
```
param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i
```
~~Feels too long ...~~ Can't seem to golf it down any -- tips appreciated.
### Explanation
```
param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i
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
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), 7 bytes
```
PoofqWs
```
[Try it online!](http://matl.tryitonline.net/#code=UG9vZnFXcw&input=JzEwMTAxMCc)
```
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
```
[Answer]
# JavaScript (ES6), 32 bytes
```
f=([...n])=>n+n&&+n.pop()+2*f(n)
```
Recursion saves the day again! Though the parameterization seems a little long...
]