Broń instrukcji matematycznych

44

Ostatnim razem, gdy próbowałem wymyślić coś łatwego, co nie było duplikatem, okazało się, że jest to zbyt trudne. Mam nadzieję, że tym razem jest to coś nowego.

Wejście:

Tablica / lista z liczbami całkowitymi / dziesiętnymi. (Lub ciąg reprezentujący tablicę z liczbami całkowitymi / dziesiętnymi.)

Wynik:

Zapętlaj liczby i zastosuj następujące pięć operandów matematycznych w tej kolejności:

  • Dodawanie ( +);
  • Odejmowanie ( );
  • Mnożenie ( *lub ×lub ·);
  • Real / Calculator Division ( /lub ÷);
  • Potęgowanie ( ^lub **).

(UWAGA: Symbole między nawiasami zostały dodane tylko jako wyjaśnienie. Jeśli twój język programowania używa zupełnie innego symbolu dla operacji matematycznej niż w przykładach, to jest to oczywiście całkowicie dopuszczalne).

Kontynuuj, aż dojdziesz do końca listy, a następnie podaj wynik sumy.

Zasady konkursu:

  • Potęgowanie przez 0 ( n ^ 0) powinno dać 1 (dotyczy to również 0 ^ 0 = 1).
  • Nie ma przypadków testowych dla dzielenia przez 0 ( n / 0), więc nie musisz się martwić o przypadek na krawędzi.
  • Jeśli tablica zawiera tylko jedną liczbę, zwracamy ją jako wynik.

Główne zasady:

  • To jest , więc wygrywa najkrótsza odpowiedź w bajtach.
    Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
  • Do odpowiedzi odnoszą się standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami, pełnych programów. Twoja decyzja.
  • Domyślne luki są zabronione.
  • Jeśli to możliwe, dodaj link z testem swojego kodu.

Przypadki testowe:

[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
źródło
Nie dzielenie liczb całkowitych?
Leaky Nun
@LeakyNun Nie. Może powinienem zmienić dane wejściowe na listę dziesiętną zamiast liczb całkowitych z powodu podziału (i przypadku testowego 3)?
Kevin Cruijssen
Czy to było w piaskownicy?
Bálint
9
W matematyce istnieją dwie sprzeczne „reguły”:, n ^ 0 = 1ale 0 ^ n = 0. Konflikt jest rozwiązywany przez ustawienie n != 0obu reguł, ale potem pozostaje 0 ^ 0niezdefiniowany. Istnieje jednak wiele rzeczy, które ładnie układają się w matematyce, jeśli tak 0 ^ 0jest zdefiniowane 1. Zobacz szczegóły w Wikipedii .
Mego
1
@ Bálint Reguły mówią, że nigdy nie będzie prawidłowego wejścia z dzieleniem przez zero. Nie musisz martwić się o tę obudowę krawędzi.
Mego

Odpowiedzi:

7

Galaretka , 13 bajtów

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

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

“+_×÷*”ṁṖ⁸ż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
źródło
Fajnie, to 8 bajtów mniej niż Pyke , który był obecnie na czele.
Kevin Cruijssen,
3
Nikt nie wyśmiewa Dennisa. Nigdy.
Blue
1
Tylko pytanie: czy to naprawdę liczy się jako 13 bajtów z tymi wszystkimi nie-ascii?
Xavier Dury,
3
@XavierDury Tak. Te bajty ogniwem w odprowadzeniach nagłówek bardzo własnej strony kodowej Jelly, który koduje 256 znaków Jelly rozumie i jako pojedynczy bajt każdego.
Dennis
@Dennis Dziękujemy za precyzję!
Xavier Dury,
19

JavaScript ES7 49 bajtów

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

Zaoszczędził 9 bajtów dzięki Domowi Hastingsowi, a kolejne 6 dzięki Dziurawej Zakonnicy

Używa nowego operatora potęgowania.

Bálint
źródło
@LeakyNun nie będzie to po prostu produkować Infinity, a nie błąd?
Dom Hastings,
Spróbuj użyć eval, może być krótszy
Downgoat
@Upgoat Najpierw używał eval, a potem Leaky Nun pokazał mi, że lepiej to zrobić w ten sposób
Bálint,
@ Nie chcesz, używając tak wielu przecinków?
Rɪᴋᴇʀ
1
@ EᴀsᴛᴇʀʟʏIʀᴋ Język ojczysty. Bálint często to robi. Gramatyka języka angielskiego jest głupia w najlepszym przypadku.
wizzwizz4
11

Haskell, 76 65 64 62 bajtów

Dzięki @Damien za usunięcie kolejnych dwóch bajtów =)

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

