Implemente una calculadora de script de operación entera simple.

Concepto

El acumulador comienza en 0 y tiene operaciones realizadas en él. Al final de la salida del programa, el valor del acumulador.

Operaciones:

• +agrega 1al acumulador
• -resta 1del acumulador
• * multiplica el acumulador por 2
• / divide el acumulador por 2

Script de muestra

La entrada ++**--/debe dar la salida 3.

Implementación de ejemplo

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

Reglas

• Este es el código de golf , por lo que la respuesta más baja en bytes gana, pero no está seleccionada.
• Se recomiendan implementaciones creativas.
• Las lagunas estándar están prohibidas.
• Obtiene el programa a través de stdin o argumentos, y puede generar la respuesta a través del valor de retorno o stdout.
• Que te diviertas.
• La división se trunca porque es una división entera.
• El programa -/vuelve -1.

Casos de prueba

*///*-*+-+
-1
/*+/*+++/*///*/+-+//*+-+-/----*-*-+++*+**+/*--///+*-/+//*//-+++--++/-**--/+--/*-/+*//*+-*-*/*+*+/+*-
-17 
+++-+--/-*/---++/-+*-//+/++-*--+*+/*/*/++--++-+//++--*/***-*+++--+-*//-*/+*/+-*++**+--*/*//-*--**-/-*+**-/*-**/*+*-*/--+/+/+//-+*/---///+**////-*//+-+-/+--/**///*+//+++/+*++**++//**+**+-*/+/*/*++-/+**+--+*++++/-*-/*+--/++*/-++/-**++++/-/+/--*/-/+---**//*///-//*+-*----+//--/-/+*/-+++-+*-*+*+-/-//*-//+/*-+//+/+/*-/-/+//+**/-****/-**-//+/+-+/*-+*++*/-/++*/-//*--+*--/-+-+/+/**/-***+/-/++-++*+*-+*+*-+-//+/-++*+/*//*-+/+*/-+/-/*/-/-+*+**/*//*+/+---+*+++*+/+-**/-+-/+*---/-*+/-++*//*/-+-*+--**/-////*/--/*--//-**/*++*+/*+/-+/--**/*-+*+/+-*+*+--*///+-++/+//+*/-+/**--//*/+++/*+*////+-*-//--*+/*/-+**/*//+*+-//+--+*-+/-**-*/+//*+---*+//*/+**/*--/--+/*-*+*++--*+//+*+-++--+-*-*-+--**+/+*-/+*+-/---+-*+-+-/++/+*///*/*-+-*//-+-++/++/*/-++/**--+-////-//+/*//+**/*+-+/+/+///*+*///*-/+/*/-//-*-**//-/-+--+/-*--+-++**++//*--/*++--*-/-///-+/+//--+*//-**-/*-*/+*/-*-*//--++*//-*/++//+/-++-+-*/*-+++**-/-*++++**+-+++-+-***-+//+-/**-+/*+****-*+++*/-*-/***/-/*+/*****++*+/-/-**-+-*-*-++**/*+-/*-+*++-/+/-++*-/*-****-*
18773342

Python 2, 48 bytes

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

Ciervas +2, -2, *2, o /2. Al hacer +2y en -2lugar de +1y -1, estamos trabajando en unidades duplicadas, por lo que el resultado final debe reducirse a la mitad. Excepto, la división de piso /ahora necesita redondearse a un múltiplo de 2, lo que se hace con &-2.

Haskell, 51 bytes

