Inspiré par cela

Dans le défi lié, il nous est demandé d'appliquer l'addition aux éléments de l'original et de l'inverse du tableau d'entrée. Dans ce défi, nous allons le rendre un peu plus difficile, en introduisant les autres opérations mathématiques de base.

Étant donné un tableau d'entiers, parcourez +, *, -, //, %, ^, où //est la division entière et ^est exposant, tout en l'appliquant à l'inverse du tableau. Ou, en d'autres termes, appliquez l'une des fonctions ci-dessus à chaque élément d'un tableau, le deuxième argument étant l'inverse du tableau, la fonction appliquée parcourant la liste ci-dessus. Cela peut encore prêter à confusion, permet donc de travailler sur un exemple.

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]

de sorte que la sortie pour [1, 2, 3, 4, 5, 6, 7, 8, 9]serait[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Pour couvrir les cas d'angle, l'entrée ne contiendra jamais de 0, mais peut contenir tout autre entier dans la plage allant de l'infini négatif à l'infini positif. Vous pouvez prendre l'entrée comme une liste de chaînes représentant des chiffres si vous le souhaitez.

Cas de test

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]

C'est un code-golf donc le code le plus court (en octets) gagne!

Gelée, 10 octets ( fourchette )

+×_:%*6ƭ"Ṛ

Je travaillais juste sur l'implémentation d'un rapide pour cela l'autre jour, il est donc assez surprenant de voir une utilisation si tôt. Il n'existe toujours qu'en tant que fork, vous ne pouvez donc pas l'essayer en ligne.

Exemple de sortie

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

Explication

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

Husk , 16 octets

Ce défi favorise les langages qui peuvent créer des listes infinies de fonctions. Peut-être pas, evalFTW

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

Essayez-le en ligne!

Comment?

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

Solution alternative à 17 octets:

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

05AB1E , 18 octets

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

Essayez-le en ligne!

Explication

                    # 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

Utilitaires Bash + GNU, 53

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

Ce script prend un nom de fichier comme paramètre de ligne de commande.

Essayez-le en ligne .

La bonne chose ici est que cela paste -dpermet de donner une liste de séparateurs, qui sont utilisés de manière cyclique. Le reste, il suffit de mettre l'entrée dans le bon format pour ce faire.

Gelée , 15 octets

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

Essayez-le en ligne! ou voir la suite de tests .

Comment?

żṚ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 octets

-3 octets grâce aux ovs.

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

Essayez-le en ligne!

Python 2 , 95 octets

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

Essayez-le en ligne!

evalest mal ... mais peut-être plus golfique. : P

JavaScript (ES7), 68 67 octets

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 octets

1 octet enregistré grâce à @nwellnhof.

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

Essayez-le en ligne!

Solution très peu imaginative (et probablement mauvaise). Zips l'argument avec lui-même inversé. La liste résultante est ensuite mappée avec le bloc qui EVALest la chaîne a (operator) b. L'opérateur est choisi dans la liste des chaînes en <+ * - div % **>utilisant la variable libre state(pensez staticen C - la valeur persiste à travers les appels du bloc) $. Ceci est créé séparément pour chaque bloc et mis à 0. Vous pouvez faire tout ce que vous voulez avec lui, mais vous ne pouvez le référencer qu'une seule fois (chaque occurrence de $fait référence à une autre variable, en fait). Il en $++%6est de même de 0 lors du premier appel, de 1 lors du second, ... de 5 lors du 6, de 0 lors du 7 et ainsi de suite.

J'ai d'abord essayé de m'en passer EVAL. Les opérateurs ne sont en fait que des sous-marins (= fonctions), mais leurs noms sont tellement peu mordants ( &infix:<+>et ainsi de suite) que j'ai dû renoncer à cette approche.

Haskell , 74 117 105 octets

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

Essayez-le en ligne!

12 octets enregistrés grâce à @nimi

Il existe certainement un meilleur moyen d'y parvenir.

EDIT 1. Exposant fixe pour les entiers; 2. Il y a certainement une meilleure façon, voir le commentaire ci-dessous: 95 91 octets

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

Essayez-le en ligne!

Python 2 , 71 octets

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

Essayez-le en ligne!

Sauvegardé 2 octets grâce aux ovs!

J, ₄₄ 42 octets

Barré 44, yada yada ...

-2 octets grâce à @ ConorO'Brien

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

Essayez-le en ligne!

Tant de parens et d'inserts ... Il y a sûrement une meilleure façon de le faire (peut-être en utilisant insert plutôt qu'infix?)