Wykorzystuje to, >>co tutaj po prostu dołącza listę [(+),...]do siebie length vrazy. Reszta nadal działa tak samo jak stare wersje.

Stare wersje:

Te rozwiązania wykorzystują nieskończone listy, ponieważ cycle[...]po prostu powtarzają podaną listę w nieskończoność. Potem jest po prostu zipedytowany z listą liczb, a my po prostu fold( zmniejszamy w innych językach) listę skompresowaną za pomocą lambda, która stosuje operatory do elementu listy akumulatorów / bieżących.

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[(+),(-),(*),(/),(**)]))
wada
źródło
cykl można zastąpić: v >>
Damien
@Damien Dziękuję bardzo!
flawr
Hm foldl(&)u$zipWith(&)v(flip<$>v>>[…])?
Bergi
@Bergi Szczerze nie mogę odczytać co to robi już =) W każdym razie, potrzebujemy importdo &, więc to byłoby już raz, ale i tak dzięki!
flawr
@flawr: Właściwie mój pomysł był całkiem taki sam jak to, co Lazersmoke opublikował jako odpowiedź , po prostu go nie przeczytałem. Doszedłem do tego, próbując uprościć twoją Lamę za pomocą czegoś takiego uncurry. Nie zadziałało, ale zauważyłem, że powinieneś być w stanie zapisać kolejny bajt, używając $zamiast nawiasów.
Bergi
8

Pyke, 22 21 bajtów

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

Wypróbuj tutaj!

lt5L%                 -    map(len(input)-1, %5)
     "+-*/^"L@        -   map(^, "+-*/^"[<])
              \RJ     -  "R".join(^)
                    E - pyke_eval(^, V)
                 Q_X  -  splat(reversed(input))
niebieski
źródło
7

Haskell, 61 bajtów

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

Tworzy serię transformacji na liście, jak w [dodaj 1, dodaj 2, odejmij 3, ...], zaczynając od 2 dodatków, ponieważ zaczynamy od 0 w zakładce. Następnie robimy coś, co nazywam List Application Fold lub foldl (flip id), który stosuje listę homomorfizmów w szeregu. Zaczyna się od zera, dodaje wartość początkową, a następnie wykonuje wszystkie powyższe obliczone transformacje, aby uzyskać końcowy wynik.

Zauważ, że (flip id) jest taki sam jak (\ x y-> yx), tylko krótszy.

Przykładowe użycie:

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0
Lazersmoke
źródło
Zamiast tego flip idmożesz po prostu użyć &. Lub flip($). Wow, nigdy nie zdawałem sobie sprawy($) = id
Bergi
1
@Bergi: &jest zdefiniowane w Data.Function, więc też potrzebujesz import. Być może jakiś tłumacz online domyślnie go importuje, ale musisz określić, którego używasz.
nimi
7

TSQL 116 115 88 bajtów

Dzięki sugestii Rossa Pressera mogłem zagrać w golfa aż do 88 postaci

-- 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 @

Wypróbuj online

