Armas de Instrucción Matemática

44

La última vez que intenté encontrar algo fácil que no fuera un duplicado, terminó siendo demasiado difícil ... Así que espero que esta vez sea algo que los recién llegados puedan probar también.

Entrada:

Una matriz / lista con enteros / decimales. (O una cadena que representa una matriz con enteros / decimales).

Salida:

Recorra los números y aplique los siguientes cinco operandos matemáticos en este orden:

  • Suma ( +);
  • Resta ( );
  • Multiplicación ( *o ×o ·);
  • División Real / Calculadora ( /o ÷);
  • Exponenciación ( ^o **).

(NOTA: Los símbolos entre paréntesis solo se agregan como aclaración. Si su lenguaje de programación usa un símbolo completamente diferente para la operación matemática que los ejemplos, entonces eso es, por supuesto, completamente aceptable).

Continúa hasta llegar al final de la lista y luego da el resultado de la suma.

Reglas de desafío:

  • La exponenciación por 0 ( n ^ 0) debería dar como resultado 1 (esto también se aplica a 0 ^ 0 = 1).
  • No hay casos de prueba para la división por 0 ( n / 0), por lo que no tiene que preocuparse por ese caso límite.
  • Si la matriz contiene solo un número, lo devolvemos como resultado.

Reglas generales:

  • Este es el , por lo que la respuesta más corta en bytes gana.
    No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
  • Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
  • Las lagunas predeterminadas están prohibidas.
  • Si es posible, agregue un enlace con una prueba para su código.

Casos de prueba:

[1,2,3,4,5] -> 0
-> 1 + 2 = 3
  -> 3 - 3 = 0
    -> 0 * 4 = 0
      -> 0 / 5 = 0 

[5,12,23,2,4,4,2,6,7] -> 539
-> 5 + 12 = 17
  -> 17 - 23 = -6
    -> -6 * 2 = -12
      -> -12 / 4 = -3
        -> -3 ^ 4 = 81
          -> 81 + 2 = 83
            -> 83 - 6 = 77
              -> 77 * 7 -> 539

[-8,50,3,3,-123,4,17,99,13] -> -1055.356...
-> -8 + 50 = 42
  -> 42 - 3 = 39
    -> 39 * 3 = 117
      -> 117 / -123 = -0.9512...
        -> -0.9512... ^ 4 = 0.818...
          -> 0.818... + 17 = 17.818...
            -> 17.818... - 99 -> -81.181...
              -> -81.181... * 13 = -1055.356...

[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256
-> 2 + 2 = 4
  -> 4 - 2 = 2
    -> 2 * 2 = 4
      -> 4 / 2 = 2
        -> 2 ^ 2 = 4
          -> 4 + 2 = 6
            -> 6 - 2 = 4
              -> 4 * 2 = 8
                -> 8 / 2 = 4
                  -> 4 ^ 2 = 16
                    -> 16 + 2 = 18
                      -> 18 - 2 = 16
                        -> 16 * 2 = 32
                          -> 32 / 2 = 16
                            -> 16 ^ 2 = 256

[1,0,1,0,1,0] -> 1
-> 1 + 0 = 1
  -> 1 - 1 = 0
    -> 0 * 0 = 0
      -> 0 / 1 = 0
        -> 0 ^ 0 = 1

[-9,-8,-1] -> -16
  -> -9 + -8 = -17
    -> -17 - -1 = -16

[0,-3] -> -3
  -> 0 + -3 = -3

[-99] -> -99
Kevin Cruijssen
fuente
¿No es una división entera?
Leaky Nun
@LeakyNun No. ¿Quizás debería cambiar la entrada a una lista con decimales en lugar de enteros debido a la división (y el caso de prueba 3)?
Kevin Cruijssen
¿Estaba esto en la caja de arena?
Bálint
99
En matemáticas, hay dos "reglas" en conflicto: n ^ 0 = 1pero 0 ^ n = 0. El conflicto se resuelve estableciendo n != 0ambas reglas, pero luego se deja 0 ^ 0indefinido. Sin embargo, hay muchas cosas que encajan bien en matemáticas si 0 ^ 0se define como tal 1. Ver Wikipedia para algunos detalles.
Mego
1
@ Bálint Las reglas establecen que nunca habrá una entrada válida con una división por cero. No tiene que preocuparse por ese caso límite.
Mego

Respuestas:

7

Jalea , 13 bytes

“+_×÷*”ṁṖ⁸żFV

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

“+_×÷*”ṁṖ⁸żFV  Main link. Argument: A (list of integers)

“+_×÷*”        Yield the list of operations as a string.
        Ṗ      Yield A popped, i.e., with its last element removed.
       ṁ       Mold; reshape the string as popped A.
               This repeats the characters of the string until it contains
               length(A)-1 characters.
         ⁸ż    Zipwith; pairs the integers of A with the corresponding characters.
           F   Flatten the result.
            V  Eval the resulting Jelly code.
               Jelly always evaluates left-to-right (with blatant disregard towards
               the order of operations), so this returns the desired result.
Dennis
fuente
Bien, eso es un conteo de 8 bytes más bajo que Pyke , que actualmente estaba a la cabeza.
Kevin Cruijssen
3
Nadie supera a Dennis. Nunca.
Azul
1
Solo una pregunta: ¿realmente cuenta como 13 bytes con todos esos caracteres no ASCII?
Xavier Dury
3
@XavierDury Sí. El enlace de bytes en el encabezado conduce a la propia página de códigos de Jelly, que codifica los 256 caracteres que Jelly entiende como un solo byte cada uno.
Dennis
@ Dennis ¡Gracias por la precisión!
Xavier Dury
19

Javascript ES7 49 bytes

a=>a.reduce((c,d,e)=>[c**d,c+d,c-d,c*d,c/d][e%5])

Ahorré 9 bytes gracias a Dom Hastings, guardé otros 6 gracias a Leaky Nun

Utiliza el nuevo operador de exponenciación.

Bálint
fuente
@LeakyNun ¿eso no solo producirá Infinity, no un error?
Dom Hastings
Intente usar eval, podría ser más corto
Downgoat
@Upgoat Usó eval primero, luego Leaky Nun me mostró que es mejor hacerlo así
Bálint
@ Bálint, ¿te gusta usar tantas comas?
Rɪᴋᴇʀ
1
@ EᴀsᴛᴇʀʟʏIʀᴋ Hablante no nativo. Bálint a menudo hace eso. La gramática inglesa es tonta en el mejor de los casos.
wizzwizz4
11

Haskell, 76 65 64 62 bytes

Gracias a @Damien por eliminar otros dos bytes =)

