Waffen des Mathematikunterrichts

44

Das letzte Mal, als ich versuchte, etwas Einfaches zu finden, das kein Duplikat war, war es viel zu schwer. Hoffentlich können es diesmal auch Neulinge versuchen.

Eingang:

Ein Array / eine Liste mit Ganzzahlen / Dezimalzahlen. (Oder eine Zeichenfolge, die ein Array mit Ganzzahlen / Dezimalzahlen darstellt.)

Ausgabe:

Durchlaufen Sie die Zahlen und wenden Sie die folgenden fünf mathematischen Operanden in dieser Reihenfolge an:

  • Zusatz ( +);
  • Subtraktion ( );
  • Multiplikation ( *oder ×oder ·);
  • Real / Calculator Division ( /oder ÷);
  • Potenzierung ( ^oder **).

(HINWEIS: Die Symbole in Klammern werden nur zur Verdeutlichung hinzugefügt. Wenn Ihre Programmiersprache für die mathematische Operation ein völlig anderes Symbol als die Beispiele verwendet, ist dies natürlich völlig akzeptabel.)

Fahren Sie fort, bis Sie das Ende der Liste erreicht haben, und geben Sie dann das Ergebnis der Summe an.

Herausforderungsregeln:

  • Die Potenzierung um 0 ( n ^ 0) sollte zu 1 führen (dies gilt auch für 0 ^ 0 = 1).
  • Es gibt keine Testfälle für die Division durch 0 ( n / 0), sodass Sie sich nicht um diesen Randfall kümmern müssen.
  • Wenn das Array nur eine einzelne Zahl enthält, geben wir dies als Ergebnis zurück.

Allgemeine Regeln:

  • Das ist , also gewinnt die kürzeste Antwort in Bytes.
    Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
  • Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
  • Standardlücken sind verboten.
  • Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.

Testfälle:

[1,2,3,4,5] -> 0
-> 1 + 2 = 3
  -> 3 - 3 = 0
    -> 0 * 4 = 0
      -> 0 / 5 = 0 

[5,12,23,2,4,4,2,6,7] -> 539
-> 5 + 12 = 17
  -> 17 - 23 = -6
    -> -6 * 2 = -12
      -> -12 / 4 = -3
        -> -3 ^ 4 = 81
          -> 81 + 2 = 83
            -> 83 - 6 = 77
              -> 77 * 7 -> 539

[-8,50,3,3,-123,4,17,99,13] -> -1055.356...
-> -8 + 50 = 42
  -> 42 - 3 = 39
    -> 39 * 3 = 117
      -> 117 / -123 = -0.9512...
        -> -0.9512... ^ 4 = 0.818...
          -> 0.818... + 17 = 17.818...
            -> 17.818... - 99 -> -81.181...
              -> -81.181... * 13 = -1055.356...

[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256
-> 2 + 2 = 4
  -> 4 - 2 = 2
    -> 2 * 2 = 4
      -> 4 / 2 = 2
        -> 2 ^ 2 = 4
          -> 4 + 2 = 6
            -> 6 - 2 = 4
              -> 4 * 2 = 8
                -> 8 / 2 = 4
                  -> 4 ^ 2 = 16
                    -> 16 + 2 = 18
                      -> 18 - 2 = 16
                        -> 16 * 2 = 32
                          -> 32 / 2 = 16
                            -> 16 ^ 2 = 256

[1,0,1,0,1,0] -> 1
-> 1 + 0 = 1
  -> 1 - 1 = 0
    -> 0 * 0 = 0
      -> 0 / 1 = 0
        -> 0 ^ 0 = 1

[-9,-8,-1] -> -16
  -> -9 + -8 = -17
    -> -17 - -1 = -16

[0,-3] -> -3
  -> 0 + -3 = -3

[-99] -> -99
Kevin Cruijssen
quelle
Nicht ganzzahlige Division?
Undichte Nonne
@LeakyNun Nein. Vielleicht sollte ich die Eingabe aufgrund der Division (und Testfall 3) in eine Liste mit Dezimalstellen anstelle von Ganzzahlen ändern?
Kevin Cruijssen
War das im Sandkasten?
Bálint
9
In der Mathematik gibt es zwei widersprüchliche "Regeln":, n ^ 0 = 1aber 0 ^ n = 0. Der Konflikt wird gelöst, indem n != 0für beide Regeln Einstellungen vorgenommen werden, die jedoch 0 ^ 0undefiniert bleiben. Es gibt jedoch eine Menge Dinge, die in der Mathematik gut zusammenpassen, wenn dies 0 ^ 0so definiert ist 1. Siehe Wikipedia für einige Details.
Mego
1
@ Bálint Die Regeln besagen, dass es niemals eine gültige Eingabe mit einer Division durch Null geben wird. Sie müssen sich nicht um diesen Randfall kümmern.
Mego

Antworten:

7

Gelee , 13 Bytes

“+_×÷*”ṁṖ⁸żFV

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

“+_×÷*”ṁṖ⁸żFV  Main link. Argument: A (list of integers)

“+_×÷*”        Yield the list of operations as a string.
        Ṗ      Yield A popped, i.e., with its last element removed.
       ṁ       Mold; reshape the string as popped A.
               This repeats the characters of the string until it contains
               length(A)-1 characters.
         ⁸ż    Zipwith; pairs the integers of A with the corresponding characters.
           F   Flatten the result.
            V  Eval the resulting Jelly code.
               Jelly always evaluates left-to-right (with blatant disregard towards
               the order of operations), so this returns the desired result.
Dennis
quelle
Gut, das sind 8 Bytes weniger als Pyke , der momentan die Führung innehatte.
Kevin Cruijssen
3
Niemand schlägt Dennis aus. Noch nie.
Blue
1
Nur eine Frage: Zählt es mit all diesen Nicht-ASCII-Zeichen wirklich 13 Bytes ?
Xavier Dury
3
@ XavierDury Ja. Der Byte- Link im Header führt zu Jellys eigener Codepage, die die 256 Zeichen codiert, die Jelly als ein einzelnes Byte versteht.
Dennis
@Dennis Danke für die Präzision!
Xavier Dury
19

Javascript ES7 49 Bytes

a=>a.reduce((c,d,e)=>[c**d,c+d,c-d,c*d,c/d][e%5])

9 Bytes dank Dom Hastings gespeichert, weitere 6 dank Leaky Nun

Verwendet den neuen Exponentiationsoperator.

Bálint
quelle
@LeakyNun wird das nicht einfach produzieren Infinity, kein Fehler?
Dom Hastings
Versuchen Sie es mit eval es könnte kürzer sein
Downgoat
@Upgoat Zuerst wurde eval verwendet, dann hat Leaky Nun mir gezeigt, dass es besser ist, es so zu machen
Bálint
@ Bálint du, wie, mit so vielen Kommas?
14.
1
@ EᴀsᴀIᴛᴇʀʟʏ Nicht-Muttersprachler. Bálint macht das oft. Englische Grammatik ist im besten Fall dumm.
wizzwizz4
11

Haskell, 76 65 64 62 Bytes

Danke an @Damien für das Entfernen weiterer zwei Bytes =)