t-clausen.dk
źródło
1
1 bajt mniej: wymagaj, aby tabela wprowadzania miała nazwę T zamiast @y. Rozwiązanie PL / SQL miało to, więc dlaczego nie TSQL.
Ross Presser,
@RossPresser tak, oczywiście. jak mi tego brakowało Nie jest to możliwe w łączu testowym, brak uprawnień do tworzenia tabel, i będzie działać poprawnie tylko za pierwszym razem w bazie danych. Ale co to ma znaczenie, gdy postać może być golfem. Dzięki za podpowiedź, Twoje ulepszenie zostało dodane
t-clausen.dk
Wyodrębniono kolejne 12 bajtów: użyj WYBIERZ zamiast zagnieżdżonego IIF, pozostawiając jeden IIF dla przypadku i = 1. Za twoim pozwoleniem edytuję odpowiedź.
Ross Presser,
odpowiedź zredagowana. Oto link do wypróbowania - jestem anonimowy, więc po nim nie ma nazwy: data.stackexchange.com/stackoverflow/query/edit/499612
Ross Presser
1
@RossPresser Nie wiedziałem WYBIERZ. uwzględnił twoją sugestię i
zagrał
6

Pyth, 27 26 25 bajtów

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

Zestaw testowy.

Pyth używa notacji przedrostkowej: 1+2jest zapisywany jako +1 2(miejsce potrzebne do oddzielenia liczb).

Dlatego w pierwszym przypadku testowym wyrażeniem byłoby (((1+2)-3)*4)/5, które w notacji przedrostkowej byłoby zapisane jako /*-+ 1 2 3 4 5.

W Pyth czamiast podziału zmiennoprzecinkowego jest /, więc staje się c*-+ 1 2 3 4 5.

Również w Pyth -100jest napisany jako _100zamiast.

Dlatego też, w trzecim przypadku testowego, który ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13)staje się: *-+^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.

Historia

Leaky Nun
źródło
Jesteś szybki! Wygląda na to, że udało mi się stworzyć łatwiejsze wyzwanie. Albo jesteś TYLKO TEN dobry. ;)
Kevin Cruijssen
1
Ponieważ jest podobny do tego .
Leaky Nun
2
24 bajty
Maltysen,
6

Właściwie 23 bajty

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

Wypróbuj online!

W rzeczywistości używa matematycznej notacji postfiksowej, a operatory, które przyjmują tylko dwa argumenty (takie jak operatory dodawania, odejmowania, mnożenia, dzielenia i potęgowania) nie robią nic, gdy na stosie jest tylko jeden element. Zatem przekształcenie danych wejściowych w kod faktycznie jest tak proste, jak odwrócenie danych wejściowych, sformatowanie ich w postaci liczbowej i dołączenie operacji. Następnie można wykonać wynikowy kod, dając pożądany wynik.

Wyjaśnienie:

;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

Przykład przetłumaczonego kodu do wprowadzania 1,2,3,4,5:

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ
Mego
źródło
3
Uwielbiam sposób, w jaki nazwa języka łączy się z liczbą bajtów
user6245072,
3
s/Actually uses postfix notation/Actually actually uses postfix notation/
Leaky Nun
5

J, 40 bajtów

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

Znajduje liczbę wartości potrzebnych do użycia wielokrotności 5 operatorów, niż padów z wartościami tożsamości tych operatorów. Kolejność +wynosi 0, -wynosi 0, *wynosi 1, %wynosi 1 i ^wynosi 1, co może być wartością bitową 00111, lub 7 w bazie 10. Następnie działa na tej liście podczas przewijania operatorów.

Stosowanie

   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

Wyjaśnienie

^~`(%~)`*`(-~)`+/@(|.@,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
mile
źródło
5

Python 2, 81 67 64 bajtów

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

Dane wejściowe to tablica liczb zmiennoprzecinkowych. Przetestuj na Ideone .

Jak to działa

'*+-*/*'[i::5]wybiera co piąty znak ciągu, zaczynając od znaku o indeksie i , więc daje to, **jeśli i = 0 , +jeśli i = 1 , -jeśli i = 2 , *jeśli i = 3 i /jeśli i = 4 . Ponieważ ciąg ma długość 6 , wyrażenie zwróci pusty ciąg, jeśli i> 5 .

