text:
Where are Champernowne's zeroes?
Consider the infinite string of all nonnegative decimal integers concatenated together in order (akin to Champernowne's constant):
0123456789101112131415161718192021222324252627282930...979899100101102103...

Write a program or function that takes in a nonnegative integer that indexes (0-based) into this infinite string. Output a truthy value if the digit indexed is 0, otherwise output a falsy value if the digit is 1-9.
The shortest code in bytes wins.
The first 25 truthy-producing inputs are:
0
11
31
51
71
91
111
131
151
171
191
192
194
197
200
203
206
209
212
215
218
222
252
282
312

Kudos if your program is memory effecient, but this is not a requirement.

https://oeis.org/A031287

is it not better that program or that function return the digit of that array from its index [not only if that is 0 or not]?

Related: Row of natural numbers

I can't understand what this question is asking at all lol can someone explain it

Can we return an infinite sequence of truthy indices?

Haskell, 25 bytes
(<'1').((show=<<[0..])!!)

Usage example: (<'1').((show=<<[0..])!!)  312 -> True

05AB1E, 5 bytes
Code:
ÝJ¹è_

Explanation:
Ý      # Get the list [0 .. input].
 J     # Join the list.
  ¹    # Get the first input again.
   è   # Get the character on that index.
    _  # Logical negate (0 -> 1, everything else -> 0).

Uses the CP-1252 encoding. Try it online!

Mathematica, 42 40 bytes
(0@@Join@@IntegerDigits@Range@#)[[#]]<1&

Anonymous function. Takes a number as input and returns either True or False as output. A longer, yet more efficient(?) solution:
RealDigits[ChampernowneNumber[],10,1,-#][[1,1]]<1&

CJam, 9 bytes
{_),s=~!}

This is an unnamed block (function) which takes in an integer and returns 0 or 1 accordingly.
Explanation:
{       }        Defines a block
 _               Copy input n
  ),             Increment n and take range
    s            Convert to string - for a list of numbers this concatenates
                 the digits
     =           Index, getting nth digit
      ~          Evaluate the digit character into a number
       !         Logical negation

Online interpreter. Note that ~ evaluates a block. Alternative, you can run this test suite which uses , to filter the first 1000 numbers for truthy values.

Jelly, 6 bytes
RDF⁸ị¬

Try it online! or verify all test cases.
How it works
RDF⁸ị¬  Main link. Argument: n

R       Range; yield [1, ..., n].
 D      Decimal; convert all integers in that range to base 10 arrays.
  F     Flatten the result.
   ⁸ị   Extract the digit at index n (1-based).
        This returns 0 if the array is empty (n = 0).
     ¬  Logical NOT; return 1 if the digit is 0, 0 if not.

MATL, 11 bytes
Qt:qVXzw)U~

Try it Online!
Explanation:
    % Implicitly grab input as an integer (N)
Qt  % Add 1 and duplicate
:q  % Create an array from [0 ... N]
V   % Convert each entry to a string (places spaces between each number)
Xz  % Remove all whitespace
w)  % Get the N+1 element of the string (since MATL uses 1-based indexing natively)
U~  % Convert the result back to a number and negate which yields TRUE if it was '0' and
    % FALSE otherwise

Brachylog, 10 8 bytes
2 bytes thanks to Fatalize.
y@ec:?m0

Try it online!
y@ec:?m0

y         range from 0 to Input, inclusive,
 @e       the digits of every number in that range,
   c      concatenated
    :?m   the Input-th digit
       0  is zero.

@e vectorizes so y@ec:?m0 works, to save 2 bytes.

@Fatalize How many other operators vectorize?

Only #0, #1, #+, #_, #> and #< vectorize like @e does. Some of the predicates that vectorize such as + or * don't vectorize recursively to the lowest list level, and don't perform the same thing depending on the structure of the input.

Perl 6, 26 25 bytes
{!+map(|*.comb,0..*)[$_]}

A lambda that takes a number as input and returns a True or False.
Memory-efficient.
How it works

0..* – Construct the range from 0 to infinity.
map(|*.comb,  ) – Lazily iterate the range, replacing each number with the characters of its string representation, and returning a new lazy sequence. The | keeps the new sequence flattened.
[$_] – Take the element at the index defined by the (implicitly declared) lambda parameter $_.
+ – Coerce it to a number. (This step is needed because coercing a string directly to a boolean always gives True unless the string is empty.)
! – Coerce it to a boolean and negate it.

(try it online)
EDIT: -1 byte thanks to b2gills.

You can shorten yours to {!+map(|*.comb,0..*)[$_]} I came up with {!+({|($++).comb}...*)[$_]} before looking to see if there was already a P6 answer. !+ can be replaced by 1>

Python 3.5, 40 bytes
lambda n:('%d'*-~n%(*range(n),n))[n]<'1'

Test it on repl.it.
How it works
For input n, '%d'*-~n repeats the format string n + 1 times.
(*range(n),n) unpacks the range [0, ..., n - 1] and yields the tuple (0, ..., n).
...%... replaces each occurrence of %d with the corresponding integer in the range, yielding the string 01234567891011...n.
(...)[n]<'1' selects the character at index n and tests if it is less than the character 1.

Python 3, 44 bytes
lambda n:''.join(map(str,range(n+1)))[n]<'1'

An anonymous function that takes input via argument and returns True or False as appropriate.
How it works
lambda n      Anonymous function with input n
range(n+1)    Yield the range [0, n]...
map(str,...)  ...convert all elements to string...
''.join(..)   ...concatenate...
...[n]        ...yield nth character...
:...<'1'      ...return True if int(character)==0 else return False

Try it on Ideone

Pyth, 8 7 bytes
Thanks to @LeakyNun for -1 byte
!s@jkUh

This is my first attempt at golfing in Pyth.
A full program that prints True or False as appropriate.
Try it online
First 25 truthy inputs
How it works
!s@jkUh    Program. Input: Q
      hQ   Head. Yield Q+1
     U     Unary range. Yield [0, Q]
   jk      Join. Join on empty string
  @     Q  Index. Yield string[Q]
 s         Integer. Convert to integer
!          Logical negation. 0 -> True, all other digits -> False
           Print. Print result implicitly

S.I.L.O.S, 141 bytes
readIO
i+1
lblL
c=C
p=1
lblc
p*10
c/10
if c c
p/10
lbln
m=C
m/p
m%10
p/10
i-1
if i C
GOTO H
lblC
if p n
C+1
GOTO L
lblH
m/m
m-1
m|
printInt m

Try it online!
Uses only 5 integers, maximum memory efficiency \o/
Explanation
We generate as many digits as the input in the Champernowne's constant.
In the main loop, we do the following:

Find the length of the current number by floor_dividing it by 10 repeatedly until it reaches 0, and then count the number of divisions used.
Instead of storing the number of divisions, we store 10 to that number power instead.
Iterate through each digit as such: the 100s digit of 1234 is obtained by (1234/10)%10 where / is floor division.
For each digit generated, take 1 from the input, while checking if the input reached zero.
If the input reaches zero, check if the current digit is 0 and then halts.

JavaScript (ES6), 45 bytes + Kudos
f=(n,s='0')=>s[n]?!+s[n]:f(n-s.length,-~s+'')

My best non-Kudos version was 34 bytes:
n=>!+(g=s=>s[n]||g(s+i++))('',i=0)

I thought kudos was a library until I realized there was a kudos on the challenge :P

JavaScript (ES6), 47 bytes
n=>[...Array(n+1)].reduce((a,_,i)=>a+i,'')[n]<1

Javascript (ES6), 42 33 bytes
n=>!+(r=i=>i>n?'':i+r(i+1))(0)[n]

Example:

let f =
n=>!+(r=i=>i>n?'':i+r(i+1))(0)[n]

// test all integers in [0, 312]
for(var n = 0, list = []; n <= 312; n++) {
  f(n) && list.push(n);
}
console.log(list.join(','));

Groovy, 56 bytes
def f(n){def s=''<<'';(0..n).each{s<<it};!(s[n] as int)}

Nothing fancy, but I'm trying out some new things.
def f(n) {
  def s = ''<<''           // declare a StringBuffer
  (0..n).each { s << it }
  !(s[n] as int)           // Groovy considers a non-null char truthy, so we have to cast
}

Perl, 24  bytes
Includes +1 for -p
Run with input on STDIN:
zero.pl <<< 31

print 1 for zero, nothing otherwise
zero.pl
$_=!(map/./g,0..$_)[$_]

zsh, 31 bytes
exit ${${(j..):-{0..$1}}[$1+1]}

exit 0 is true in zsh

Ruby, 35 23 bytes
This is an anonymous function that concatenates [0..n], takes the nth index and checks if that char is "0" (less than "1"). Golfing suggestions welcome.
->n{([*0..n]*'')[n]<?1}

Ungolfing
->n{...}   # Create an anonymous function with parameter n.
[*0..n]    # Create an array of the range [0..n].
[...]*''   # Join the array using the empty string.
(...)[n]   # Take the char at the n-th index of the string.
<?1        # Check if the char is < "1" (that is, "0").

PHP, 36 bytes
<?=!join(range(0,$a=$argv[1]))[$a];

Print 1 if Champernowne argument-th decimal is 0, else print '' (empty string).

R, 61 57 bytes
Thanks to @plannapus for 4 bytes.
n=scan();strsplit(paste(0:n,collapse=""),"")[[1]][n+1]==0

Creates a vector of numbers 0:n (for 0 indexing), creates a string of them, pulls the nth value from string (adjusting for 0 indexing). Converts to numeric and tests if it is 0.

Bash, 31 28 bytes
seq -s "" 0 $1|egrep ^.{$1}0

Output is non-empty (truthy) or empty (falsy). Test it on Ideone.

Julia, 21 20 bytes
!n=join(0:n)[n+1]<49

Thanks to @LuisMendo for golfing off 1 byte!
Try it online!

APL (Dyalog Unicode), 14 bytes
{~×⍎⍵⊃∊⍕¨⍳1+⍵}

Try it online!
Explanation
{~×⍎⍵⊃∊⍕¨⍳1+⍵}     ⍝
{            }     ⍝ A dfn, in this case with a single argument (⍵)
         ⍳1+⍵      ⍝ Computes the range of 0..arg
       ⍕¨          ⍝ For each (¨), convert to a string (⍕)
      ∊            ⍝ Enlist all strings into a single string
    ⍵⊃             ⍝ Pick (⊃) the element at the index of the given arg (⍵)
   ⍎               ⍝ 'Execute' to treat it as a numeric
  ×                ⍝ Turn >1 into 1
 ~                 ⍝ Negate

Vyxal, 38 bitsv2, 4.75 bytes
ʀṅi0=

Try it Online!

GolfScript, 12 bytes
~.),""*\=48=

Explanation:
~             Evaluate the input.
 .            Duplicate it
  )           Increment the duplicate.
   ,          Create an array from 0 to it.
    ""*       Join it with an empty string.
       \=     Get the n-th index of this string, where n is the input
         48=  Is it equal to 0?

Try it online or verify all test cases!

Javascript (ES5): 61 60 bytes
function(b){for(s="";s.length<b;)s+=s.length;return 0==s[b]}

Ungolfed:
function a(b){
  for(var s="";s.length<b;)
    s+=s.length;
  }
  return (s[b]==0);
}

Old:
function(n){s="";while(s.length<n)s+=s.length;return s[n]==0}

Ungolfed old:
function a(n){
  var str="";
  while(str.length<n)str+=str.length; //Create String as long as needed
  return str[n]==0 //Check for 0 and return
}

How about !s[n] instead of s[n]==0?

@ConorO'Brien Does not work for me. My function a returns a(31)=true, while yours (function(n){s="";while(s.length<n)s+=s.length;return !s[n]}) returns a(31)=false.

hm. my mistake.

C, 154 bytes
s(n,v,k,z){for(k=1;(z=n%10,n/=10)&&!v||k<v;++k); return v?z:k;}
f(n,i,j,c){for(i=0,j=0;;++i){c=s(i,0,0,0);j+=c;if(j>n){c=s(i,j-n,c,0);break;}}return !c;}

the function that calculate the value is f(n,0,0,0) where n is the input index.
it can calculate from index changing "return !c" in "return c" the value of the array in that index...
i don't understand how but it seems to work ok....
main()
{int   i,r;
 char  a[]="0123456789101112131415161718192021222324252627282930313233343536";

 for(i=0; i<1000; ++i)
    if(r=f(i,0,0,0))
        printf("%u|",i);
}
/*
 154
 0|11|31|51|71|91|111|131|151|171|191|192|194|197|200|203|206|209|212|215|218|222
|252|282|312|342|372|402|432|462|491|492|494|497|500|503|506|509|512|515|518|522|552
|582|612|642|672|702|732|762|791|792|794|797|800|803|806|809|812|815|818|822|852
|882|912|942|972|
*/