f(u:v)=foldl(\x(f,y)->f x y)u(zip(v>>[(+),(-),(*),(/),(**)])v)

Dies nutzt das >>was hier einfach mal die Liste [(+),...]an sich anhängt length v. Der Rest funktioniert noch genauso wie die alten Versionen.

Alte Versionen:

Diese Lösungen verwenden die unendlichen Listen, da cycle[...]nur die angegebene Liste unendlich oft wiederholt wird. Dann wird es im Grunde genommen zipmit der Liste der Zahlen bearbeitet, und wir reduzieren die gezippte Liste nur fold( in anderen Sprachen) über ein Lambda, das die Operatoren auf das Akkumulator- / aktuelle Listenelement anwendet.

f(u:v)=foldl(\x(f,y)->f x y)u(zip(cycle[(+),(-),(*),(/),(**)])v)

f(u:v)=foldl(\x(y,f)->f x y)u(zip v(cycle[(+),(-),(*),(/),(**)]))

f l=foldl(\x(y,f)->f x y)(head l)(zip(drop 1l)(cycle[(+),(-),(*),(/),(**)]))
fehlerhaft
quelle
Sie können Zyklus ersetzen durch: v >>
Damien
@ Damien Vielen Dank!
Fehler
Hm foldl(&)u$zipWith(&)v(flip<$>v>>[…])?
Bergi
@Bergi Ich kann ehrlich gesagt nicht mehr lesen, was das macht =) Wie auch immer, wir brauchen eine importfür &, das wäre also wieder länger, aber trotzdem danke!
Fehler
@flawr: Eigentlich war meine Idee ziemlich die gleiche wie die, die Lazersmoke als Antwort gepostet hat , ich hatte sie einfach nicht gelesen. Ich habe es verstanden, als ich versucht habe, dein lamda mit so etwas wie zu vereinfachen uncurry. Hat nicht geklappt, aber mir ist aufgefallen, dass Sie in der Lage sein sollten, ein weiteres Byte zu speichern, indem Sie $anstelle von Klammern verwenden.
Bergi
8

Pyke, 22 21 Bytes

lt5L%"+-*/^"L@\RJQ_XE

Probieren Sie es hier aus!

lt5L%                 -    map(len(input)-1, %5)
     "+-*/^"L@        -   map(^, "+-*/^"[<])
              \RJ     -  "R".join(^)
                    E - pyke_eval(^, V)
                 Q_X  -  splat(reversed(input))
Blau
quelle
7

Haskell, 61 Bytes

foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])

Erstellt eine Reihe von Transformationen in einer Liste, wie in [Addiere 1, Addiere 2, Subtrahiere 3, ...], beginnend mit 2 Additionen, da wir mit 0 in der Falte beginnen. Als nächstes machen wir das, was ich List Application Fold nenne, oder foldl (Flip-ID), das eine Liste von Homomorphismen in Reihe anwendet. Dies beginnt mit Null, addiert den Anfangswert und führt dann alle oben berechneten Transformationen durch, um ein Endergebnis zu erhalten.

Beachten Sie, dass (Flip-ID) dasselbe ist wie (\ x y-> yx), nur kürzer.

Beispielnutzung:

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0
Lazersmoke
quelle
Stattdessen flip idkönnten Sie einfach verwenden &. Oder flip($). Wow, ich habe es nie ($) = id
bemerkt
1
@Bergi: &ist in definiert Data.Function, also brauchst du das importauch. Möglicherweise importiert es ein Online-Interpreter standardmäßig, aber dann müssen Sie angeben, welchen Sie verwenden.
Nimi
7

TSQL 116 115 88 Bytes

Dank des Vorschlags von Ross Presser konnte ich dies auf 88 Zeichen reduzieren

-- In Try-it code, this must be DECLARE @y TABLE 
CREATE TABLE T(a real, i int identity)
INSERT T values(5),(12),(23),(2),(4),(4),(2),(6),(7)

DECLARE @ REAL SELECT @=CHOOSE(i%5+1,@/a,ISNULL(POWER(@,a),a),@+a,@-a,@*a)FROM T
PRINT @

Probieren Sie es online aus

t-clausen.dk
quelle
1
1 Byte weniger: Die Eingabetabelle muss T anstelle von @y heißen. Die PL / SQL-Lösung hatte dies, warum also nicht TSQL.
Ross Presser
@ RossPresser ja natürlich. wie habe ich das vermisst Es ist in der Testverknüpfung nicht möglich, keine Berechtigungen zum Erstellen von Tabellen zu haben, und es wird nur beim ersten Mal in einer Datenbank korrekt ausgeführt. Aber was macht das schon, wenn ein Charakter Golf spielen kann? Vielen Dank für Ihren Hinweis, Ihre Verbesserung wurde hinzugefügt
t-clausen.dk
Weitere 12 Bytes ausgeben: Verwenden Sie CHOOSE anstelle von verschachteltem IIF, und lassen Sie ein IIF für den Fall i = 1 übrig. Mit Ihrer Erlaubnis bearbeite ich die Antwort.
Ross Presser
Antwort bearbeitet. Hier ist der Try-It-Link - ich bin anonym und habe keinen Namen danach: data.stackexchange.com/stackoverflow/query/edit/499612
Ross Presser
1
@ RossPresser Ich wusste nicht, WÄHLEN. schloss deinen Vorschlag ein und spielte ein bisschen weiter
t-clausen.dk
6

Pyth, 27 26 25 Bytes

.v+>tlQ*lQ"^c*-+":jdQ\-\_

Testsuite.

Pyth verwendet die Präfixnotation: 1+2wird geschrieben als +1 2(Leerzeichen zum Trennen von Zahlen).