Inicjujemy zmienną i na 10 . Dla każdej liczby nw tablicy wejściowej konstruujemy ciąg r<op>=n, który jest execwykonywany.

Początkowo i = 10 , podobnie <op>jak pusty ciąg i inicjuje r za pomocą r+=n. Po każdym kroku możemy zwiększać i modulo 5 z i=-~i%5, więc następnym krokiem będzie pobranie właściwego operatora.

Gdy wszystkie liczby wejściowe zostaną przetworzone, a my wypisujemy r , który przechowuje pożądany wynik.

Dennis
źródło
5

Matlab - 95 91 85 bajtów / oktawa - 81 bajtów

Dane wejściowe są w takiej formie: a = ['1' '2' '3' '4' '5'];Mam nadzieję, że są one objęte „ciągiem znaków reprezentującym tablicę z liczbami całkowitymi / dziesiętnymi”, w przeciwnym razie potrzebne są dodatkowo 2 wartości num2str.

Każdy wynik pośredni jest drukowany na konsoli, ponieważ pozwala mi to zaoszczędzić trochę średników. a(1)jest wykonywany, więc jego wartość jest następnie zapisywana w ans. Oczywiście używanie anskodu jest złą praktyką.

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

W Octave '+-*/^'(mod(i+2,5)+1)działa również, co oszczędza kolejne 4 bajty, dzięki Adám i Luis Mendo:

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

Dziennik zmian:

  • Usunięto spacje tam, gdzie to możliwe
  • dodano rozwiązanie Octave
  • zamieniono strcat () na []
Lukas K.
źródło
Cześć, witamy w PPCG! Dane wejściowe są w ten sposób w porządku, ponieważ nadal łatwo można je odróżnić. Hmm, nigdy nie użyłem Matlab, więc może mówię idiotycznych rzeczy tutaj, ale nie może b = '+-*/^'być golfed się b='+-*/^'i for i = 2:length(a)do for i=2:length(a)(usuwając spacje)? Również być może Porady dotyczące gry w golfa w MATLAB mogą być dla Ciebie interesujące. :)
Kevin Cruijssen
Jest '+-*/^'(mod(i+2,5)+1)ważny?
Adám
@ Adám Nie, ale prawdopodobnie jest w Octave
Luis Mendo
@ Adám: działa w Octave, dodałem go.
Lukas K.,
4

Mathematica, 67 66 65 bajtów

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

Proste Foldze zmienną itrzymającą indeks.

LegionMammal978
źródło
+##Zamiast tego można zapisać bajt zamiast#+#2
LLlAMnYP,
4

CJam, 18 bajtów

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

Dane wejściowe to tablica liczb zmiennoprzecinkowych. Wypróbuj online!

Jak to działa

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
źródło
4

R , 87 78 70 bajtów

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

Wypróbuj online!

JayCe
źródło
w pewnym momencie naprawdę muszę nauczyć się obsługiwać do.call... Prawdopodobnie nie powinienem uważać się za programistę R.
Giuseppe,
1
@Giuseppe Advanced Rautorstwa Hadley Wickam to świetna plaża czytana :)
JayCe
@Giuseppe dziękuję za zwrócenie uwagi do.call- uświadomiłem sobie, że szukam get.
JayCe,
3

Haskell - 74

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

Przypadki testowe:

λ> 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

Prawdopodobnie może być krótszy; Jednak wsparcie Haskella dla nieskończonych list i funkcji wyższego rzędu sprawia, że ​​bezpośrednie rozwiązanie jest całkiem przyjemne. Wersja ^ :: Double -> Double -> Doublebyłaby lepsza do gry w golfa, ale nie mogłem jej znaleźć. Na szczęście nie potrzebowałem pełnej lambda, więc bezsensowny styl ogolił kilka bajtów.

C. Quilley
źródło
2
Można poprzedzić jeden (+)na liście operatorów i rozpocząć foldlz 0przejść całkowicie pointfree i zapisać nazwę funkcji i parametrów: foldl(\x(o,y)->o x y)0.zip((+):cycle[(+),(-),(*),(/),(**)]).
nimi
3