CoffeeScript, 56 bytes
a=(b)->
 s=""
 while s.length<b #loop for building string with required length
  s+=s.length     #add number
 "0"==s[b]        #return, if the number at the position equals zero

C#, 71 bytes
And I thought it was short at first, but then I had to add n+=11 to prevent it from throwing a System.IndexOutOfRangeException when numbers below 11 were input
return String.Join("",Enumerable.Range(0,n+=11).ToArray())[n]=='0'?1:0;

Pyke, 7 bytes
m`sQ@b!

Try it here!

Actually, 9 8 bytes
This answer concatenates the range [0..n], takes the nth index and checks if that char is "0". Golfing suggestions welcome. Try it online!
;urεjE≈Y

Ungolfing
;          Duplicate n
 ur        Increment the duplicate and create range [0..n].
   εj      Join the range with an empty string. Stack: <string> n
     E     Take the char at the n-th index.
      ≈    int(a)
       Y   Logical NOT. If the digit is 0, then return 1, else return 0.

PowerShell v2+, 32 bytes
param($n)(-join(0..$n))[$n]-eq48

Does the same as other answers -- takes the range from 0 to input $n, -joins together into a string, takes the [$n] index, checks if it's -equal to 48 (i.e., ASCII for 0).
Note this will only work up to input 49999, as the PowerShell range operator .. only supports ranges of 50,000 elements or fewer. For larger inputs, you'll need to use the following, based on my previous Champernowne answer, at 58 bytes:
param($n)$j=$n;for($c='';$j-ge0;$j--){$c+=$i++}$c[$n]-eq48

Octave, 41 29 bytes
Credit to Dennis, whose Julia answer made me realize I wasn't treating input 0 correctly.
@(n)sprintf('%i',0:n)(n+1)<49

This is an anonymous function.
Try at Ideone.
Explanation
For input n, this generates the Champernowne digits corresponding to the first n+1 numbers starting at 0 (which is more than enough). sprintf is used for this so that no blank spaces appear. The result is true if the n+1-th  digit (1-based) is zero, that is, if its ASCII code is less than 49.

R, 57 bytes
grepl("0$",substr(paste(0:(n=scan()),collapse=""),1,n+1))

Build a string corresponding to 0:n, keeps the first n+1 characters and check if the last character is a zero.

Thunno 2 !, 4 bytes
ĖJiN

Try it online!
or verify some more cases
Explanation
ĖJiN  # Implicit input
Ė     # Push [0..input]
 J    # Join into string
  i   # Index using input
   N  # Cast to integer
      # Logical NOT
      # Implicit output


text:
Simple integer operation calculator
Implement a simple integer operation scriptable calculator.
Concept
The accumulator starts at 0 and has operations performed on it. At the end of the program output the value of the accumulator.
Operations:

+ adds 1 to the accumulator
- subtracts 1 from the accumulator
* multiplies the accumulator by 2
/ divides the accumulator by 2

Sample script
The input ++**--/ should give the output 3.
Example implementation
def calc(s)
    i = 0
    s.chars.each do |o|
        case o
            when '+'
                i += 1
            when '-'
                i -= 1
            when '*'
                i *= 2
            when '/'
                i /= 2
        end
    end
    return i
end

Rules

This is code-golf, so lowest answer in bytes wins, but is not selected.
Creative implementations are encouraged.
Standard loopholes are prohibited.
You get the program via stdin or arguments, and you can output the answer via return value or stdout.
Have fun.
Division truncates down because it is integer division.
The program -/ returns -1.

Test cases
*///*-*+-+
-1
/*+/*+++/*///*/+-+//*+-+-/----*-*-+++*+**+/*--///+*-/+//*//-+++--++/-**--/+--/*-/+*//*+-*-*/*+*+/+*-
-17
+++-+--/-*/---++/-+*-//+/++-*--+*+/*/*/++--++-+//++--*/***-*+++--+-*//-*/+*/+-*++**+--*/*//-*--**-/-*+**-/*-**/*+*-*/--+/+/+//-+*/---///+**////-*//+-+-/+--/**///*+//+++/+*++**++//**+**+-*/+/*/*++-/+**+--+*++++/-*-/*+--/++*/-++/-**++++/-/+/--*/-/+---**//*///-//*+-*----+//--/-/+*/-+++-+*-*+*+-/-//*-//+/*-+//+/+/*-/-/+//+**/-****/-**-//+/+-+/*-+*++*/-/++*/-//*--+*--/-+-+/+/**/-***+/-/++-++*+*-+*+*-+-//+/-++*+/*//*-+/+*/-+/-/*/-/-+*+**/*//*+/+---+*+++*+/+-**/-+-/+*---/-*+/-++*//*/-+-*+--**/-////*/--/*--//-**/*++*+/*+/-+/--**/*-+*+/+-*+*+--*///+-++/+//+*/-+/**--//*/+++/*+*////+-*-//--*+/*/-+**/*//+*+-//+--+*-+/-**-*/+//*+---*+//*/+**/*--/--+/*-*+*++--*+//+*+-++--+-*-*-+--**+/+*-/+*+-/---+-*+-+-/++/+*///*/*-+-*//-+-++/++/*/-++/**--+-////-//+/*//+**/*+-+/+/+///*+*///*-/+/*/-//-*-**//-/-+--+/-*--+-++**++//*--/*++--*-/-///-+/+//--+*//-**-/*-*/+*/-*-*//--++*//-*/++//+/-++-+-*/*-+++**-/-*++++**+-+++-+-***-+//+-/**-+/*+****-*+++*/-*-/***/-/*+/*****++*+/-/-**-+-*-*-++**/*+-/*-+*++-/+/-++*-/*-****-*
18773342

So... it's not strictly integer, since / can yield non-integers.

Then you should specify this explicitly.

What should -/ return?

@Dennis Well, C truncation says it should round to 0, so that should be 0...

@LegionMammal978 Yet the reference implementation returns -1.

I can't help but notice that the snippet of code featured on the home page of rust-lang solves this challenge.

@Zwei That's exactly where I got this challenge.

My recursive solution returns an floating point number. Is this allowed? The results are correct, but they contain .0 at the end.

Does the program have to handle the empty input string ?

Please add more test cases.

Curse that nasty round-down requirement!  I had a nice 41-byte GNU sed + dc answer: s/[+-]/1&/g;s/[*/]/2&/g;s/.*/dc -e 0d&p/e, but it rounds towards zero when you divide a negative  :-(

May we substitute the symbols with +-×÷ or 'PMTD'?

@TobySpeight you can divide this way in dc to have the desired rounding: [1-]S@d0>@2/, because the default output precision is 0 (see my answer)

@TonHospel It outputs 0 because the accumulator starts at 0 and changes only with operations.

@MartinEnder xnor did that for me

@Adám no, they must be exactly as specified. Sorry.

Python 2, 48 bytes
i=0
for c in input():exec"i=i%s2&-2"%c
print i/2

Does +2, -2, *2, or /2. By doing +2 and -2 rather than +1 and -1, we're working in doubled units, so the final output needs to be halved. Except, the floor-division / now needs to round down to a multiple of 2, which is done with &-2.

This is brilliant! If you want to post it yourself a  CJam port of this would currently be leading the challenge: 0q{2\~-2&}/2/ (2\~ evals the operator with second operand 2, -2& is the bitwise AND, 2/ is the final division by two. q{...}/ is a foreach over the input and 0 is just the initial value.)

You can post it, I don't know CJam.

Really clever! Ported to ES6 this would easily outperform my answer

Brilliant use of python. Learned something new from this.

Jelly, 18 17 bytes
‘

’

:2
Ḥ
O0;ṛĿ/

Try it online!
How it works
The first six lines define helper links with indices ranging from 1 to 6; they increment, do nothing, decrement, do nothing, halve (flooring), and double.
The main link – O0;ṛĿ/ – converts the input characters to their code points (O), prepends a 0 (initial value) to the array of code points 0;, then reduces the generated array as follows.
The initial value is the first element of the array, i.e., the prepended 0. The quicklink ṛĿ is called for every following element in the array, with the last return value as left argument and the current element as right one. It inspects its right argument (ṛ) and evaluates the link with that index monadically (Ŀ), thus applying the desired operation.

This looks like the jelly answer with the most newlines

Haskell, 51 bytes
x#'+'=x+1
x#'-'=x-1
x#'*'=x*2
x#_=div x 2
foldl(#)0

Usage example: foldl(#)0 $ "++**--/" -> 3.

Python 2, 54 bytes
i=0
for c in input():exec"i=i"+c+`~ord(c)%5%3`
print i

Input is taken as a string literal. ~ord(c)%5%3 maps the operators to the corresponding right operands.
Previously, I used hash(c)%55%3 which didn't yield consistent results between different versions of Python. This encouraged me to explore other formulas.

doesn't seem to work...

55,3 and 65,4 are the two shortest for double mod of hash in python 2

@DestructibleWatermelon does for me: ideone

I think hash is Python version specific - ideone uses 2.7.10 which gives [1, 1, 2, 2] as the four mappings, whereas locally on 2.7.12 I get [2, 0, 1, 0]

it works on ideone, but not on my computers python. Probably version dependent, in which case version should be noted EDIT: ninja'd :/

@sp3000 I see. I didn't know hash isn't  backwards compatible especially considering such a small difference in versions.

FWIW, 2-ord(c)%11%3 is only a byte longer and works everywhere.

@lynn Thanks, you prompted me to look for an even shorter formula that doesn't rely on hash.

S.I.L.O.S, 133 211 bytes
:s
def : lbl G GOTO
readIO
i-46
if i a
i+2
if i b
i+2
if i c
i+1
if i d
G e
:a
G v
:p
a-1
a/2
G o
:v
a+1
if a p
a-1
j=a
j/2
k=j
k*2
k-a
a/2
if k t
G o
:t
a-1
:o
G s
:b
a-1
G s
:c
a+1
G s
:d
a*2
G s
:e
printInt a

Takes the ASCII codes of operators.
Try it online with test cases:
-/
++**--/
*///*-*+-+

is loadLine golfier?

The OP clarified; -/ should return -1, not 0.

@Dennis fixed. Added a lot of bytes though :/

Turing Machine - 23 states (684 bytes)
Try it here - permalink
0 * * r 0
0 _ . l 1
1 * * l 1
1 _ * l 2
2 * 0 r 3
3 _ * r 3
3 + _ l +
3 - _ l -
3 x _ l x
3 / _ l /
+ _ * l +
+ * * * 4
4 - * l 5
4 _ 1 r 6
4 0 1 l 7
4 1 0 l 4
- _ * l -
- * * * 5
5 - * l 4
5 _ * r 8
5 0 1 l 5
5 1 0 l 7
x * * l x
x 1 0 l 9
x 0 0 l a
9 _ 1 r 6
9 1 1 l 9
9 0 1 l a
a _ _ r 6
a 1 0 l 9
a 0 0 l a
/ _ * l /
/ * * l b
b * * l b
b _ * r c
c 0 0 r d
c 1 0 r e
d * * l 7
d 0 0 r d
d 1 0 r e
e _ * l 7
e - * l 4
e 0 1 r d
e 1 1 r e
8 * * r 8
8 - _ r 3
8 _ - r 3
7 * * l 7
7 _ * r f
f 0 _ r f
f 1 * r 6
f * _ l g
g * 0 r 6
6 * * r 6
6 _ * r 3
3 . _ l h
h _ * l h
h - _ l i
h * * l halt
i * * l i
i _ - r halt

Input should not contain any '*' since it is a special character in Turing machine code. Use 'x' instead.
Outputs the answer in binary.
Unobfuscated Code
init2 * * r init2
init2 _ . l init0
init0 * * l init0
init0 _ * l init1
init1 * 0 r readop
readop _ * r readop
readop + _ l +
readop - _ l -
readop x _ l x
readop / _ l /
+ _ * l +
+ * * * inc
inc - * l dec
inc _ 1 r return
inc 0 1 l zero
inc 1 0 l inc
- _ * l -
- * * * dec
dec - * l inc
dec _ * r neg
dec 0 1 l dec
dec 1 0 l zero
x * * l x
x 1 0 l x1
x 0 0 l x0
x1 _ 1 r return
x1 1 1 l x1
x1 0 1 l x0
x0 _ _ r return
x0 1 0 l x1
x0 0 0 l x0
/ _ * l /
/ * * l //
// * * l //
// _ * r div
div 0 0 r div0
div 1 0 r div1
div0 * * l zero
div0 0 0 r div0
div0 1 0 r div1
div1 _ * l zero
div1 - * l inc
div1 0 1 r div0
div1 1 1 r div1
neg * * r neg
neg - _ r readop
neg _ - r readop
zero * * l zero
zero _ * r zero1
zero1 0 _ r zero1
zero1 1 * r return
zero1 * _ l zero2
zero2 * 0 r return
return * * r return
return _ * r readop
readop . _ l fin
fin _ * l fin
fin - _ l min
fin * * l halt
min * * l min
min _ - r halt

Explanation of the states:
Initialization:
These states are visited once at the beginning of each run, starting with init2

init2: Move all the way to the right and put a '.'. That way the TM knows when to stop. Change to 'init0'.
init0: Move all the back to the left until the head reads a space. Then move one cell to the left. Change to 'init1'.
init1: Put a zero and move one cell to the right and change to 'readop'.

Reading instructions:
These states will be visited multiple times throughout the program

readop: Moves all the way to the right until it reads an operator or the '.'. If it hits an operator, change to the corresponding state (+,-,x,/). If it hits a '.', change to state 'fin'.
return: Returns the head to the empty space between the running total and the operators. Then changes to 'readop'.

Operations:
These operations do the actual dirty work

+: Move to the left until the head reads any non-
whitespace character. If this character is a '-', move left and change to 'dec'. Otherwise, change to 'inc'.
-: Similar to '+', except change to 'inc' if there is a '-' and 'dec' otherwise.
inc: If the digit under the head is a 0 (or a whitespace), change it to 1 and change to 'zero'. If the digit is a 1, change it to 0, then repeat on the next digit.
dec: Similar to inc, except 1 goes to 0, 0 goes to 1, and if the head reads a whitespace, change to 'neg'.
x, x0, x1: Bitshift the number one to the left. Change to 'return'.
/, //, div, div0, div1: Move all the way to the right of the number, then bitshift one to the right. If there is a '-', change to 'inc'. This simulates rounding down negative numbers. Otherwise, change to 'zero'
neg: Place a '-' after the number then change to 'readop'
zero, zero1, zero2: Remove leading zeros and change to 'readop'

Cleanup:
Makes the output presentable

fin, min: Move the '-' in front of the number if necessary. Halt.

Thought reading this code was very very cool. So thanks for brightening up my day.

Perl 6,  53  52  bytes

{([Ro] %(<+ - * />Z=>*+1,*-1,* *2,*div 2){.comb})(0)}

{[Ro](%(<+ - * />Z=>*+1,*-1,*×2,*div 2){.comb})(0)}

Explanation:
# bare block lambda that has one implicit parameter ｢$_｣
{
  (
    # reduce the code refs using ring operator ｢∘｣ in reverse ｢R｣
    [R[o]]

      # produce a hash from:
      %(

        # list of pairs of "operator" to code ref
        # ( similar to ｢'+' => { $^a + 1 }｣ )

          # keys
          < + - * / >

        # keys and values joined using infix zip operator ｢Z｣
        # combined with the infix Pair constructor operator ｢=>｣
        Z[=>]

          # values (Whatever lambdas)
          * + 1,
          * - 1,
          * × 2, # same as ｢* * 2｣
          * div 2,

      ){

        # split the block's argument into chars
        # and use them as keys to the hash
        # which will result in a list of code refs
        .comb

      }

  # call composed code ref with 0
  )(0)
}

Usage:
my $input = '++**--/'
my $output = {[Ro](%(<+ - * />Z=>*+1,*-1,*×2,*div 2){.comb})(0)}.( $input );
say $output; # 3
say $output.^name; # Int

C, 63 62 57 bytes
s,t;c(char*x){for(;*x;s+=t<4?t?2-t:s:-s>>1)t=*x++%6;s=s;}

Wandbox

05AB1E, 20 bytes
Thanks to Emigna for fixing the -/-bug!
For 16 bytes if it wasn't integer division: Î"+-*/""><·;"‡.V.
Î…+-*"><·"‡'/"2÷":.V

Explanation:
Î                      # Push 0, which is our starting variable, and input
 …+-*                  # Push the string "+-*"
     "><·"             # Push the string "><·"
          ‡            # Transliterate. The following changes:
                           "+" -> ">"
                           "-" -> "<"
                           "*" -> "·"
           '/"2÷":     # Replace "/" by "2÷"
                  .V   # Evaluate the code as 05AB1E code...
                           '>' is increment by 1
                           '<' is decrement by 1
                           '·' is multiply by 2
                           '2÷' is integer divide by two
                       # Implicitly output the result

Uses the CP-1252 encoding. Try it online!

The OP clarified; -/ should return -1, not 0.

The negative number division issue could be fixed with Î…+-*"><·"‡'/"2÷":.V for the same byte count.

@Dennis Fixed the problem.

JavaScript ES6, 80 68 bytes
k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o],0)

Saved a whopping 12 bytes thanks to Neil!

Second answer would be more readable if you removed the "c"+ and wrote "c+1 c-1 c*2 c/2|0".split etc.

For the first answer, why not write o=>c=[c+1,c-1,c*2,c/2|0]["+-*/".indexOf(o)], or I think you can then go on to save a further byte using o=>c={"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o].

k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o],0) might work out even shorter still, but I've lost count...

@Neil Ah, yes, I forgot about this

@Neil fantastic!

@DanTheMan Did you actually read the answer? n/2|0 performs integer division.

@ConorO'Brien I was confusing |  and ||. Sorry! Try to not be so condescending next time though.

You somehow got to zero-width characters between } and [o], so this is actually only 66 bytes long. Also, the OP clarified; -/ should return -1, not 0.

@Dennis Excellent, that saves another byte by using >>1 instead of /2|0.

@Dennis I will fix the next opportunity I can.

@LeakyNun done.

Ruby, 48 44 42 + 1 = 43 bytes
+1 byte for -n flag. Takes input on STDIN.
i=0
gsub(/./){i=i.send$&,"+-"[$&]?1:2}
p i

See it on ideone (uses $_ since ideone doesn't take command line flags): http://ideone.com/3udQ3H

PHP 76 Bytes
for(;$c=$argv[1][$n++];)eval('$s=floor($s'.$c.(2-ord($c)%11%3).');');echo$s;

Mathematica, 83 73 70 bytes
10 bytes saved due to @MartinEnder.
(#/*##2&@@#/.Thread[{"+","-","*","/"}->{#+1&,#-1&,2#&,⌊#/2⌋&}])@0&

Anonymous function. Takes a list of characters as input and returns a number as output. Golfing suggestions welcome.

Python 2, 58 56 bytes
-2 bytes thanks to @Lynn
r=0
for c in input():exec'r=r'+c+`2-ord(c)%11%3`
print r

The ordinals of the characters +-*/ are 43,45,42,47 modulo 11 these are 10,1,9,3 modulo 3 those are 1,1,0,0, 2 less those are 1,1,2,2 giving the amounts we need for each operation: r=r+1, r=r-1, r=r*2, and r=r/2

Previous:
r=0
for c in input():exec'r=r'+c+`(ord(c)%5==2)+1`
print r

How about 2-ord(c)%11%3?

@Lynn Well I'll take it if its OK with you? (but really think it's enough of a change you could post it)

Go ahead :) ----

S.I.L.O.S, 175 164 bytes
loadLine
a=256
o=get a
lbla
a+1
o-42
p=o
p-1
p/p
p-1
r-p
s=o
s-3
s/s
s-1
r+s
m=o
m/m
m-2
m|
r*m
t=r
t%2
d=o
d-5
d/d
d-1
t*d
d-1
d|
r-t
r/d
o=get a
if o a
printInt r

Try it online!
Sane input method. Correct integer division (round towards -infinity).

Javascript (ES6), 57 bytes (array) / 60 bytes (integer)
Returning an array of all intermediate results:
o=>[...o].map(c=>x=[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],x=0)

For instance, the output for "++**--/" will be [1, 2, 4, 8, 7, 6, 3].
Returning only the final result:
o=>[...o].reduce((x,c)=>[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],0)

How it works
Both solutions are based on the same idea: using the perfect hash function eval(2+c+3)&3 to map the different operator characters c in [0, 3].
 operator | eval(2+c+3)  | eval(2+c+3)&3
----------+--------------+---------------
    +     |  2+3 = 5     |    5 & 3 = 1
    -     |  2-3 = -1    |   -1 & 3 = 3
    *     |  2*3 = 6     |    6 & 3 = 2
    /     |  2/3 ~= 0.67 | 0.67 & 3 = 0

C#, 87 81 bytes
int f(string s){int i=0;foreach(var c in s)i=c<43?i*2:c<46?i+44-c:i>>1;return i;}

Ungolfed:
int f(string s)
{
    int i = 0;

    foreach (var c in s)
        i = c < 43 ? i * 2
          : c < 46 ? i + 44 - c
          : i >> 1;

    return i;
}

Input is assumed to be valid. Division by two is done by shifting right one bit, because regular division always rounds towards zero, and bit shifting always rounds down. Increment and decrement make handy use of the 1 distance between the ASCII codes for + and -.

Some love for new C#6 syntax and aggregate method of Linq? int f(string s)=>s.Aggregate(0,(i,c)=>c<43?i*2:c<46?i+44-c:i>>1); (65 bytes)

@CyrilGandon as far as I'm aware that would have to include the "using System.Linq;", making it 19 longer and putting it at 84 bytes. Which is why I didn't do it.

JavaScript (ES6), 57
a=>[...a].map(c=>a=c<'+'?a<<1:c<'-'?-~a:c<'/'?~-a:a>>1)|a

Note: the initial value for accumulator is the program string, using bit operations (~, >>, <<, |) it is converted to 0 at first use.
As a side note, the clever answer of @xnor would score 40 ported to javascript:
a=>[...a].map(c=>a=eval(~~a+c+2))&&a>>1

(if you like this, vote for him)
Test

f=a=>[...a].map(c=>a=c<'+'?a<<1:c<'-'?-~a:c<'/'?~-a:a>>1)|a

function update() {
  O.textContent = f(I.value);
}

update()
<input value='++**--/' id=I oninput='update()'>

GNU sed, 65 59 57 bytes
Edit: 2 bytes shorter thanks to Toby Speight's comments
s/[+-]/1&/g
s/*/2&/g
s:/:d0>@2&:g
s/.*/dc -e"0[1-]s@&p"/e

Run:
sed -f simple_calculator.sed <<< "*///*-*+-+"

Output:
-1

The sed script prepares the input for the dc shell call at the end, the latter accepting the input in Reverse Polish notation. On division, if the number is negative (d0>), the [1-] decrement command stored in register @ is called. Conversion example: + - * / --> 1+ 1- 2* d0>@2/.

You don't need the quotes around the argument to dc, if there's no spaces, and no files matching the [1-] pattern...

@TobySpeight In my mind I switched the meaning of s with S. I forgot that it doesn't replace the registry's stack, it pushes onto it, having the contrary effect of what I wanted (since I used it for every /). The quotes are still needed because you have / symbols in it making the string interpreted as a file path :) I shaved 1 byte more by removing the space after the -e.

dc won't intepret argument of -e as a filename, so you don't need quotes for the / - try it!  I think it's a reasonable for a code-golf to require that the current working directory not contain any files beginning with 01s@ or 0-s@.

@TobySpeight you were right about -e regarding /, however the quotes are still required as I just saw now. The > is interpreted directly by the shell as a redirect operator I think, since I got this error: cannot create @2/d0: Directory nonexistent

Ah, yes, I didn't consider the >.  You do need quotes, after all.  Apologies for (attempting to) mislead!  And, although adding a backslash looks like one character, it needs to be doubled in a s/// replacement, so no benefit there...

PHP, 75 bytes
This uses a modified version of Jörg Hülsermann's answer.
eval(preg_replace('~.~','$s=($s\0(2-ord("\0")%11%3))|0;',$argv[1]));echo$s;

It heavily relies on string substitution, using a simple regular expression (~.~).
The variable $s is re-assigned with the new value for each character. At the end, it outputs the result.

Note: This is meant to be executed using the -r flag.

Try it here:

if('\0' == "\0")
{
 $argv = Array($s = 0, prompt());
 function preg_replace($pattern, $replacement, $subject)
 {
  $regexp = new RegExp($pattern.replace(new RegExp('~', 'g'), ''), 'g');
  return $subject.replace($regexp, $replacement.split('\0').join('$&'));
 }

 function printf($string)
 {
  console.log($string);
 }

 function ord($chr)
 {
  return $chr.charCodeAt(0);
 }
}
else
{
    if(!isset($argv))
    {
        $argv = array('', '++*+');
    }
}

eval(preg_replace('~.~','$s=($s\0(2-ord("\0")%11%3))|0;',$argv[1]));printf($s);

Or try on: http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa
Differences:

Instead of echo$s, I'm using sprintf($s).
Both perform the same action on numbers. Since this is just for testing, it is fine.
In case there's no passed argument, it will run as if you passed ++*+ as the first argument, which should show 5.

Yay! The e modifier is back! :D

@Titus I don't get it. Can you elaborate a little?

PHP before version 7 had a pattern modifier e, which was replaced by preg_replace_callback and could be abused to ... but this isn´t quite that.

@Titus That patern modifier was used to tell that the output would be actual PHP code, and to try to keep the syntax correct. This here, doesn't use it, but replace every single character with a piece of code to execute, regardless of it's syntax. Bad inputs will cause severe security issues.

I know. But it resembles.

@Titus To be honest, it does resemble. This answer would (probably) benefict from it. But, to be even more honest, I'm more proud of the polyglot I wrote to test the basic implementation in PHP and Javascript (in a StackSnippet)

Java, 77 bytes
int f(String s){return s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1);}

Uses java 8 streams.

Nice answer, and welcome to the site! I don't know anything about java, but can you change r >> 1 to r>>1 and save 2 bytes?

You're absolutely correct, thanks @DJMcMayhem

Awesome, glad I could help! One more note, I'm counting 77 bytes. Did you happen to include the newline in your byte count? You can take one more byte off since that isn't necessary.

Correct again @DJMcMayhem , aparently wc counts the null-terminanting byte or something...

as you are using java8, why don't define function by using lambda, s->s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1); that will give you 56 bytes

Python 3, 98 66 60 bytes
Thanks Tukkax!
Not as golfy as the other answer, but I can't compete with them without plagiarism.
i=0
for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4]
print(i)

Also, I have a recursive lambda solution as well
73 67 bytes (improved!)
s=lambda x,z=0:s(x[1:],z+[1,-z//2,-1,z][ord(x[0])%23%4])if x else z

By applying part of your recursive solution to the procedural version: 60 bytes: i=0 for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4] print(i). (not formatted properly of course). Also I think you should mention that you're using Python3. In Python2, input() would evaluate to int(raw_input()).

@TuukkaX doesn't work for z=0 (+- does 1)

oh yes, my mistake.

Add the title Python3 please.

Pyke, 24 22 bytes
\*\}:\/\e:\+\h:\-\t:0E

Try it here!
Or 12 bytes (noncompetitive)
~:"ht}e".:0E

Try it here!
Add translate node - basically multiple find and replace.
~:           -   "+-*/"
        .:   -  input.translate(^, V)
  "ht}e"     -   "ht}e"
          0E - eval(^, stack=0)

Batch, 61 bytes
@set n=
@for %%a in (%*)do @set/an=n%%a2^&-2
@cmd/cset/an/2

Translation of @xnor's xcellent Python answer.

PHP, 104 102 82 bytes
First version with eval:
$i=0;while($c<9999)eval('$i'.['+'=>'++','-'=>'--','*'=>'*=2','/'=>'>>=1'][$argv[1]{$c++}].';');echo$i;

Second version with ternary operators:
while($o=ord($argv[1]{$c++}))$i=$o<43?$i*2:($o<44?$i+1:($o<46?$i-1:$i>>1));echo$i;

Takes the input string as first argument from the command line.
This "only" works for input strings shorter than 10,000 characters - which should be plenty. Tested with all the test cases, unfortunately can't save on the initialization in the beginning. Second version works with strings of any length and without initialization. :-)
The main element is the eval function which manipulates $i based on a map of arithmetic operations, which are pretty straightforward except for the division. PHP returns a float when using / and intdiv is too many bytes, so we do a right-shift.
Updates

Saved 2 bytes by shortening $i=$i>>1 to $i>>=1 for integer division.
Threw out eval in favor of ternary operators.

R, 201 bytes
Golfed
p=.Primitive;"-"="+"=function(x)p("+")(x,1);body(`-`)[[1]]=p("-");"*"="/"=function(x)p("*")(x,2);body(`/`)[[1]]=p("%/%");Reduce(function(f, ...)f(...),rev(mget(strsplit(scan(stdin(),""),"")[[1]])),0,T)

Commented
p = .Primitive                       # Redefine
"-" = "+" = function(x)p("+")(x,1)   # Define - and +
body(`-`)[[1]] = p("-")              # Change the body, what we do to save a byte
"*" = "/" = function(x)p("*")(x,2)   # Same as above
body(`/`)[[1]] = p("%/%")            # Same as above
Reduce(function(f, ...)f(...),       # Function wrapper to evaluate list of func.
  rev(mget(strsplit(scan(stdin(),""),"")[[1]])), # Strsplit input into list of functions
  init = 0,                                      # Starting Arg = 1
  right = T)                                     # Right to left = True

Strategy is to refine the +, -, % operators. Split the string then parse the string into a long list of functions, to be fed into Reduce()'s accumulator.
Couldn't golf it anymore. If someone can get b=body<- to work, there could be a few bytes of savings (refine every function with b after "-"="+"="/"="*"). Initially tried to substitute and parse eval, but the order of operations and parentheses were terrifying.

This is a year later, but I managed to get it down 10 bytes by swapping your approach a bit -- you can drop 8 bytes by removing the space between f, ... in the definition of the Reduce function and getting rid of stdin() in scan but I just tried a naive approach that dropped two more bytes by defining the functions a little differently.
https://tio.run/##XcvLCsMgEAXQrwnO6Gge29B/KKW7EDBYU4TmgZqQv7dmU2gWcxfn3vEp6UIU@jZus4lumeHAQ9StLuQF5Yn8grzJWP6juns3ueh2Cyx3DOGgBtuHfW3Gwm84klIKRziTvN1hetsI6xCirfIjoxB9WD8uQjDDDMQYntd1dd9T7hGRKnpiEoJzKcv0BQ

Python3, 98 85 74 bytes
C=lambda s,n:s and C(s[1:],{3:n+1,5:n-1,2:n*2,7:n/2}[ord(s[0])%10])or n//1

A recursive solution that loops over the string and takes the (modulo 10) from the ASCII value of the iterated character and treats the carried number accordingly. The dictionary keys are the last digits of the possible ASCII values that may occur (+, -, *, /) and the values are the corresponding results for the symbol.We pass the input string s forward by taking everything onward from the next character with s[1:] (thanks to @Destructible Watermelon!).
Could be shortened even more, by picking the actions from a list and moduloing to keep the index in range, but that feels like plagiarism at this point, so unless I find my own method for that, it won't happen.
Called like: C("+-+**+/",0) ==> 2.0
(Ps. Is it allowed to return -1.0 from input -/?)

PHP, 79 bytes
<?$i=0;switch($_POST['a']){case"+":$i+1;case"-":$i-1;case"/":$i/2;case"*":$i*2}

Include the bytecount in your header, remove uneccesary spaces and use 1-letter variable names.

Is this even golfed?! :-D

@TùxCräftîñg I did it.

You divide and multiply by 1; you need to divide and multiply by 2

@TùxCräftîñg I did it.

Please update your bytecount... The bytecount here is of 81 bytes

I typed "81", What did you see

If I POST "-+", I get 0, in $i, and $i is never outputted.

Shouldn´t there be a loop of some kind? Save one byte with $_GET instead of $_POST.

Lex + C, 78, 74, 73 bytes
The first character is a space.
 c;F(){yylex(c=0);return c;}
%%
\+ c++;
- c--;
\* c*=2;
\/ c=floor(c/2.);

Reads from stdin, returns result.
Compile with lex golfed.l && cc lex.yy.c main.c -lm -lfl, test main:
int main() { printf("%d\n", F()); }

ARM Machine Code, 30 bytes
Hex Dump (little endian):
2000 f811 2b01 b14a 2a2a bf08 0040 d0f8 2a2e bf3a 3a2c 1a80 1040 e7f2 4770

This is a function that takes in a string, and returns the accumulated result. In C, the function would be declared int sioc(int dummy, char* string) where the dummy argument is ignored. Tested on the Raspberry Pi 3. No libraries or system calls are used.
Ungolfed assembly:
.syntax unified
.text
.global sioc
.thumb_func
sioc:
    @Input: r0 - dummy argument
    @r1 - string of operations
    @Output: r0 - result of those operations
    movs r0,#0 @Initialize accumulator to 0
    loop:
        ldrb r2,[r1],#1 @r2=*r1++
        cbz r2,end @If (r2==0), goto end
    mul:
        cmp r2,#42
        it eq @if r2==42
        lsleq r0,r0,#1 @r0<<=1
        beq loop @continue
    addsub: @else
        cmp r2,#46
        itte lo @If r2<46, then r2 is either + or -
        sublo r2,r2,#44
        sublo r0,r0,r2 @Add 1 if r2 is +, subtract 1 if r0 is -
        asrhs r0,r0,#1 @else arithmatically shift right by 1
        b loop @while (true)
    end:
        bx lr

Testing script (also assembly):
.syntax unified
.text
.global main
.thumb_func
main:
    ldr r1,[r1,#4] @r0=argv[1]
    bl sioc
    mov r1,r0
    adr r0,msg
    bl printf
    movs r7,#1
    swi #0
.balign 4
msg:
    .asciz "%d\n"

Java 8, 56 bytes
s->s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1);

PHP, 146 138, 133, 131 bytes
$a=$_POST['s'];$i=0;while($a){$c=substr($a,0,1);$i=$c=='+'?$i+=1:($c=='-'?$i-1:($c=='*'?$i*2:round($i/2)));$a=substr($a,1);}echo$i;

Takes argument from $_POST['s'].
Uses ternary operator as "if's".
Takes one character at a time, parse that char in operation, then continue reading next char
EDIT 1: Shortened "while(strlen($a))" to "while($a)"
EDIT 2: Removed some useless paranthesis
EDIT 3. Removed extra space after last "echo"

I think with even PHP 5.5 having reached EOL it's safe to say that nobody SHOULD use PHP 4 anymore, so the "5+" is not necessary, imho.

That is ok. For some scripts, it is important to show PHP version, maybe here it's not the case. Thanks, however.

Yes, but if they start including the leaderboard snippet then your entry will be the top entry for the language "PHP 5+" while another one's entry will be leading "PHP 5.6" and maybe somebody else with worse score posts for "PHP 5.6.13 and up" ... You see my point? :-)

That is correct. Thanks, again

You can change $_POST['s'] to $_GET[s], which is bad practice but saves you 2 bytes.You might also try to remove the bracketrs of the while (-2) if you add a newline before the echo (+1) Not 100% sure about that.

I had tried with $_GET, but because of "/" chars in string there is a problem with resulted link. Regarding paranthesis for while, that is ok.

Tried it. It is not ok while without brackets.

Javascript (ES5), 127 bytes
function(b){for(a=c=0;a<b.length;++a)switch(b[a]){case"+":++c;break;case"-":--c;break;case"*":c*=2;break;case"/":c/=2}return c}

Ungolfed:
function c(a){
  c=0;
  for(var i=0;i<a.length;++i){
    switch(a[i]){
      case "+":++c;break;
      case "-":--c;break;
      case "*":c*=2;break;
      case "/":c/=2;break;
    }
  }
  return c;
}

Pyth, 23 bytes
FNQ=Z.v%".&%sZ2_2"N;/Z2

A full program that takes input as a string and prints the result.
This is a port of @xnor's Python answer.
Try it online
How it works
FNQ=Z.v%".&%sZ2_2"N;/Z2   Program. Input: Q. Z initialised as 0
FNQ                       For. For N in Q:
        ".&%sZ2_2"         String. Literal string ".&%sZ2_2"
       %          N        String format. Replace %s with the current operator N
           %sZ2            Operator. Yield Z*2, Z//2, Z+2, Z-2 as appropriate
         .&    _2          Bitwise and. Result of above & -2
     .v                    Evaluate. Yield the result of the expression
   =Z                      Assignment. Assign result of above to Z
                   ;      End. End for loop
                    /Z2   Integer division. Yield Z//2
                          Print. Print the above implicitly

Converting Python to Pyth is mostly a bad idea. u@[yGhG0tG0/G2)CHQ0 19 bytes

@Jakube Thanks - I am very new to Pyth, so any advice is appreciated. Feel free to post that as a separate answer, since it is a different approach.

Ruby, 37 bytes
#!ruby -n
gsub(/./){eval"$.=$./2*2#$&2"}
p$./2

The shebang counts as 1 byte. This program uses xnor's creative approach. We avoid the need to initialise an accumulator variable by using $.. As it has a value of 1 after the input is read, we have to clear the LSB before applying each operator. This also requires changing &-2 to /2*2 for the correct precedence.

Java 7, 73 bytes
int c(char[]i){int r=0;for(int c:i)r=c<43?r*2:c<46?r+44-c:r>>1;return r;}

Shamelessly stolen from @Scepheo's amazing C# answer and implemented in Java 7.
Ungolfed & test cases:
Try it here.
class M{
  static int c(char[] i){
    int r = 0;
    for(int c : i) {
      r = c < 43
           ? r * 2
           : c < 46
              ? r+44 - c
              : r >> 1;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("*///*-*+-+".toCharArray()));
    System.out.println(c("/*+/*+++/*///*/+-+//*+-+-/----*-*-+++*+**+/*--///+*-/+//*//-+++--++/-**--/+--/*-/+*//*+-*-*/*+*+/+*-".toCharArray()));
    System.out.println(c("+++-+--/-*/---++/-+*-//+/++-*--+*+/*/*/++--++-+//++--*/***-*+++--+-*//-*/+*/+-*++**+--*/*//-*--**-/-*+**-/*-**/*+*-*/--+/+/+//-+*/---///+**////-*//+-+-/+--/**///*+//+++/+*++**++//**+**+-*/+/*/*++-/+**+--+*++++/-*-/*+--/++*/-++/-**++++/-/+/--*/-/+---**//*///-//*+-*----+//--/-/+*/-+++-+*-*+*+-/-//*-//+/*-+//+/+/*-/-/+//+**/-****/-**-//+/+-+/*-+*++*/-/++*/-//*--+*--/-+-+/+/**/-***+/-/++-++*+*-+*+*-+-//+/-++*+/*//*-+/+*/-+/-/*/-/-+*+**/*//*+/+---+*+++*+/+-**/-+-/+*---/-*+/-++*//*/-+-*+--**/-////*/--/*--//-**/*++*+/*+/-+/--**/*-+*+/+-*+*+--*///+-++/+//+*/-+/**--//*/+++/*+*////+-*-//--*+/*/-+**/*//+*+-//+--+*-+/-**-*/+//*+---*+//*/+**/*--/--+/*-*+*++--*+//+*+-++--+-*-*-+--**+/+*-/+*+-/---+-*+-+-/++/+*///*/*-+-*//-+-++/++/*/-++/**--+-////-//+/*//+**/*+-+/+/+///*+*///*-/+/*/-//-*-**//-/-+--+/-*--+-++**++//*--/*++--*-/-///-+/+//--+*//-**-/*-*/+*/-*-*//--++*//-*/++//+/-++-+-*/*-+++**-/-*++++**+-+++-+-***-+//+-/**-+/*+****-*+++*/-*-/***/-/*+/*****++*+/-/-**-+-*-*-++**/*+-/*-+*++-/+/-++*-/*-****-*".toCharArray()));
  }
}

Output:
-1
-17
18773342

Haskell - 70 bytes
f x=foldl1(flip(.))[[(*2),succ,id,pred,id,(`div`2)]!!(ord n-42)|n<-x]0

64 if I may take the input in RPN:
f x=foldl1(.)[[(*2),succ,id,pred,id,(`div`2)]!!(ord n-42)|n<-x]0

In addition to + - * / my implementation also support , and ., both of which does nothing. It crashes for any other input.

Racket 116 bytes
(λ(s)(let((l(string->list s))(a 0))(for((i l))(set! a(match i[#\+(+ a 1)][#\-(- a 1)][#\*(* a 2)][#\/(/ a 2)])))a))

Ungolfed version:
(define f
  (lambda(s)
    (let ((l (string->list s))
          (a 0))
      (for ((i l))
        (set! a (match i
                  [#\+ (+ a 1)]
                  [#\- (- a 1)]
                  [#\* (* a 2)]
                  [#\/ (/ a 2)]
                )))
      a)))

Testing:
(f "++**--/")

3

GolfScript - 45 bytes
{1+}:"+";{1-}:"-";{2/}:"/";{2*}:"*";0\1/{`~}/

