Davon inspiriert

In der verknüpften Abfrage werden wir aufgefordert, die Elemente des Originals und die Umkehrung des Eingabearrays zu ergänzen. In dieser Herausforderung werden wir es etwas schwieriger machen, indem wir die anderen grundlegenden mathematischen Operationen einführen.

Bei einem gegebenen Array von Ganzzahlen durchlaufen Sie +, *, -, //, %, ^, wobei //Ganzzahldivision und ^Exponent sind, während Sie es auf die Rückseite des Arrays anwenden. Mit anderen Worten, wenden Sie eine der obigen Funktionen auf jedes Element eines Arrays an, wobei das zweite Argument die Umkehrung des Arrays ist und die Funktion die obige Liste durchläuft. Dies kann immer noch verwirrend sein, lassen Sie uns also ein Beispiel durcharbeiten.

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]

so dass der Ausgang für [1, 2, 3, 4, 5, 6, 7, 8, 9]wäre[10, 16, -4, 0, 0, 1296, 10, 16, 8]

Um die Eckfälle abzudecken, enthält die Eingabe niemals eine 0, sondern kann eine beliebige andere Ganzzahl im Bereich von negativer Unendlichkeit bis positiver Unendlichkeit enthalten. Sie können Eingaben als Liste von Zeichenfolgen annehmen, die Ziffern darstellen, wenn Sie möchten.

Testfälle

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]

Dies ist ein Code-Golf, so dass der kürzeste Code (in Bytes) gewinnt!

Gelee, 10 Bytes ( Gabel )

+×_:%*6ƭ"Ṛ

Ich habe neulich gerade daran gearbeitet, ein Quick für dieses Problem zu implementieren. Es ist also ziemlich überraschend, so bald eine Verwendung dafür zu sehen. Es gibt es immer noch nur als Gabel, Sie können es also nicht online ausprobieren.

Beispielausgabe

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

Erläuterung

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

Schale , 16 Bytes

Diese Herausforderung bevorzugt Sprachen, mit denen sich unendlich viele Funktionen erstellen lassen. Vielleicht nicht, evalFTW

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

Probieren Sie es online!

Wie?

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

Alternative 17-Byte-Lösung:

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

05AB1E , 18 Bytes

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

Probieren Sie es online!

Erläuterung

                    # 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 + GNU-Dienstprogramme, 53

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

Dieses Skript verwendet einen Dateinamen als Befehlszeilenparameter.

Probieren Sie es online aus .

Das Schöne dabei ist, paste -ddass eine Liste von Trennzeichen angegeben werden kann, die zyklisch verwendet werden. Der Rest ist es nur die Eingabe in das richtige Format zu bekommen, um dies zu tun.

Gelee , 15 Bytes

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

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Wie?

żṚ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 dank ovs.

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

Probieren Sie es 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*

Probieren Sie es online!

evalist böse ... aber vielleicht mehr golfen. : P

JavaScript (ES7), 68 bis 67 Byte

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

1 Byte dank @nwellnhof gespeichert.

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

Probieren Sie es online!

Sehr einfallslose (und wahrscheinlich schlechte) Lösung. Zippt das Argument mit sich selbst umgekehrt. Die resultierende Liste wird dann dem Block zugeordnet, der EVALdie Zeichenfolge ist a (operator) b. Der Operator wird aus der Liste der Zeichenfolgen <+ * - div % **>mit der Variablen free state(denken Sie statican C - der Wert bleibt über die Aufrufe des Blocks hinweg erhalten) ausgewählt $. Dies wird für jeden Block separat erstellt und auf 0 gesetzt. Sie können alles tun, was Sie wollen, aber Sie können nur einmal darauf verweisen (jedes Vorkommen von $bezieht sich tatsächlich auf eine andere Variable). Ist $++%6also tatsächlich 0 während des ersten Anrufs, 1 während des zweiten, ... 5 während des 6., 0 während des 7. und so weiter.

Ich habe zunächst versucht, auf eine zu verzichten EVAL. Die Operatoren sind in der Tat nur Subs (= Funktionen), aber ihre Namen sind so extrem ungolfartig ( &infix:<+>und so weiter), dass ich auf diesen Ansatz verzichten musste.

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

Probieren Sie es online!

12 Bytes dank @nimi gespeichert

Es gibt sicherlich einen besseren Weg, dies zu erreichen.

EDIT 1. Fester Exponent für ganze Zahlen; 2. Es gibt definitiv einen besseren Weg, siehe Kommentar unten: 95 91 Bytes

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

Probieren Sie es online!

Python 2 , 71 Bytes

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

Probieren Sie es online!

2 Bytes gespart dank ovs!

J, ₄₄ 42 Bytes

44 durchgestrichen, yada yada ...

-2 Bytes dank @ ConorO'Brien

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

Probieren Sie es online!

So viele Parens und Inserts ... Sicher gibt es einen besseren Weg, dies zu tun (vielleicht mit Insert anstatt Infix?)

