[Question]
  [
### About Zeckendorf Representations/Base Fibonacci Numbers
This is a number system which uses Fibonacci numbers as its base. The numbers consist of 0 and 1's and each 1 means that the number contains the corresponding Fibonacci number, and 0 means it does not.
For example, let's convert all natural numbers <=10 to base Fibonacci.
* 1 will become 1, because it is the sum of 1, which is a Fibonacci number,
* 2 will become 10, because it is the sum of 2, which is a Fibonacci number, and it does not need 1, because we already achieved the desired sum.
* 3 will become 100, because it is the sum of 3, which is a Fibonacci number and it does not need 2 or 1 because we already achieved the desired sum.
* 4 will become 101, because it is the sum of [3,1], both of which are Fibonacci numbers.
* 5 will become 1000, because it is the sum of 5, which is a Fibonacci number, and we do not need any of the other numbers.
* 6 will become 1001, because it is the sum of the Fibonacci numbers 5 and 1.
* 7 will become 1010, because it is the sum of the Fibonacci numbers 5 and 2.
* 8 will become 10000, because it is a Fibonacci number.
* 9 will become 10001, because it is the sum of the Fibonacci numbers 8 and 1.
* 10 will become 10010, because it is the sum of the Fibonacci numbers 8 and 2.
Let's convert a random Base Fibonacci number, 10101001010 to decimal:
First we write the corresponding Fibonacci numbers.
Then we compute the sum of the numbers under 1's.
```
 1   0   1   0   1   0   0   1   0   1   0
 144 89  55  34  21  13  8   5   3   2   1  -> 144+55+21+5+2 = 227.
```
Read more about Base Fibonacci numbers: [link](http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibrep.html), it also has a tool which converts regular integers to base Fibonacci. You can experiment with it.
### Now the Question:
Your task is to take a number in the Zeckendorf Representation, and output its decimal value.
Input is a string which contains only 0 and 1's (although you can take the input in any way you want).
Output one number in decimal.
Test cases: (in the format input->output)
```
 1001 -> 6
 100101000 -> 73
 1000000000 -> 89
 1001000000100100010 -> 8432
 1010000010001000100001010000 -> 723452
```
This is code-golf, so the shortest answer in bytes wins.
Note: The input will not contain any leading 0's or consecutive 1's.
  
[Answer]
# [Taxi](https://bigzaphod.github.io/Taxi/), ~~1987~~ 1927 bytes
*-60 bytes due to the realization that linebreaks are optional.*
```
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[B]Switch to plan C if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 3 l.Pickup a passenger going to Narrow Path Park.Pickup a passenger going to Sunny Skies Park.Go to Zoom Zoom:n.Go to Sunny Skies Park:w 2 l.Go to Narrow Path Park:n 1 r 1 r 1 l 1 r.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan B.[C]1 is waiting at Starchild Numerology.1 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 3 l 3 l 2 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Cyclone.Go to Cyclone:w 1 r 4 l.[D]Pickup a passenger going to Addition Alley.Pickup a passenger going to Cyclone.Go to Addition Alley:n 2 r 1 r.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Multiplication Station.Go to Zoom Zoom:n.Go to Narrow Path Park:w 1 l 1 l 1 r.Switch to plan E if no one is waiting.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:e 1 r.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:n 1 r 2 l.Pickup a passenger going to Joyless Park.Go to Joyless Park:n 2 l 1 r 1 r.Go to Addition Alley:w 1 r 2 l 1 l.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Addition Alley.Switch to plan D.[E]Go to Addition Alley:w 1 l 1 r 1 l.Pickup a passenger going to Riverview Bridge.Go to Riverview Bridge:n 1 r.Go to Joyless Park:e 1 r 2 l.Pickup a passenger going to Addition Alley.[F]Switch to plan G if no one is waiting.Pickup a passenger going to Addition Alley.Go to Fueler Up:w 1 l.Go to Addition Alley:n 3 l 1 l.Pickup a passenger going to Addition Alley.Go to Joyless Park:n 1 r 1 r 2 l.Switch to plan F.[G]Go to Addition Alley:w 1 r 2 l 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:n 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.
```
[Try it online!](https://tio.run/##tVXJboMwEP2V@QKU7ZRbdqlS06i0lyIOLjFgxbGRMaF8fWowThOHQNKqCGOwx7O8eTNI9EWOxxUHyWHDUwkvYUgCPM6hD1QNUc7OhgS7LAEECUpTzCIsIOKEReWpWcwTcDNcOFrL6XvMzHkY1Xq8qe/mRAZxKZhQxGAGJATGgTMMJIUcEan0thssAqrEjTn9VRmjMOxwdo2E4DlskIzVQ@xahd2MsQLcHcGpFtYWPzjfV48xq1dsQYXeQDmiN22TJ1iEgfgKOHyxayE2dbyZ3z8DC5AEVyIRxIRuYZ3tseCUR4Vzl1AdQcPWD6TVGChX2tCabLfKEmcwoVSR4fEM5lXUo5Imc/9fLF0eVPENdCIaqdTF@@eMSpJQEqBKpUKwnG9y5IoGpsIak7x4vCzeYgxT9IlpSNIYC5NZe1mT6/eRNW/WpB50YPbEC4rTi2o6X6oyYrqOaE5abgx1N6aWPtF11qKYlZ254y38m97d1zZfyQGLA8E5TAXZRsZNe1kD24QVvgtxKxBvaTfg1eNMs3Rq35YZpkroPdEY3Kq44ePgN/LEtNAyfiuipeOt/D9y595iOjnSqu3sx@pc/2rZqQkcj/1eT93lVb/1e98 "Taxi – Try It Online")
Because I don't return to the Taxi Garage at the end, my boss fires me, so it exits with an error.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~28~~ 23 bytes
```
{[+] (1,2,*+*...*)Z*$_}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwvzpaO1ZBw1DHSEdLW0tPT09LM0pLJb72f3FipUKahqGBgaFeWk5mgV5yfm6SpjUXQhgIDQywy0EBLo1gAGUZYldlCFMDx1ALUZT/BwA "Perl 6 – Try It Online")
Anonymous codeblock that takes a list of `1`s and `0`s in LSB ordering and returns a number.
### Explanation:
```
{                     }   # Anonymous codeblock
 [+]                      # The sum of
     (1,2,*+*...*)        # The infinite Fibonacci sequence starting from 1,2
                  Z*      # Zip multiplied by
                    $_    # The input list in LSB form
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
T‘ÆḞS
```
A monadic link accepting a list in Little-endian form (i.e. from the LSB at the left to MSB at the right).
**[Try it online!](https://tio.run/##y0rNyan8/z/kUcOMw20Pd8wL/v//f7SBDgQaQjGCh42Gq4wFAA "Jelly – Try It Online")**
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 35 32 29 28 bytes
```
Fibonacci[Range@Tr[#!]+1].#&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73y0zKT8vMTk5MzooMS891SGkKFpZMVbbMFZPWe1/WnRQallqUXFqdLWhjoKBjgKEREaGRLDhXBTB2tjY//91C4oy80oA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 43 bytes
```
a=b=0
for x in input():b+=a+x;a=b-a
print b
```
[Try it online!](https://tio.run/##K6gsycjPM/pfnpGZk6pgaJVakZqspKT0P9E2ydaAKy2/SKFCITMPiApKSzQ0rZK0bRO1K6yBsrqJXAVFmXklCkn/QeqjDXUUDMDIMJYLiYNEghCyHBaEqRUNYZU1RNZpiFsPHjYWp4IMBQA "Python 2 – Try It Online")
Takes input as a list. The update is a shorter version of `a,b=b+x,a+b+x`, which is like the Fibonacci update `a,b=b,a+b` if you ignore `x`.
---
# [Python 2](https://docs.python.org/2/), 45 bytes
```
f=lambda n,a=1,b=1:n and n%10*b+f(n/10,b,a+b)
```
[Try it online!](https://tio.run/##PYvBCgIxEEPvfsVchNYtOPG40I@ZYS1bWMciFfHrq9VqQkJ4kPKs69VOraW4yUUXIQsSETRiNhJbyPbgg07J2REcNMikvj3WvJ0Jc7llq5RctnKvzvsGZux6vc3c19AXfjQWOsOP/DOu/AI "Python 2 – Try It Online")
Takes input as decimal numbers.
[Answer]
# [Haskell](https://www.haskell.org/), 38 bytes
```
f=1:scanl(+)2f
sum.zipWith(*)f.reverse
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P83W0Ko4OTEvR0Nb0yiNK922uDRXryqzIDyzJENDSzNNryi1LLWoOPV/bmJmnm1BUWZeiUp6tKGOARACydj/AA "Haskell – Try It Online")
Takes input as a list of 1s and 0s.
## Explanation
---
```
f=1:scanl(+)2f
```
Makes a list of the Fibonacci numbers sans the first one, in variable `f`.
```
sum.zipWith(*)f.reverse
```
Takes the input list `reverse`s it the multiplies each entry by the corresponding entry in `f`, then `sum`s the results.
# [Haskell](https://www.haskell.org/), 30 bytes
```
f=1:scanl(+)2f
sum.zipWith(*)f
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P83W0Ko4OTEvR0Nb0yiNK922uDRXryqzIDyzJENDSzPtf25iZp5tQVFmXolKerSBjqGOARAaxv4HAA "Haskell – Try It Online")
If we take input in with the least significant bit first we don't need `reverse` so we can save 8 bytes.
[Answer]
# Pyth, 13 bytes
Most of this (8 bytes) is just generating the Fibonacci numbers.
```
s*V_m=+Z|~YZ1
```
[Try it out with this test suite!](http://pyth.herokuapp.com/?code=s%2aV_m%3D%2BZ%7C%7EYZ1&test_suite=1&test_suite_input=1%2C0%2C0%2C1%0A1%2C0%2C0%2C1%2C0%2C1%2C0%2C0%2C0%0A1%2C0%2C0%2C0%2C0%2C0%2C0%2C0%2C0%2C0%0A1%2C0%2C0%2C1%2C0%2C0%2C0%2C0%2C0%2C0%2C1%2C0%2C0%2C1%2C0%2C0%2C0%2C1%2C0%0A1%2C0%2C1%2C0%2C0%2C0%2C0%2C0%2C1%2C0%2C0%2C0%2C1%2C0%2C0%2C0%2C1%2C0%2C0%2C0%2C0%2C1%2C0%2C1%2C0%2C0%2C0%2C0&debug=0)
Explanation:
```
s*V_m=+Z|~YZ1QQ     Autofill variables
    m=+Z|~YZ1Q      Generate the first length(input) Fibonacci numbers as follows:
       Z             Start with Z=0
         ~YZ         And Y=[] (update it to Y=Z, return old Y)
        |   1        if Y is [], then replace with 1
      +              Sum Z and Y
     =               Replace Z with sum
    m                Repeat process
             Q       once for each element of the input
   _                Reverse the order of the Fibonacci numbers
 *V                 Vectorize multiplication
s                   Sum
```
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~110~~, ~~102~~, ~~96~~, ~~94~~, ~~78~~, 74 bytes
```
([[]]<>((()))){({}()<([({})]({}({})))>)}{}{}({<>{<{}><>({})(<>)}{}<><{}>})
```
[Try it online!](https://tio.run/##HYqxDYBADAPXsTu@j7LIK8VDA0KioI0ye0iwC@tO3t91Pec67kzMaSYKgBWHByiYtbSGWlIZHg2iLh5a//KQ34u2CmbmyK06Pg "Brain-Flak (BrainHack) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~24~~ 14 bytes
```
#.~2+&%&1~#-#\
```
[Try it online!](https://tio.run/##fZFdUoMwEMffOcWOO0Bi0iUJYG2mdTIewAtU9MHRUV98ZhCujkkLA7S1k1mS7P@3H2G/@xuC9AN2NgUJrQUF3nqkzogkTnSHK3zueRQ9PRIEDBSVW3KCxbbkccdW9sGGI5JMFKiJy8GmIqtvmew0kmm8rvmLZVuLNdfpBVDLrhL@09K/XEOB/CUmMtkcsUDBnGvJMYEN5TgQ1iF3zLfHl8lOQZ@plmqWySCdMq9GIF8QInOsJWnNZSIUqv3v9D1rEY8dm1kVL@7tILsqAA7dnifmgFyNn0TDKhF33A/sixzWaRS9v33@gIadL6KPl7vjxY9Yja51PvcNFsZ4UO83M3WxBr3IzUn8tJY@PcasTV6UU5Q@izjf1ZIcXqY2RblIc9X6Pw "J – Try It Online")
Golfed down the 24-byte version that uses the mixed base for Fibonacci.
### How it works
```
#.~2+&%&1~#-#\  Example input: y=1 0 0 1 0
          #-#\  Length minus 1-based indices; 4 3 2 1 0
   2     ~      Starting from 2, run the following (4,3,2,1,0) times:
    +&%&1         Given y, compute 1 + 1 / y
                The result is 13/8 8/5 5/3 3/2 2
#.~             Mixed base conversion of y into base above; 2+8=10
```
---
# [J](http://jsoftware.com/), 21 bytes
```
1#.|.*[:+/@(!~#-])\#\
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8N9QWa9GTyvaSlvfQUOxTlk3VjNGOea/JpeSnoJ6mq2euoKOQq2VQloxF5efk55CmoKtlQJMiwaQEQvXgymPYiQXV2pyRj5QgSHQYgMFQzQumIRBVDEgjazYEEMhJm2AqpLrPwA "J – Try It Online")
Refined version of [Galen Ivanov's 25-byte solution](https://tio.run/##y/qfVmyrp2CgYKVg8L9GT1tfQU9LuVov2kpbX19POUZRv85ARznmvyaXkp6CepqtnrqCjkKtlUJaMRdXanJGvkKagiFQs4GCIRoXTMIgqhiQRlZsiKEQkzZAVcn1HwA).
Uses the diagonal sum of Pascal's triangle, which is equivalent to the sum of binomial coefficients:
\$ F\_n = \sum\limits\_{i=0}^{n} {}\_{n-i}C\_{i} \$
### How it works
```
1#.|.*[:+/@(!~#-])\#\
                       Example input: 1 0 0 1 0
                   #\  Generate 1-based index; 1 2 3 4 5
      [:          \    For each prefix of above... (ex. 1 2 3)
              #-]        Subtract each element from the length (ex. 2 1 0)
           (!~   )       Compute binomial coefficient (ex. 3C0 + 2C1 + 1C2)
        +/@              Sum
                       The result is Fibonacci numbers; 1 2 3 5 8
   |.*                 Multiply with mirrored self; 0 2 0 0 8
1#.                    Sum; 10
```
---
# [J](http://jsoftware.com/), 24 bytes
```
3 :'y#.~|.(1+%)^:(<#y)2'
```
[Try it online!](https://tio.run/##fZFBboMwEEX3nGJUi2DX7mAbaJpRUlk9QC4QpV1UrapuukYUrk7tBAQmSWUNxvPf/xrwd3@HkH3CjjJQ0BJo8NUXQFnNsPtFbmQqXolvWS1s1osk2b8gBANorLboJE@pEmnHH@iZwitDtdKgJy6Eyby@56ozDG3jdXOKJJ9psiugUd1R@keLN7kGA@nnk7lqcJzQwJxr0XHJGizYQJBjwnE/nojDlqBPqpWeJVmGS@bNSiYiQuaOt6jIXidu/dOJ8OKBBtkdA@CYO4iVTZKP968fMLDzoDkfHs8Hf2F6bK2LeW@ocBUn9WkzU6M16GVhF/5pxT0zeta2KKvJZS4cl7uOyeHL9Kasoph/q/8D "J – Try It Online")
Monadic explicit verb. Generates the mixed base that represents the Fibonacci base, and then feeds into base conversion `#.`.
### How it works
```
y#.~|.(1+%)^:(<#y)2  Explicit verb, input: y = Fibonacci digit array, n = length of y
      (1+%)          x -> 1 + 1/x
           ^:(<#y)2  Apply the above 0..n-1 times to 2
                     The result looks like 2/1, 3/2, 5/3, 8/5, 13/8, ...
    |.               Reverse
                     Now, if it is fed into #. on the left, the digit values become
                     ...(8/5 * 5/3 * 3/2 * 2/1), (5/3 * 3/2 * 2/1), (3/2 * 2/1), 2/1, 1
                     which is ... 8 5 3 2 1 (Yes, it's Fibonacci.)
y#.~                 Convert y to a number using Fibonacci base
```
---
## Alternatives
### [J](http://jsoftware.com/), 27 bytes
```
}.@(+#{.3#{.)^:(<:@#)@(,&0)
```
[Try it online!](https://tio.run/##fZFLTsMwEIb3OcUIK42NzcSPhFKrRRYH4AJVYYFAiA3rKCRXDzZJFDstlTV@zP/947H8NdwgFB9wsAUI6CxI8DF06CgnLRof7MXSvXWEOSo2kg0sy56fEIIHJNZ7dJzmtmZ5T@/sow1bgp4EuXAGbMHL5paKXhHUrdfVWJc0TBUXQCX6E/dTh/9yLQbyBykvxdRmoCDmrjwkLbYGfaVGyKiSJrhmXjUnLCF46WiHwurLRLioIdj7nhXP5451dIsXj3aS3SkAjrgj2@gse3/7/AYFBw@q8XA/HvyfyTm1NXFuivAVf@rDLlKTMemV0Sv/MtKcmj1bbap6cakzx/kqU3J6mdxVdVLmagy/ "J – Try It Online")
The idea:
```
 1  0  0  1  0  1
-1 +1 +1
------------------
    1  1  1  0  1
   -1 +1 +1
------------------
       2  2  0  1
      -2 +2 +2
------------------
          4  2  1
         -4 +4 +4
------------------
             6  5
            -6 +6 +6 <- Add an imaginary digit that has value 1
---------------------
               11  6
              -11+11
---------------------
                  17 <- the answer
```
### [J](http://jsoftware.com/), 30 bytes
```
0.5<.@+(%:5)%~(-:>:%:5)#.,&0 0
```
[Try it online!](https://tio.run/##fZFNTsMwEIX3OcUIK42NzcR2EkpHLbI4ABeoCgsEQmxYRyG5erBJosRpqazxz7zvjcfyV3@DkH3AgTJQ0BJo8NFrrPboJE@pEmnH7@iRwpah2mgviyR5fkIINriOzlwBlMm8vuWqMwxt43UjXojvidXCZBdAo7qT9FOL/3INBvIHucxVM2CBgiXXouOSNViwkSDHhOO@PREXW4O@Uq30opJluGZerWQiImTueIuK7GUiXFQz7HzPRqZTx3ZxixePNMruFADH3FFsbJK8v31@g4GDB81wuB8O/tv0lNoWy9wY4Sv@1IfdQo3GqJeFXfnnEefM5NnaoqxmlzlznK86JseX6V1ZRWWuRv8L "J – Try It Online")
This one took the most effort to build. Uses the closed-form expression with rounding trick. In the expression, 0th and 1st values are 0 and 1 respectively, so the actual digit power must start with 2.
```
0.5<.@+(%:5)%~(-:>:%:5)#.,&0 0  Tacit verb.
                         ,&0 0  Add two zeroes at the end
              (-:>:%:5)#.       Convert to a number using base phi (golden ratio)
       (%:5)%~                  Divide by sqrt(5)
0.5<.@+                         Round to nearest integer
```
While the error (`((1-sqrt(5))/2)^n` terms) may build up, it never exceeds 0.5, so the rounding trick works up to infinity. Mathematically:
\$ \max(|error|) = \frac{1}{\sqrt{5}} \sum\limits\_{1}^{\infty} (\frac{1-\sqrt{5}}{2})^{2n} = \frac{1}{\sqrt{5}} \sum\limits\_{0}^{\infty} (\frac{1-\sqrt{5}}{2})^{n} = \frac{\sqrt{5}-1}{2\sqrt{5}} < \frac{1}{2} \$
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~8~~ 6 bytes
```
{î)f*+
```
[Try it online!](https://tio.run/##y00syUjPz0n7/7/68DrNNC3t//@jDXUMgNAwlivaAMKCYmQxZAgRNdRBqEbwUMSA6vDIInhIthiiqDbEQcNVxgIA "MathGolf – Try It Online")
## Explanation
```
{        Start block (foreach in this case)
 î)      Push loop index (1-based) and increment by 1
   f     Get fibonacci number of that index
    *    Multiply with the array value (0 or 1)
     +   Add top two elements of stack. This implicitly pops the loop index the first iteration, which makes the addition become 0+a, where a is the top of the stack.
```
Saved 1 byte thanks to JoKing, and another byte thanks to LSB ordering.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~11~~ ~~9~~ 8 bytes
```
vyiNÌÅfO
```
[Try it online!](https://tio.run/##yy9OTMpM/f@/rDLT73DP4dY0////DYDAEAjBFAKDBQE "05AB1E – Try It Online")
Explanation:
```
v             : For each character in input string (implicit) in LSB order
  yi          : If the current character is truthy (1)
    NÌ        : Add 2 to the current index
       ÅfO    : Add the fibonacci of this number to the stack
```
* *-2 bytes*: Thanks to @KevinCruijssen for pointing out small ways to shorten this code!
* *-1 byte*: Thanks to @JonathanAllan for pointing out LSB order for input!
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 23 bytes
```
0?
;
+`1;(1*);
;1$1;1
1
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w38Cey5pLO8HQWsNQS9Oay9pQxdDakMvw/39DAwMgDSSA0MAAxIICiCAYQFmGBgA "Retina 0.8.2 – Try It Online") Link includes the faster test cases. Explanation:
```
0?
;
```
Insert separators everywhere and delete any zeros. For example, `1001` becomes `;1;;;1;`.
```
+`1;(1*);
;1$1;1
```
Repeatedly replace each `1` with a `1` in each of the next two places, as the sum of their values equals the value of the original `1`. `1`s therefore migrate and accumulate until they reach the last two places, which (due to the newly added separator) now both have value `1`.
```
1
```
Count the `1`s.
[Answer]
# [Python 3](https://docs.python.org/3/), 63 bytes
```
a=b=n=1
for i in input()[::-1]:n+=b*int(i);a,b=b,a+b
print(n-1)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9E2yTbP1pArLb9IIVMhMw@ICkpLNDSjrax0DWOt8rRtk7Qy80o0MjWtE3WSbJN0ErWTuAqKQEJ5uoaa//8bGhgAEQhAWYYGAA "Python 3 – Try It Online")
Takes input through STDIN as a string.
[Answer]
# [Red](http://www.red-lang.org), 142, 126 106 bytes
```
func[a][b: copy[1 1]reverse a s: 0 n: 1
until[s: b/1 * a/:n + s insert b b/1 + b/2(n: n + 1)> length? a]s]
```
[Try it online!](https://tio.run/##bY3BCsIwDIbve4r/qO6w1WMP@g5eSw7dFmthxNF2gk9fowiiyEcS8v2BJJ7qiSdHTbD1vMroPLnBYrwud2dgKPGNU2Z4ZIseYmGaVUqcne5DZ7CD76ygRUaUzKlgePlW@36j98/MbA@YWUK5HOEpU11SlIIA/dErhppf8y7lb/bh2@mk@gA "Red – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 39 bytes
```
->n{a,b=0,1;n.digits.sum{|x|x*b=a+a=b}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOlEnydZAx9A6Ty8lMz2zpFivuDS3uqaipkIryTZRO9E2qbb2f7ShgYGhDogAQgMDEAsKIIJgAGUZgsQMYSJwDNVqEKuXm1gAMr9AIbpCJy26Ija29j8A "Ruby – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 6 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
çéC◘0â
```
[Run and debug it](https://staxlang.xyz/#p=878243083083&i=[0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1])
```
:1F^|5+           #Full program, unpacked, implicit input as array    
:1                #Get indicies of truthy
  F               #Use rest of program to loop through elements
   ^              #Increment current element
    |5+           #Get n-th fib and Add
```
Pretty straight forward. LSB Ordering. 
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 40 bytes
```
([]){{}([({}<>{})]({}{}))<>([])}<>({}{})
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fIzpWs7q6ViNao7rWxq66VjMWyABSmjZ2ICmgGIT///9/w/8GQGgIxUAIAA "Brain-Flak (BrainHack) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 63 bytes
Takes input as an array of `1`'s and `0`'s, along with the length of the array. This solution is a rather straight-forward backwards loop.
```
f(_,l,a,b,t)int*_;{a=b=1;for(t=0;l--;b=(a+=b)-b)t+=a*_[l];_=t;}
```
[Try it online!](https://tio.run/##ZZBRS8MwFIWf219RMoRkS6FZq3YLQfqgIA4E59s2SpImo1DraAMKpX/dmuLQxnEIuXzn3EOIDI9SDoOGOa4wxwIbVNZmntOOM8EI1e8NNCyiVRhSwSBfMIFCgcyC8Xm@qw40Z4b2w6xQuqxVkG239y@vUH2eUHBqbJOGIGtb1Zjgql3vDZhZC@xrgAM73IHnJ7AGD9njBiD/jZc1REHne3Yv4LuDxzqCIyvSY98TU3A@VqMlJ5aj0Sz@7f3JZeQnrn7j5CJ6eTtPsQXU985foCHHCWLsBk2ZwCvLbmMHSkwiS9OVQwtMxmyaxEuHK7xMx45lnFyPTj98SV3xYzuEH98 "C (gcc) – Try It Online")
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), 74 bytes
```
\D-->[X,Y],{D is 2*X+Y};[D];a,\D.
a,[A],[B]-->[X,Y,Z],{A is X+Y,B is X+Z}.
```
[Try it online!](https://tio.run/##KyjKz8lP1y0uz/z/P8ZFV9cuOkInMlan2kUhs1jBSCtCO7LWOtol1jpRJ8ZFjytRJ9oxVifaKRaqUCcKqNQRpBSoUMcJwoiq1fv/vyCjKLE4VSMmQifaUMdAB4hjNfW4uAA "Prolog (SWI) – Try It Online")
Takes input as a list of integers 1 and 0 with the most significant bit first.
[Answer]
# Japt `-x`, 9 bytes
```
Ë*MgUÊa´E
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=yypNZ1XKYbRF&input=WzEsMCwxLDAsMSwwLDAsMSwwLDEsMF0KLXg=)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 41 bytes
A port of [xnor's answer](https://codegolf.stackexchange.com/a/173603/58563). Takes input as a BigInt literal.
```
f=(n,a=1n,b=a)=>n&&n%10n*b+f(n/10n,b,a+b)
```
[Try it online!](https://tio.run/##dc5NDsIgEAXgvafoxgYsCgP1b4F3gVpMTTMYa7w@0gZNDO2bTPI2X2bu5m2G5tk9Xlv01zYEpwkyowGZ1YbqC5YlrkHgxlaOII@NWWYqS0PjcfB9u@v9jTgCQgBSWiyF8@KwykkcIRZcJEeVm5R5FM3pPHdnSmrwj0dTK5kp@Jrfpn8nPn4nVb2X4QM "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 44 bytes
Takes input as an array of characters, in LSB-first order.
```
s=>s.map(k=>t+=k*(z=x,x=y,y+=z),x=t=0,y=1)|t
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1q5YLzexQCPb1q5E2zZbS6PKtkKnwrZSp1LbtkoTyCqxNdCptDXUrCn5n5yfV5yfk6qXk5@ukaYRraenp2RoYGCoFKupqYAL6OsrmHFh0WgA1GiATzdQo7kxDp0QgEsrUKeFJVadhmBbwRSUhWoESKeJsREuWw0hOg2RMFgQbAjIvUbGJqZG/wE "JavaScript (Node.js) – Try It Online")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 8 bytes
```
;r⌐@░♂FΣ
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9@66FHPBIdH0yY@mtnkdm7x//@GOgZACCFhEFUMSAMA "Actually – Try It Online")
Input is taken as a list of bits in LSB-first order.
Explanation:
```
;r⌐@░♂FΣ
;r        range(0, len(input))
  ⌐       add 2 to every element in range (range(2, len(input)+2))
   @░     filter: take values in range that correspond to 1s in input
     ♂F   Fibonacci number at index of each element in list (Actually uses the F(0)=F(1)=1 definition, which is why we needed to add 2 earlier)
       Σ  sum
```
[Answer]
# Powershell, 68 bytes
```
param($s)$b=1
$s[$s.Length..0]|%{$a,$b=$b,($a+$b)
$x+=($_-48)*$b}
$x
```
Test script:
```
$f = {
param($s)$b=1
$s[$s.Length..0]|%{$a,$b=$b,($a+$b)
$x+=($_-48)*$b}
$x
}
@(
    ,("1001", 6)
    ,("100101000", 73)
    ,("1000000000", 89)
    ,("1001000000100100010", 8432)
    ,("1010000010001000100001010000", 723452)
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $r"
}
```
Output:
```
True: 6
True: 73
True: 89
True: 8432
True: 723452
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 65 bytes
Pretty small for a Java answer to I'm happy with that. Takes input as a LSB-first ordered array of ints.
```
d->{int s=0,f=1,h=1;for(int i:d){s+=i>0?f:0;f=h+(h=f);}return s;}
```
[Try it online!](https://tio.run/##nVKxboMwEJ3LV5wyGRGQkTpUpaRqpW5tlnSLMrhgglNiI9skqSK@nR6YIFXtkhphjN@7e8933rEDC1XN5S7/7LKKGQNvTMizB1A3H5XIwFhm8SOk5bpgGYdlD04w7oMkOK83kPsJQq2H0xi1BAkpdHm4OPdEk9J5kcbzMo2TQuk@DMR97p9NkIoFfSzuaVKkZUDKtPCTVnPbaAkmabvE@@XooEQOezRLVlYLuUUDzAdbanU08HLKeG2Fks7s6stYvo9UY6MaubaSREaSZEoeuLbv6nX1TGYxpfHM94dDXBGCD6XXx43jP4LDGFfx9RniS/z0joeYUrXeX/3HAv9I5cqOSN1YH1yh@45WXG5tiX0fkMj9ktGjy6M5pjE8R5Lkx2HT0TaONV0OJNAExINDcRUEFyknJmTOT8gaRUMgIohHLZh01gNtM3nKSqafLBF@eHvnuK3n@MONu4QNtbjx2u4b "Java (OpenJDK 8) – Try It Online")
**Ungolfed**
```
d->{                        // Lambda function that takes array of ints
    int s=0,f=1,h=1;        // Initialise sum and fibonacci vars
    for(int i:d){           // Loop through each input integer
        s+=i>0?f:0;         // If it's 1 add current fibonacci number to sum
        f=h+(h=f);          // Increase fibonacci number 
    }return s;              // return sum
}
```
[Answer]
# [Z80Golf](https://github.com/lynn/z80golf), 34 bytes
```
00000000: dde1 f1b7 2819 fe30 2812 4504 aff5 3cf5  ....(..0(.E...<.
00000010: d1f1 82d5 f510 f9c1 f17c 8067 2c18 e3dd  .........|.g,...
00000020: e5c9                                     ..
```
[Example with input 1001-Try it online!](https://tio.run/##bZFfT8IwFMWf2ac44WWYkOZ2g22gkmjim8YHP8HoH7ZYNsI6FcJ3xztG0Ij3oT29uefXk3af0ap29nikc80RGyLYaWwQSzvlY9wdeyVZKQ2Z8ggWQiykWNBp4wp6gmRGqlSCmHiUKCOkidYw0kos0yiDnFmGEyscBNvFR2cfCUGjMyNihowmU9Akt10YxYvm22UWQXdhJNkZVIeEeGL3nbjUmRGfcvDtSRopyMzE0NpMoWa4roNYjU/m4/Ghacx66Xaw9Ra2rZQv6woqd26O0WvrN61HU9St01gahEl4E7DMx6DB4BZV6xy82a7LKvf1Nti0TYHcnkdCGfLMy9vj3z6Fl85/judfji4J9ka9c/@kfWF@cn6WvkBZccj7oeTPGApcZU56dhHk/C30FVPPzPjRCobqstm4fIetaVrngyJ3/hs "Z80Golf – Try It Online")
[Example with input 100101000-Try it online!](https://tio.run/##fVPRbtowFH2Ov@IIaYJKkWUTIIGtSKXrG9Me9gGVYztNupBEIalatH9n107oKibVD/b19Tnn3nMJp0Q81WV2PotxbaCybInIRhLZMrKIBF2HSA4PYriC863kW3E5tmxQkKTxEerp2iBKhECspQWBaFNiBQwCnCf8jzv4qDEnDSHW0pEiiIVMkKlEQq@8ZJxA6jTGXFjj@kg8lwv@yjkuGhFpLKKMSIYKJ9QXacQrGGPJmnT0RK6RuS5xPyi8uG1GSqPGgjQINcdiKRbjZDRtRpJuMjfOmtNdawnM@AOxv/HLGjWWpJHJWFMLK6qpyYuNjIFd6jWuF43hKfTs8/nueLSHtHxDVrfI@kp3RV1Bq7LcYPaz75q@wzGv@9IgtZjE0eSGvRJUBcFXqFsRourLEp1tD0WlurplTX/MyQUjhgoxlVMC/vi1u86L6XvmP8Yn2E8wVGf/oc716TzhZPVvwhUV@bqdSPch0SYmg0rOiq5Wj01bVN2GYD5Al1syeUhti6rQtnxjAaFtCMECjy/rutn4pA4hKfu9eCmMpVSwN9iFQ2Y/oIJjn@IuvKfouSUCvTxUhm5FpbEbsiPa0@jRsZRxDWrmg0jkfvwUkm90NdQXV/diNRhmkjIvalngfjDmlKtTiPeePS4NHcA7vRgJmrrxMoGfGf2lRE4X81yd8A/IclV2fwE "Z80Golf – Try It Online")
Assembly:
```
zeck:		; input=push on stack in MSB order (eg top is LSB) output=reg h
pop ix		; save return addr in ix
f:
pop af		; get next digit
or a
jr z, return	; if current digit==0, return
cp 0x30
jr z, skip	; if current digit=='0' (e.g. not '1'), skip loop
ld b, l		; find fib of counter
fib:
	inc b	; 1-indexing for func to work
	xor a	; set a to 0 (1st fibo num)
	push af
	inc a	; set a to 1 (2nd fibo num)
	push af
	fib_loop:
		pop de
		pop af
		add d
		push de
		push af
		djnz fib_loop
pop bc		; get the fibo num just calculated
pop af		; pop just to reset stack frame
ld a, h
add b		; add current fibo number to sum
ld h, a
skip:
inc l		; increment counter reg
jr f		; repeat loop
return:
push ix		; push the return addr to ret to it
ret
```
]