Inspirado por esto

En el desafío vinculado, se nos pide que apliquemos la suma de los elementos del original y el reverso de la matriz de entrada. En este desafío, lo haremos un poco más difícil, introduciendo las otras operaciones matemáticas básicas.

Dada una matriz de enteros, recorra +, *, -, //, %, ^, donde //es la división de enteros y ^es exponente, mientras se aplica al reverso de la matriz. O, en otras palabras, aplique una de las funciones anteriores a cada elemento de una matriz, siendo el segundo argumento el reverso de la matriz, con la función aplicada recorriendo la lista anterior. Esto aún puede ser confuso, así que analicemos un ejemplo.

Input:   [1, 2, 3, 4, 5, 6, 7, 8, 9]
Reverse: [9, 8, 7, 6, 5, 4, 3, 2, 1]

         [ 1,  2,  3,  4,  5,    6,  7,  8,  9]
Operand:   +   *   -   /   %     ^   +   *   -
         [ 9,  8,  7,  6,  5,    4,  3,  2,  1]

Result:  [10, 16, -4,  0,  0, 1296, 10, 16,  8]

entonces la salida para [1, 2, 3, 4, 5, 6, 7, 8, 9]sería[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Para cubrir los casos de esquina, la entrada nunca contendrá un 0, pero puede contener cualquier otro número entero en el rango de infinito negativo a infinito positivo. Puede tomar la entrada como una lista de cadenas que representan dígitos si lo desea.

Casos de prueba

input => output

[1, 2, 3, 4, 5, 6, 7, 8, 9]     => [10, 16, -4, 0, 0, 1296, 10, 16, 8]
[5, 3, 6, 1, 1]                 => [6, 3, 0, 0, 1]
[2, 1, 8]                       => [10, 1, 6]
[11, 4, -17, 15, 2, 361, 5, 28] => [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Este es un código de golf, por lo que gana el código más corto (en bytes).

Gelatina, 10 bytes ( tenedor )

+×_:%*6ƭ"Ṛ

Estaba trabajando en implementar un rápido para esto el otro día, por lo que es bastante sorprendente ver un uso tan pronto. Todavía existe como una bifurcación, por lo que no puede probarlo en línea.

Salida de muestra

$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[1,2,3,4,5,6,7,8,9]'
[10, 16, -4, 0, 0, 1296, 10, 16, 8]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[5,3,6,1,1]'
[6, 3, 0, 0, 1]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[2,1,8]'
[10, 1, 6]
$ ./jelly eun '+×_:%*6ƭ"Ṛ' '[11,4,-17,15,2,361,5,28]'
[39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Explicación

+×_:%*6ƭ"Ṛ  Input: array
      6ƭ    Tie 6 dyads
+             Addition
 ×            Multiplication
  _           Subtraction
   :          Integer division
    %         Modulo
     *        Power
        "   Vectorize with
         Ṛ  Reverse

Casco , 16 bytes

Este desafío favorece los idiomas que pueden crear infinitas listas de funciones. Quizás no, evalFTW

zF¢+ë+*-÷e%^Ṡze↔

Pruébalo en línea!

¿Cómo?

  ¢+ë+*-÷e%^         The infinite list [+,*,-,÷,%,^,+,*,-,...
    ë+*-÷            The list [+,*,-,÷]
         e%^         The list [%,^]
   +                 Concatenated
  ¢                  Then repeated infinitely
               ↔     The input reversed e.g [9,8,7,6,5,4,3,2,1]
            Ṡze      Zipped with itself     [[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8],[1,9]]
zF                   Zipwith reduce, the list of functions and the list of lists.
                     [F+[9,1],F*[8,2],F-[7,3],F÷[6,4],F%[5,5],F^[4,6],F+[3,7],F*[2,8],F-[1,9]]
                     [10     ,16     ,-4     ,0      ,0      ,1296   ,10     ,16     ,8      ]

Solución alternativa de 17 bytes:

ṠozIzI¢+ë+*-÷e%^↔

05AB1E , 18 bytes

Â"+*-÷%m"Ig×)øε`.V

Pruébalo en línea!

Explicación

                    # push a reversed copy of the input
 "+*-÷%m"            # push the list of operators
         Ig×         # repeat it input times
            )ø       # zip together
              ε      # apply to each triplet
               `     # push separately to stack
                .V   # evaluate

Bash + utilidades GNU, 53

tac $1|paste -d, $1 -|tr ',
' '
;'|paste -sd+*-/%^|bc

Este script toma un nombre de archivo como parámetro de línea de comando.

Pruébalo en línea .

Lo bueno aquí es que paste -dpermite dar una lista de separadores, que se usan cíclicamente. El resto es solo obtener la entrada en el formato correcto para hacer esto.

Jalea , 15 bytes

żṚj"“+×_:%*”ṁ$V

Pruébalo en línea!o ver el conjunto de pruebas .

¿Cómo?

żṚj"“+×_:%*”ṁ$V - Link: list of numbers, a       e.g. [5, 3, 6, 1, 1]
 Ṛ              - reverse a                           [1, 1, 6, 3, 5]
ż               - interleave                          [[5,1],[3,1],[6,6],[1,3],[1,5]
             $  - last two links as a monad:
    “+×_:%*”    -   literal list of characters        ['+','×','_',':','%','*']
            ṁ   -   mould like a                      ['+','×','_',':','%']
   "            - zip with the dyad:
  j             -   join                              ["5+1","3×1","6_6","1:3","1%5"]
              V - evaluate as Jelly code (vectorises) [6, 3, 0, 0, 1]

Python 2 , 67 bytes

-3 bytes gracias a los ovs.

lambda l:[eval(j+'*+*-/%*'[-~i%6::6]+l[~i])for i,j in enumerate(l)]

Pruébalo en línea!

Python 2 , 95 bytes

lambda l:[[add,mul,sub,div,mod,pow][i%6](v,l[~i])for i,v in enumerate(l)]
from operator import*

Pruébalo en línea!

evales malvado ... pero quizás más golfista. :PAG

JavaScript (ES7), 68 67 bytes

a=>[...a].map((v,i)=>(x=a.pop(),o='+*-/%'[i%6])?eval(v+o+x)|0:v**x)

let f =

a=>[...a].map((v,i)=>(x=a.pop(),o='+*-/%'[i%6])?eval(v+o+x)|0:v**x)

console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9]    ))) // [10, 16, -4, 0, 0, 1296, 10, 16, 8]
console.log(JSON.stringify(f([5, 3, 6, 1, 1]                ))) // [6, 3, 0, 0, 1]
console.log(JSON.stringify(f([2, 1, 8]                      ))) // [10, 1, 6]
console.log(JSON.stringify(f([11, 4, -17, 15, 2, 361, 5, 28]))) // [39, 20, -378, 7, 2, 3.32948887119979e-44, 9, 308]