Erläuterung

_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

Einige Notizen:

J hat keine Ganzzahldivision, daher komponieren wir -division %mit >.-floor. Js mod ( |) macht die umgekehrte Reihenfolge wie erwartet, also müssen wir seine Reihenfolge mit ~-reflexive umkehren.

Obwohl wir uns über Intervalle von 2 bewegen, müssen wir /-insert verwenden , um die Verben einzufügen, damit sie dyadisch verwendet werden, da \-infix so funktioniert.

Ruby , 63 57 Bytes

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

Eigentlich nichts Besonderes. Iterieren Sie einfach auf dem Array, verwenden Sie einen Index als Reverse-Iterator, fügen Sie mit dem richtigen Operator einen String hinzu, bewerten, spülen und wiederholen Sie ihn.

Probieren Sie es online!

k , 40 Bytes

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

Probieren Sie es 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 dank @LuisMendo

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

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

Nimmt die Eingabe als durch Leerzeichen getrennte Liste von Zahlen.

R 74 Bytes

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

Probieren Sie es online!

Dies ist die endgültige Antwort, die ich mir ausgedacht habe. Es wird eine Liste mit der Länge zurückgegeben, length(l)wobei jedes Element eine Liste ist, die das entsprechende Element enthält. Ein bisschen beschissen, aber sie sind alle da. Wenn dies nicht akzeptabel ist, kann eine der beiden Mapdurch mapply+3 Bytes ersetzt werden.

Da R-Operatoren alle Funktionen sind (die Infix-Notation ist nur syntaktischer Zucker), habe ich versucht, eine aus einer Liste auszuwählen. Zum Beispiel die 94-Byte-Lösung unten.

Um zu versuchen, die Schleife loszuwerden, habe ich versucht sapply, aber das funktioniert nur mit einer einzigen Funktion und Eingabeliste. Dann erinnerte ich mich an die multivariate Form, mapplydie eine n-aryFunktion FUNund nnachfolgende Argumente annimmt und FUNauf die ersten, zweiten, ... Elemente der einzelnen Argumente anwendet, um sie gegebenenfalls zu recyceln . Es gibt auch eine Wrapper-Funktion mapply, Mapdie "keinen Versuch macht, das Ergebnis zu vereinfachen" . Da es drei Bytes kürzer ist, ist es eine gute Gelegenheit zum Golfen.

Also habe ich eine trinäre Funktion definiert (wie in der folgenden 80-Byte-Lösung), die eine Funktion als erstes Argument verwendet und auf die zweite und dritte anwendet. Mir wurde jedoch klar, dass dies Mapeine Funktion ist, die eine Funktion als erstes Argument verwendet und auf nachfolgende anwendet. Ordentlich!

Schließlich wird am Ende eine Teilmenge erstellt, um sicherzustellen, dass nur die ersten length(l)Werte zurückgegeben werden.

R , 80 Bytes

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

Probieren Sie es online!

Dieser Befehl funktioniert nicht, da er 6 Werte für Listen mit weniger als 6 Elementen zurückgibt.

R , 94 Bytes

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

Probieren Sie es online!

Erklärung (mild ungolfed):

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
}

Da jede der Funktionen vektorisiert ist, können wir am Ende ( res[i]) indizieren . Dies ist besser als der evalAnsatz unten.

R , 100 Bytes

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

Probieren Sie es online!

Dies ist der kürzeste evalAnsatz, den ich finden konnte. weil wir die Ergebnisse in ein Vektor zu sammeln, müssen wir zu pasteeinem c( )der Ausdrücke alle um, die eine Tonne unnötigen Bytes hinzuzufügt

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)

Das war schmerzhaft. Vor allem, weil es mod(x,y)zurückkommt, xwenn es wirklich nicht sollte, was bedeutete, dass ich meine eigene Mod-Funktion erstellen musste: daher die x-int(x/y)y.

Schleifen ivon 0 bis length(l)-1, wobei aufeinanderfolgende Elemente in die oListe aufgenommen und l[i]für xund l[-i]für beantragt werden y. (Negative Indizes funktionieren jedoch nicht. Stattdessen subtrahiere ich ivon der Länge der Liste und nehme diesen Index.)

107 Bytes für die Funktion, +1 Byte zum Hinzufügen lim Parameterfeld.

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

Probieren Sie es hier aus.

Seufz ..
Eingabe als int[], Ausgabe als java.math.BigInteger[].

Ohne die Regel „ die Ecke Fälle abzudecken, wird der Eingang nie ein 0 enthalten, kann aber jede andere ganze Zahl im Bereich von minus unendlich bis plus unendlich enthalten. “, Ganze Zahlen im Bereich verwenden -2147483648zu 2147483647, wäre es 186 Bytes (Eingang as int[]und keine Ausgabe, da dieses Eingabearray geändert wird, um Bytes zu sparen):

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

Probieren Sie es hier aus.

Erläuterung:

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