Su tarea es tomar una lista de argumentos que sean enteros u operadores, y analizarlos así:

1. Hay un operador actual, que comienza como +.

2. Cada vez que se encuentra un operador, el operador actual cambiará a él.

3. Los operadores posibles son: "+", "-", "*", "/" y "%", que corresponden a sus significados en C y la mayoría de los lenguajes.

4. Hay una solución en ejecución que comienza en 0.

5. Cada vez que se encuentra un número entero, la solución se modifica por el número dependiendo del operador; por ejemplo, si el operador es "/", entonces la solución se divide por el número.

6. Si una operación daría como resultado un número mixto (es decir, con un decimal), debe volver a un número entero (es decir, el decimal debe cortarse).

7. Salida de la solución final.

Por ejemplo:

Los argumentos 5 8 25 * 9 6 2 - 104 / 4 7 + 6 % 14darían como resultado:

  5 8  25 * 9   6    2    - 104  / 4    7      + 6 % 14
0 5 13 38   342 2052 4104   4000   1000 142   148    8  -> 8

Las entradas serán como argumentos de línea de comando o función, o un equivalente para su idioma.

¡El código más corto gana!

Pyth - 24 23 22 20 bytes

¡2 bytes guardados gracias a @issacg y 1 gracias a @orlp!

Los usos se reducen con el caso base 0y se comprueba si 'está en repr para detectar la cadena frente a int.

u.xsv++GbH&=bHG+\+QZ

No funciona en línea porque uso eval completo que está deshabilitado en línea por razones de seguridad. Toma de entrada de la entrada estándar en una lista como tal: 5, 8, 25, "*", 9, 6, 2, "-", 104, "/", 4, 7, "+", 6.

JavaScript (ES6) 53

Una función que toma una matriz como entrada.

Ejecute el fragmento en Firefox para probar.

f=a=>a.map(t=>t<'0'?o=t:v=eval(v+o+t)|0,v=0,o='+')&&v

// TEST
out=x=>O.innerHTML=x;

input = [5,8,25,"*",9,6,2,"-",104,"/",4,7,"+",6,"%",14];
out(input.join(' ')+' -> '+f(input));

function go() {
  i=I.value.split(/ +/),out(I.value+' -> '+f(i))
}  

<pre id=O></pre>
Your test:<input id=I><button onclick='go()'>GO</button>

Julia, 85 83 bytes

s->(o=0;p="+";for i=split(s) isdigit(i)?o=eval(parse("ifloor($o$p$i)")):(p=i)end;o)

Esto crea una función sin nombre que acepta una cadena como entrada y devuelve un entero.

Sin golf:

function f(s::String)
    # Assign the starting output value o and operator p
    o = 0
    p = "+"

    # Split the input string into an array on spaces
    for i = split(s)
        if isdigit(i)
            # Assign o using string interpolation
            o = eval(parse("ifloor($o $p $i)"))
        else
            # Assign p to the new operator
            p = i
        end
    end
end

Problema solucionado y ahorró 2 bytes gracias a Glen O.

elisp, 101 bytes