f(u:v)=foldl(\x(f,y)->f x y)u(zip(v>>[(+),(-),(*),(/),(**)])v)

Esto usa el >>que aquí solo agrega la lista [(+),...]a sí mismo length vveces. El resto todavía funciona igual que las versiones anteriores.

Versiones antiguas:

Estas soluciones hacen uso de las listas infinitas, ya que cycle[...]solo repite la lista dada infinitamente. Luego, básicamente, se zipedita con la lista de números, y solo fold( reducimos en otros idiomas) la lista comprimida a través de una lambda, que aplica los operadores al acumulador / elemento de la lista actual.

f(u:v)=foldl(\x(f,y)->f x y)u(zip(cycle[(+),(-),(*),(/),(**)])v)

f(u:v)=foldl(\x(y,f)->f x y)u(zip v(cycle[(+),(-),(*),(/),(**)]))

f l=foldl(\x(y,f)->f x y)(head l)(zip(drop 1l)(cycle[(+),(-),(*),(/),(**)]))
falla
fuente
puede reemplazar el ciclo por: v >>
Damien
@Damien Muchas gracias!
flawr
Hm, foldl(&)u$zipWith(&)v(flip<$>v>>[…])?
Bergi
@Bergi Honestamente, ya no puedo leer lo que esto está haciendo =) De todos modos, necesitamos un importpara &, así que sería más tiempo nuevamente, ¡pero gracias de todos modos!
flawr
@flawr: En realidad, mi idea era la misma que Lazersmoke publicó como respuesta , simplemente no la había leído. Llegué a eso cuando intenté simplificar esa lamda tuya con algo así uncurry. No funcionó, pero noté que debería poder guardar otro byte usando en $lugar de paréntesis.
Bergi
8

Pyke, 22 21 bytes

lt5L%"+-*/^"L@\RJQ_XE

Pruébalo aquí!

lt5L%                 -    map(len(input)-1, %5)
     "+-*/^"L@        -   map(^, "+-*/^"[<])
              \RJ     -  "R".join(^)
                    E - pyke_eval(^, V)
                 Q_X  -  splat(reversed(input))
Azul
fuente
7

Haskell, 61 bytes

foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])

Crea una serie de transformaciones en una lista, como en [sumar 1, sumar 2, restar 3, ...], comenzando con 2 adiciones porque comenzamos con 0 en el pliegue. A continuación, hacemos lo que yo llamo el Pliegue de aplicación de lista, o foldl (flip id), que aplica una lista de homomorfismos en serie. Esto comienza con cero, agrega el valor inicial, luego realiza todas las transformaciones calculadas anteriormente para obtener un resultado final.

Tenga en cuenta que (flip id) es lo mismo que (\ x y-> yx), solo que más corto.

Uso de la muestra:

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0
Lazersmoke
fuente
En lugar de flip id, simplemente podría usar &. O flip($). Wow, nunca me di cuenta($) = id
Bergi
1
@Bergi: &está definido en Data.Function, por lo que también necesita el import. Tal vez algún intérprete en línea lo importe por defecto, pero luego debe especificar cuál utiliza.
nimi
7

TSQL 116 115 88 bytes

Gracias a la sugerencia de Ross Presser, pude jugar golf hasta 88 caracteres

-- In Try-it code, this must be DECLARE @y TABLE 
CREATE TABLE T(a real, i int identity)
INSERT T values(5),(12),(23),(2),(4),(4),(2),(6),(7)

DECLARE @ REAL SELECT @=CHOOSE(i%5+1,@/a,ISNULL(POWER(@,a),a),@+a,@-a,@*a)FROM T
PRINT @

Pruébalo en línea

t-clausen.dk
fuente
1
1 byte menos: requiere que la tabla de entrada se denomine T en lugar de @y. La solución PL / SQL tenía esto, entonces, ¿por qué no TSQL?
Ross Presser
@RossPresser sí, por supuesto. ¿Cómo extrañé eso? No es posible en el enlace de prueba, no hay permisos para crear tablas, y solo se ejecutará correctamente la primera vez en una base de datos. Pero, ¿qué importa eso cuando un personaje puede jugar al golf? Gracias por su sugerencia, su mejora se ha agregado
t-clausen.dk
Aprovechó otros 12 bytes: use CHOOSE en lugar de IIF anidado, dejando un IIF para el caso i = 1. Con su permiso, editaré la respuesta.
Ross Presser
respuesta editada Aquí está el enlace de prueba: soy anónimo, por lo que no tiene nombre después: data.stackexchange.com/stackoverflow/query/edit/499612
Ross Presser
1
@RossPresser No sabía ELEGIR. incluí tu sugerencia y jugué un poco más lejos
t-clausen.dk
6

Pyth, 27 26 25 bytes

.v+>tlQ*lQ"^c*-+":jdQ\-\_

Banco de pruebas.

Pyth usa notación de prefijo: 1+2se escribe como +1 2(espacio necesario para separar números).

