Inspirado por isso

No desafio vinculado, somos solicitados a aplicar adição aos elementos do original e o inverso da matriz de entrada. Neste desafio, tornaremos um pouco mais difícil, apresentando as outras operações matemáticas básicas.

Dada uma matriz de números inteiros, percorra +, *, -, //, %, ^, onde //é a divisão inteira e ^é expoente, enquanto a aplica no reverso da matriz. Ou, em outras palavras, aplique uma das funções acima a cada elemento de uma matriz, com o segundo argumento sendo o inverso da matriz, com a função aplicada percorrendo a lista acima. Isso ainda pode ser confuso, então vamos trabalhar com um exemplo.

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]

então a saída para [1, 2, 3, 4, 5, 6, 7, 8, 9]seria[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Para cobrir os casos de canto, a entrada nunca conterá um 0, mas pode conter qualquer outro número inteiro no intervalo de infinito negativo a infinito positivo. Você pode receber a entrada como uma lista de cadeias que representam dígitos, se desejar.

Casos de teste

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 é um código-golfe, pelo que o código mais curto (em bytes) vence!

Gelatina, 10 bytes ( bifurcação )

+×_:%*6ƭ"Ṛ

Eu estava trabalhando na implementação de um rápido para isso outro dia, então é bastante surpreendente ver um uso para ele tão cedo. Ele ainda existe apenas como um fork, portanto você não pode experimentá-lo online.

Saída de amostra

$ ./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]

Explicação

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

Casca , 16 bytes

Esse desafio favorece idiomas que podem criar listas infinitas de funções. Talvez não, evalFTW

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

Experimente online!

Quão?

  ¢+ë+*-÷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      ]

Solução alternativa de 17 bytes:

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

05AB1E , 18 bytes

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

Experimente online!

Explicação

                    # 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

Utilitários Bash + GNU, 53

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

Este script usa um nome de arquivo como um parâmetro de linha de comando.

Experimente online .

O bom aqui é que paste -dpermite uma lista de separadores, que são usados ​​ciclicamente. O resto é apenas colocar a entrada no formato certo para fazer isso.

Gelatina , 15 bytes

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

Experimente online! ou veja a suíte de testes .

Quão?

żṚ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 graças a ovs.

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

Experimente online!

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*

Experimente online!

evalé mau ... mas talvez mais golfista. : P

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

Guardou 1 byte graças a @nwellnhof.

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

Experimente online!

Solução muito sem imaginação (e provavelmente ruim). Fecha o argumento invertido. A lista resultante é então mapeada com o bloco que EVALé a string a (operator) b. O operador é escolhido na lista de strings <+ * - div % **>usando a variável free state(pense staticem C - o valor persiste nas chamadas do bloco) $. Isso é criado para cada bloco separadamente e definido como 0. Você pode fazer o que quiser com ele, mas pode fazer referência apenas uma vez (cada ocorrência de $refere-se a outra variável, na verdade). Então, $++%6na verdade, é 0 durante a primeira chamada, 1 durante a segunda, ... 5 durante a 6ª, 0 durante a 7ª e assim por diante.

Eu primeiro tentei fazer sem um EVAL. Os operadores são de fato apenas subs (= funções), mas seus nomes são tão extremamente não-voláteis ( &infix:<+>e assim por diante) que eu tive que renunciar a essa abordagem.

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

Experimente online!

Guardado 12 bytes graças a @nimi

Certamente, há uma maneira melhor de conseguir isso.

EDIT 1. Expoente fixo para números inteiros; 2. Definitivamente, existe uma maneira melhor, veja o comentário abaixo: 95 91 bytes

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

Experimente online!

Python 2 , 71 bytes

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

Experimente online!

Economizou 2 bytes graças a ovs!

J, ₄₄ bytes 42

Riscado 44, yada yada ...

-2 bytes graças a @ ConorO'Brien

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

Experimente online!