x#'+'=x+1
x#'-'=x-1
x#'*'=x*2
x#_=div x 2 
foldl(#)0

Ejemplo de uso: foldl(#)0 $ "++**--/"-> 3.

Jalea , 18 17 bytes

‘

’

:2
Ḥ
O0;ṛĿ/

Pruébalo en línea!

Cómo funciona

Las primeras seis líneas definen enlaces auxiliares con índices que van del 1 al 6 ; aumentan, no hacen nada, disminuyen, no hacen nada, se reducen a la mitad (pisos) y se duplican.

El enlace principal O0;ṛĿ/- convierte los caracteres de entrada a sus puntos de código ( O), antepone un 0 (valor inicial) a la matriz de puntos de código 0;, luego reduce la matriz generada de la siguiente manera.

El valor inicial es el primer elemento de la matriz, es decir, el 0 antepuesto . Se ṛĿllama al enlace rápido para cada elemento siguiente en la matriz, con el último valor de retorno como argumento izquierdo y el elemento actual como derecho. Inspecciona su argumento correcto ( ṛ) y evalúa el enlace con ese índice de forma monádica ( Ŀ), aplicando así la operación deseada.

Python 2, 54 bytes

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

La entrada se toma como un literal de cadena. ~ord(c)%5%3asigna los operadores a los correspondientes operandos derechos.

Anteriormente, utilicé hash(c)%55%3lo que no produjo resultados consistentes entre diferentes versiones de Python. Esto me animó a explorar otras fórmulas.

SILOS , 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

Toma los códigos ASCII de los operadores.

Pruébelo en línea con casos de prueba:
-/
++**--/
*///*-*+-+

Máquina de Turing - 23 estados (684 bytes)

Pruébalo aquí - enlace permanente

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

La entrada no debe contener ningún '*' ya que es un carácter especial en el código de máquina de Turing. Use 'x' en su lugar. Emite la respuesta en binario.

Código no ofuscado

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

Explicación de los estados:

Inicialización:
estos estados se visitan una vez al comienzo de cada ejecución, comenzando con init2

• init2: muévete completamente hacia la derecha y pon un '.'. De esa manera, el TM sabe cuándo detenerse. Cambie a 'init0'.
• init0: mueve toda la espalda hacia la izquierda hasta que la cabeza lea un espacio. Luego mueva una celda hacia la izquierda. Cambie a 'init1'.
• init1: Pon un cero y mueve una celda a la derecha y cambia a 'readop'.

Instrucciones de lectura:
estos estados se visitarán varias veces durante todo el programa

• readop: se mueve completamente hacia la derecha hasta que lee un operador o el '.'. Si golpea a un operador, cambie al estado correspondiente (+, -, x, /). Si toca un '.', Cambie al estado 'fin'.

• return: Devuelve la cabeza al espacio vacío entre el total acumulado y los operadores. Luego cambia a 'readop'.

Operaciones:
estas operaciones hacen el trabajo sucio real

• +: Mueve hacia la izquierda hasta que la cabeza lea cualquier carácter que no sea un espacio en blanco. Si este personaje es un '-', muévase a la izquierda y cambie a 'dec'. De lo contrario, cambie a 'inc'.

• -: Similar a '+', excepto cambiar a 'inc' si hay un '-' y 'dec' de lo contrario.

• inc: si el dígito debajo de la cabecera es un 0 (o un espacio en blanco), cámbielo a 1 y cambie a 'cero'. Si el dígito es un 1, cámbielo a 0, luego repita en el siguiente dígito.

• dec: Similar a inc, excepto que 1 va a 0, 0 va a 1, y si la cabeza lee un espacio en blanco, cambie a 'neg'.

• x, x0, x1: Bitshift el número uno a la izquierda. Cambiar a 'volver'.

• /, //, div, div0, div1: muévete completamente a la derecha del número, luego desplaza uno a la derecha. Si hay un '-', cambie a 'inc'. Esto simula redondear números negativos. De lo contrario, cambie a 'cero'

• neg: coloque un '-' después del número y luego cambie a 'readop'

• cero, cero1, cero2: elimine los ceros a la izquierda y cambie a 'readop'

Limpieza: hace que la salida sea presentable

• fin, min: mueva el '-' delante del número si es necesario. Detener.

Perl 6 , 53  52 bytes

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

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

Explicación:

# 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)
}

Uso:

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;}