PowerShell v2 +, 124 bajty

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

Długo, ponieważ PowerShell nie ma operatora ^lub **, więc musimy wziąć pod uwagę osobną sprawę i użyć wywołania .NET.

Pobiera dane wejściowe $njako tablicę, ustawia nasz wynik $ojako pierwszą cyfrę. Następnie sprawdzamy .counttablicę i dopóki jest ona większa niż jedna, wchodzimy do if. W przeciwnym razie pomijamy if.

Wewnątrz ifpętli przechodzimy przez tablicę 1..$y|%{...}i każdą iterację przywracamy $odo nowej wartości, wynik innej if/elseinstrukcji. Tak długo, jak nasz licznik $i++nie jest modulo-5 równy 4 (tzn. Nie jesteśmy przy ^operatorze), po prostu bierzemy $oi łączymy go z odpowiednim symbolem '+-*/'[$x]i kolejną liczbą w tablicy wejściowej $n[$_]. Przesyłamy to do iex(alias Invoke-Expressioni podobne do eval), a to zostaje ponownie zapisane w $o. Jeśli jesteśmy na ^operatora, jesteśmy w else, więc możemy wykonać [math]::Pow()połączenia, i że wynik robi re-zapisywane z powrotem do $o.

W obu przypadkach po prostu wysyłamy dane wyjściowe $odo potoku i kończymy , z niejawnym wynikiem.

AdmBorkBork
źródło
3

Rdza, 123 , 117 bajtów

Oryginalna odpowiedź:

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

głupie długie nazwy metod ^^ ahh znacznie lepiej

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

bez golfa

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)
        }
    )
}
obdarty
źródło
3

Perl 6 ,  70 68 65   62 bajtów

{$/=[(|(&[+],&[-],&[*],&[/],&[**])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*}

Wyjaśnienie:

-> *@_ {
  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
}

Technicznie * + *jest to cokolwiek lambda, ale w rzeczywistości jest takie samo, jak &[+]skrót dla &infix:<+>zestawu podprogramów, które obsługują dodawanie liczbowe w postaci niepoprawnej.
Nie użyłem tego do mnożenia lub potęgowania, ponieważ sposoby na pisanie ich w ten sposób są przynajmniej tak długie, jak to, co mam ( *×*lub * * *i * ** *)

Test:

Przetestuj to na ideone.com
(po aktualizacji do wersji Rakudo, która nie pochodzi z półtora roku przed oficjalnym wydaniem widm Perla 6 )

#! /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
źródło
51 bajtów
Jo King
3

Python 3, 88 93 bajtów

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

Zaczęło się od tego, że był znacznie krótszy, ale potem pierwszeństwo operatora pokonało mnie i musiałem podać wiele nawiasów ...

MSeifert
źródło
3

Oracle PL / SQL, 275 254 bajtów

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;

Dane należy wstawić do tabeli nazywanej Tkolumną NtypuNUMBER

Stosowanie:

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;

Wynik:

-1055,356943846277162152071601242992595623

Wersja 275 bajtów:

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
źródło
3

Java 8, 173 172 167 138 137 118 118 113 bajtów

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

Wyjaśnienie:

Wypróbuj tutaj.

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
źródło
2
Ponieważ, tak, java. 1,5 razy dłuższa niż bieżąca najdłuższa odpowiedź .... która jest w SQL
Bálint
1
Można zmienić double r=a[0];, aby double r=a[0],b;zaoszczędzić kilka bajtów.
Leaky Nun
1
@LeakyNun Pierwotnie miałem float, ale nie ma Math.powfor floatów, stąd doublezamiast tego. Dzięki za ,b. I z i++<a.lengthotrzymuję ArrayOutOfBoundsException w b=a[i];(chyba że zrobię i++<a.length-1zamiast tego, który jest o jeden bajt dłuższy niż krótszy).
Kevin Cruijssen
1
Możesz zmienić == 4na > 3i == 0na < 1. Nie jestem pewien, ale myślę, że możesz trochę zaoszczędzić, tworząc zmienną dla i % 5.
Frozn
1
Pomyślałem, że możesz to wszystko zmienić w połączenie trójskładników. We wszystkich porównaniach możesz użyć <xlewy, zmniejszając całą funkcję do 137 znaków.
Frozn
3

Kilka lew może zmniejszyć podejście @ Willmore'a o 23 do 174 bajtów (wymaga php 5.6 lub nowszego). Najbardziej oszczędzającą częścią jest usuwanie niepotrzebnych nawiasów (-10 bajtów).

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

Ale użycie **operatora zamiast pow()pozwala również na użycie evalz tablicą do operacji; i kilkoma sztuczkami ...

PHP> = 5,6, 82 bajtów

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

pobiera listę z parametrów wiersza poleceń. Uruchom php -nr '<code>'lub wypróbuj online .

stara wersja, 161 157 151 145 144 140 137 117 bajtów

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

Najbardziej efektywne gra w golfa pochodzi z zapisania wyniku pośredniego bezpośrednio do pierwszego elementu - po przesunięciu poprzedniego wyniku z tablicy.

awaria

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
}

pakiet testowy

$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>';
Tytus
źródło
Ładnie wykonane. Możesz usunąć jeszcze 3 bajty, zwracając ostatnią wartość jako tablicę (zmień „return $ a [0]” na „return $ a”), co nie jest szczególnie sprzeczne z regułami. :)
640 KB
@gwaugh Imo If the array contains just a single number, we return that as the result.jest całkiem jasne. Ale dziękuję za umożliwienie mi ponownej wizyty.
Tytus
Można by argumentować semantycznie, że „to” w zdaniu może odnosić się do „tablicy”. Niezależnie od tego, twoją odpowiedzią jest zdecydowanie najkrótszy PHP. Bardzo ładnie wykonane i jeszcze raz dziękuję za wskazówki dotyczące mojego dłuższego składania.
640 KB
3