Por lo tanto, para el primer caso de prueba, la expresión sería (((1+2)-3)*4)/5, que en notación de prefijo, se escribiría como /*-+ 1 2 3 4 5.

En Pyth, la división flotante es en clugar de /, por lo que se convierte c*-+ 1 2 3 4 5.

Además, en Pyth, -100se escribe como en su _100lugar.

Por lo tanto, para el caso de prueba tercero, que es ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), se convierte en: *-+^c*-+ _8 50 3 3 _123 4 17 99 13.

.v+>tlQ*lQ"^c*-+":jdQ\-\_
                  jdQ       Join input by space.
                 :   \-\_   Replace "-" with "_".
   >tlQ*lQ"^c*-+"           Generate the string "...^c*-+" of suitable length.
  +                         Join the two strings above.
.v                          Evaluate as a Pyth expression.

Historia

Monja permeable
fuente
¡Tu eres rápido! Parece que logré hacer un desafío más fácil. O simplemente eres así de bueno. ;)
Kevin Cruijssen
1
Porque es similar a esto .
Leaky Nun
2
24 bytes
Maltysen
6

En realidad, 23 bytes

;l"+-*/ⁿ"*@R':j':+'?o+ƒ

Pruébalo en línea!

En realidad, usa la notación postfix para las matemáticas, y los operadores que solo toman dos argumentos (como los operadores de suma, resta, multiplicación, división y exponenciación) no hacen nada cuando solo hay un elemento en la pila. Por lo tanto, convertir la entrada en Código de hecho es tan simple como invertir la entrada, formatearla como números y agregar las operaciones. Entonces, el código resultante se puede ejecutar, dando la salida deseada.

Explicación:

;l"+-*/ⁿ"*@R':j':+'?o+ƒ
;l"+-*/ⁿ"*               repeat the operations a number of times equal to the length of the input
                            (since extraneous operations will be NOPs, there's no harm in overshooting)
          @R             reverse the input
            ':j          join on ":" (make a string, inserting ":" between every pair of elements in the list)
               ':+       prepend a ":" (for the first numeric literal)
                  '?o    append a "?"
                           (this keeps the poor numeric parsing from trying to gobble up the first + as part of the numeric literal, since ? isn't interpreted as part of the literal, and is a NOP)
                     +   append the operations string
                      ƒ  cast as a function and call it

Ejemplo de código traducido para entrada 1,2,3,4,5:

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ
Mego
fuente
3
Me encanta la forma en que el nombre del idioma se fusiona con el recuento de bytes
user6245072
3
s/Actually uses postfix notation/Actually actually uses postfix notation/
Leaky Nun
5

J, 40 bytes

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)

Encuentra el número de valores necesarios para usar un múltiplo de 5 operadores, que los pads con los valores de identidad de esos operadores. En orden, +es 0, -es 0, *es 1, %es 1 y ^es 1, que puede ser un valor de bit 00111, o 7 en la base 10. Luego opera en esa lista mientras se desplaza por los operadores.

Uso

   f =: ^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)
   f 1 2 3 4 5
0
   f 5 12 23 2 4 4 2 6 7
539
   f _8 50 3 3 _123 4 17 99 13
_1055.36
   f 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
256
   f 1 0 1 0 1 0
1
   f _9 _8 _1
_16
   f 0 _3
_3
   f _99
_99

Explicación

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#) Input: A
                                      #  Get length of A
                                    4+   Add four to it
                                  5|     Take it mod 5
                                5-       Find 5 minus its value, call it x
                           #&2           Create x copies of 2
                       7#:~              Convert 7 to base 2 and take the last x digits
                      ,                  Append those x digits to the end of A
                   |.@                   Reverse it, call it A'