Caja de varitas

05AB1E , 20 bytes

¡Gracias a Enigma por arreglar el -/error!

Para 16 bytes si no fuera número entero división: Î"+-*/""><·;"‡.V.

Î…+-*"><·"‡'/"2÷":.V

Explicación:

Î                      # 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

Utiliza la codificación CP-1252 . Pruébalo en línea!

JavaScript ES6, 80 68 bytes

k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}‌​[o],0)

¡Ahorró la friolera de 12 bytes gracias a Neil!

Ruby, 48 44 42 + 1 = 43 bytes

+1 byte para -nbandera. Toma entrada en STDIN.

i=0
gsub(/./){i=i.send$&,"+-"[$&]?1:2}
p i

Véalo en ideone (usos $_ya que ideone no toma banderas de línea de comando): http://ideone.com/3udQ3H

PHP 76 bytes

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

Python 2, 58 56 bytes

-2 bytes gracias a @Lynn

r=0
for c in input():exec'r=r'+c+`2-ord(c)%11%3`
print r

Los ordinales de los personajes +-*/son 43,45,42,47de módulo 11 son 10,1,9,3de módulo 3 son aquellos 1,1,0,0, 2 menos los que están 1,1,2,2dando las cantidades que necesitamos para cada operación: r=r+1, r=r-1, r=r*2, yr=r/2

Anterior:

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

Mathematica, 83 73 70 bytes

^{10 bytes guardados debido a @MartinEnder .}

(#/*##2&@@#/.Thread[{"+","-","*","/"}->{#+1&,#-1&,2#&,⌊#/2⌋&}])@0&

Función anónima. Toma una lista de caracteres como entrada y devuelve un número como salida. Sugerencias de golf bienvenidas.

SILOS , 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

Pruébalo en línea!

Método de entrada sano. División entera correcta (redondeada hacia -infinito).

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;}

Sin golf:

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;
}

Se supone que la entrada es válida. La división por dos se realiza desplazando un bit hacia la derecha, porque la división regular siempre se redondea hacia cero, y el desplazamiento de bits siempre se reduce. El incremento y la disminución hacen un uso útil de la distancia 1 entre los códigos ASCII para +y -.

Javascript (ES6), 57 bytes (matriz) / 60 bytes (entero)

Devolver una matriz de todos los resultados intermedios:

o=>[...o].map(c=>x=[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],x=0)

Por ejemplo, la salida para "++**--/"será [1, 2, 4, 8, 7, 6, 3].

Devolviendo solo el resultado final:

o=>[...o].reduce((x,c)=>[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],0)

Cómo funciona

Ambas soluciones se basan en la misma idea: el uso de la función hash perfecta eval(2+c+3)&3para mapear los diferentes caracteres operadores cen [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

JavaScript (ES6), 57

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

Nota: el valor inicial para el acumulador es la cadena del programa, utilizando operaciones de bit (~, >>, <<, |) se convierte a 0 en el primer uso.

Como nota al margen, la respuesta inteligente de @xnor obtendría 40 puntos portados a javascript:

a=>[...a].map(c=>a=eval(~~a+c+2))&&a>>1

(si te gusta esto, vota por él)

Prueba

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()'><pre id=O></pre>

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);}

Utiliza java 8 transmisiones.

GNU sed, 65 59 57 bytes

Editar: 2 bytes más cortos gracias a los comentarios de Toby Speight

s/[+-]/1&/g
s/*/2&/g
s:/:d0>@2&:g
s/.*/dc -e"0[1-]s@&p"/e

Correr:

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

Salida:

-1

El sedscript prepara la entrada para la dcllamada de shell al final, este último acepta la entrada en notación polaca inversa . En la división, si el número es negativo ( d0>), se llama al [1-]comando de disminución almacenado en el registro @. Ejemplo de conversión: + - * /-> 1+ 1- 2* d0>@2/.