PHP ,135 130 bajtów

Dzięki @titus, -5 bajtów, plus 0 poprawek!

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

Wypróbuj online!

Mniej golfa:

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

Naprawdę był rootowaniem dla array_reduce (), aby do tego działać, ale wymaga zbyt wielu znaków, aby pobić bieżący najniższy wynik PHP.

Publikowanie go mimo to na wypadek, gdyby ktoś miał jakieś sugestie!

640 KB
źródło
1
Ładne podejście; ale sądzę, że zawiedzie za każdym razem, gdy $ctrafi 0. Zapisz dwa bajty z anonimową funkcją zamiast w. eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x');return$c;jest o sześć bajtów krótszy i powinien rozwiązać problem zerowy.
Tytus
Dzięki @Titus! Masz całkowitą rację w sprawie 0. Musiałem dodać z powrotem; po = $ x, ponieważ eval nie uruchomiłoby się bez niego. Gdybym uczynił to funkcją anonową, musiałbym mieć do niej zmienne przypisanie lub uruchomić ją w kodzie testowym, prawda? Nie chciałbym kwestionować liczby bajtów. : D
640 KB
2

Brachylog , 68 bajtów

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

To długo… ale nie korzysta z predykatu oceny.

Wyjaśnienie

  • Główny predykat

    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
    
  • Predykat 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:
    
Fatalizować
źródło
Pokonał cię o 1̶ ̶b̶y̶t̶e̶ 2 bajty;)
LegionMammal978
2

IBM PC 8087 FPU, 66 82 bajty

Do obliczeń wykorzystuje wyłącznie koprocesor matematyczny Intel 8087 komputera IBM.

Wypróbuj offline! (w DOSBox lub cokolwiek innego). Daj znudzonemu chipowi 8087 staremu komputerowi coś do zrobienia, inne niż wszystkie arkusze kalkulacyjne Lotus 1-2-3, które robiłeś w latach 80-tych.

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