Daher wäre für den ersten Testfall der Ausdruck (((1+2)-3)*4)/5, der in Präfixnotation geschrieben würde als /*-+ 1 2 3 4 5.

In Pyth ist float Division cstatt /, so wird es c*-+ 1 2 3 4 5.

In Pyth -100wird _100stattdessen auch als geschrieben .

Daher wird für den dritten Testfall, das ist ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), wird es: *-+^c*-+ _8 50 3 3 _123 4 17 99 13.

.v+>tlQ*lQ"^c*-+":jdQ\-\_
                  jdQ       Join input by space.
                 :   \-\_   Replace "-" with "_".
   >tlQ*lQ"^c*-+"           Generate the string "...^c*-+" of suitable length.
  +                         Join the two strings above.
.v                          Evaluate as a Pyth expression.

Geschichte

Undichte Nonne
quelle
Du bist schnell! Es scheint, als wäre es mir gelungen, eine leichtere Herausforderung zu meistern. Oder du bist einfach so gut. ;)
Kevin Cruijssen
1
Weil es ähnlich ist .
Undichte Nonne
2
24 Bytes
Maltysen
6

Eigentlich 23 Bytes

;l"+-*/ⁿ"*@R':j':+'?o+ƒ

Probieren Sie es online!

Verwendet tatsächlich die Postfix-Notation für Mathematik, und Operatoren, die immer nur zwei Argumente verwenden (z. B. die Operatoren für Addition, Subtraktion, Multiplikation, Division und Exponentiation), tun nichts, wenn sich nur ein Element auf dem Stapel befindet. Das Umwandeln der Eingabe in tatsächlichen Code ist daher so einfach wie das Umkehren der Eingabe, das Formatieren als Zahlen und das Anhängen der Operationen. Dann kann der resultierende Code ausgeführt werden, was die gewünschte Ausgabe ergibt.

Erläuterung:

;l"+-*/ⁿ"*@R':j':+'?o+ƒ
;l"+-*/ⁿ"*               repeat the operations a number of times equal to the length of the input
                            (since extraneous operations will be NOPs, there's no harm in overshooting)
          @R             reverse the input
            ':j          join on ":" (make a string, inserting ":" between every pair of elements in the list)
               ':+       prepend a ":" (for the first numeric literal)
                  '?o    append a "?"
                           (this keeps the poor numeric parsing from trying to gobble up the first + as part of the numeric literal, since ? isn't interpreted as part of the literal, and is a NOP)
                     +   append the operations string
                      ƒ  cast as a function and call it

Beispiel für übersetzten Code zur Eingabe 1,2,3,4,5:

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ
Mego
quelle
3
Lieben Sie die Art und Weise, wie der Name der Sprache mit der
Byteanzahl
3
s/Actually uses postfix notation/Actually actually uses postfix notation/
Undichte Nonne
5

J, 40 Bytes

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)

Ermittelt die Anzahl der Werte, die zur Verwendung eines Vielfachen von 5 Operatoren erforderlich sind, als Pads mit den Identitätswerten dieser Operatoren. In der angegebenen Reihenfolge +ist 0, -ist 0, *ist 1, %ist 1 und ^ist 1, was ein Bitwert 00111oder 7 in Basis 10 sein kann. Anschließend wird diese Liste bearbeitet, während die Operatoren durchlaufen werden.

Verwendungszweck

   f =: ^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)
   f 1 2 3 4 5
0
   f 5 12 23 2 4 4 2 6 7
539
   f _8 50 3 3 _123 4 17 99 13
_1055.36
   f 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
256
   f 1 0 1 0 1 0
1
   f _9 _8 _1
_16
   f 0 _3
_3
   f _99
_99

Erläuterung

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#) Input: A
                                      #  Get length of A
                                    4+   Add four to it
                                  5|     Take it mod 5
                                5-       Find 5 minus its value, call it x
                           #&2           Create x copies of 2
                       7#:~              Convert 7 to base 2 and take the last x digits
                      ,                  Append those x digits to the end of A
                   |.@                   Reverse it, call it A'