Explanation
{1+}:"+";  # Creates aliases for operators
{1-}:"-";
{2/}:"/";
{2*}:"*";
0\1/       # Pushes 0 and splits the string in bytes
{`~}/      # Executes each character

you can shave off 2 bytes by using ) and ( instead of 1+ and 1-
and you can also lose 2 more by using ]; after declaring the aliases instead of removing them from the stack one at a time

TSQL, 115 bytes
After some golfing I was finally able to replace -IIF(@<0,@,@+1)/2 with (@+ABS(@%2))/-2 saving 2 bytes.
Golfed:
DECLARE @i varchar(max)='*///*-*+-+'
,@ INT=0WHILE @i>''SELECT @+=CHOOSE(CHARINDEX(LEFT(@i,1),'+-*/'),1,-1,@,(@+ABS(@%2))/-2),@i=STUFF(@i,1,1,'')PRINT @

Ungolfed:
DECLARE @i varchar(max)='*///*-*+-+'

,@ INT=0
WHILE @i>''
  SELECT @+=CHOOSE(CHARINDEX(LEFT(@i,1),'+-*/'),1,-1,@,(@+ABS(@%2))/-2),
  @i=STUFF(@i,1,1,'')
PRINT @

Fiddle

MMIX, 64 bytes (16 instrs)
00000000: e3010000 f000000b 31ff022f 5aff0003  ẉ¢¡¡ṅ¡¡¿1”£/Z”¡¤
00000010: 3d010101 f0000007 31ff022a 5aff0003  =¢¢¢ṅ¡¡¬1”£*Z”¡¤
00000020: 39010101 f0000003 34ff2c02 200101ff  9¢¢¢ṅ¡¡¤4”,£ ¢¢”
00000030: 81ff0000 e7000001 5b02fff4 f8020000  ¹”¡¡ḃ¡¡¢[£”ṡẏ£¡¡

clc SET  $1,0           // acc = 0
    JMP  1F             // goto load
0H  CMP  $255,$2,'/'
    PBNZ $255,2F        // loop: if(c != '/') goto notdiv
    SR   $1,$1,1        // acc /= 2
    JMP  1F             // goto load
2H  CMP  $255,$2,'*'
    PBNZ $255,2F        // notdiv: if(c != '*') goto notmul
    SL   $1,$1,1        // acc *= 2
    JMP  1F             // goto load
2H  NEG  $255,',',$2
    ADD  $1,$1,$255     // notmul: acc += ',' - c
1H  LDB  $255,$0
    INCL $0,1           // load: c = *s++
    PBNZ $255,0B        // if(c) goto loop
    POP  2,0            // return acc

Stax, 12 bytes
î┴$'▌>bå╦♦\‼

Run and debug it
14 bytes unpacked.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Lucas Vs. The Garage Door Remote
Disclaimer
While I know there is this particular related question, my question uses two garage doors, a randomizing component, and I'm also basing this on real life events, seeing my son accidentally lowered one of said garage doors whilst I was walking out of the garage last week... Nothing like a blow to the head to get the creative juices flowing! ;)
The Background
Lucas (my 15 month old son) likes to play with the garage remote. There are two buttons on this remote, one for the left garage door, and one for the right garage door. Both buttons work in the same manner; press once to get the door to start opening, press again to stop, press again to start closing, press again to stop again, and so on.
Lucas loves this remote, he'll randomly press one of the buttons, or both, or none at all. If both are pressed, no signal is sent, but a press of one button will send out a signal.
So, the code-golf challenge is divided on two parts:
Part One
Generate a 60 character long string representing Lucas random button presses over a minute. "Random" in this case means "with an equal chance of each input at each tick". The characters are as follows:

0: Lucas has either pressed no button, or has pressed both buttons. Either way, no signal has been sent.
1: The button for the left garage door has been pressed by Lucas
2: The button for the right garage door has been pressed by Lucas

Part Two
Using the string generated in Part One, simulate the opening and closing of the two-car garage using the numbers as triggers for opening, stopping and closing these doors.
My garage doors are pretty quick (see Disclaimer above as to why).  Once you press the button it takes four seconds to be fully open or closed.
So, if closed:

0 sec: 0% open (closed); when button is pressed, door starts opening
1 sec: 25% open
2 sec: 50% open
3 sec: 75% open
4 sec: 100% open, door stops

And therefore, if open:

0 sec: 100% open; when button is pressed, door starts closing
1 sec: 75% open
2 sec: 50% open
3 sec: 25% open
4 sec: 0% open (closed), door stops

If a particular door is in motion, a signal to that same door will stop it. The next signal sent to that same door after that will send it moving in the opposite direction. If a door is stopped when it has previously been in motion and is now fully open or fully closed when the "stop" signal is received, the door will register as "stopped" in the fully-open or fully-closed state, ready to move in the opposite direction when it receives a new signal.
With this simulation, both garage doors will be initially in the closed position. So, let's look at a 10 second list of commands and see what happens if Lucas was to perform them on the remote:
2120221120
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
2: (L:25% opening, R:50% stopped)
0: (L:50% opening, R:50% stopped)
2: (L:75% opening, R:50% closing)
2: (L:100% stopped, R:25% stopped)
1: (L:100% closing, R:25% stopped)
1: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% opening)
0: (L:75% stopped, R:50% opening)

Output
The first part of the output requires the display of the 60 character long string of random "0", "1" and "2" characters generated from Part One. eg.
212022112021202211202120221120212022112021202211202120221120
Below this string, is the processing of these "signals" according to the rules mentioned above of how the garage doors will behave with each respective character (on a second by second basis). You should end up with 60 lines as a result below the initial display string.
Each of these processed lines will be in the form of:
N: (L:X% XXXXXXX, R:Y% YYYYYYY) where:

N is the nth character from the respective random string, which will be in the form of a 0, 1, or 2.
X% is the percentage of openness of the left door (there is no zero padding)
XXXXXXX is the status of the left door. If the door is not in motion (i.e. not opening or closing) the status "stopped" is enforced, meaning it has been stopped in motion (only possible at 25%, 50% or 75%) or stopped when fully open (100%) or fully closed (0%). Otherwise, the door will either be "opening" or "closing".
Y% is the percentage of openness of the right door (there is no zero padding)
YYYYYYY is the status of the right door. If the door is not in motion (i.e. not opening or closing) the status "stopped" is enforced, meaning it has been stopped in motion (only possible at 25%, 50% or 75%) or stopped when fully open (100%) or fully closed (0%). Otherwise, the door will either be "opening" or "closing".

Example shown below using 10 "signals" and 10 processed lines
2120221120
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
2: (L:25% opening, R:50% stopped)
0: (L:50% opening, R:50% stopped)
2: (L:75% opening, R:50% closing)
2: (L:100% stopped, R:25% stopped)
1: (L:100% closing, R:25% stopped)
1: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% opening)
0: (L:75% stopped, R:50% opening)

This is code-golf, so the shortest code will be the clear winner. I've made this a little easy by using phrases like "opening", "stopped" and "closing", which are all seven letters... so you may want to work that into your strategy.
Best of luck!

You should define a clearer output format for Part 2.

@LegionMammal978 What do you feel is missing from the output?

You haven't really defined what needs to be there and what doesn't (e.g. does it exactly have to match the given format?)

"Output" section redesigned... and yes, it is required that the format match the one above in the example. Note the example format is for 10 "signals", the full output should be based on 60 "signals"
.

#MinorNitPicks resolved... @DLosc. I sincerely hope you have a solution available...

I don't at the moment, but I do think it's a neat question--I may tackle it.

Why isn't the last 1 command stopping the left door at 75% in your example?

Should 0,1, and 2 all appear equally in the first part, or should no-press, double-press, left-press, and right-press all appear equally? (meaning, 0 is more likely because it represents two scenarios which cause the same and result...)

@Arnauld probably becuse it was 2am when i put this question in... I'll fix that...

@SocraticPhoenix I'm treating the 0 values as having the same probability as the 1 or 2 for the purposes of sharing the probability. Just treat them all with 33.33% chance of showing.

When a door has fully opened/closed, should the motor stop?

@Titus When the door stops, the motor stops...

Pyth, 156 149 145 bytes
jkJmO3U60K=G*]Z3=b*3]_1VJFHS2I&=T@KHq*2hT@XHGTH XbHT XKH0)) XKN*_@XbN|@KN@bNN!@KN%+N": (L:%s, R:%s)"m++*@Gd25"% "%3>"csoltpooespnipinengdg"h@KdS2

A direct translation of my Python answer.
Try it online!
Explanation:
jk                              " print ''.join(map(str,                   "
JmO3U60                         "  J = [randint(0,2) for _ in range(60)])) "
K=G*]Z3                         " K = copy(G = [0] * 3)                    "
=b*3]_1                         " b = [-1] * 3                             "
VJ                              " for N in J:                              "
FHS2                            "  for H in range(1, 3):                   "
I&=T@KH                         "   if ((T = K[H]) and                     "
q*2hT@XHGTH                     "       (2 * (T + 1) == (G[H] += T)[H]):   "
 XbHT                           "    b[H] = T                              "
 XKH0))                         "    K[H] = 0                              "
 XKN*_@XbN|@KN@bNN              "  K[N] = (-(b[N] = K[N] or B[N])[N] *     "
!@KN                            "   (not K[N]))                            "
%+N": (L:%s, R:%s)"             "  print(str(N) + ': (L:%s, R:%s)' %       "
m++                             "   map(lambda d:                          "
*@Gd25                          "    G[d] * 25 +                           "
"% "                            "    '% ' +                                "
%3>"csoltpooespnipinengdg"h@Kd  "    'csoltpooespnipinengdg'[K[d]+1::3]]   "
S2                              "   ), range(1, 3))                        "

Wow! Thanks for this answer, as well as the explanation of the code... I was actually  making sense of it by the time I reached the end of it...

Javascript (ES6), 277 275 263 253 250 247 234 bytes
_=>(d=[0,0],l=s='',[...Array(60)].map(_=>(s+=`
${c=Math.random()*3|0}:(`,l+=c,d=d.map((v,i)=>(v=v&8?v&16?v-27?v+1:20:v-9?v-1:0:v,v^=c+~i?0:v&8||24,s+='LR'[i]+`:${(v&7)*25}% `+(v&8?v&16?'opening':'closing':'stopped')+',)'[i],v)))),l+s)

Ungolfed and commented
_ => (
  // Initialize array:
  //   - d = door states as integers
  //     - bits 0 to 2: door opening state (from 0b000 = 0% to 0b100 = 100%)
  //     - bit #3: door in motion (0: no, 1: yes)
  //     - bit #4: door direction (0: closing, 1: opening)
  d = [0, 0],

  // Initialize strings:
  //   - l = list of commands
  //   - s = door states in plain text
  l = s = '',

  // Iterate on an array of 60 entries.
  [...Array(60)].map(_ => (
    // c = new random command (0, 1 or 2)
    // Append new line and new command to s.
    s += `\n${c = Math.random() * 3 | 0}:(`,

    // Append new command to l.
    l += c,

    // For each door ...
    d = d.map((v, i) => (
      // If the door is in motion, update its opening state.
      // Clear the 'in motion' bit if a bound is reached (either closed or fully open).
      v = v & 8 ? v & 16 ? v - 27 ? v + 1 : 20 : v - 9 ? v - 1 : 0 : v,

      // If the current command is intended for this door, update its direction and
      // 'in motion' bit. Direction is changed on the 'stopped => moving' transition.
      v ^= c + ~i ? 0 : v & 8 || 24,

      // Translate the door state in plain text and append it to s
      s +=
        'LR'[i] +
        `:${(v & 7) * 25}% ` +
        (v & 8 ? v & 16 ? 'opening' : 'closing' : 'stopped') +
        ',)'[i],

      // Value to be taken into account by map()
      v
    ))
  )),

  // Final result to be returned
  l + s
)

Demo

let f =
_=>(d=[0,0],l=s='',[...Array(60)].map(_=>(s+=`
${c=Math.random()*3|0}:(`,l+=c,d=d.map((v,i)=>(v=v&8?v&16?v-27?v+1:20:v-9?v-1:0:v,v^=c+~i?0:v&8||24,s+='LR'[i]+`:${(v&7)*25}% `+(v&8?v&16?'opening':'closing':'stopped')+',)'[i],v)))),l+s)

console.log(f())

Wow, I'm impressed with the one liner and throwing it into console.log at that! Well done!

Curiously not working in Firefox, just 4 lines in output, like this 112200001100122021010101012100000010011200201022122021012211 [   "L:25% stopped",   "R:25% stopped" ](newlines after comma and brackets)

@edc65 - My bad, actually. I misread the instructions about the output format. This is fixed.

@Arnauld You could also remove the parentheses from v^=(c-i-1?0:v&8||24) to save you two bytes.

PS @Arnauld, thanks for taking part!

@WallyWest - Thanks for noticing the useless parentheses. Updated.

Python 2, 377 370 361 357 345 335 326 316 312 306 304 bytes
The second indent level is a raw tab (\t), which plays really badly with Markdown, so it's been replaced by two spaces.
from random import*
p=[randint(0,2)for d in[[0]*3]*60]
print`p`[1::3]
v=[-1]*3
c=[0]*3
f=lambda y:str(c[y]*25)+'% '+'csoltpooespnipinengdg'[d[y]+1::3]
for x in p:
 for i in 1,2:
  q=d[i];c[i]+=q
  if(2*-~q==c[i])*q:v[i]=q;d[i]=0
 z=d[x]
 if z:v[x]=z
 d[x]=-v[x]*(z==0);print'%d: (L:%s, R:%s)'%(x,f(1),f(2))

I'm almost certain this can be golfed further.
Ungolfed, with comments:
import random

# Generate the random string - represented as a list of ints
presses = [random.randint(0, 2) for _ in range(60)]
print ''.join(map(str, presses))

# Constants for door states used for easier reading
CLOSING = -1
STOPPED = 0
OPENING = 1

# Variables representing the state of the garage doors
# There's a third element in these so that x[0] resolves to a dummy slot
# (this way, we can avoid a conditional down the road)
prev_states = [CLOSING, CLOSING, 0]
door_states = [STOPPED, STOPPED, 0]
door_pcts = [0, 0, 0]  # delta 1 = 25%

for press in presses:
  # Close/open the door 1 more
  for i in 1, 2:
    if door_states[i] != STOPPED:
      delta_pct, stop_pct = (-1, 0) if door_states[i] == CLOSING else (1, 4)
      door_pcts[i] += delta_pct
      if door_pcts[i] == stop_pct:
        prev_states[i] = door_states[i]
        door_states[i] = STOPPED

  # Handle pressing a button
  # If the press is 0 (no press), the 0th element resolves to a dummy
  # door, thus saving us an expensive conditional

  if door_states[press] == STOPPED:
    door_states[press] = -prev_states[press]
  else:
    prev_states[press] = door_states[press]
    door_states[press] = STOPPED

  # Print the status update
  print '%d: (L:%d%% %s, R:%d%% %s)' % (
    press,
    door_pcts[0]*25,
    ['closing', 'stopped', 'opening'][door_states[0]+1],
    door_pcts[1]*25,
    ['closing', 'stopped', 'opening'][door_states[1]+1],
  )

Saved 4 14 15 bytes thanks to @TheBikingViking!
Saved 6 bytes thanks to @ValueInk!

You can change range(60) to [0]*60.

@TheBikingViking Thanks! I'm editing that in now.

Nice work @Copper! My Python's a little rusty, but could d=[0]*3;c=[0]*3 be replaced with d=c=[0]*3 to save you more? Also, you may find http://codegolf.stackexchange.com/q/54/8555 useful for Python golfing...

@Copper I'd love to see if those tips could bring it down further...

@WallyWest I can't use your tip because it assigns d and c to the same list in memory, so changes in one are reflected in the other.

Ah, so basically cloning the effect... I wasn't sure... But please check that tips link I've supplied... I hope there may be a few more bytes you can shave off. Keep up the good work!

You can do 'p'[1::3] (replace apostrophes with backticks) instead of ''.join(map(str,p)).

(4,0)[q<0]==c[i]and q -> ((4,0)[q<0]==c[i])*q

Is there any reason why you need the 'csoltpooespnipinengdg'?

@ValueInk That line abuses a bug in Python 2's list comprehensions to set n to that string. n is used on the final line to extract closing, stopped, opening from that string.

Could you possibly have your dummy door be 0 and have the valid ones be 1 and 2, directly corresponding to the button presses? That's what I do in my Ruby solution

C, 420 433 424 374 bytes
#define F(X,x) X=x==1?X+1:x==2?X-1:X;X=X<0?0:X>4?4:X;x=X==0?0:X==4?3:x
#define G(x) x=x==1?3:x==2?0:x==3?2:x+1
#define H(X,x) X*25,x==0||x==3?"stopped":x==1?"opening":"closing"
c,i,l,r,L,R,x[60];main(){while(i<60)printf("%d",x[i++]=random()%3);while(c<60){if(x[c]==1)G(l);else if(x[c]==2)G(r);printf("\n%d: (L:%d%% %s, R:%d%% %s)",x[c++],H(L,l),H(R,r));F(L,l);F(R,r);}}

Doesn't seed the random generator but does use random for a better distribution.
There must be a better way to golf this logic though...
110121100121212100112200222111200020111100022122202112202211002
1: (L:0% opening, R:0% stopped)
1: (L:25% stopped, R:0% stopped)
0: (L:25% stopped, R:0% stopped)
1: (L:25% closing, R:0% stopped)
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
1: (L:25% stopped, R:50% opening)
0: (L:25% stopped, R:75% opening)
0: (L:25% stopped, R:100% stopped)
1: (L:25% closing, R:100% stopped)
2: (L:0% stopped, R:100% closing)
1: (L:0% opening, R:75% closing)
2: (L:25% opening, R:50% stopped)
1: (L:50% stopped, R:50% stopped)
2: (L:50% stopped, R:50% opening)
1: (L:50% closing, R:75% opening)
0: (L:25% closing, R:100% stopped)
0: (L:0% stopped, R:100% stopped)
1: (L:0% opening, R:100% stopped)
1: (L:25% stopped, R:100% stopped)
2: (L:25% stopped, R:100% closing)
2: (L:25% stopped, R:75% stopped)
0: (L:25% stopped, R:75% stopped)
0: (L:25% stopped, R:75% stopped)
2: (L:25% stopped, R:75% opening)
2: (L:25% stopped, R:100% closing)
2: (L:25% stopped, R:75% stopped)
1: (L:25% closing, R:75% stopped)
1: (L:0% opening, R:75% stopped)
1: (L:25% stopped, R:75% stopped)
2: (L:25% stopped, R:75% opening)
0: (L:25% stopped, R:100% stopped)
0: (L:25% stopped, R:100% stopped)
0: (L:25% stopped, R:100% stopped)
2: (L:25% stopped, R:100% closing)
0: (L:25% stopped, R:75% closing)
1: (L:25% closing, R:50% closing)
1: (L:0% opening, R:25% closing)
1: (L:25% stopped, R:0% stopped)
1: (L:25% closing, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
2: (L:0% stopped, R:0% opening)
2: (L:0% stopped, R:25% stopped)
1: (L:0% opening, R:25% stopped)
2: (L:25% opening, R:25% closing)
2: (L:50% opening, R:0% opening)
2: (L:75% opening, R:25% stopped)
0: (L:100% stopped, R:25% stopped)
2: (L:100% stopped, R:25% closing)
1: (L:100% closing, R:0% stopped)
1: (L:75% stopped, R:0% stopped)
2: (L:75% stopped, R:0% opening)
2: (L:75% stopped, R:25% stopped)
0: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% closing)
2: (L:75% stopped, R:0% opening)
1: (L:75% opening, R:25% opening)
1: (L:100% closing, R:50% opening)

Older version 1:
c,i,l,r,L,R,x[60];main(){while(i<60)printf("%d",x[i++]=random()%3);while(c<60){if(x[c]==1)l=l==1?3:l==2?0:l==3?2:l+1;else if(x[c]==2)r=r==1?3:r==2?0:r==3?2:r+1;printf("\n%d: (L:%d%% %s, R:%d%% %s)",x[c++],L*25,l==0||l==3?"stopped":l==1?"opening":"closing",R*25,r==0||r==3?"stopped":r==1?"opening":"closing");L=l==1?L+1:l==2?L-1:L;R=r==1?R+1:r==2?R-1:R;L=L<0?0:L>4?4:L;R=R<0?0:R>4?4:R;l=L==0?0:L==4?3:l;r=R==0?0:R==4?3:r;}}

Older version 2:
c,i,l,r,L,R,x[60];g(){while(i<60)printf("%d",x[i++]=random()%3);}main(){g();while(c<60){if(x[c]==1)l=l==1?3:l==2?0:l==3?2:l+1;else if(x[c]==2)r=r==1?3:r==2?0:r==3?2:r+1;printf("%d: (L:%d%% %s, R:%d%% %s)\n",x[c++],L*25,l==0||l==3?"stopped":l==1?"opening":"closing",R*25,r==0||r==3?"stopped":r==1?"opening":"closing");L=l==1?L+1:l==2?L-1:L;R=r==1?R+1:r==2?R-1:R;L=L<0?0:L>4?4:L;R=R<0?0:R>4?4:R;l=L==0?0:L==4?3:l;r=R==0?0:R==4?3:r;}}

Can you convert that into code?

Ruby, 263 261 260 254 bytes
How did JavaScript's answer get so short??? It overtook mine while I was away and still is winning currently...
s=(1..60).map{rand 3}
puts s*''
D=1,2
d=[25]*3;a=[0]*3;m=[p]*3
s.map{|i|D.map{|j|m[j]&&a[j]+=d[j];(0..100)===a[j]+d[j]||i!=j&&(d[j]*=-1;m[j]=p)}
(m[i]^=1)||d[i]*=-1
puts"#{i}: (L%s, R%s)"%D.map{|j|":#{a[j]}% #{%w"stopped opening closing"[m[j]?d[j]:0]}"}}

PHP, 254 247 246 245 235 230 226 bytes
beating ES again!
for($t=60;$t--;)$s.=rand()%3;echo$s;for(;++$t<60;print"
$c: ($o[1], $o[2])")for($i=3;--$i;$o[$i]='.LR'[$i].':'.$d[$i]*25 .'% '.[opening,stopped,closing][abs($z-1)])if(((1&$z=&$r[$i])&&!(3&$d[$i]+=2-$z))|$i&$c=$s[$t])$z=++$z%4;

golfed down from these 311 (the first complete version, already had some golfing):
<?for($i=60;$i--;)$s.=rand(0,2);echo$s;$d=$r=[0,0];$n=[L,R];$p=[stopped,opening,stopped,closing];for($t=-1;++$t<60;print"
$c: (".join(', ',$x).")")for($m=$c=$s[$t],$i=-1;$i++<1;){if($r[$i]&1)if(!($d[$i]+=2-$r[$i])||4==$d[$i])$m|=$i+1;if($m&$i+1)$r[$i]=(1+$r[$i])%4;$x[$i]="$n[$i]:".($d[$i]*25)."% ".$p[$r[$i]];}

breakdown
for($t=60;$t--;)$s.=rand()%3;   // part 1               also initializes $t to -1
echo$s;
for(
    ;
    ++$t<60;
    print"\n$c: ($o[1], $o[2])" // print output
)
    for($i=3;--$i;  // loop $i from 2 to 1 (door number)
        // generate output
        $o[$i]='.LR'[$i].':'.$d[$i]*25 .'% '
        .[opening,stopped,closing][abs($z-1)]           // map 0123 to 1012
    )
        if(((1&$z=&$r[$i])  // if door in motion        ... and reference the array item
            &&!(3&              // 2. if end position   "&&" needed for short circuit
            $d[$i]+=2-$z        // 1. move door         2-$z maps 1,3 to 1,-1 = delta
            )
        )|$i&$c=$s[$t])     // 3. or if button $i pressed   "|" needed for no short circuit
            $z=++$z%4;          // rotate direction     ++$z%4 maps 0,1,2,3 to 1,2,3,0
        // generate output (loop post condition)
    // print output (loop post condition)

@Arnauld: got you! :)

Java 8 lambda, 500 characters
I did my best, here is what I came up with:
()->{String r="";int i=0,l=0,m=0,n=1,o=1,p=0,q=0;for(;i++<60;)r+=(int)(Math.random()*3);for(char s:r.toCharArray()){l+=p;m+=q;if(l>99&p>0){l=100;p=25*(((n=++n%4)-1)%2);}if(l<1&p<0){l=0;p=25*(((n=++n%4)-1)%2);}if(m>99&q>0){m=100;q=25*(((o=++o%4)-1)%2);}if(m<1&q<0){m=0;q=25*(((o=++o%4)-1)%2);}if(s<49);else if(s>49)q=25*(((o=++o%4)-1)%2);else p=25*(((n=++n%4)-1)%2);r+="\n"+s+": (L:"+l+"% "+(p<0?"closing":p>0?"opening":"stopped")+", R:"+m+"% "+(q<0?"closing":q>0?"opening":"stopped")+")";}return r;}

Ungolfed into a complete class:
public class Q91479 {

    public static String movedDoorsCombined() {
        String result = "";
        int i = 0, leftDoor = 0, rightDoor = 0, stepLeft = 1, stepRight = 1, changeLeft = 0, changeRight = 0;

        for (; i++ < 60;) {
            result += (int) (Math.random() * 3);
        }

        for (char step : result.toCharArray()) {
            // update stats
            leftDoor += changeLeft;
            rightDoor += changeRight;

            if (leftDoor > 99 & changeLeft > 0) {
                leftDoor = 100;
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            if (leftDoor < 1 & changeLeft < 0) {
                leftDoor = 0;
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            if (rightDoor > 99 & changeRight > 0) {
                rightDoor = 100;
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }
            if (rightDoor < 1 & changeRight < 0) {
                rightDoor = 0;
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }

            if (step < 49) {
                // 0
            }
            else if (step > 49) {
                // right
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }
            else {
                // left
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            result += "\n" + step + ": (L:" + leftDoor + "% "
                        + (changeLeft < 0 ? "closing" : changeLeft > 0 ? "opening" : "stopped")
                        + ", R:" + rightDoor + "% "
                        + (changeRight < 0 ? "closing" : changeRight > 0 ? "opening" : "stopped")
                        + ")";
        }
        return result;
    }
}

Pretty straight forward. The stepLeft/stepRight variables circle from 0-3. Doing some simple maths changeLeft/changeRight hold the respective relative changes per step, which will be added to leftDoor/rightDoor. Many if statements for catching when the door has to stop on it's own.
Feel free to help me shorten this, I think there's a lot to do.

Haskell (lambdabot) - 409 bytes
p=(cycle[0,1,0,-1],0)
t(d:q,s)=(if d/=0&&(s+d<1||3<s+d)then q else d:q,s+d)
k i(a,b)=[o i,": (L:",j a,", ","R:",j b,")"]>>=id
j(d:_,s)=o(round$(fromIntegral s/4)*100)++"% "++words"closing stopped opening"!!(d+1)
s=scanl$ \(a,b)i->i(t a,t b)
main=do b<-(fmap(round.(*(2::Float))).take 60<$>randoms)<$>getStdGen;putStrLn.unlines$(o=<<b):(zipWith k b.w.s(p,p)$([id,f$f w,second$f w]!!)<$>b)
o=show;f=first;w=tail

Please add all the necessary imports, e.g. for randoms to your code (and byte count). If there's an interpreter that imports by default, refer to it in the language name.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Highlight the Bounding Box, Part II: Hexagonal Grid
You're given a hexagonal grid of the characters . and #, like this:
 . . . . . . . .
. . . . # . . .
 . # . . . # . .
. . . # . . . .
 . . . . . # . .
. . . . . . . .

Your task is to fill the entire axis-aligned bounding box of the # with further #:
 . . . . . . . .
. . # # # # . .
 . # # # # # . .
. . # # # # # .
 . . # # # # . .
. . . . . . . .

The axis-aligned bounding box is the smallest convex hexagonal shape which contains all the #. Note that in the case of the hexagonal grid, there are three axes to consider (W/E, SW/NE, NW/SE):

Here is another example to show that in some cases, one or more sides will contain only one #:
. . . . . . . .         . . . . . . . .
 . # . . . . . .         . # # # # . . .
. . . . . # . .         . . # # # # . .
 . . # . . . . .         . . # # # . . .
. . . . . . . .         . . . . . . . .

You can either view these as hexagons with degenerate sides, or you can draw the bounding box around them, like I have done above, in which case they are still hexagons:

Too hard? Try Part I!
Rules
You may use any two distinct non-space printable ASCII characters (0x21 to 0x7E, inclusive), in place of # and .. I'll continue referring to them as # and . for the remainder of the specification though.
Input and output may either be a single linefeed-separated string or a list of strings (one for each line), but the format has to be consistent.
You may assume that the input contains at least one # and all lines are the same length. Note that there are two different "kinds" of lines (starting with a space or a non-space) - you may not assume that the input always starts with the same type. You may assume that the bounding box always fits inside the grid you are given.
You may write a program or a function and use any of the our standard methods of receiving input and providing output.
You may use any programming language, but note that these loopholes are forbidden by default.
This is code-golf, so the shortest valid answer – measured in bytes – wins.
Test Cases
Each test case has input and output next to each other.
#    #

 . .      . .
# . #    # # #
 . .      . .

 . #      . #
. . .    . # .
 # .      # .

 # .      # .
. . .    . # .
 . #      . #

 # .      # .
# . .    # # .
 . #      # #

 . #      # #
# . .    # # #
 . #      # #

. . #    . # #
 . .      # #
# . .    # # .

# . .    # # .
 . .      # #
. . #    . # #

. . . . . . . .         . . . . . . . .
 . . # . # . . .         . . # # # . . .
. . . . . . . .         . . . # # . . .
 . . . # . . . .         . . . # . . . .

. . . . . . . .         . . . . . . . .
 . . # . . . # .         . . # # # # # .
. . . . . . . .         . . . # # # # .
 . . . # . . . .         . . . # # # . .

. . . . . . . .         . . . . . . . .
 . # . . . . . .         . # # # # . . .
. . . . . # . .         . . # # # # . .
 . . . . . . . .         . . . . . . . .

. . . . . . . .         . . . . . . . .
 . # . . . . . .         . # # # # . . .
. . . . . # . .         . . # # # # . .
 . . # . . . . .         . . # # # . . .

. . . . # . . .         . . # # # # . .
 . # . . . # . .         . # # # # # . .
. . . # . . . .         . . # # # # # .
 . . . . . # . .         . . # # # # . .

My head is spinning trying to find any obvious pattern. You said 'hexagonal' but there are only two inputs form into hexagons in the test cases. I'm lost.

@Anastasiya-Romanova秀 If you picture the shape as going through the centres of the outer characters, then yes some hexagons will have degenerate sides (like in the rectangular grid, where you can get cases where the rectangle reduces to a line). However, if you draw the rectangle around the characters (as I have done in the diagram), all the examples are hexagons (some of which have very short sides).

@Anastasiya-Romanova秀 Does the new diagram help?

I! looks like II if I have the wrong glasses on..

@Neil Or, you know, too much alcohol ;)

I don't understand these boxes fine. Do I have to process multiple boxes with my program, line by line, column by column? Yea, I'm beginner and english isn't my first language :p

@nicematt No, you take a single grid (e.g. the very first code block in the challenge) and return a single grid (e.g. the second code block in the challenge). The final code block is just compressed a bit to save space for the large number of test cases. Your program should be able to receive any of the grids on the left and produce the corresponding grid on the right.

Sorry @MartinEnder, I still don't get it. You don't have to explain anything anymore, let's see how one approaches this challenge, maybe I can get some ideas. Thanks.

@MartinEnder Can I right-pad?

@LeakyNun Yes: "You may assume that [...] all lines are the same length."

Can I also take input without the spaces?

@ThreeFx No, because then there's no way to tell whether the first row was indented or not.

Technically I could, since they would have different length, but I get what you mean (it's not a costly workaround relatively speaking).

@ThreeFx They wouldn't always have different lengths (see for instance the 8x4-sized test cases at the end).

I know it's highly unlikely but I want to see a Hexagony solution

Actually a quincunx lattice and not a hexagonal one, the angles are slightly off to be hexagonal. But +1 for fun problem.

@mathreadler I never said they were regular hexagons. ;)

What if the total field would need to grow to contain the hexagon ? Think of an input consisting of a narrow high vertical line

@TonHospel Ohhh, very good catch. I didn't consider that at all (and apparently no one else either so far). As I doubt any of the existing answers will handle that correctly, I'll say you can assume that won't happen.

Pyth, 82 71 bytes

L,hbebMqH@S+GH1KhMyJs.e,Lkfq\#@bTUb.zA,ySm-FdJySsMJj.es.eXW&&gKkgG-kYgH+kYZ\.\#b.z
MqH@S[hGHeG)1j.es.eXW&&ghMJs.e,Lkfq\#@bTUb.zkgSm-FdJ-kYgSsMJ+kYZ\.\#b.z

Try it online!
Explanation

Let A be the point with the lowest y-coordinate and B the point with the highest y-coordinate.
Let C be the point with the lowest (x-value minus y-value) and D the point with the highest.
Let E be the point with the lowest (x-value plus y-value) and F the point with the highest.

Then it is equivalent to finding the coordinates which the y-coordinate is between A and B, the x-value minus y-value is between C and D, and the x-value plus y-value is between E and F.

the first time when I could post a solution earlier, if only the SE android app could correctly handle tab characters (for some reason they disappeared when pasted) :/

@SargeBorsch I'm sorry :(

haha why, it's SE Android app that made me fail :D

Haskell, 256 254 243 bytes
import Data.List
f=z(\l->(,).(,))[0..]l)[0..]
q l=m(m(\e->min(snd e).(".#"!!).fromEnum.and.z($)(m(\x y->y>=minimum x&&y<=maximum x).transpose.m b.filter((==)'#'.snd).concat$l)$b e))l
b=(m uncurry[const,(-),(+)]<*>).pure.fst
z=zipWith
m=map
q.f

Thanks @Damien for golfing f!
Input is taken as list of list of chars, output is provided the same way.
Soo this was a beast to write. It's based on LeakyNun's idea using a maximum and minimum based filtering on the coordinates of the items.
I'm really surprised by the fact that m=map actually saves bytes since it seems so costly.

Explanation:
Here's a slightly less butchered version (emphasis on slightly):
import Data.List
f=zipWith(\y l->zipWith(\x e->((y,x),e))[0..]l)[0..]
p=map(\x y->y>=minimum x&&y<=maximum x).transpose.map b.filter((==)'#'.snd).concat
q l=map(map(\e->min(snd e).(".#"!!).fromEnum.and.zipWith($)(p$l)$b e))l
b=(map uncurry[const,(-),(+)]<*>).pure.fst

f is a function which assigns each char an index (y-index, x-index) while preserving the original structure of the list.
b: Given an item of the indexed list, b computes [y-index, y - x, y + x].
p: Given the indexed field, return 3 functions Int -> Bool, the first of which is the check of the y-index, the second of the difference and the third of the sum. min(snd e) takes care of the spaces (a space is smaller than both). This function is inlined in the golfed code.
q given the indexed field, change all necessary . to # by checking if that specific field return True to every test function.

The final solution is then the composition of q and f.

f=z(\y->z((,).(,)y)[0..])[0..]

or h x=z x[0..] f=h$h.curry(,)

Jelly, 45 3513 42 41 bytes
Ṁ€»\
ṚÇṚ«Çṁ"
ŒDṙZL$ÇṙL’$ŒḌ«Ç
ṚÇṚ«Ç
n⁶aÇo⁶

This is a list of links; the last one has to be called on the input to produce the output.
I/O is in form of string arrays, where . indicates empty and @ indicates filled.
Try it online! or verify all test cases.
Background
Let's consider the following example.
. . . . . . . .
 . @ . . . . . .
. . . . . @ . .
 . . @ . . . . .

By drawing a pair or parallel lines – the closest pair that encloses all filled positions – in each of the three directions, we can determine the hexagonal bounding box.
In the implementation, we replace all characters between those two lines with @, and everything outside these lines with ., with the possible exception of diagonals that only contains spaces).
For the horizontal axis, this gives
................
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@

for the falling diagonal axis, it gives
..@@@@@@@......
...@@@@@@@......
....@@@@@@@.....
 ....@@@@@@@....

and for the raising diagonal axis, it gives
....@@@@@@@@@...
...@@@@@@@@@....
..@@@@@@@@@....
.@@@@@@@@@.... .

By taking the character-wise minimum of all three, since . < @, we get
...............
...@@@@@@@......
....@@@@@@@....
 ....@@@@@.... .

All that's left to do is restoring the spaces.
How it works
n⁶aÇo⁶           Main link. Argument: A (array of strings)

n⁶               Not-equal space; yield 0 for spaces, 1 otherwise.
  aÇ             Take the logical AND with the result the 4th helper link.
                 This will replace 1's (corresponding to non-space characters) with
                 the corresponding character that result from calling the link.
    o⁶           Logical OR with space; replaces the 0's with spaces.

ṚÇṚ«Ç            4th helper link. Argument: A

Ṛ                Reverse the order of the strings in A.
 Ç               Call the 3rd helper link.
  Ṛ              Reverse the order of the strings in the resulting array.
    Ç            Call the 3rd helper link with argument A (unmodified).
   «             Take the character-wise minimum of both results.

ŒDṙZL$ÇṙL’$ŒḌ«Ç  3rd helper link. Argument: L (array of strings)

ŒD               Yield all falling diagonals of L. This is a reversible operation,
                 so it begins with the main diagonal.
   ZL$           Yield the length of the transpose (number of columns).
  ṙ              Shift the array of diagonals that many units to the left.
                 This puts the diagonals in their natural order.
      Ç          Call the helper link on the result.
        L’$      Yield the decremented length (number of columns) of L.
       ṙ         Shift the result that many units to the left.
                 This puts the changed diagonals in their original order.
           ŒḌ    Undiagonal; reconstruct the string array.
              Ç  Call the 2nd helper link with argument L (unmodified).
             «   Take the character-wise minimum of both results.

ṚÇṚ«Çṁ"          2nd helper link. Argument: M (array)

Ṛ                Reverse the rows of M.
 Ç               Call the 1st helper link on the result.
  Ṛ              Reverse the rows of the result.
    Ç            Call the 1nd helper link with argument M (unmodified).
   «             Take the minimum of both results.
     ṁ"          Mold zipwith; repeat each character in the result to the left
                 as many times as needed to fill the corresponding row of M.

Ṁ€»\             1st helper link. Argument: N (array)

Ṁ€               Take the maximum of each row of N.
  »\             Take the cumulative maxima of the resulting characters.

Python 3, 380 378 348 346 bytes
Note that the indentation is with tabs, not spaces.
Golfed version:
def s(i):
    L=i.splitlines();E=enumerate;A=lambda x,y:(y,x+y,x-y);N=(2**64,)*3;X=(-2**64,)*3
    for y,l in E(L):
        for x,c in E(l):
            if c=='#':p=A(x,y);X=tuple(map(max,X,p));N=tuple(map(min,N,p))
    R=''
    for y,l in E(L):
        for x,c in E(l):
            if c!='.':R+=c
            else:p=A(x,y);f=all(N[j]<=p[j]<=X[j]for j in range(0,3));R+='.#'[f]
        R+='\n'
    return R

Test it on Ideone
Explanation (for ungolfed version below):
All processing is done without any conversion, space characters are simply skipped.
Function axes_pos calculates 3-tuple of imaginary "3D" coordinates, they are accumulated into (element wise) minimum and maximum 3-tuples (bmin, bmax) for all # characters.
Coordinates are calculated in def axes_pos(x, y): return y, x + y, lc - y + x;
where X counts from 0 to right, and Y counts from 0 to bottom (from first line to last).
First imaginary coordinate is basically Y, because it's obvious why. Its axe is orthogonal to green bounds (in the OP's pictures)
Second is orthogonal to red bounds, and third is orthogonal to blue bounds.
In the second pass, replacement is done for all . characters which "3D" coordinates fall into bmin..bmax range, element wise — this is checked in this expression all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3)).
Ungolfed version with tests, also on Ideone:
def solve(i):
    ls = i.splitlines()
    lc = len(ls)

    def axes_pos(x, y):
        return y, x + y, lc - y + x

    I = 2 ** 64
    bmin = (I, I, I)
    bmax = (0, 0, 0)

    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '#': continue
            p = axes_pos(x, y)
            bmax = tuple(map(max, bmax, p))
            bmin = tuple(map(min, bmin, p))

    result = ''
    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '.':
                result += char
            else:
                p = axes_pos(x, y)
                f = all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3))
                result += '#' if f else char
        result += '\n'

    return result

def run_test(a, b):
    result = solve(a)
    if result != b:
        raise AssertionError('\n' + result + '\n\nshould be equal to\n\n' + b)

def run_tests():
    run_test(
        "#\n",

        "#\n")

    run_test(
        " . . \n"
        "# . #\n"
        " . . \n",

        " . . \n"
        "# # #\n"
        " . . \n")

    run_test(
        " . # \n"
        ". . .\n"
        " # . \n",

        " . # \n"
        ". # .\n"
        " # . \n")

    run_test(
        " # . \n"
        ". . .\n"
        " . # \n",

        " # . \n"
        ". # .\n"
        " . # \n")

    run_test(
        " # . \n"
        "# . .\n"
        " . # \n",

        " # . \n"
        "# # .\n"
        " # # \n")

    run_test(
        " . # \n"
        "# . .\n"
        " . # \n",

        " # # \n"
        "# # #\n"
        " # # \n")

    run_test(
        ". . . . . . . . \n"
        " . . # . # . . .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # . . .\n"
        ". . . # # . . . \n"
        " . . . # . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . . # . . . # .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # # # .\n"
        ". . . # # # # . \n"
        " . . . # # # . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . . . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . . . . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . # . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . # # # . . .\n")

    run_test(
        ". . . . # . . . \n"
        " . # . . . # . .\n"
        ". . . # . . . . \n"
        " . . . . . # . .\n",

        ". . # # # # . . \n"
        " . # # # # # . .\n"
        ". . # # # # # . \n"
        " . . # # # # . .\n")

if __name__ == '__main__':
    run_tests()

Update 1:

Removed unnecessary -1 for third imaginary coordinate, because it doesn't change anything

Update 2,3:

Partially implemented improvements suggested by Leaky Nun + my own too.

Do we basically use the same algorithm? Could you append an explanation?

def A(x,y):return y,x+y,len(L)-1-y+x -> A=lambda x,y:(y,x+y,len(L)-1-y+x)

Also, list comprehensions could help you golf some bytes off.

@LeakyNun hmm I guess the algorithm is similar. (Can't really read Pyth, but sounds similar to your explanation) I'll add the explanation soon.

@LeakyNun added explanation

Can you explain how the imaginary 3D coordinates are generated?

@LeakyNun yes, added this. Not sure if I explained it good though.

Would you mind if I port my Pyth answer to Python?

@LeakyNun No problem. I know it'd probably be shorter than this.

I think you can turn len(L)-y+x into x-y

@LeakyNun oh yeah. however, then sometimes it'll be negative, and I think I can construct a test when it'll fail (but the tests from the question do work). So the correct minimum should be something like -inf. But it's shorter overall.

You can take in list of lines

Python, 237 230 bytes
7 bytes thanks to Dennis.
def f(a):i=range(len(a[0]));j=range(len(a));b,c,d=map(sorted,zip(*[[x,x+y,x-y]for y in i for x in j if"?"<a[x][y]]));return[[[a[x][y],"#"][(a[x][y]>" ")*(b[0]<=x<=b[-1])*(c[0]<=x+y<=c[-1])*(d[0]<=x-y<=d[-1])]for y in i]for x in j]

Port of my answer in Pyth.
Takes array of lines as input, outputs 2D array of characters.

Python 2: Ideone it!
Python 3: Ideone it!

Perl, 128 126 bytes
Includes +6 for -0F\n
Run with input on STDIN. Use 1 for filled, 0 for empty.
Lines do not have to be padded with spaces at the end:
perl -M5.010 hexafill.pl
 0 0 0 0 0 0 0 0
0 0 1 1 1 1 0 0
 0 1 1 1 1 1 0 0
0 0 1 1 1 1 1 0
 0 0 1 1 1 1 0 0
0 0 0 0 0 0 0 0
^D

hexafill.pl
#!/usr/bin/perl -0F\n
$-=map{s%$=%$=^!map{/$/;grep{pos=$`;$=?$_|="!"x$`.1:!/\b.*\G./}${--$@}}@F-$-+pos,$-+pos,$-%eeg;--$-;$=||say}@F while$=--

Uses cube coordinates. Determine maximum and minimum during the $= == 1 loop and fills coordinates between these bounds during the $= == 0 loop. The first 58 loops are pointless and are only there to fill $- with the number of lines

TSQL, 768 bytes
I wrote a query to solve this - which I found quite difficult. It is not able to compete with all the excellent shorter answer. But wanted to post it anyway for those interested. Sorry about the length of the answer - hoping codegolf is also about different approachs.
Golfed:
DECLARE @ varchar(max)=
'
. . . . # . . .
 . # . . . # . .
. . . # . . . .
 . . . . . # . .
. . . . . . . .
'

;WITH c as(SELECT cast(0as varchar(max))a,x=0,y=1,z=0UNION ALL SELECT SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),z+1FROM c WHERE LEN(@)>z)SELECT @=stuff(@,z-1,1,'#')FROM c b WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)or exists(SELECT*FROM c WHERE b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.y>y and'#'=a))and a='.')and(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))OPTION(MAXRECURSION 0)PRINT @

Ungolfed:
DECLARE @ varchar(max)=
'
. . . . # . . .
 . # . . . # . .
. . . # . . . .
 . . . . . # . .
. . . . . . . .
'
;WITH c as
(
  SELECT
    cast(0as varchar(max))a,x=0,y=1,z=0
  UNION ALL
  SELECT
    SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),
    IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),
    z+1
  FROM c
  WHERE LEN(@)>z
)
SELECT @=stuff(@,z-1,1,'#')FROM c b
WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)
or exists(SELECT*FROM c WHERE b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.y>y and'#'=a)
)and a='.')
and
(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)
and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))
and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))
OPTION(MAXRECURSION 0)
PRINT @

Fiddle ungolfed

GNU Octave, 212, 196 bytes
Maybe not really a golfer's favourite choice language, but that's what makes the challenge, isn't it? Assuming m is taken as a char matrix: 178 bytes stand alone and 196 if stuffed into a function.
golfed:
function k=f(m)[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;for j=1:3l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});endk(s&mod(x+y,2))=['#']end

ungolfed:
function k=f(m)
[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;
for j=1:3
  l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);
  s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});
end
k(s&mod(x+y,2))=['#']
end

Explanation : we build a coordinate system, 3 axes - orthogonal to the hexagons sides, find max and min of each coordinate, then build a logical mask starting with 1 everywhere and logically and:ing each coordinate max and min constraint, finally re-setting each remaining "true" position to "#" char.
If you want to test it, you can just create m matrix like this:
m = [' . . . . . . . .. . . . # . . .  . # . . . # . .. . . # . . . .  . . . . . # . .. . . . . . . . ']; m = reshape(m,[numel(m)/6,6])';

and then call the f(m) and compare with m by building a matrix with both of them in:
['     before           after      ';m,ones(6,1)*'|',f(m)]

(Belated) Welcome to PPCG! Octave answers are more than welcome. :) Two things though: 1) please include the code that you've actually counted(without unnecessary whitespace), so that people can check the score more easily. You can include a readable version separately. 2) It appears that your submission is a snippet which assumes the input to be stored in m and the output to be stored in k. Answers should always be full programs or callable functions.

Thanks! Yes you are right, I have embedded k and m in a function f now and added a snippet constructing a first test m for validation.