PHP, 75 bytes

Utiliza una versión modificada de la respuesta de Jörg Hülsermann .

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

Se basa en gran medida en la sustitución de cadenas, utilizando una expresión regular simple ( ~.~).

La variable $sse reasigna con el nuevo valor para cada carácter. Al final, genera el resultado.

Pruébalo aquí:

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);

O prueba: http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa

Diferencias:

• En lugar de echo$s, estoy usando sprintf($s). Ambos realizan la misma acción en números. Como esto es solo para probar, está bien.
• En caso de que no haya un argumento aprobado, se ejecutará como si hubiera pasado ++*+como primer argumento, que debería mostrar 5.

Lote, 61 bytes

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

Traducción de la respuesta de @ xnor's xcellent Python.

Pyke, 24 22 bytes

\*\}:\/\e:\+\h:\-\t:0E

Pruébalo aquí!

O 12 bytes (no competitivo)

~:"ht}e".:0E

Pruébalo aquí!

Agregar translatenodo: básicamente, buscar y reemplazar múltiples

~:           -   "+-*/"
        .:   -  input.translate(^, V)
  "ht}e"     -   "ht}e"
          0E - eval(^, stack=0)

PHP, 104 102 82 bytes

Primera versión con eval:

$i=0;while($c<9999)eval('$i'.['+'=>'++','-'=>'--','*'=>'*=2','/'=>'>>=1'][$argv[1]{$c++}].';');echo$i;

Segunda versión con operadores ternarios:

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

Toma la cadena de entrada como primer argumento de la línea de comando.

Este "solo" funciona para cadenas de entrada de menos de 10,000 caracteres, lo que debería ser suficiente. Probado con todos los casos de prueba, desafortunadamente no se puede ahorrar en la inicialización al principio.La segunda versión funciona con cadenas de cualquier longitud y sin inicialización. :-)

El elemento principal es la función eval que manipula en $ibase a un mapa de operaciones aritméticas, que son bastante sencillas excepto por la división. PHP devuelve un flotante cuando se usa /y intdivtiene demasiados bytes, por lo que hacemos un desplazamiento a la derecha .

Actualizaciones

1. Guardado 2 bytes por el acortamiento $i=$i>>1de $i>>=1la división de número entero.
2. Descartó eval a favor de los operadores ternarios.

Python 3, 98 66 60 bytes

Gracias Tukkax!

No es tan elegante como la otra respuesta, pero no puedo competir con ellos sin plagio.

i=0
for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4]
print(i)

Además, también tengo una solución lambda recursiva

73 67 bytes (¡mejorado!)

s=lambda x,z=0:s(x[1:],z+[1,-z//2,-1,z][ord(x[0])%23%4])if x else z

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)

Comentado

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 

La estrategia es refinar los +, -, %operadores. Divida la cadena y luego analice la cadena en una larga lista de funciones, para alimentar al Reduce()'sacumulador.

No podía seguir jugando al golf. Si alguien puede ponerse b=body<-a trabajar, podría haber algunos bytes de ahorro (refine cada función con bafter "-"="+"="/"="*"). Inicialmente trató de sustituir y analizar eval, pero el orden de las operaciones y los paréntesis fueron aterradores.

Lex + C, 78 , 74 , 73 bytes

El primer personaje es un espacio.

 c;F(){yylex(c=0);return c;}
%%
\+ c++;
- c--;
\* c*=2;
\/ c=floor(c/2.);

Lee desde stdin, devuelve resultado.

Compilar con lex golfed.l && cc lex.yy.c main.c -lm -lfl, prueba principal:

int main() { printf("%d\n", F()); }

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}

Sin golf:

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

Un programa completo que toma la entrada como una cadena e imprime el resultado.

Este es un puerto de la respuesta Python de @ xnor .

Pruébalo en línea

Cómo funciona

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 

PHP, 79 bytes

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