^~                                       Power, reversed operators
    %~                                   Division, reversed operators
       *                                 Multiplication
         -~                              Subtraction, reversed operators
            +                            Addition
             /@                          Insert the previous operations, separated by `,
                                         into A' in order and cycle until the end
                                         Then evaluate the equation from right-to-left
                                         and return
Meilen
quelle
5

Python 2, 81 67 64 Bytes

i=10
for n in input():exec'r%s=n'%'*+-*/*'[i::5];i=-~i%5
print r

Input ist ein Array von Floats. Teste es auf Ideone .

Wie es funktioniert

'*+-*/*'[i::5]Wählt jedes fünfte Zeichen der Zeichenfolge aus, beginnend mit dem Zeichen am Index i , sodass sich ergibt, **wenn i = 0 , +wenn i = 1 , -wenn i = 2 , *wenn i = 3 und /wenn i = 4 . Da der String die Länge 6 hat , ergibt der Ausdruck einen leeren String, wenn i> 5 ist .

Wir initialisieren die Variable i auf 10 . Für jede Zahl n im Eingabearray konstruieren wir den String r<op>=n, der execausgeführt wird.

Anfangs ist i = 10 , also <op>die leere Zeichenfolge, und sie initialisiert r mit r+=n. Nach jedem Schritt inkrementieren wir i modulo 5 mit i=-~i%5, sodass der nächste Schritt den richtigen Operator abruft.

Wenn alle Eingabenummern verarbeitet wurden, drucken wir r , das die gewünschte Ausgabe enthält.

Dennis
quelle
5

Matlab - 95 91 85 Bytes / Oktave - 81 Bytes

Die Eingabe erfolgt in der folgenden Form: a = ['1' '2' '3' '4' '5'];Ich hoffe, dies wird durch "Zeichenfolge, die ein Array mit Ganzzahlen / Dezimalzahlen darstellt" abgedeckt, andernfalls werden zusätzlich 2 num2str benötigt.

Jedes Zwischenergebnis wird an die Konsole ausgegeben, da ich dadurch einige Semikolons einsparen kann. a(1)wird ausgeführt, damit sein Wert in gespeichert wird ans. Natürlich ist die Verwendung ansvon Code auch eine schlechte Übung.

b='+-*/^'
a(1)
for i=2:length(a)
  ['(',ans,')',b(mod(i-2,5)+1),a(i)]
end
eval(ans)

In Octave '+-*/^'(mod(i+2,5)+1)funktioniert auch, was weitere 4 Bytes spart, danke Adám und Luis Mendo:

a(1)
for i=2:length(a)
  strcat('(',ans,')','+-*/^'(mod(i-2,5)+1),a(i))
end
eval(ans)

Änderungsprotokoll:

  • Leerzeichen soweit möglich entfernt
  • Oktavlösung zugegeben
  • strcat () durch [] ersetzt
Lukas K.
quelle
Hallo, willkommen bei PPCG! Die Eingabe ist in Ordnung so, da es immer noch leicht zu unterscheiden ist, was die Eingabe ist. Hmm, ich habe Matlab nie benutzt, also sage ich hier vielleicht idiotische Dinge, kann aber nicht b = '+-*/^'nach b='+-*/^'und for i = 2:length(a)nach golfen for i=2:length(a)(die Leerzeichen entfernen)? Vielleicht sind auch Tipps zum Golfen in MATLAB für Sie interessant. :)
Kevin Cruijssen
Ist '+-*/^'(mod(i+2,5)+1)gültig?
Adám
@ Adám Nein, aber es ist wahrscheinlich in Octave
Luis Mendo
@Adam: es funktioniert in Octave, ich habe es hinzugefügt.
Lukas K.
4

Mathematica, 67 66 65 Bytes

Fold[{+##,#-#2,#2#,#/#2,If[#2==0,1,#^#2]}[[i++~Mod~5+1]]&,i=0;#]&

Einfach Foldmit einer Variablen, idie den Index enthält.

LegionMammal978
quelle
Ein Byte kann gespeichert werden , +##anstatt#+#2
LLlAMnYP
4

CJam, 18 Bytes

q~{"+-*/#"W):W=~}*

Input ist ein Array von Floats. Probieren Sie es online!

Wie es funktioniert

q~                  Read and evaluate all input.
  {             }*  Reduce:
   "+-*/#"            Push the string of operators.
          W           Push W (initially -1).
           ):W        Increment and save in W.
              =       Retrieve the character at that index.
               ~      Evaluate.
Dennis
quelle
4

R , 87 78 70 Bytes

i=0
Reduce(function(a,j)get(substr("+-*/^",i<<-i%%5+1,i))(a,j),scan())

Probieren Sie es online!

JayCe
quelle
Irgendwann muss ich wirklich lernen, wie man es benutzt do.call... Ich sollte mich wahrscheinlich erst dann als R-Programmierer bezeichnen, wenn ich es tue!
Giuseppe
1
@ Giuseppe Advanced Rvon Hadley Wickam ist ein großer Strand lesen :)
JayCe
@ Giuseppe danke für den Hinweis do.call- machte mir klar, dass ich gesucht hatte get.
JayCe
3

Haskell - 74

f(x:xs)=foldl(\x(o,y)->o x y)x(zip(cycle[(+),(-),(*),(/),flip(^).floor])xs)

Testfälle:

λ> f[1,2,3,4,5] -> 0.0
λ> f[5,12,23,2,4,4,2,6,7] -> 539.0
λ> f[-8,50,3,3,-123,4,17,99,13] -> -1055.356943846277
λ> f [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256.0

Es könnte wahrscheinlich kürzer sein; Die Unterstützung von Haskell für unendliche Listen und Funktionen höherer Ordnung macht die direkte Lösung jedoch recht angenehm. Eine Version von ^ :: Double -> Double -> Doublewäre schöner zum Golfen, aber ich konnte keine finden. Zum Glück brauchte ich kein volles Lambda, also hat der sinnlose Stil ein paar Bytes abgeschwächt.

C. Quilley
quelle
2
Sie können eine einzelne prepend (+)in die Liste der Operatoren und starten Sie das foldlmit 0vollständig pointfree zu gehen und den Funktionsnamen und Parameter speichern: foldl(\x(o,y)->o x y)0.zip((+):cycle[(+),(-),(*),(/),(**)]).
Nimi
3

PowerShell v2 +, 124 Byte

param($n)$o=$n[0];if($y=$n.count-1){1..$y|%{$o=if(($x=$i++%5)-4){"$o"+'+-*/'[$x]+$n[$_]|iex}else{[math]::pow($o,$n[$_])}}}$o

Lange, weil PowerShell keinen ^oder **-Operator hat, müssen wir einen separaten Fall berücksichtigen und einen .NET-Aufruf verwenden.

Nimmt Eingaben $nals Array, setzt unsere Ausgabe $oauf die erste Ziffer. Wir überprüfen dann .countdas Array und geben es ein, solange es größer als eins ist if. Ansonsten überspringen wir die if.

Innerhalb der ifSchleife durchlaufen wir das Array 1..$y|%{...}und setzen bei jeder Iteration $oeinen neuen Wert, das Ergebnis einer anderen if/elseAnweisung. Solange unser Zähler $i++nicht modulo-5 gleich 4 ist (dh wir sind nicht am ^Operator), nehmen wir es einfach $ound verketten es mit dem entsprechenden Symbol '+-*/'[$x]und der nächsten Zahl im Eingabearray $n[$_]. Wir leiten das an iex(Alias ​​für Invoke-Expressionund ähnlich wie eval) weiter, und das wird wieder in gespeichert $o. Wenn wir in der ^Vermittlung sind, sind wir in der else, also führen wir einen [math]::Pow()Anruf aus und dieses Ergebnis wird wieder in gespeichert $o.

In beiden Fällen geben wir einfach $oin die Pipeline aus und beenden sie, wobei die Ausgabe implizit erfolgt.

AdmBorkBork
quelle
3

Rust, 123 , 117 Bytes

Ursprüngliche Antwort:

fn a(v:&[f32])->f32{v.iter().skip(1).enumerate().fold(v[0],|s,(i,&x)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

blöde lange methodennamen ^^ ahh viel besser

fn f(v:&[f32])->f32{v[1..].iter().zip(0..).fold(v[0],|s,(&x,i)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

ungolfed

fn f(values : &[f32]) -> f32 {
    values[1..].iter().zip(0..)
    .fold(values[0], |state,(&x,i)|
        match i%5 {
            0=>state+x,
            1=>state-x,
            2=>state*x,
            3=>state/x,
            _=>state.powf(x)
        }
    )
}
rauh
quelle
3

Perl 6 ,  70 68 65   62 Bytes

{$/=[(|(&[+],&[-],&[*],&[/],&[**])xx*)];.reduce: {$/.shift.($^a,$^b)}}
{(@_ Z |(&[+],&[-],&[*],&[/],&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{(@_ Z |(*+*,*-*,&[*],*/*,&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],*/*,&[**])xx*}

Erläuterung:

-> *@_ {
  reduce
    -> $a, &b, $c { b($a,$c) },

    flat       # flatten list produced from zip
      zip
        @_,    # input

        slip(  # causes the list of operators to flatten into the xx list

          # list of 5 infix operators
          &infix:<+>, &infix:<->, &infix:<*>, &infix:</>, &infix:<**>

        ) xx * # repeat the list of operators infinitely
}

Technisch gesehen * + *ist dies ein beliebiges Lambda, aber es ist praktisch dasselbe, &[+]das für &infix:<+>die Unterroutinengruppe, die die numerische Addition von Infixen handhabt, kurz ist.
Ich habe das nicht zur Multiplikation oder Potenzierung verwendet, da die Art und Weise, wie ich sie so schreibe, mindestens so lang ist wie das, was ich habe ( *×*oder * * *und * ** *).

Prüfung:

Teste es auf ideone.com
(nachdem ein Upgrade auf eine Rakudo- Version durchgeführt wurde, die nicht länger als eineinhalb Jahre vor der offiziellen Veröffentlichung der Perl 6- Spektakel liegt )

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,2,3,4,5] => 0,
  [5,12,23,2,4,4,2,6,7] => 539,
  [-8,50,3,3,-123,4,17,99,13] => -1055.35694385, # -2982186493/2825761
  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] => 256,
  [1,0,1,0,1,0] => 1,
  [-9,-8,-1] => -16,
  [0,-3] => -3,
  [-99] => -99,
);

plan +@tests;

my &code = {reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],&[/],&[**])xx*}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is code(@input), $expected, .gist
}
1..8
ok 1 - [1 2 3 4 5] => 0
ok 2 - [5 12 23 2 4 4 2 6 7] => 539
ok 3 - [-8 50 3 3 -123 4 17 99 13] => -1055.35694385
ok 4 - [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2] => 256
ok 5 - [1 0 1 0 1 0] => 1
ok 6 - [-9 -8 -1] => -16
ok 7 - [0 -3] => -3
ok 8 - [-99] => -99
Brad Gilbert b2gills
quelle
51 Bytes
Jo King
3

Python 3, 88 93 Bytes

f=lambda x:eval('('*(len(x)-1)+'){}'.join(map(str,x)).format(*['+','-','*','/','**']*len(x)))

Es begann viel kürzer zu sein, aber dann besiegte mich die Operator-Priorität und ich musste viele Klammern einfügen ...

MSeifert
quelle
3

Oracle PL / SQL, 275 254 Bytes

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Die Daten müssen in eine Tabelle eingefügt werden, die Tmit einer Spalte Nvom Typ aufgerufen wirdNUMBER

Verwendungszweck:

drop table t;
create table t (n number);
insert into t values (-8);
insert into t values (50);
insert into t values (3);
insert into t values (3);
insert into t values (-123);
insert into t values (4);
insert into t values (17);
insert into t values (99);
insert into t values (13);

declare r number;begin for x in (select n,mod(rownum,5)r from t) loop if r is null then r:=x.n;elsif x.r=2then r:=r+x.n;elsif x.r=3then r:=r-x.n;elsif x.r=4then r:=r*x.n;elsif x.r=0then r:=r/x.n;else r:=r**x.n;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;

Ausgabe:

-1055,356943846277162152071601242992595623

275 Bytes Version:

declare r number;cursor c is select n,mod(rownum,5) r from t;begin for x in c loop if r is null then r:=x.n;else case x.r when 2 then r:=r+x.n;when 3 then r:=r-x.n;when 4 then r:=r*x.n;when 0 then r:=r/x.n;else r:=r**x.n; end case;end if;end loop;DBMS_OUTPUT.PUT_LINE(r);end;
Giacomo Garabello
quelle
3

Java 8, 173 172 167 138 137 118 113 Bytes

a->{double r=a[0],t;for(int i=1;i<a.length;r=new double[]{Math.pow(r,t),r+t,r-t,r*t,r/t}[i++%5])t=a[i];return r;}

Erläuterung:

Probieren Sie es hier aus.

a->{                     // Method with double-array parameter and double return-type
  double r=a[0],         //  Result-double, starting at the first item of the input
         t;              //  Temp double
  for(int i=1;           //  Index-integer, starting at the second item
      i<a.length;        //  Loop over the input-array
      r=new double[]{    //    After every iteration, change `r` to:
         Math.pow(r,t),  //      If `i%5` is 0: `r^t`
         r+t,            //      Else-if `i%5` is 1: `r+t`
         r-t,            //      Else-if `i%5` is 2: `r-t`
         r*t,            //      Else-if `i%5` is 3: `r*t`
         r/t}[i++%5])    //      Else-if `i%5` is 4: `r/t`
                         //      And increase `i` by 1 afterwards with `i++`
    t=a[i];              //   Change `t` to the next item in the array
  return r;}             //  Return result-double
Kevin Cruijssen
quelle
2
Denn, weißt du, java.1.5 mal länger als die aktuelle längste Antwort .... Wich in SQL ist
Bálint
1
Sie können ändern , double r=a[0];um double r=a[0],b;einige Bytes zu speichern.
Undichte Nonne
1
@LeakyNun Ursprünglich hatte ich float, aber es gibt keine Math.powfür Schwimmer, daher die doublestatt. Danke für die ,b. Und mit i++<a.lengthbekomme ich eine ArrayOutOfBoundsException bei b=a[i];(es sei denn ich tue i++<a.length-1stattdessen, das ist ein Byte länger statt kürzer).
Kevin Cruijssen
1
Sie können == 4zu > 3und == 0zu wechseln < 1. Ich bin mir nicht sicher, aber ich denke, Sie könnten ein bisschen sparen, indem Sie eine Variable für erstellen i % 5.
Frozn
1
Ich dachte, Sie können das Ganze in eine Verkettung von Ternären verwandeln. In allen Vergleichen können Sie dann den <xTrick anwenden und die gesamte Funktion auf 137 Zeichen verkleinern.
Frozn
3

Ein paar Tricks können @ Willmores Ansatz um 23 bis 174 Bytes reduzieren (benötigt PHP 5.6 oder höher). Der sparsamste Teil ist das Entfernen nicht benötigter Klammern (-10 Byte).

Funktion f ($ a) {while (count ($ a)> 1) {$ l = array_shift ($ a); $ r = array_shift ($ a); array_unshift ($ a, ($ j = $ i ++% 5) ($ j == 1? $ l- $ r: ($ j == 2? $ l * $ r: ($ j == 3? $ l / $ r: $ l ** $ r))): $ l + $ r);} return end ($ a);}

Die Verwendung des **Operators anstelle von pow()ermöglicht jedoch auch die Verwendung evalmit einem Array für die Operationen. und mit ein paar weiteren Tricks ...

PHP> = 5,6, 82 Bytes

while(--$argc)eval('$x'.['/','**','+','-','*'][$i++?$i%5:2]."=$argv[$i];");echo$x;

Nimmt die Liste von den Kommandozeilenparametern. Laufen Sie mit php -nr '<code>'oder versuchen Sie es online .

alte Version, 161 157 151 145 144 140 137 117 Bytes

function f($a){while(count($a)>1)eval('$a[0]=array_shift($a)'.['+','-','*','/','**'][$i++%5].'$a[0];');return$a[0];}

Am effektivsten war es, das Zwischenergebnis direkt in das erste Element zu schreiben - nachdem das vorherige Ergebnis aus dem Array verschoben wurde.

Nervenzusammenbruch

function f($a)
{
    while(count($a)>1)  // while array has more than one element ...
        eval('$a[0]='                           // future first element :=
            . 'array_shift($a)'                 // = old first element (removed)
            . ['+','-','*','/','**'][$i++%5]    // (operation)
            .'$a[0];'                           // new first element (after shift)
        );
    return$a[0];        // return last remaining element
}

Testsuite

$cases = array (
    0=>[1,2,3,4,5],
    539=>[5,12,23,2,4,4,2,6,7],
    '-1055.356...' => [-8,50,3,3,-123,4,17,99,13],
    256 => [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
    1 => [1,0,1,0,1,0],
    -16 => [-9,-8,-1],
    -3 => [0, -3],
    -99 => [-99]
);
echo '<table border=1><tr><th>values</th><th>expected</th><th>actual result</th></tr>';
foreach ($cases as $expect=>$a)
{
    $result=f($a);
    echo "<tr><td>[", implode(',',$a),"]</td><td>$expect</td><td>$result</td></tr>";
}
echo '</table>';
Titus
quelle
Schön gemacht. Sie können 3 weitere Bytes entfernen, indem Sie den letzten Wert als Array zurückgeben (ändern Sie 'return $ a [0]' in 'return $ a'), was nicht unbedingt gegen die Regeln verstößt. :)
640 KB
@gwaugh Imo If the array contains just a single number, we return that as the result.ist ziemlich klar. Aber danke, dass ich das noch einmal überdenken durfte.
Titus
Man könnte ein semantisches Argument vorbringen, dass sich das "das" im Satz auf "das Array" beziehen kann. Unabhängig davon ist Ihre Antwort bei weitem das kürzeste PHP. Sehr schön gemacht, und nochmals danke für Hinweise auf meine längere Vorlage.
10.
3

PHP ,135 130 Bytes

Danke @titus, -5 Bytes, plus 0 Groß- / Kleinschreibung!

function f($z){return array_reduce($z,function($c,$x)use(&$i){eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');return$c;});};

Probieren Sie es online!

Weniger golfen:

function f( $t ) {
    return array_reduce( $t,
        function( $c, $x ) use( &$i ) {
            eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x;');
            return $c;
        }
    );
};

Wurde wirklich verwurzelt, damit array_reduce () dafür funktioniert, erfordert aber zu viele Zeichen, um den aktuell niedrigsten PHP-Score zu übertreffen.

Poste es trotzdem, falls jemand irgendwelche Vorschläge hat!

640 KB
quelle
1
Netter Ansatz; aber ich gehe davon aus, dass es immer dann scheitern wird, wenn es $ctrifft 0. Speichern Sie stattdessen zwei Bytes mit einer anonymen Funktion w. eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x');return$c;ist sechs Bytes kürzer und sollte das Null-Problem beheben.
Titus
Vielen Dank @ Titus! Sie haben absolut Recht mit dem Fall 0. Ich musste das wieder hinzufügen; nach dem = $ x weil eval ohne es nicht laufen würde. Wenn ich es zu einer anon-Funktion gemacht hätte, müsste ich eine variable Zuweisung haben oder es innerhalb des Testcodes ausführen, richtig? Ich möchte die Anzahl der Bytes nicht in Frage stellen. : D
640 KB
2

Brachylog , 68 Bytes

hI,?bL,1:+:-:*:/:^b:L:I{bhv?t.|[O:L:I]h$(P,LbM,OhA,Lh:Ir:A&:M:Pr&.}.

Das ist lang ... aber es wird kein Bewertungsprädikat verwendet.

Erläuterung

  • Hauptprädikat

    hI,                                  Unify I with the first element of the input
       ?bL,                              L is the input minus the first element
           1:+:-:*:/:^b                  Construct the list of predicates [+:-:*:/:^]
                       :L:I{...}.        Call predicate 1 with [[+:-:*:/:^]:L:I] as input
    
  • Prädikat 1

    bhv?t.                               If the second element of Input is empty (i.e. L),
                                         unify Output with the last element of Input
    |                                    Or
    [O:L:I]                              Input = [O:L:I]
           h$(P,                         P is O circularly permutated to the left
                LbM,                     M is L minus the first element
                    OhA,                 A is the first element of O
                        Lh:Ir:A&         Call predicate A on [I:First element of L]
                                :M:Pr&.  Call predicate 1 recursively with P:M:
    
Tödlich
quelle
Schlage dich um 1̶ ̶b̶y̶t̶e̶ 2 Bytes;)
LegionMammal978
2

IBM PC 8087 FPU, 66 82 Bytes

Verwendet nur den Intel 8087-Mathe-Coprozessor des IBM-PCs für Berechnungen.

Probieren Sie es offline! (in DOSBox oder was auch immer). Geben Sie Ihrem alten PC mit dem gelangweilten 8087-Chip etwas, das Sie tun können, abgesehen von all den Lotus 1-2-3-Tabellen, die Sie in den Achtzigern verwendet haben.

9bdf 0783 c302 499b de07 83c3 0249 e342 9bde 2783 c302 49e3 399b de0f 83c3 0249 
e330 9bde 3783 c302 49e3 2751 8b0f 9bd9 e883 f900 7413 9c7f 02f7 d99b d8c9 e2fb 
9d7d 069b d9e8 9bd8 f159 83c3 0249 e302 ebb5 c3

Ungolfed (nicht zusammengebaut):

START: 
    ; RUN TESTS  
    MOV  BX, OFFSET TST     ; 5, 12, 23, 2, 4, 4, 2, 6, 7
    MOV  CX, CTST           ; input array length
    CALL WOMI               ; calculate sequence
    CALL PRINT_FLT          ; output to console

    MOV  BX, OFFSET TST1    ; 5, 12, 23, 2, 4, -4, 2, 6, 7
    MOV  CX, CTST1
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST2    ; -8, 50, 3, 3, -123, 4, 17, 99, 13
    MOV  CX, CTST2
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST3    ; 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
    MOV  CX, CTST3
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST4    ; 1,0,1,0,1,0
    MOV  CX, CTST4
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST5    ; -9, -8, -1
    MOV  CX, CTST5
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST6    ; 0, -3
    MOV  CX, CTST6
    CALL WOMI
    CALL PRINT_FLT

    MOV  AX, 4C00H          ; exit to DOS
    INT  21H

;  TEST DATA

TST   DW  5, 12, 23, 2, 4, 4, 2, 6, 7
CTST  EQU ($-TST)/(SIZE TST)    ; count of items on list

TST1  DW  5, 12, 23, 2, 4, -4, 2, 6, 7
CTST1 EQU ($-TST1)/(SIZE TST1)  ; count of items on list

TST2  DW -8, 50, 3, 3, -123, 4, 17, 99, 13
CTST2 EQU ($-TST2)/(SIZE TST2)  ; count of items on list

TST3  DW 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
CTST3 EQU ($-TST3)/(SIZE TST3)  ; count of items on list

TST4  DW 1,0,1,0,1,0
CTST4 EQU ($-TST4)/(SIZE TST4)  ; count of items on list

TST5  DW -9, -8, -1
CTST5 EQU ($-TST5)/(SIZE TST5)  ; count of items on list

TST6  DW 0, -3
CTST6 EQU ($-TST6)/(SIZE TST6)  ; count of items on list

; 8087 exponent: ST(0) = ST(0) ^ EXP
FIEXP   MACRO   EXP
        LOCAL   REPEAT, DONE
        PUSH CX
        MOV  CX, EXP        ; Exponent is count for loop
        FLD1                ; load 1 into ST
        CMP  CX, 0          ; is exponent pos, neg or 0?
        JZ   DONE           ; exit (with value 1) if exponent is 0
        PUSHF               ; save result flags for later
        JG   REPEAT         ; if exp > 1 start calculation
        NEG  CX             ; make exponent positive for loop
REPEAT:
        FMUL ST(0), ST(1)   ; multiply ST0 = ST0 * ST1
        LOOP REPEAT
        POPF                ; retrieve flags from earlier
        JGE  DONE           ; if exponent was negative, divide 1 by result
        FLD1                ; push 1 into numerator
        FDIV ST(0), ST(1)   ; ST0 = 1 / ST1
DONE:
        POP  CX
        ENDM

; Function WOMI: (Weapons of Math Instruction)
; input: BX - address of start of input array
;       CX - length of input array
; output: ST - result on top of 8087 register stack
WOMI PROC
    FILD WORD PTR [BX]      ; load first item
    ADD  BX, 2              ; move to next
    DEC  CX
CALC:
    FIADD WORD PTR [BX]     ; add
    ADD  BX, 2              ; move to next
    DEC  CX                 ; decrement counter
    JCXZ OUTPUT             ; check if done

    FISUB WORD PTR [BX]     ; subtract
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIMUL WORD PTR [BX]     ; multiply
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIDIV WORD PTR [BX]     ; divide
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIEXP [BX]              ; exponent
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT
    JMP CALC                ; start again

OUTPUT:
    RET 
WOMI ENDP

PRINT_FLT PROC
; print top of 8087 stack
; scaling: 14 digits, 4 decimal places
; input: BX = address of a TBYTE (BCD) output buffer
;       ST = value to display on top of 8087 stack  
    LEA   BX, BUFF                  ; set BX to BCD output buffer
    MOV   AH, 2
    MOV   WORD  PTR[BX], 10000      ; ten thousand (scale factor)
    FIMUL WORD  PTR[BX]             ; scale up by 10000
    FBSTP TBYTE PTR[BX]             ; store as BCD
    FWAIT                           ; sync 8088 and 8087
    TEST  BYTE  PTR[BX+9], 80H      ; check sign bit
    JE    PF_1                      ; 0, goto PF_1
    MOV   DL, '-'                   ; output '-'
    INT   21H
PF_1:
    ADD   BX, 8                     ; point to high byte
    MOV   CH, 7                     ; 14 digits before decimal point
    MOV   CL, 4                     ; 4 shifts (8 bytes / 2 = 4 = 1 nibble)
    MOV   DH, 2                     ; 2 times (8 bytes / 4)
PF_LOOP:
    MOV   DL, [BX]                  ; get BCD digits
    SHR   DL, CL                    ; move high digit to low nibble
    OR    DL, 30H                   ; convert to ASCII
    INT   21H
    MOV   DL, [BX]                  ; get byte again
    AND   DL, 0FH                   ; mask out high digit
    OR    DL, 30H                   ; convert to ASCII
    INT   21H                       ; output
    DEC   BX                        ; next byte
    DEC   CH                        ; decrement byte
    JG    PF_LOOP                   ; repeat if more bytes
    DEC   DH                        ; second time?
    JE    PF_DONE                   ; yes, done
    MOV   DL, '.'                   ; no, output decimal point
    INT   21H
    MOV   CH, 2                     ; 4 more digits after decimal point
    JMP   PF_LOOP                   ; go print digits
PF_DONE:
    MOV  DL, 0DH                    ; display newline CRLF
    MOV  AH, 2
    INT  21H
    MOV  DL, 0AH
    INT  21H
    RET 
PRINT_FLT ENDP

BUFF DT 0   ; output buffer for floating point digit string

_TEXT ENDS
END START

Ausgabe:

A>WOMI.COM
00000000000539.0000
-00000000000027.9136
-00000000001055.3569
00000000000256.0000
00000000000001.0000
-00000000000016.0000
-00000000000003.0000

Die Eingabe erfolgt über ein PROC (x86 entspricht am ehesten einer Funktion), wobei BX ein Zeiger auf ein Array von WORDs im Speicher ist und CX die Anzahl der darin enthaltenen Elemente ist und das Ergebnis in ST zurückgibt.

* Hinweis: Der tatsächliche Code für die Funktion lautet 6682 Bytes. Der Code zum Schreiben einer Gleitkommazahl auf die Konsole (Kochbuchcode) beträgt natürlich 83 Byte. Das Testprogramm und die Daten sind183215 Bytes, wodurch die .COM-Datei ausführbar wird 305 Insgesamt 380 Byte.

640 KB
quelle
1
Das ist toll! Ich habe eine ähnliche Lösung für x86-64 (Linux) geschrieben, aber ich habe noch nicht viel Golf gespielt, was wahrscheinlich einen großen Teil der Logik verändern wird. Für Ihre Exponentenberechnung war es ein notwendiger Teil der Programmlogik, auch wenn die angegebenen Tests keinen negativen Exponenten liefern, zumal es so einfach ist, 1 nach st0 zu drücken und dann eine Division zwischen st0 und durchzuführen st1 (zumindest bei x86 sind dies zwei Anweisungen).
Davey
Vielen Dank @ Davey - sehr guter Punkt! Ich habe den Code aktualisiert, um negative Exponenten zu behandeln, und einen weiteren Testfall hinzugefügt.
9.
2

APL (Dyalog Unicode) , 29 27 Bytes SBCS

Anomyme implizite Präfixfunktion. Beachten Sie, dass dies *die Potenzierung in APL ist.

≢{⍎3↓⍕⌽⍵,¨⍨⍺⍴'+-×÷*''⍨'}⊢

Probieren Sie es online!

Da APL von rechts nach links ausgeführt wird, können wir einfach die Reihenfolge der Argumente der eingefügten Operationen umkehren und den gesamten Ausdruck umkehren. Postfix kehrt Argumente um. Nachdem wir eine perfekte Mischung von Zahlen und Operationen durchgeführt haben, müssen wir nur noch Folgendes umkehren, reduzieren und auswerten:

≢{}⊢ Rufen Sie die folgende Funktion mit Anzahl und tatsächlichen Zahlen als und auf :

'⍨' dieser Charakter

'+-×÷*',¨ stellen Sie jedes dieser Zeichen davor; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

⍺⍴ verwenden das linke Argument (Anzahl von Zahlen) , um zyklisch r eshape dass

 umkehren

 Format als flache Zeichenfolge

3↓Füge führende 3 Zeichen ein (ein Leerzeichen und ein Symbol und )

 Als APL-Code ausführen

Adam
quelle
2

Japt , 16 Bytes

r@[XY]r"p+-*/"gZ

Probieren Sie es online!

Erläuterung:

r@                  #Reduce the input list:
       "p+-*/"      # The list of functions to apply (offset by one due to the behavior of Z)
              gZ    # Choose the one at the current index, wrapping
  [  ]r             # Apply that function to:
   X                #  The result of the previous step
    Y               #  and the current number
                    #Implicitly return the result of the final step
Kamil Drakari
quelle
Ah, verdammt, ich habe gerade selbst daran gearbeitet und versucht herauszufinden, warum es zu falschen Ergebnissen führte - ich hatte die verdammte Potenzierung verpasst! : \
Shaggy
1

c #, 238 , 202 Bytes

double d(double[]a){Array.Reverse(a);var s=new Stack<double>(a);int i=0,j;while(s.Count>1){double l=s.Pop(),r=s.Pop();j=i++%5;s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l,r));}return s.Peek();}

Ich habe keine c # -Lösung gesehen, daher werde ich eine geben. Dies ist mein erster Codegolf. Ich habe vor zwei Monaten angefangen, in c # zu schreiben (obwohl ich Java einigermaßen kenne).

Es benutzt Stack

Online versuchen!

Ungolfed und Testfälle

using System;
using System.Collections.Generic;

class M 
{
    double d(double[]a) {
        Array.Reverse(a);
        var s = new Stack<double>(a);
        int i=0,j;
        while (s.Count>1)
        {
            double l=s.Pop(),r=s.Pop();
            j=i++%5;
            s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l, r));
        }
        return s.Peek();
    }

    public static void Main()
    {
        int[][] a = new int[][]{
            new int[]{1,2,3,4,5},
            new int[]{5,12,23,2,4,4,2,6,7},
            new int[]{-8,50,3,3,-123,4,17,99,13},
            new int[]{2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
            new int[]{1,0,1,0,1,0},
            new int[]{-9,-8,-1},
            new int[]{0,-3},
            new int[]{-99}
        };

        for (int i = 0; i < a.Length; i++)
        {
            Console.WriteLine(new M().d(Array.ConvertAll(a[i], e => Convert.ToDouble(e))));
        }
        Console.ReadKey();
    }
}

Ausgabe:

0
539
-1055,35694384628
256
1
-16
-3
-99
Anzeigename
quelle
Hallo und willkommen bei PPCG! Dies könnte ein interessantes Thema sein: Tipps zum Code-Golfen in C # . Einige Dinge, die Sie in Ihrem Code ausprobieren können: Leerzeichen ( a, Double.Parse-> a,Double.Parse; while (s.Count-> while(s.Count; Pow(l, r)-> Pow(l,r)). Außerdem können Sie entfernen int vor dem j=und hinter dem setzen int i=0,j;. Tolle erste Antwort und noch einmal willkommen. :)
Kevin Cruijssen
@ KevinCruijssen Hallo! Ty! Leerzeichen entfernt und j verschoben, wie Sie vorgeschlagen haben :)
display_name
1

PHP, 206 , 198 , 197 Bytes

function f($a){while(count($a)>1){$l=array_shift($a);$r=array_shift($a);array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));}return array_pop($a);}

Online versuchen!

Ungolfed

<?php

function f($a)
{
    while(count($a)>1)
    {
        $l = array_shift($a); $r = array_shift($a);
        array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));
    }
    return array_pop($a);
}

echo f([1,2,3,4,5])."\n";
echo f([5,12,23,2,4,4,2,6,7])."\n";
echo f([-8,50,3,3,-123,4,17,99,13])."\n";
echo f([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2])."\n";
echo f([1,0,1,0,1,0])."\n";
echo f([-9,-8,-1])."\n";
echo f([0,-3])."\n";
echo f([-99])."\n";

In PHP ähnelt die Logik meiner c # -Antwort ( 202 Bytes ) :).

Anzeigename
quelle