[Question]
  [
I noticed that my car's odometer was at 101101 when I got to work today. Which is a cool number because it's binary (and a palindrome, but that's not important). Now, I want to know when the next time I'll have a binary odometer reading. I can't read the odometer while I'm driving, because that would be dangerous, so it'll have to be binary either when I get to work or get home. 
There's really bad traffic on the way to and from my office, so I have to take a different route each day.
For the purposes of this challenge, a day is a round trip and starts with my commute to work. 
You'll need to take the initial reading of the odometer and a 10 element sequence representing the amount of miles each way. This sequence should be repeated until you get to a binary odometer reading. You should then output the number of days it takes until we get to a binary reading.
Both the milage for the route and the odometer reading will be positive integers. The count of days will either be `x` or `x.5`, so your output of the day count needs to support floating point for half days. If the day count is an integer, you don't need to output the `.0`. The odometer will always eventually reach a binary state.
Any form of input/output is acceptable and [standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default?lq=1) are disallowed.
Test cases:
```
101101, [27, 27, 27, 27, 27, 27, 27, 27, 27, 27] == 165.0
1, [13, 25, 3, 4, 10, 8, 92, 3, 3, 100] == 22.5
2, [2, 3, 1, 2, 7, 6, 10, 92, 3, 7] == 2.0
```
  
[Answer]
# Javascript, ~~68~~ ~~63~~ ~~61~~ ~~60~~ 52 bytes
5 bytes off thanks [@ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions). ~~2~~ ~~3~~ 11!! bytes off thanks [@NotthatCharles](https://codegolf.stackexchange.com/users/13950/not-that-charles).
```
f=(i,a,m=0)=>/[^01]/.test(i+=a[m++%10])?f(i,a,m):m/2
```
[Test here.](http://vihan.org/p/esfiddle/?code=f%3D(i%2Ca%2Cm%3D0)%3D%3E%2F%5B%5E01%5D%2F.test(i%2B%3Da%5Bm%2B%2B%2510%5D)%3Ff(i%2Ca%2Cm)%3Am%2F2%0A%0A%0AF%3D(i%2Ca)%3D%3Ealert(f(i%2Ca))%0A%0AF(101101%2C%5B27%2C27%2C27%2C27%2C27%2C27%2C27%2C27%2C27%2C27%5D)%0AF(1%2C%5B13%2C25%2C3%2C4%2C10%2C8%2C92%2C3%2C3%2C100%5D)%0AF(2%2C%5B2%2C3%2C1%2C2%2C7%2C6%2C10%2C92%2C3%2C7%5D))
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), ~~29~~ ~~26~~ 25 bytes
```
`tvyyYs+V50<!A~]xx1Mf1)2/
```
Input format is 
```
[27; 27; 27; 27; 27; 27; 27; 27; 27; 27]
101101
```
*EDIT (June 10, 2016): The following link replaces `v` by `&v` (**26 bytes**) to adapt to changes in the language*
[**Try it online!**](http://matl.tryitonline.net/#code=YHQmdnl5WXMrVjUwPCFBfl14eDFNZjEpMi8&input=WzI3OyAyNzsgMjc7IDI3OyAyNzsgMjc7IDI3OyAyNzsgMjc7IDI3XQoxMDExMDEK)
```
`              ]           % do---while loop. Exit loop when top of stack is falsy
 t                         % duplicate. Takes first input (array) first time
  v                        % concat vertically (doubles length of array)
   yy                      % copy top two. Takes second input (todasy's value) first time
     Ys                    % cumulative sum of (repeated) miles each way
       +                   % add to today's value
        V                  % convert each number to a string
         50<!A             % true for strings than only contain '01 ' (ASCII less than 50)
              ~            % negate. This is the loop condition
                xx         % delete stack contents
                  1M       % push again array that tells which strings only contain '01 '
                    f1)    % pick index of first true entry
                       2/  % divide by 2
```
[Answer]
# Jelly, ~~22~~ ~~17~~ 16 bytes
```
RịS+³DṀ=1
Ṡç1#SH
```
[Try it online!](http://jelly.tryitonline.net/#code=UuG7i1MrwrNE4bmAPTEK4bmgw6cxI1NI&input=&args=MQ+WzEzLCAyNSwgMywgNCwgMTAsIDgsIDkyLCAzLCAzLCAxMDBd)
### How it works
```
Ṡç1#SH     Main link. Left input: n (initial reading). Right input: A (distances)
Ṡ          Compute the sign of n. Since n is positive, this returns 1.
 ç         Apply the helper link to 1, 2, 3, ... until...
  1#         one match is found. Return the match in an array.
    S      Compute the sum of the array. This yields the match.
     H     Halve the result.
RịS+³DṀ=1  Helper link. Left argument: k (integer). Right argument: A (distances)
R          Range; yield [1, ..., k].
 ị         Retrieve the elements of A at those indices.
           Indexing in modular in Jelly.
  S        Compute the sum of the retrieved distances.
   +³      Add n (left input) to the sum.
     D     Convert the sum to base 10.
      Ṁ    Get the maximum digit.
       =1  Compare it with 1.
```
[Answer]
## Lua, 108 Bytes
First time using the repeat..until loop in a codegolf!
```
function f(o,t)i=0repeat i,o=i+1,(o+t[i%#t+1]).."."o=o:sub(1,o:find("%.")-1)until tonumber(o,2)print(i/2)end
```
### Ungolfed
```
function f(o,t)               -- o can either be a number or a string, t is a table
                              -- call it like f(2,{27,14,5...})
  i=0                         -- initialise the travel count
  repeat                      -- proceed like a do..while in C
    i,o=i+1,(o+t[i%#t+1]).."."-- increment i, and add t[i] to the odometer
    o=o:sub(1,o:find("%.")-1) -- remove the decimal part of the odometer
  until tonumber(o,2)         -- tries to convert o from binary to decimal
                              -- return nil (and repeat the loop) if it can't
  print(i/2)                  -- print i/2 which is the number of days for i travels
end
```
After the first loop, `o` will have a decimal part because of `tonumber`, I had to remove it... And to add it for the first case, that's why I concatenate it with a `"."`.
[Answer]
# Java, 112 ~~miles~~ bytes
```
float c(int r,int[]d){float y=0;for(int i=0;;i%=d.length){y+=.5;r+=d[i++];if((""+r).matches("[01]+"))return y;}}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 31 bytes
Code:
```
0IE\[²vs>sy+D§'aT«-""Qi\2/?}Ž}Ž
```
~~Somehow, the code doesn't stop running (and I can't figure out why)~~. Apparently I forgot that there are three loops going on instead of 2. So it would still get into an infinite loop...
[Try it online!](http://05ab1e.tryitonline.net/#code=MElFXFvCsnZzPnN5K0TCpydhVMKrLSIiUWlcMi8_fcW9fcW9&input=MQpbMTMsIDI1LCAzLCA0LCAxMCwgOCwgOTIsIDMsIDMsIDEwMF0)
[Answer]
## PowerShell, ~~84~~ ~~73~~ ~~67~~ ~~59~~ 57 bytes
```
param($a,$b)do{$a+=$b[$i++%10]}until(!+($a-replace1))$i/2
```
Takes input `$a` and `$b`, expecting `$b` to be an explicit array of mileages (e.g., `.\binary-car.ps1 1 @(13,25,3,4,10,8,92,3,3,100)`). We then enter a `do`/`until` loop. Each iteration, we increment `$a` with the mileage in `$b` at position `$i++ % 10` so that we continually loop through the array. This will start at zero since for the first loop the `$i` is not initialized, and so evaluates to `$null`, which equates to `0` in this context, and it's only *after* that evaluation that the `++` occurs.
Then, the `until` statement checks if our number is only `0` and `1` by first `-replace`ing all `1` with nothing, casting that back as an integer with `+`, and then taking the Boolean-not with `!`. If it evaluates true, we'll finish the loop, output `$i / 2`, and terminate the program.
**Explanation for the loop conditional --** In PowerShell, any non-zero integer is `$true`, and any non-empty string is also `$true`. For example, `231145` (an integer) will change to `"2345"` (a string) after the `-replace`, which will integer-cast as `2345` (an integer), the `!` of which is `$false`. However, `101101` (an integer) will change to `"00"` (a string) which will cast as `0` (an integer), the `!` of which is `$true`. If we didn't have the `+`, the `"00"` will `!` to `$false` since it's a non-empty string.
Edit - Saved 11 bytes by swapping equality-on-length for strictly-zero  
Edit 2 -- Saved another 6 bytes by realizing that `$b.count` will always be `10` ...  
Edit 3 -- Saved another 8 bytes by using do/until instead of for  
Edit 4 -- If the object being `-replace`d is an integer value, don't need quotes, saving another 2 bytes
[Answer]
# Ruby, 58
Nothing special. Just a cycle...
```
->s,a,i=0{a.cycle{|e|i+=0.5;break i if/[2-9]/!~'%d'%s+=e}}
```
[Answer]
# Mathematica, 92 bytes
```
(y=1;x=#+#2[[1]];While[!StringMatchQ[ToString@x,{"0","1"}..],x+=#2[[y++~Mod~10+1]]];N@y/2)&
```
Yep.
Input is the odometer and a list of times. Output is the day count.
[Answer]
# PHP, ~~102~~ 98
```
function f($i,$s){while(1)foreach($s as$v){$d+=.5;$i+=$v;if(preg_match('/^[01]+$/',$i))return$d;}}
```
Ungolfed Version
```
function f($i,$s) {
    $d = 0;
    while(true) {
        foreach($s as $v) {
            $d += 0.5;
            $i+=$v;
            if(preg_match('/^[0|1]+$/', $i)) {
                return $d;
            }
        }
    }
}
```
PHP Notices can be removed of extra cost of 4 characters `$d = 0;` in golfed version.
Example
```
$i = 101101;
$s = [27, 27, 27, 27, 27, 27, 27, 27, 27, 27];
f($i,$s);
```
[Answer]
# Pyth, ~~36~~ ~~32~~ 30 bytes
```
Jvz.V0=J+J@QbI<ssM{`J2KbB;chK2
```
[Try it here!](http://pyth.herokuapp.com/?code=Jvz.V0%3DJ%2BJ%40QbI%3CssM%7B%60J2KbB%3BchK2&input=1%0A%5B13%2C+25%2C+3%2C+4%2C+10%2C+8%2C+92%2C+3%2C+3%2C+100%5D&test_suite=1&test_suite_input=101101%0A%5B27%2C+27%2C+27%2C+27%2C+27%2C+27%2C+27%2C+27%2C+27%2C+27%5D%0A1%0A%5B13%2C+25%2C+3%2C+4%2C+10%2C+8%2C+92%2C+3%2C+3%2C+100%5D%0A2%0A%5B2%2C+3%2C+1%2C+2%2C+7%2C+6%2C+10%2C+92%2C+3%2C+7%5D&debug=0&input_size=2)
### Explanation
```
Jvz.V0=J+J@QbI<ssM{`J2KbB;chK2  # Q = input sequence
Jvz                             # assign starting value to J
   .V0                          # Start an infinite loop iterating over b starting at 0
      =J                        # Set J to
        +J                      # the sum of J
          @Qb                   # and the value at Q[b % len(q)]
             I                  # if
              <      2          # lower than 2
                  {`J           # Remove duplicate digits from J 
               ssM              # Map the remaning digits back to integers and sum them
                      KbB       # if the above evals to true, save b to K and leave the loop
                         ;      # End loop body
                           hK   # Increment K because we missed one loop increment
                          c  2  # and divide it by 2 to get the days
                       
```
[Answer]
# C Sharp, 180.
Dear lord C# is long.
```
using System.Text.RegularExpressions;class a{double c(int a,int[]b){var d=0.5;a+=b[0];var i=1;while(!Regex.IsMatch(a.ToString(),"^[01]+$")){a+=b[i];i+=1;i=i%10;d+=0.5;}return d;}}
```
]