Con los argumentos pasados ​​como una lista citada: ej. (c '(5 5 * 10))

    (defun c(a)(let((f 0)(o '+))(dolist(x a)(if(not(integerp x))(setf o x)(setq f (eval(list o f x)))))f))

Versión con nuevas líneas:

    (defun c (a)
      (let ((f 0)
            (o '+))
        (dolist (x a)
          (if (not (integerp x))
              (setf o x) 
            (setq f (eval (list o f x)))))
        f))

CJam, 24 bytes

0'+ea+{_A,s&O{:O;}?S}%s~

Este es un programa completo que lee la entrada como argumentos de línea de comandos.

Para probar el código en línea en el intérprete de CJam (que no admite argumentos de línea de comandos), reemplace eacon lS/para leer desde STDIN simulado.

Cómo funciona

0'+                       Push a 0 and the character '+'.
   ea                     Push the array of command-line arguments.
     +                    Prepend the character to the array.
      {             }%    For each element:
       _                    Push a copy.
        A,s                 Push "0123456789".
           &                Intersect the copy with the string of digits.
             {   }?         If the intersection is non-empty:
            O                 The element is a number. Push O.
              :O;             The element is an operator. Save it in O.
                   S        Push a space.
                      s~  Flatten the array of strings and evaluate it.

JavaScript, 85 bytes

r=0;o="+";prompt().split(" ").forEach(t=>+t+1?r=parseInt(eval(r+o+ +t)):o=t);alert(r)

Lua, 142 bytes

function f(s)o="+"r=0 for c in s:gmatch"%S+" do if tonumber(c)~=nil then loadstring("r=r"..o..c)() else o=c end r=math.floor(r)end print(r)end

Sin golf:

function f(s)
    o="+" --original operator
    r=0 --return value
    for c in s:gmatch"%S+" do --split by spaces
        if tonumber(c)~=nil then --check if the current character is a number
            loadstring("r=r"..o..c)() --appends the current operator and current character ex "r=r+5" and then evaluates as another Lua script 
        else 
            o=c --if the character is not a number, it is the new operator
        end
        r=math.floor(r) --floor after each operation
    end 
    print(r) --print the result
end

Powershell, 57 bytes

$o="+"
$args|%{$r=iex "$r$o$_"
if(!$?){$o=$_}$r-=$r%1}
$r

sin golf

$operator="+"
$args | ForEach-Object
{
    $result = Invoke-Expression "$result $operator $_"
    if(!$?)
    {
        $operator=$_
    }
    $result -= $result % 1
}
$result

Si la variable implícita en for-each es un operador en lugar de un número, Invoke-Expression (POSH's eval()) fallará y el estado de ejecución $?será falso.

Floor en POSH es difícil de manejar, $foo=[math]::floor($foo)y $foo-=$foo%1fue la alternativa de golf que se me ocurrió.

GNU Sed (con la extensión eval, + dc), 102

(La puntuación incluye +1 para la opción -r de sed.)

s/.*/0 + &p/
s/([-+/*%]) ([0-9]+)/\2 \1/g
:
s/([-+/*%] )([0-9]+ )([0-9]+)/\1\2\1\3/
t
s/.*/dc<<<'&'/e

Transforma la expresión de entrada a notación polaca inversa y luego la usa dcpara evaluarla.

Prueba de salida:

$ sed -rf calclist.sed <<< '5 8 25 * 9 6 2 - 104 / 4 7 + 6 % 14'
8
$ 

CJam, 34 bytes

'+0lS/{"+-*/%"1$#){@;\}{i2$~}?}/\;

Pruébalo en línea

Pensé que esto sería bastante razonable. Pero no fui lo suficientemente rápido para publicarlo como para ser la respuesta más corta de CJam al menos por un momento. :(

Python 3: 131 bytes 129 bytes 121 bytes 116 bytes

Gracias a Maltysen por eliminar dos bytes, Beta Decay por eliminar 8 y Steven Rumbalski por eliminar 5.

def f(x):
    a,b="+",0
    for i in x:
        if i in"+-*/%":a=i
        else:b=int(eval(str(b)+a+i))
    return b

Estoy tratando de encontrar una manera de reducir la longitud de la declaración if, pero por ahora esto parece lo más complejo posible. Toma la entrada como una lista.

Bash, 69

set -f
for t in $*
do
((1${t}1>2))&&((r${o-+}=$t))||o=$t
done
echo $r

Esto solo funciona con enteros no negativos: no está claro en la pregunta si está bien o no.

Groovy, 79 bytes

def f(x,a=0,b='+'){x.each{z->a=z=~/\d/?Eval.me(a+b+z)as int:a;b=z=~/\d/?b:z};a}

Manifestación:

groovy> f([5,8,25,'*',9,6,2,'-',104,'/',4,7,'+',6,'%', 14])
Result: 8

Sin golf:

def f(x, a=0, b='+') {                                   
    x.each {z->
        a = z =~ /\d/ ? Eval.me(a+b+z) as int : a
        b = z =~ /\d/ ? b : z
    }
    a
}

gcc (con advertencias) 165 (si el final de línea cuenta como 1)

#define A atoi(*a);break;case
o='+',s=0;main(c,a)char**a;{while(*++a)if(**a<48)o=**a;else switch(o){case'+':s+=A'-':s-=A'*':s*=A'/':s/=A'%':s%=A 0:;}printf("%d",s);}

Pero si lo está compilando con mingw32, debe desactivar el globbing (consulte https://www.cygwin.com/ml/cygwin/1999-11/msg00052.html ) compilando así:

gcc x.c C:\Applications\mingw32\i686-w64-mingw32\lib\CRT_noglob.o

Perl 5.10+, 52 bytes

perl -E '$o="+";/\D/?$o=$_:eval"\$x=int\$x$o$_"for@ARGV;say$x'

Manifestación:

$ perl -E '$o="+";/\D/?$o=$_:eval"\x=int\$x$o$_"for@ARGV;say$x' 5 8 25 \* 9 6 2 - 104 / 4 7 + 6 % 14
8

(Tenga en cuenta que *se debe escapar en mi shell para que no se interprete como un patrón global).

Sin golf:

$o="+";                      # Start with addition
/\D/ ? $o=$_                 # If not a number, update the current operator
     : eval"\$x=int\$x$o$_"  # Otherwise, make a string like '$x=int$x+1' and eval it
for@ARGV;                    # Repeat for each item in the argument list
say$x                        # Print the result

C #, 132165168 bytes

Esta función asume que la entrada es válida. Esto es difícil para C # dado que no hay evalequivalente.

¡Gracias edc65 por guardar 33 bytes!

Sangrado por claridad.

int C(string[]a){
    int o=1,r=0,n;
    foreach(var b in a)
        n=int.TryParse(b,out n)
            ?r=o<0?r%n
              :o<1?r*n
              :o<2?r+n
              :o<4?r-n
                  :r/n
            :o=b[0]-42;
    return r;
}

Ruby, 59 bytes

a=0
o=?+
gets.split.map{|s|s=~/\d/?a=eval([a,s]*o):o=s}
p a

Prueba de funcionamiento:

$ ruby calc.rb <<< "5 8 25 * 9 6 2 - 104 / 4 7 + 6 % 14"
8