Tantas parênteses e inserções ... Certamente, há uma maneira melhor de fazer isso (talvez usando a inserção em vez do infix?)

Explicação

_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

Algumas notas:

J não tem divisão inteira, então compomos %-division com -floor >.. O mod ( |) de J faz a ordem inversa do que esperávamos, portanto, temos que inverter sua ordem usando ~-reflexive.

Mesmo nos movendo sobre os intervalos de 2, temos que usar /-insert para inserir os verbos para que eles sejam usados ​​diariamente, pois é assim que o \-infix funciona.

Ruby , 63 57 bytes

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

Nada extravagante, realmente. Apenas itere na matriz, use um índice como iterador reverso, junte-se a uma string usando o operador certo, avalie, enxágue e repita.

Experimente online!

k , 40 bytes

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

Experimente online!

{                                      } /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

MATL ,27 23 bytes

-4 bytes graças a @LuisMendo

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

Experimente online!

Explicação:

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

Experimente online!

Aceita entrada como lista de números separados por espaço.

R , 74 bytes

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

Experimente online!

Esta é a resposta final que eu vim. Retorna uma lista de comprimento em length(l)que cada elemento é uma lista que contém o elemento correspondente. Meio ruim, mas estão todos lá. Se isso é inaceitável, qualquer um dosMap pode ser substituído pormapply por +3 bytes.

Como os operadores R são todas funções (a notação infix sendo apenas açúcar sintático), tentei selecionar uma em uma lista; por exemplo, a solução de 94 bytes abaixo.

Para tentar me livrar do loop, tentei sapply, mas isso só funciona com uma única função e lista de entradas. Lembrei-me então da forma multivariada mapply, que assume uma n-aryfunção FUNe nos argumentos seguintes, aplicando FUNao primeiro, segundo, ..., elementos de cada um dos argumentos, reciclando se necessário . Há também uma função de invólucro para mapply, Mapque "não faz nenhuma tentativa para simplificar o resultado" . Como é três bytes mais curto, é uma boa oportunidade de golfe.

Então, eu defini uma função trinária (como na solução de 80 bytes abaixo) que assume uma função como seu primeiro argumento e a aplica ao seu segundo e terceiro. No entanto, percebi que Mapé uma função que assume uma função como seu primeiro argumento e a aplica a sucessivas. Arrumado!

Por fim, fazemos um subconjunto no final para garantir que retornemos apenas os primeiros length(l)valores.

R , 80 bytes

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

Experimente online!

Este não funciona, pois retornará 6 valores para listas com 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}

Experimente online!

Explicação (levemente não destruída):

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
}

Como cada uma das funções é vetorizada, podemos indexar no final ( res[i]). Isso é melhor que oeval abordagem abaixo.

R , 100 bytes

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

Experimente online!

Essa é a evalabordagem mais curta que pude encontrar; porque temos de recolher os resultados em um vetor, é preciso pasteum c( )em torno de toda a expressão, o que acrescenta uma tonelada de bytes desnecessários

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)

Isso foi doloroso. Especialmente porque mod(x,y)retorna xquando realmente não deveria, o que significava que eu tinha que fazer minha própria função de mod: daí o x-int(x/y)y.

Loops ide 0 a length(l)-1, pegando elementos sucessivos na olista e aplicando l[i]para xe l[-i]para y. (índices negativos não funcionam, então eu subtraioi o comprimento da lista e pego esse índice.)

107 bytes para a função, +1 byte para adicionar lna caixa 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;}

Experimente aqui.

Suspiro ..
Entrada como int[], saída como java.math.BigInteger[].

Sem a regra " Para cobrir os casos de canto, a entrada nunca conterá um 0, mas pode conter qualquer outro número inteiro no intervalo de infinito negativo a infinito positivo. ", Usando números inteiros no intervalo -2147483648até 2147483647, seria 186 bytes (entrada como int[], e nenhuma saída porque modifica essa matriz de entrada para salvar 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];}

Experimente aqui.

Explicação:

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