Nie golfowane (niezmontowane):

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

Wynik:

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

Wprowadzanie odbywa się za pomocą PROC (x86 najbardziej równoważne funkcji), przy czym BX jest wskaźnikiem do tablicy WORD w pamięci, a CX jest liczbą elementów i zwraca wynik w ST.

* Uwaga: Rzeczywisty kod funkcji to 6682 bajty. Oczywiście kod po prostu do zapisania liczby zmiennoprzecinkowej na konsoli (kod książki kucharskiej) ma 83 bajty. Program testowy i dane są183215 bajtów, co czyni plik wykonywalny .COM 305 Łącznie 380 bajtów.

640 KB
źródło
1
To jest świetne! Napisałem podobne rozwiązanie dla x86-64 (linux), ale jeszcze nie grałem w golfa, co prawdopodobnie zmieni wiele logiki. Do obliczenia wykładnika, mimo że podane testy nie potwierdziły otrzymania wykładnika ujemnego, czułem, że była to niezbędna część logiki programu, zwłaszcza że jest to tak proste, jak przesunięcie 1 do st0, a następnie wykonanie div między st0 i st1 (przynajmniej na x86 to dwie instrukcje).
davey
Dzięki @davey - bardzo dobry punkt! Zaktualizowałem kod, by obsługiwał wykładniki ujemne, i dodałem dla niego kolejny przypadek testowy.
640 KB
2

APL (Dyalog Unicode) , 29 27 bajtów SBCS

Anomymiczna ukryta funkcja prefiksu. Zauważ, że *jest to potęgowanie w APL.

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

Wypróbuj online!

Ponieważ APL wykonuje się od prawej do lewej, możemy po prostu odwrócić kolejność argumentów wstawionych operacji i odwrócić całe wyrażenie. Postfiks odwraca argumenty. Po wykonaniu idealnego losowania liczb i operacji wystarczy tylko cofnąć, spłaszczyć i ocenić:

≢{}⊢ Wywołać następującą funkcję z liczbą rzeczywistych liczb jako i :

'⍨' ta postać

'+-×÷*',¨ dołącz do tego każdy z tych znaków; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

⍺⍴ za pomocą lewego argumentu (liczba cyfr) cyklicznie R eshape że

 rewers

 format jako ciąg płaski

3↓upuść 3 wiodące znaki (spację i symbol oraz )

 wykonać jako kod APL

Adám
źródło
2

Japt , 16 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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
źródło
Ach, kurwa, właśnie nad tym pracowałem, próbując dowiedzieć się, dlaczego dawało mi to nieprawidłowe wyniki - przegapiłem potworne potęgowanie! : \
Shaggy
1

c #, 238 , 202 bajtów

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

Nie widziałem żadnego rozwiązania c #, więc dam jedno. To jest mój pierwszy codegolf. Zacząłem pisać w c # „dwa miesiące temu” (choć do pewnego stopnia znam Javę).

Używa stosu

Wypróbuj online!

Przypadki bez golfa i testy

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

Wynik:

0
539
-1055,35694384628
256
1
-16
-3
-99
wyświetlana nazwa
źródło
Cześć, witamy w PPCG! To może być przyjemny temat: Porady dotyczące gry w golfa w C # . Niektóre rzeczy, które można zagrać w golfa w kodzie: spacje ( a, Double.Parse-> a,Double.Parse; while (s.Count-> while(s.Count; Pow(l, r)-> Pow(l,r)). Możesz również usunąć int przed j=i umieścić go za int i=0,j;. Świetna pierwsza odpowiedź i jeszcze raz witamy. :)
Kevin Cruijssen
@KevinCruijssen Cześć! Ty! Usunięto spacje i j przesunięto zgodnie z sugestią :)
nazwa_wyświetlacza
1

PHP, 206 , 198 , 197 bajtów

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

Wypróbuj online!

Nie golfił

<?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";

W PHP logika podobna do mojej c # answer ( 202 bajtów ) :).

wyświetlana nazwa
źródło