Perl 6 ,67 66 bytes

Guardado 1 byte gracias a @nwellnhof.

{map {EVAL ".[0] {<+ * - div % **>[$++%6]} .[1]"},zip $_,.reverse}

Pruébalo en línea!

Solución muy poco imaginativa (y probablemente mala). Comprime el argumento consigo mismo invertido. La lista resultante se asigna con el bloque que EVALes la cadena a (operator) b. El operador se elige de la lista de cadenas <+ * - div % **>utilizando la variable libre state(piense staticen C: el valor persiste en todas las llamadas del bloque) $. Esto se crea para cada bloque por separado y se establece en 0. Puede hacer lo que quiera con él, pero puede hacer referencia a él solo una vez (cada aparición se $refiere a otra variable, en realidad). Entonces, en $++%6realidad es 0 durante la primera llamada, 1 durante la segunda, ... 5 durante la sexta, 0 durante la séptima y así sucesivamente.

Al principio intenté prescindir de un EVAL. De hecho, los operadores son solo subs (= funciones), pero sus nombres son tan extremadamente despiadados ( &infix:<+>y así sucesivamente) que tuve que renunciar a ese enfoque.

Haskell , 74 117 105 bytes

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f u=[o a b|(o,a,b)<-zip3(cycle[(+),(*),(-),(#),(%),(**)])u(reverse u)]

Pruébalo en línea!

Guardado 12 bytes gracias a @nimi

Ciertamente hay una mejor manera de lograr esto.

EDITAR 1. Exponente fijo para enteros; 2. Definitivamente hay una mejor manera, vea el comentario a continuación: 95 91 bytes

x#y=fromIntegral.floor$x/y
x%y=x-x#y
f=zipWith3($)(cycle[(+),(*),(-),(#),(%),(**)])<*>reverse

Pruébalo en línea!

Python 2 , 71 bytes

lambda l:[eval(y+'+*-/%*'[x%6]*-~(x%6>4)+l[~x])for x,y in enumerate(l)]

Pruébalo en línea!

¡Ahorré 2 bytes gracias a los ovs!

J, ₄₄ 42 bytes

Tachado 44, yada yada ...

-2 bytes gracias a @ ConorO'Brien

_2+/`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.

Pruébalo en línea!

Tantos parens e insertos ... Seguramente hay una mejor manera de hacer esto (¿tal vez usando insert en lugar de infix?)

Explicación

_2(+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)\[:,],.|.  Input: a
                                       ],.|.  Join a with reverse(a)
                                      ,       Ravel (zip a with reverse(a))
_2                                 \          To non-overlapping intervals of 2
  (+/)`(*/)`(-/)`(<.@%/)`(|~/)`(^/)           Apply the cyclic gerund
   +/                                           Insert addition
        */                                      Insert subtraction
             -/                                 Insert division 
                  <.@%/                         Insert integer division
                          |~/                   Insert mod
                                ^/              Insert exponentiation

Algunas notas:

J no tiene división entera, por lo que %componimos -división con -floor >.. J's mod ( |) hace el orden inverso de lo que esperaríamos, por lo que tenemos que invertir su orden usando ~-reflexive.

A pesar de que nos movemos en intervalos de 2, tenemos que usar /-insertar para insertar los verbos para que se usen de forma periódica, ya que así es como \funciona -infix.

Ruby , 63 57 bytes

->a{t=0;a.map{|x|eval [x,a[t-=1]]*%w(** % / - * +)[t%6]}}

Nada lujoso, de verdad. Simplemente itere en la matriz, use un índice como iterador inverso, únase a una cadena usando el operador correcto, evalúe, enjuague y repita.

Pruébalo en línea!

k , 40 bytes

{_((#x)#(+;*;-;%;{y!x};{*/y#x})).'x,'|x}

Pruébalo en línea!

{                                      } /function(x)
                                     |x  /reverse x
                                  x,'    /zip concat with x
        ( ; ; ; ;     ;       )          /list of operations
         + * - %                         /add, mult, sub, div
                 {y!x}                   /mod (arguments need to be reversed)
                       {*/y#x}           /pow (repeat and fold multiply)
  ((#x)#                       )         /resize operations to length of x
                                .'       /zip apply
 _                                       /floor result

MAT ,27 23 bytes

-4 bytes gracias a @LuisMendo

tP+1M*1M-IM&\w1M^v"@X@)

Pruébalo en línea!

Explicación:

tP         % duplicate and flip elements
+          % push array of sums (element-wise)
1M*        % push array of products (element-wise)
1M-        % push array of subtractions (element-wise)
IM&\w      % push array of divisions and modulo (element-wise)
1M^        % push array of power (element-wise)
v          % vertically concatenate all arrays
"@X@)    % push to stack values with the correct index based on operator
           % (implicit) convert to string and display

Perl 5 , 68 + 1 (-p) = 69 bytes

print$",eval'int 'x($i%6==3).$_.qw|+ ** % / - *|[$i--%6].$F[$i]for@F

Pruébalo en línea!

Toma la entrada como una lista de números separados por espacios.

R , 74 bytes

function(l)Map(Map,c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))[1:sum(l|1)]

Pruébalo en línea!

Esta es la respuesta final que se me ocurrió. Devuelve una lista de longitudlength(l) donde cada elemento es una lista que contiene el elemento correspondiente. Un poco horrible, pero todos están ahí. Si eso es inaceptable, cualquiera de los dos Mappuede reemplazarse mapplypor +3 bytes.

Como los operadores R son todas funciones (la notación infija solo es azúcar sintáctica), intenté seleccionar una de una lista; por ejemplo, la solución de 94 bytes a continuación.

Para intentar deshacerme del ciclo, lo intenté sapply, pero eso solo funciona con una sola función y lista de entrada. Luego recordé la forma multivariada mapply, que toma una n-aryfunción FUNy nargumentos posteriores, aplicando FUNal primero, segundo, ..., elementos de cada uno de los argumentos, reciclando si es necesario . También hay una función de contenedor a mapply, Mapque "no hace ningún intento de simplificar el resultado" . Como es tres bytes más corto, es una buena oportunidad para jugar al golf.

Así que definí una función trinaria (como en la solución de 80 bytes a continuación) que toma una función como su primer argumento y la aplica a su segunda y tercera. Sin embargo, me di cuenta de que Mapes una función que toma una función como primer argumento y la aplica a las sucesivas. ¡Ordenado!

Finalmente, subconjunto al final para asegurarnos de que solo devolvamos el primer length(l) valores.

R , 80 bytes

function(l)Map(function(x,y,z)x(y,z),c(`+`, `*`, `-`, `%/%`, `%%`,`^`),l,rev(l))

Pruébalo en línea!

Este no funciona, ya que devolverá 6 valores para listas con menos de 6 elementos.

R , 94 bytes

function(l){for(i in 1:sum(l|1))T[i]=switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`)(l,rev(l))[i]
T}

Pruébalo en línea!

Explicación (levemente no golfista):

function(l){
 for(i in 1:length(l)){
  fun <- switch(i%%6+1,`^`,`+`,`*`,`-`,`%/%`,`%%`) # select a function
  res <- fun(l,rev(l))                             # apply to l and its reverse
  T[i] <- res[i]                                   # get the i'th thing in the result
 }
 T                                                 # return the values
}

Debido a que cada una de las funciones está vectorizada, podemos indexar al final ( res[i]). Esto es mejor que el evalenfoque a continuación.

R , 100 bytes

function(l)eval(parse(t=paste("c(",paste(l,c("+","*","-","%/%","%%","^"),rev(l),collapse=","),")")))

Pruébalo en línea!

Este es el evalenfoque más corto que pude encontrar; porque tenemos que recopilar los resultados en un vector, necesitamos pasteun c( )alrededor de todas las expresiones, lo que agrega una tonelada de bytes innecesarios

Casio-Basic, 108 bytes

{x+y,x*y,x-y,int(x/y),x-int(x/y)y,x^y}⇒o
dim(l)⇒e
Print seq(o[i-int(i/6)6+1]|{x=l[i+1],y=l[e-i]},i,0,e-1)

Eso fue doloroso. Especialmente porque mod(x,y)regresa xcuando realmente no debería, lo que significa que tuve que hacer mi propia función de mod: de ahí el x-int(x/y)y.

Recorre ide 0 a length(l)-1, tomando elementos sucesivos en la olista y solicitando l[i]por xy l[-i]para y. (Sin embargo, los índices negativos no funcionan, por lo que restoi de la longitud de la lista y tomo ese índice).

107 bytes para la función, +1 byte para agregar len el cuadro de parámetros.

Java 8, 336 bytes

import java.math.*;a->{int b[]=a.clone(),i=0,l=b.length,s,t;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];BigInteger r[]=new BigInteger[l],u,v;for(i=-1;++i<l;t=b[i],v=new BigInteger(t+""),r[i]=(s=i%6)<1?u.add(v):s<2?u.multiply(v):s<3?u.subtract(v):s<4?u.divide(v):s<5?u.remainder(v):t<0?u.ZERO:u.pow(t))u=new BigInteger(a[i]+"");return r;}

Pruébalo aquí

Suspiro ..
Entrada como int[], salida como java.math.BigInteger[].

Sin la regla " Para cubrir los casos de esquina, la entrada nunca contendrá un 0, pero puede contener cualquier otro número entero en el rango de infinito negativo a infinito positivo. ", Usando números enteros en el rango -2147483648de 2147483647, sería 186 bytes (entrada como int[], y sin salida porque modifica esta matriz de entrada en su lugar para guardar bytes):

a->{int b[]=a.clone(),i=0,l=b.length,t,u,v;for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];for(i=-1;++i<l;v=b[i],a[i]=(t=i%6)<1?u+v:t<2?u*v:t<3?u-v:t<4?u/v:t<5?u%v:(int)Math.pow(u,v))u=a[i];}

Pruébalo aquí

Explicación:

import java.math.*;            // Required import for BigInteger

a->{                           // Method with int[] parameter and BigInteger[] return-type
  int b[]=a.clone(),           //  Make a copy of the input-array
      i=0,                     //  Index-integer
      l=b.length,              //  Length of the input
      s,t;                     //  Temp integers
  for(;i<l/2;b[i]=b[l+~i],b[l+~i++]=t)t=b[i];
                               //  Reverse the input-array and store it in `b`
  BigInteger r[]=new BigInteger[l],
                               //  Result-array
             u,v;              //  Temp BigIntegers
  for(i=-1;                    //  Reset `i` to -1
      ++i<l;                   //  Loop over the array(s):
                               //    After every iteration:
      t=b[i],                  //     Set the current item of `b` in `t`
      v=new BigInteger(t+""),  //     And also set it in `v` as BigInteger
      r[i]=(s=i%6)<1?          //   If the index `i` modulo-6 is 0:
            u.add(v)           //    Add the items with each other
           :s<2?               //   Else-if index `i` modulo-6 is 1:
            u.multiply(v)      //    Multiply the items with each other
           :s<3?               //   Else-if index `i` modulo-6 is 2:
            u.subtract(v)      //    Subtract the items with each other
           :s<4?               //   Else-if index `i` modulo-6 is 3:
            u.divide(v)        //    Divide the items with each other
           :s<5?               //   Else-if index `i` modulo-6 is 4:
            u.remainder(v)     //    Use modulo for the items
           :                   //   Else (index `i` modulo-6 is 5):
            t<0?               //    If `t` is negative:
             u.ZERO            //     Simply use 0
            :                  //    Else:
             u.pow(t))         //     Use the power of the items
    u=new BigInteger(a[i]+""); //  Set the current item of `a` to `u` as BigInteger
                               //  End of loop (implicit / single-line body)
  return r;                    //  Return the result BigInteger-array
}                              // End of method