Mathe-Zyklen umkehren


18

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 so dass der kürzeste Code (in Bytes) gewinnt!



@AdmBorkBork Er spricht es an, darauf habe ich im Chat hingewiesen.
Mr. Xcoder

@AdmBorkBork korrigiert. Ich habe das in meinem Testfallgenerator verpasst
caird coinheringaahing

Ihr dritter Testfall enthält noch 0>.>
Mr. Xcoder

1
@DigitalTrauma für Sprachen, die standardmäßig ganze Zahlen enthalten, ich denke, die Ausgabe von 0 ist für kleine Zahlen wie diese akzeptabel.
Caird Coinheringaahing

Antworten:


6

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

whaaaaaaaat kommen wirklich :( aber schön, scheint dies schnell ganz nützlich: D
HyperNeutrino

Dies muss zu Jelly gezogen werden. +1, obwohl Sie möglicherweise auch die ƭUnterstützung von Nilads (Wert ersetzen) und Monaden (linkes Argument) erweitern
möchten

@EriktheOutgolfer Es funktioniert schon mit Monaden. Sehen Sie sich die Beispiele an, die ich im Jelly-Chat gepostet habe. Niladen sind ein anderer Fall.
Meilen

@miles Ich meine genau so, wie sich Niladen hier verhalten .
Erik der Outgolfer

@EriktheOutgolfer Ok, es unterstützt jetzt Nilads, aber Sie müssen deren Länge definieren und jeweils ein Leerzeichen dazwischen verwenden. Beispiel 2 1”q3ƭ€für [7,4,9,0]Retouren[2, 1, 'q', 2]
Meilen

4

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%^↔

Warum kannst du es aus Neugier nicht tun ë+*-÷%^? Warum das eNotwendige tun ?
Caird Coinheringaahing

@cairdcoinheringaahing ëdauert 4 Argumente, edauert 2. Es gibt keine für 6
H.PWiz

3

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

Ig∍wenn du den "newish" -Befehl verwenden wolltest (habe hier nicht viel gesehen ).
Magic Octopus Urn

3

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.


Schlägt für den letzten Testfall fehl
Shaggy


3

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]

Sparen Sie ein paar Bytes mitż“+×_:%*”;"ṚV
Erik the Outgolfer

@EriktheOutgolfer, das funktioniert nur, wenn die Länge der Eingabe genau 6 ist. Ich denke, Sie müssten das tun, ż“+×_:%*”ṁ$;"ṚVwas auch 15 Bytes ist.
Jonathan Allan

ok, woran habe ich gedacht ... Ich vermisse so "Krawatte" :(
Erik der Outgolfer


2

JavaScript (ES7), 68 bis 67 Byte

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


Schöne lösung! Vielleicht können Sie die Zuweisung von oinnerhalb der Klammern von verschieben .pop(), um ein paar Bytes zu sparen.
Luke

@Luke Die Zuweisung zu owird auch als Bedingung des ternären Operators verwendet. Das würde dieses Schema brechen.
Arnauld

@Zottelig. Das war genau die gleiche erste Antwort von Arnauld.

@ThePirateBay: Ah. Auf SE Mobile werden also keine Bearbeitungsverläufe angezeigt.
Shaggy

2

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.


map {EVAL ".[0] ... .[1]"},zip $_,.reverseist 1 Byte kürzer.
Nwellnhof

@nwellnhof, danke!
Ramillies

2

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!


zipWith3($)(cycle[(+),(*),(-),div,mod,(^)])<*>reverseIst eine kürzere, jetzt gelöschte Version von dir.
H.PWiz

@ H.PWiz Ich habe so etwas gesucht, hatte aber nicht die Zeit weiterzuschauen. Warum hast du es gelöscht? Ich glaube, es ist nicht verboten, zwei verschiedene Lösungen in derselben Sprache zu haben, besonders wenn eine weitaus besser ist als die andere ...
jferard

@ H.PWiz Fester Exponent.
jferard,

Keine Notwendigkeit für das him Aufruf von o: o a bund ohne das kannst du inline h( TIO ).
nimi


1

J, 44 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.


Ich würde auch gerne wissen, wie man all das vermeidet ()und wiederholte /- ich konnte es nicht herausfinden ....
Jonah

@Jonah, das Beste, woran ich denken kann, ist so etwas wie /ein umgekehrtes Array (da es rückwärts arbeitet ...) mit Verben wie, (,+)`(,*)aber das hilft nicht viel ... (auch es funktioniert nicht)
cole

1
Das Gerundium kann sein+/`(*/)`...
Conor O'Brien

1

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!


1

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

1

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


0

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


0

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.


0

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
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.