^~                                       Power, reversed operators
    %~                                   Division, reversed operators
       *                                 Multiplication
         -~                              Subtraction, reversed operators
            +                            Addition
             /@                          Insert the previous operations, separated by `,
                                         into A' in order and cycle until the end
                                         Then evaluate the equation from right-to-left
                                         and return
millas
fuente
5

Python 2, 81 67 64 bytes

i=10
for n in input():exec'r%s=n'%'*+-*/*'[i::5];i=-~i%5
print r

La entrada es una matriz de flotadores. Pruébalo en Ideone .

Cómo funciona

'*+-*/*'[i::5]selecciona cada quinto carácter de la cadena, comenzando con el que está en el índice i , por lo que esto produce **si i = 0 , +si i = 1 , -si i = 2 , *si i = 3 y /si i = 4 . Como la cadena tiene una longitud 6 , la expresión producirá una cadena vacía si i> 5 .

Inicializamos la variable i a 10 . Para cada número n en la matriz de entrada, construimos la cadena r<op>=n, que se execejecuta.

Inicialmente, i = 10 , también lo <op>es la cadena vacía, e inicializa r con r+=n. Después de cada paso, incrementamos i modulo 5 con i=-~i%5, por lo que el siguiente paso recuperará el operador adecuado.

Cuando se han procesado todos los números de entrada e imprimimos r , que contiene la salida deseada.

Dennis
fuente
5

Matlab - 95 91 85 bytes / octava - 81 bytes

La entrada está en esa forma: a = ['1' '2' '3' '4' '5'];espero que esto esté cubierto por "cadena que representa una matriz con enteros / decimales", de lo contrario, se necesitan 2 num2str adicionalmente.

Cada resultado intermedio se imprime en la consola porque eso me ahorra algunos puntos y comas. a(1)se ejecuta para que su valor se guarde en ans. También, por supuesto, usar anscódigo es una mala práctica.

b='+-*/^'
a(1)
for i=2:length(a)
  ['(',ans,')',b(mod(i-2,5)+1),a(i)]
end
eval(ans)

En Octave, '+-*/^'(mod(i+2,5)+1)también funciona, lo que ahorra otros 4 bytes, gracias Adám y Luis Mendo:

a(1)
for i=2:length(a)
  strcat('(',ans,')','+-*/^'(mod(i-2,5)+1),a(i))
end
eval(ans)

Registro de cambios:

  • Espacios eliminados donde sea posible
  • solución de octava agregada
  • reemplazado strcat () con []
Lukas K.
fuente
Hola, bienvenido a PPCG! La entrada está bien así, ya que todavía es fácilmente distinguible cuál es la entrada. Hmm, nunca he usado Matlab, por lo que tal vez estoy diciendo idioteces aquí, pero no puedo b = '+-*/^'estar Jugamos al golf a b='+-*/^'y for i = 2:length(a)a for i=2:length(a)(quitando los espacios)? Además, quizás los consejos para jugar golf en MATLAB puedan ser interesantes para usted. :)
Kevin Cruijssen
Es '+-*/^'(mod(i+2,5)+1)valido?
Adám
@ Adám No, pero probablemente esté en Octave
Luis Mendo
@ Adám: funciona en Octave, lo agregué.
Lukas K.
4

Mathematica, 67 66 65 bytes

Fold[{+##,#-#2,#2#,#/#2,If[#2==0,1,#^#2]}[[i++~Mod~5+1]]&,i=0;#]&

Simple Foldcon una variable que icontiene el índice.

LegionMammal978
fuente
Se puede guardar un byte en +##lugar de#+#2
LLlAMnYP
4

CJam, 18 bytes

q~{"+-*/#"W):W=~}*

La entrada es una matriz de flotadores. Pruébalo en línea!

Cómo funciona

q~                  Read and evaluate all input.
  {             }*  Reduce:
   "+-*/#"            Push the string of operators.
          W           Push W (initially -1).
           ):W        Increment and save in W.
              =       Retrieve the character at that index.
               ~      Evaluate.
Dennis
fuente
4

R , 87 78 70 bytes

i=0
Reduce(function(a,j)get(substr("+-*/^",i<<-i%%5+1,i))(a,j),scan())

Pruébalo en línea!

JayCe
fuente
en algún momento realmente necesito aprender a usar do.call... ¡Probablemente no debería considerarme un programador de R hasta que lo haga!
Giuseppe
1
@Giuseppe Advanced Rpor Hadley Wickam es una gran lectura de playa :)
JayCe
@Giuseppe gracias por señalarme do.call, me hizo darme cuenta de que estaba buscando get.
JayCe
3

Haskell - 74

f(x:xs)=foldl(\x(o,y)->o x y)x(zip(cycle[(+),(-),(*),(/),flip(^).floor])xs)

Casos de prueba:

λ> f[1,2,3,4,5] -> 0.0
λ> f[5,12,23,2,4,4,2,6,7] -> 539.0
λ> f[-8,50,3,3,-123,4,17,99,13] -> -1055.356943846277
λ> f [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256.0

Probablemente podría ser más corto; Sin embargo, el soporte de Haskell para listas infinitas y funciones de orden superior hacen que la solución directa sea bastante agradable. Una versión de ^ :: Double -> Double -> Doublesería mejor para jugar al golf, pero no pude encontrar una. Afortunadamente, no necesitaba una lambda completa, por lo que el estilo sin sentido redujo algunos bytes.

C. Quilley
fuente
2
Puede anteponer una sola (+)a la lista de operadores e iniciar el foldlcon 0a llevar por completo pointfree y guardar el nombre de la función y los parámetros: foldl(\x(o,y)->o x y)0.zip((+):cycle[(+),(-),(*),(/),(**)]).
nimi
3

PowerShell v2 +, 124 bytes

param($n)$o=$n[0];if($y=$n.count-1){1..$y|%{$o=if(($x=$i++%5)-4){"$o"+'+-*/'[$x]+$n[$_]|iex}else{[math]::pow($o,$n[$_])}}}$o

Mucho tiempo porque PowerShell no tiene un operador ^u **, por lo que debemos tener en cuenta un caso diferente y usar una llamada .NET.

Toma la entrada $ncomo una matriz, establece nuestra salida $ocomo el primer dígito. Luego verificamos la .countmatriz, y siempre que sea mayor que una ingresamos if. De lo contrario, nos saltamos el if.

Dentro del ifbucle, recorremos la matriz 1..$y|%{...}y cada iteración lo restablecemos $oa un nuevo valor, el resultado de otra if/elsedeclaración. Mientras nuestro contador $i++no sea módulo 5 igual a 4 (es decir, no estamos en el ^operador), simplemente lo tomamos $oy concatenamos con el símbolo apropiado '+-*/'[$x]y el siguiente número en la matriz de entrada $n[$_]. Lo canalizamos a iex(alias para Invoke-Expressiony similar a eval), y eso se vuelve a guardar en $o. Si estamos en el ^operador, estamos en el else, así que ejecutamos una [math]::Pow()llamada, y ese resultado se vuelve a guardar $o.

En cualquier caso, simplemente salimos $oa la tubería y salimos , con salida implícita.

AdmBorkBork
fuente
3

Óxido, 123 , 117 bytes

Respuesta original:

fn a(v:&[f32])->f32{v.iter().skip(1).enumerate().fold(v[0],|s,(i,&x)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

estúpidos nombres largos de métodos ^^ ahh mucho mejor

fn f(v:&[f32])->f32{v[1..].iter().zip(0..).fold(v[0],|s,(&x,i)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

sin golf

fn f(values : &[f32]) -> f32 {
    values[1..].iter().zip(0..)
    .fold(values[0], |state,(&x,i)|
        match i%5 {
            0=>state+x,
            1=>state-x,
            2=>state*x,
            3=>state/x,
            _=>state.powf(x)
        }
    )
}
desigual
fuente
3

Perl 6 ,  70 68 65   62 bytes

{$/=[(|(&[+],&[-],&[*],&[/],&[**])xx*)];.reduce: {$/.shift.($^a,$^b)}}
{(@_ Z |(&[+],&[-],&[*],&[/],&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{(@_ Z |(*+*,*-*,&[*],*/*,&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],*/*,&[**])xx*}

Explicación:

-> *@_ {
  reduce
    -> $a, &b, $c { b($a,$c) },

    flat       # flatten list produced from zip
      zip
        @_,    # input

        slip(  # causes the list of operators to flatten into the xx list

          # list of 5 infix operators
          &infix:<+>, &infix:<->, &infix:<*>, &infix:</>, &infix:<**>

        ) xx * # repeat the list of operators infinitely
}

Técnicamente * + *es un Lambda Cualquiera, pero efectivamente es el mismo &[+]que es la abreviatura &infix:<+>del conjunto de subrutinas que manejan la suma numérica infija.
Yo no utilizar que para la multiplicación o la exponenciación como las formas de escribirlas como que es al menos tan larga como lo que tengo ( *×*o * * *e * ** *)

Prueba:

Pruébelo en ideone.com
(después de actualizar a una versión Rakudo que no es de un año y medio antes del lanzamiento oficial de las especificaciones de Perl 6 )

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,2,3,4,5] => 0,
  [5,12,23,2,4,4,2,6,7] => 539,
  [-8,50,3,3,-123,4,17,99,13] => -1055.35694385, # -2982186493/2825761
  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] => 256,
  [1,0,1,0,1,0] => 1,
  [-9,-8,-1] => -16,
  [0,-3] => -3,
  [-99] => -99,
);

plan +@tests;

my &code = {reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],&[/],&[**])xx*}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is code(@input), $expected, .gist
}
1..8
ok 1 - [1 2 3 4 5] => 0
ok 2 - [5 12 23 2 4 4 2 6 7] => 539
ok 3 - [-8 50 3 3 -123 4 17 99 13] => -1055.35694385
ok 4 - [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2] => 256
ok 5 - [1 0 1 0 1 0] => 1
ok 6 - [-9 -8 -1] => -16
ok 7 - [0 -3] => -3
ok 8 - [-99] => -99
Brad Gilbert b2gills
fuente
51 bytes
Jo King
3

Python 3, 88 93 bytes

f=lambda x:eval('('*(len(x)-1)+'){}'.join(map(str,x)).format(*['+','-','*','/','**']*len(x)))

Comenzó siendo mucho más corto, pero luego la precedencia del operador me derrotó y tuve que incluir muchos paréntesis ...

MSeifert
fuente
3

Oracle PL / SQL, 275254 bytes

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Los datos deben insertarse en una tabla llamada Tcon una columna Nde tipoNUMBER

Uso:

drop table t;
create table t (n number);
insert into t values (-8);
insert into t values (50);
insert into t values (3);
insert into t values (3);
insert into t values (-123);
insert into t values (4);
insert into t values (17);
insert into t values (99);
insert into t values (13);

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Salida:

-1055,356943846277162152071601242992595623

Versión de 275 bytes:

declare r number;cursor c is select n,mod(rownum,5) r from t;begin for x in c loop if r is null then r:=x.n;else case x.r when 2 then r:=r+x.n;when 3 then r:=r-x.n;when 4 then r:=r*x.n;when 0 then r:=r/x.n;else r:=r**x.n; end case;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;
Giacomo Garabello
fuente
3

Java 8, 173 172 167 138 137 118 113 bytes

a->{double r=a[0],t;for(int i=1;i<a.length;r=new double[]{Math.pow(r,t),r+t,r-t,r*t,r/t}[i++%5])t=a[i];return r;}

Explicación:

Pruébalo aquí

a->{                     // Method with double-array parameter and double return-type
  double r=a[0],         //  Result-double, starting at the first item of the input
         t;              //  Temp double
  for(int i=1;           //  Index-integer, starting at the second item
      i<a.length;        //  Loop over the input-array
      r=new double[]{    //    After every iteration, change `r` to:
         Math.pow(r,t),  //      If `i%5` is 0: `r^t`
         r+t,            //      Else-if `i%5` is 1: `r+t`
         r-t,            //      Else-if `i%5` is 2: `r-t`
         r*t,            //      Else-if `i%5` is 3: `r*t`
         r/t}[i++%5])    //      Else-if `i%5` is 4: `r/t`
                         //      And increase `i` by 1 afterwards with `i++`
    t=a[i];              //   Change `t` to the next item in the array
  return r;}             //  Return result-double
Kevin Cruijssen
fuente
2
Porque, ya sabes, java. 1.5 veces más que la respuesta más larga actual ... que está en SQL
Bálint
1
Puede cambiar double r=a[0];a double r=a[0],b;para guardar algunos bytes.
Leaky Nun
1
@LeakyNun Originalmente tenía float, pero no hay una Math.powpara flotadores, de ahí el doublelugar. Gracias por el ,b. Y con i++<a.lengthobtengo una ArrayOutOfBoundsException en b=a[i];(a menos que lo haga i++<a.length-1, que es un byte más largo en lugar de más corto).
Kevin Cruijssen
1
Puedes cambiar == 4a > 3y == 0para < 1. No estoy seguro, pero creo que podría ahorrar un poco creando una variable para i % 5.
Frozn
1
Supuse que puedes cambiarlo todo por una concatenación de terrarios. En todas las comparaciones, puede usar el <xtruco, reduciendo toda la función a 137 caracteres.
Frozn
3

Algunos trucos pueden reducir el enfoque de @ Willmore de 23 a 174 bytes (requiere php 5.6 o posterior). La parte que más ahorra es eliminar paréntesis innecesarios (-10 bytes).

función f ($ a) {while (count ($ a)> 1) {$ l = array_shift ($ a); $ r = array_shift ($ a); array_unshift ($ a, ($ j = $ i ++% 5) ? ($ j == 1? $ l- $ r: ($ j == 2? $ l * $ r: ($ j == 3? $ l / $ r: $ l ** $ r))): $ l + $ r);} return end ($ a);}

Pero usar el **operador en lugar de pow()también permite usarlo evalcon una matriz para las operaciones; y con algunos trucos más ...

PHP> = 5.6, 82 bytes

while(--$argc)eval('$x'.['/','**','+','-','*'][$i++?$i%5:2]."=$argv[$i];");echo$x;

toma la lista de los parámetros de la línea de comandos. Ejecutar php -nr '<code>'o probarlo en línea .

versión anterior, 161 157 151 145 144 140 137 117 bytes

function f($a){while(count($a)>1)eval('$a[0]=array_shift($a)'.['+','-','*','/','**'][$i++%5].'$a[0];');return$a[0];}

El golf más efectivo provino de escribir el resultado intermedio directamente en el primer elemento, después de cambiar el resultado anterior de la matriz.

Descompostura

function f($a)
{
    while(count($a)>1)  // while array has more than one element ...
        eval('$a[0]='                           // future first element :=
            . 'array_shift($a)'                 // = old first element (removed)
            . ['+','-','*','/','**'][$i++%5]    // (operation)
            .'$a[0];'                           // new first element (after shift)
        );
    return$a[0];        // return last remaining element
}

Banco de pruebas

$cases = array (
    0=>[1,2,3,4,5],
    539=>[5,12,23,2,4,4,2,6,7],
    '-1055.356...' => [-8,50,3,3,-123,4,17,99,13],
    256 => [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
    1 => [1,0,1,0,1,0],
    -16 => [-9,-8,-1],
    -3 => [0, -3],
    -99 => [-99]
);
echo '<table border=1><tr><th>values</th><th>expected</th><th>actual result</th></tr>';
foreach ($cases as $expect=>$a)
{
    $result=f($a);
    echo "<tr><td>[", implode(',',$a),"]</td><td>$expect</td><td>$result</td></tr>";
}
echo '</table>';
Titus
fuente
Bien hecho. Puede eliminar 3 bytes más devolviendo el último valor como una matriz (cambie 'return $ a [0]' por 'return $ a'), lo que no veo es específicamente en contra de las reglas. :)
640 KB
@gwaugh Imo If the array contains just a single number, we return that as the result.es bastante claro. Pero gracias por dejarme volver a visitar esto.
Tito
Se podría hacer un argumento semántico de que "eso" en la oración puede referirse a "la matriz". De todos modos, su respuesta es, con mucho, el PHP más corto. Muy bien hecho, y gracias de nuevo por los consejos sobre mi presentación más larga.
640 KB
3

PHP ,135 130 bytes

¡Gracias @titus, -5 bytes, más 0 arreglos de caso!

function f($z){return array_reduce($z,function($c,$x)use(&$i){eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');return$c;});};

Pruébalo en línea!

Menos golf:

function f( $t ) {
    return array_reduce( $t,
        function( $c, $x ) use( &$i ) {
            eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');
            return $c;
        }
    );
};

Realmente estaba enraizando para que array_reduce () funcionara para esto, pero requiere demasiados caracteres para superar el puntaje PHP más bajo actual.

¡Publicarlo de todos modos en caso de que alguien tenga alguna sugerencia!

640 KB
fuente
1
Buen enfoque; pero creo que fallará cada vez que $cgolpee 0. Guarde dos bytes con una función anónima en lugar de w. eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x');return$c;es seis bytes más corto y debería resolver el problema cero.
Tito
¡Gracias @Titus! Tienes toda la razón sobre el caso 0. Tuve que volver a agregar el; después de = $ x porque eval no se ejecutaría sin él. Si lo convirtiera en una función anon, tendría que tener una asignación variable o ejecutarlo dentro del código de prueba, ¿verdad? No quisiera poner en duda el recuento de bytes. : D
640KB
2

Brachylog , 68 bytes

hI,?bL,1:+:-:*:/:^b:L:I{bhv?t.|[O:L:I]h$(P,LbM,OhA,Lh:Ir:A&:M:Pr&.}.

Eso es largo ... pero no utiliza un predicado de evaluación.

Explicación

  • Predicado principal

    hI,                                  Unify I with the first element of the input
       ?bL,                              L is the input minus the first element
           1:+:-:*:/:^b                  Construct the list of predicates [+:-:*:/:^]
                       :L:I{...}.        Call predicate 1 with [[+:-:*:/:^]:L:I] as input
    
  • Predicado 1

    bhv?t.                               If the second element of Input is empty (i.e. L),
                                         unify Output with the last element of Input
    |                                    Or
    [O:L:I]                              Input = [O:L:I]
           h$(P,                         P is O circularly permutated to the left
                LbM,                     M is L minus the first element
                    OhA,                 A is the first element of O
                        Lh:Ir:A&         Call predicate A on [I:First element of L]
                                :M:Pr&.  Call predicate 1 recursively with P:M:
    
Fatalizar
fuente
Te venció por 1̶ ̶b̶y̶t̶e̶ 2 bytes;)
LegionMammal978
2

IBM PC 8087 FPU, 66 82 bytes

Utiliza solo el coprocesador matemático Intel 8087 de la PC IBM para los cálculos.

¡Pruébalo sin conexión! (en DOSBox o lo que sea). Déle algo al chip 8087 aburrido de su vieja PC, aparte de todas esas hojas de cálculo Lotus 1-2-3 que solía hacer en los años 80.

9bdf 0783 c302 499b de07 83c3 0249 e342 9bde 2783 c302 49e3 399b de0f 83c3 0249 
e330 9bde 3783 c302 49e3 2751 8b0f 9bd9 e883 f900 7413 9c7f 02f7 d99b d8c9 e2fb 
9d7d 069b d9e8 9bd8 f159 83c3 0249 e302 ebb5 c3

Sin golf (sin montar):

START: 
    ; RUN TESTS  
    MOV  BX, OFFSET TST     ; 5, 12, 23, 2, 4, 4, 2, 6, 7
    MOV  CX, CTST           ; input array length
    CALL WOMI               ; calculate sequence
    CALL PRINT_FLT          ; output to console

    MOV  BX, OFFSET TST1    ; 5, 12, 23, 2, 4, -4, 2, 6, 7
    MOV  CX, CTST1
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST2    ; -8, 50, 3, 3, -123, 4, 17, 99, 13
    MOV  CX, CTST2
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST3    ; 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
    MOV  CX, CTST3
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST4    ; 1,0,1,0,1,0
    MOV  CX, CTST4
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST5    ; -9, -8, -1
    MOV  CX, CTST5
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST6    ; 0, -3
    MOV  CX, CTST6
    CALL WOMI
    CALL PRINT_FLT

    MOV  AX, 4C00H          ; exit to DOS
    INT  21H

;  TEST DATA

TST   DW  5, 12, 23, 2, 4, 4, 2, 6, 7
CTST  EQU ($-TST)/(SIZE TST)    ; count of items on list

TST1  DW  5, 12, 23, 2, 4, -4, 2, 6, 7
CTST1 EQU ($-TST1)/(SIZE TST1)  ; count of items on list

TST2  DW -8, 50, 3, 3, -123, 4, 17, 99, 13
CTST2 EQU ($-TST2)/(SIZE TST2)  ; count of items on list

TST3  DW 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
CTST3 EQU ($-TST3)/(SIZE TST3)  ; count of items on list

TST4  DW 1,0,1,0,1,0
CTST4 EQU ($-TST4)/(SIZE TST4)  ; count of items on list

TST5  DW -9, -8, -1
CTST5 EQU ($-TST5)/(SIZE TST5)  ; count of items on list

TST6  DW 0, -3
CTST6 EQU ($-TST6)/(SIZE TST6)  ; count of items on list

; 8087 exponent: ST(0) = ST(0) ^ EXP
FIEXP   MACRO   EXP
        LOCAL   REPEAT, DONE
        PUSH CX
        MOV  CX, EXP        ; Exponent is count for loop
        FLD1                ; load 1 into ST
        CMP  CX, 0          ; is exponent pos, neg or 0?
        JZ   DONE           ; exit (with value 1) if exponent is 0
        PUSHF               ; save result flags for later
        JG   REPEAT         ; if exp > 1 start calculation
        NEG  CX             ; make exponent positive for loop
REPEAT:
        FMUL ST(0), ST(1)   ; multiply ST0 = ST0 * ST1
        LOOP REPEAT
        POPF                ; retrieve flags from earlier
        JGE  DONE           ; if exponent was negative, divide 1 by result
        FLD1                ; push 1 into numerator
        FDIV ST(0), ST(1)   ; ST0 = 1 / ST1
DONE:
        POP  CX
        ENDM

; Function WOMI: (Weapons of Math Instruction)
; input: BX - address of start of input array
;       CX - length of input array
; output: ST - result on top of 8087 register stack
WOMI PROC
    FILD WORD PTR [BX]      ; load first item
    ADD  BX, 2              ; move to next
    DEC  CX
CALC:
    FIADD WORD PTR [BX]     ; add
    ADD  BX, 2              ; move to next
    DEC  CX                 ; decrement counter
    JCXZ OUTPUT             ; check if done

    FISUB WORD PTR [BX]     ; subtract
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIMUL WORD PTR [BX]     ; multiply
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIDIV WORD PTR [BX]     ; divide
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIEXP [BX]              ; exponent
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT
    JMP CALC                ; start again

OUTPUT:
    RET 
WOMI ENDP

PRINT_FLT PROC
; print top of 8087 stack
; scaling: 14 digits, 4 decimal places
; input: BX = address of a TBYTE (BCD) output buffer
;       ST = value to display on top of 8087 stack  
    LEA   BX, BUFF                  ; set BX to BCD output buffer
    MOV   AH, 2
    MOV   WORD  PTR[BX], 10000      ; ten thousand (scale factor)
    FIMUL WORD  PTR[BX]             ; scale up by 10000
    FBSTP TBYTE PTR[BX]             ; store as BCD
    FWAIT                           ; sync 8088 and 8087
    TEST  BYTE  PTR[BX+9], 80H      ; check sign bit
    JE    PF_1                      ; 0, goto PF_1
    MOV   DL, '-'                   ; output '-'
    INT   21H
PF_1:
    ADD   BX, 8                     ; point to high byte
    MOV   CH, 7                     ; 14 digits before decimal point
    MOV   CL, 4                     ; 4 shifts (8 bytes / 2 = 4 = 1 nibble)
    MOV   DH, 2                     ; 2 times (8 bytes / 4)
PF_LOOP:
    MOV   DL, [BX]                  ; get BCD digits
    SHR   DL, CL                    ; move high digit to low nibble
    OR    DL, 30H                   ; convert to ASCII
    INT   21H
    MOV   DL, [BX]                  ; get byte again
    AND   DL, 0FH                   ; mask out high digit
    OR    DL, 30H                   ; convert to ASCII
    INT   21H                       ; output
    DEC   BX                        ; next byte
    DEC   CH                        ; decrement byte
    JG    PF_LOOP                   ; repeat if more bytes
    DEC   DH                        ; second time?
    JE    PF_DONE                   ; yes, done
    MOV   DL, '.'                   ; no, output decimal point
    INT   21H
    MOV   CH, 2                     ; 4 more digits after decimal point
    JMP   PF_LOOP                   ; go print digits
PF_DONE:
    MOV  DL, 0DH                    ; display newline CRLF
    MOV  AH, 2
    INT  21H
    MOV  DL, 0AH
    INT  21H
    RET 
PRINT_FLT ENDP

BUFF DT 0   ; output buffer for floating point digit string

_TEXT ENDS
END START

Salida:

A>WOMI.COM
00000000000539.0000
-00000000000027.9136
-00000000001055.3569
00000000000256.0000
00000000000001.0000
-00000000000016.0000
-00000000000003.0000

La entrada es a través de un PROC (x86 más equivalente a una función), con BX como un puntero a una matriz de WORD en la memoria, y CX es el número de elementos que contiene y devuelve el resultado en ST.

* Nota: El código real para la función es 6682 bytes. Por supuesto, el código solo para escribir un número de coma flotante en la consola (código del libro de cocina) es 83 bytes. El programa de prueba y los datos son183215 bytes, lo que hace que .COM sea ejecutable 305 380 bytes en total.

640 KB
fuente
1
¡Esto es genial! He escrito una solución similar para x86-64 (linux) pero aún no la he jugado mucho, lo que probablemente cambiará mucha de la lógica. Para su cálculo de exponente, aunque las pruebas dadas no prueban recibir un exponente negativo, sentí que era una parte necesaria de la lógica del programa, especialmente porque es tan simple como presionar 1 a st0 y luego hacer un div entre st0 y st1 (al menos en x86, estas son dos instrucciones).
davey
Gracias @davey - muy buen punto! He actualizado el código para manejar exponentes negativos y agregué otro caso de prueba.
640 KB
2

APL (Dyalog Unicode) , 29 27 bytes SBCS

Función de prefijo tácito anónimo. Tenga en cuenta que *es exponenciación en APL.

≢{⍎3↓⍕⌽⍵,¨⍨⍺⍴'+-×÷*''⍨'}⊢

Pruébalo en línea!

Debido a que APL se ejecuta de derecha a izquierda, podemos simplemente invertir el orden de los argumentos de las operaciones insertadas e invertir toda la expresión. Postfix invierte los argumentos. Después de hacer una combinación perfecta de números y operaciones, solo necesitamos revertir, aplanar y evaluar:

≢{... }⊢ llame a la siguiente función con recuento de y números reales como y :

'⍨' Este personaje

'+-×÷*',¨ anteponer cada uno de estos caracteres a eso; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

⍺⍴ utilizar el argumento de la izquierda (recuento de los números) de forma cíclica r eshape que

 marcha atrás

 formatear como cadena plana

3↓suelte los 3 caracteres principales (un espacio y un símbolo y )

 ejecutar como código APL

Adán
fuente
2

Japt , 16 bytes

r@[XY]r"p+-*/"gZ

Pruébalo en línea!

Explicación:

r@                  #Reduce the input list:
       "p+-*/"      # The list of functions to apply (offset by one due to the behavior of Z)
              gZ    # Choose the one at the current index, wrapping
  [  ]r             # Apply that function to:
   X                #  The result of the previous step
    Y               #  and the current number
                    #Implicitly return the result of the final step
Kamil Drakari
fuente
Ah, feck, solo estaba trabajando en esto, tratando de descubrir por qué me estaba dando resultados incorrectos: ¡me había perdido la exponenciación de fecking! : \
Shaggy
1

c #, 238 , 202 bytes

double d(double[]a){Array.Reverse(a);var s=new Stack<double>(a);int i=0,j;while(s.Count>1){double l=s.Pop(),r=s.Pop();j=i++%5;s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l,r));}return s.Peek();}

No vi ninguna solución de C #, así que le daré una. Este es mi primer codegolf. Empecé a escribir en c # "hace dos meses" (aunque conozco Java hasta cierto punto).

Utiliza pila

¡Prueba en línea!

Sin golf y casos de prueba

using System;
using System.Collections.Generic;

class M 
{
    double d(double[]a) {
        Array.Reverse(a);
        var s = new Stack<double>(a);
        int i=0,j;
        while (s.Count>1)
        {
            double l=s.Pop(),r=s.Pop();
            j=i++%5;
            s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l, r));
        }
        return s.Peek();
    }

    public static void Main()
    {
        int[][] a = new int[][]{
            new int[]{1,2,3,4,5},
            new int[]{5,12,23,2,4,4,2,6,7},
            new int[]{-8,50,3,3,-123,4,17,99,13},
            new int[]{2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
            new int[]{1,0,1,0,1,0},
            new int[]{-9,-8,-1},
            new int[]{0,-3},
            new int[]{-99}
        };

        for (int i = 0; i < a.Length; i++)
        {
            Console.WriteLine(new M().d(Array.ConvertAll(a[i], e => Convert.ToDouble(e))));
        }
        Console.ReadKey();
    }
}

Salida:

0
539
-1055,35694384628
256
1
-16
-3
-99
nombre para mostrar
fuente
Hola y bienvenidos a PPCG! Este podría ser un buen tema para ver: Consejos para jugar golf en código en C # . Algunas cosas que se pueden jugar en su código: espacios ( a, Double.Parse-> a,Double.Parse; while (s.Count-> while(s.Count; Pow(l, r)-> Pow(l,r)). Además, puede quitarlo int delante j=y ponerlo detrás delint i=0,j; . Excelente primera respuesta, y una vez más, bienvenido. :)
Kevin Cruijssen
@KevinCruijssen ¡Hola! Ty! Espacios eliminados y j movido como sugirió :)
display_name
1

PHP, 206 , 198 , 197 bytes

function f($a){while(count($a)>1){$l=array_shift($a);$r=array_shift($a);array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));}return array_pop($a);}

¡Prueba en línea!

Sin golf

<?php

function f($a)
{
    while(count($a)>1)
    {
        $l = array_shift($a); $r = array_shift($a);
        array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));
    }
    return array_pop($a);
}

echo f([1,2,3,4,5])."\n";
echo f([5,12,23,2,4,4,2,6,7])."\n";
echo f([-8,50,3,3,-123,4,17,99,13])."\n";
echo f([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2])."\n";
echo f([1,0,1,0,1,0])."\n";
echo f([-9,-8,-1])."\n";
echo f([0,-3])."\n";
echo f([-99])."\n";

En PHP, lógica similar a mi respuesta de C # ( 202 bytes ) :).

nombre para mostrar
fuente