Explication

_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

Quelques notes:

J n'a pas de division entière, donc nous composons -division %avec >.-floor. Le mod ( |) de J fait l'ordre inverse de ce que nous attendons, nous devons donc inverser son ordre en utilisant ~-reflexive.

Même si nous nous déplaçons sur des intervalles de 2, nous devons utiliser /-insert pour insérer les verbes pour les utiliser dyadiquement puisque c'est ainsi que \-infix fonctionne.

Rubis , 63 57 octets

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

Rien d'extraordinaire, vraiment. Il suffit d'itérer sur le tableau, d'utiliser un index comme itérateur inverse, de se joindre à une chaîne en utilisant le bon opérateur, d'évaluer, de rincer et de répéter.

Essayez-le en ligne!

k , 40 octets

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

Essayez-le en ligne!

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

-4 octets grâce à @LuisMendo

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

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Prend l'entrée comme une liste de nombres séparés par des espaces.

R , 74 octets

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

Essayez-le en ligne!

C'est la réponse finale que j'ai trouvée. Il renvoie une liste de longueur length(l)où chaque élément est une liste contenant l'élément correspondant. Un peu merdique mais ils sont tous là. Si cela est inacceptable, l'un ou l'autre Mappeut être remplacé par mapply+3 octets.

Puisque les opérateurs R sont toutes des fonctions (la notation infixe étant simplement du sucre syntaxique), j'ai essayé d'en sélectionner une dans une liste; par exemple, la solution de 94 octets ci-dessous.

Pour essayer de me débarrasser de la boucle, j'ai essayé sapply, mais cela ne fonctionne qu'avec une seule fonction et une seule liste d'entrée. Ensuite, je me suis souvenu de la forme multivariée mapply, qui prend une n-aryfonction FUNet des narguments successifs, s'appliquant FUNaux premier, deuxième, ..., éléments de chacun des arguments, recyclant si nécessaire . Il y a aussi une fonction wrapper pour mapply, Mapqui "ne fait aucune tentative pour simplifier le résultat" . Comme il est plus court de trois octets, c'est une bonne opportunité de jouer au golf.

J'ai donc défini une fonction trinaire (comme dans la solution de 80 octets ci-dessous) qui prend une fonction comme premier argument et l'applique à ses deuxième et troisième. Cependant, j'ai réalisé que Mapc'est une fonction qui prend une fonction comme premier argument et l'applique à des fonctions successives. Soigné!

Enfin, nous sous-ensemble à la fin pour nous assurer de ne renvoyer que les premières length(l)valeurs.

R , 80 octets

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

Essayez-le en ligne!

Celui-ci ne fonctionne pas, car il renverra 6 valeurs pour les listes de moins de 6 éléments.

R , 94 octets

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

Essayez-le en ligne!

Explication (légèrement non golfée):

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
}

Parce que chacune des fonctions est vectorisée, nous pouvons indexer à la fin ( res[i]). C'est mieux que l' evalapproche ci-dessous.

R , 100 octets

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

Essayez-le en ligne!

C'est l' evalapproche la plus courte que j'ai pu trouver; parce que nous devons recueillir les résultats dans un vecteur, nous devons pasteun c( )autour de toutes les expressions, ce qui ajoute une tonne d'octets inutiles

Casio-Basic, 108 octets

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

C'était douloureux. Surtout parce que mod(x,y)revient xquand il ne devrait vraiment pas, ce qui signifie que j'ai dû créer ma propre fonction de mod: d'où le x-int(x/y)y.

Boucles ide 0 à length(l)-1, en prenant des éléments successifs dans la oliste et en demandant l[i]pour xet l[-i]pour y. (les indices négatifs ne fonctionnent pas cependant, donc à la place je soustrais ide la longueur de la liste et prends cet index.)

107 octets pour la fonction, +1 octet à ajouter ldans la boîte de paramètres.

Java 8, 336 octets

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

Essayez-le ici.

Soupir ..
Entrée comme int[], sortie comme java.math.BigInteger[].

Sans la règle " Pour couvrir les cas d'angle, l'entrée ne contiendra jamais de 0, mais peut contenir tout autre entier dans la plage de l'infini négatif à l'infini positif. ", En utilisant des entiers dans la plage -2147483648de 2147483647, ce serait 186 octets (entrée as int[], et aucune sortie car il modifie ce tableau d'entrée à la place pour économiser des octets):

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

Essayez-le ici.

Explication:

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