前回、私は複製ではない簡単なものを思いついたとき、それは非常に難しいものになりました。ですから、今回はそれが実際に新人にも試せるものであることを願っています。

入力：

整数/小数の配列/リスト。（または、整数/小数の配列を表す文字列。）

出力：

数字をループし、次の5つの数学オペランドをこの順序で適用します。

• 追加（+）;
• 減算（−）;
• 乗算（*または×または·）;
• 実数/電卓部門（/または÷）;
• べき乗（^または**）。

（注：括弧で囲まれた記号は、明確化のために追加されたものです。プログラミング言語で数学演算に例とはまったく異なる記号を使用している場合、それはもちろん完全に受け入れられます。）

リストの最後に達するまで続けて、合計の結果を出します。

チャレンジルール：

• 0（n ^ 0）によるべき乗は1になります（これはにも当てはまります0 ^ 0 = 1）。
• 0（n / 0）による除算のテストケースはないため、そのエッジケースについて心配する必要はありません。
• 配列に含まれる数値が1つだけの場合は、結果としてそれを返します。

一般的なルール：

• これはcode-golfであるため、バイト単位の最短回答が優先されます。
  コードゴルフ言語では、非コードゴルフ言語で回答を投稿しないようにしてください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
• 回答には標準の規則が適用されるため、STDIN / STDOUT、適切なパラメーターを持つ関数/メソッド、完全なプログラムを使用できます。あなたの電話。
• デフォルトの抜け穴は禁止されています。
• 可能であれば、コードのテストへのリンクを追加してください。

テストケース：

[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

ゼリー、13 バイト

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

オンラインでお試しください！または、すべてのテストケースを確認します。

使い方

“+_×÷*”ṁṖ⁸ż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.

Javascript ES7 49バイト

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

Dom Hastingsのおかげで9バイト節約、Leaky Nunのおかげでさらに6バイト節約

新しい指数演算子を使用します。

Haskell、76 65 64 62バイト

別の2バイトを削除してくれた@Damienに感謝します=）

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

これは、>>ここでリスト[(+),...]をそれ自体に追加するだけを使用しlength vます。残りはまだ古いバージョンと同じように機能します。

古いバージョン：

これらのソリューションcycle[...]は、与えられたリストを無限に繰り返すように、無限リストを利用します。その後、基本的zipに数値のリストが追加され、演算子をアキュムレータ/現在のリスト要素に適用するラムダを介してzip形式のリストをfold（他の言語では減らす）そのままにします。

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[(+),(-),(*),(/),(**)]))

パイク、22 21バイト

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

ここで試してみてください！

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

Haskell、61バイト

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

[add 1、add 2、減算3、...]のように、フォールドが0で始まるため、2つの加算で始まる一連の変換をリストに作成します。次に、一連の準同型のリストを適用するList Application Foldまたはfoldl（flip id）と呼ばれる処理を行います。これはゼロで始まり、初期値を追加してから、上記の計算された変換をすべて実行して最終結果を取得します。

（flip id）は（\ x y-> yx）と同じで、より短いことに注意してください。

サンプル使用法：

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0

TSQL 116 115 88バイト

ロス・プレッサーの提案のおかげで、これを88文字までゴルフすることができました

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

オンラインで試す

Pyth、27 26 25バイト

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

テストスイート。

Pythは接頭辞表記法を使用します：（数字を区切るのに必要なスペース）と1+2書かれ+1 2ています。

したがって、最初のテストケースでは、式はになり(((1+2)-3)*4)/5、プレフィックス表記ではとして記述され/*-+ 1 2 3 4 5ます。

Pythでは、float除算はのc代わりに/なりc*-+ 1 2 3 4 5ます。

また、Pythでは、代わりに次の-100よう_100に記述されています。

したがって、3番目のテストケース（）((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13)では、次のようになります*-+^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.

歴史

• 33バイト： v:P+*lQ\(ssV+R\)Q*"+-*/p"lQ\p"**"
• 27バイト： .vs+_XUtQUQ"+-*c^"m:+;d\-\_
• 26バイト： .vs+_XUtQUQ"+-*c^":jdQ\-\_

実際には、23バイト

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

オンラインでお試しください！

実際には数学に後置記法を使用し、スタックに要素が1つしかない場合、2つの引数のみをとる演算子（加算、減算、乗算、除算、べき乗の演算子など）は何も行いません。したがって、入力を実際にコードに変換するのは、入力を反転し、数値としてフォーマットし、操作を追加するだけです。次に、結果のコードを実行して、目的の出力を得ることができます。

説明：

;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

入力用の翻訳されたコードの例1,2,3,4,5：

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ

ジュリア、53 50バイト

!x=(i=0;foldl((a,b)->(+,-,*,/,^)[i=i%5+1](a,b),x))

オンラインでお試しください！

J、40バイト

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

5つの演算子の倍数を使用するために必要な値の数を検索し、それらの演算子のID値を埋め込みます。ために、+0、-0、*1、%1であり、^ビット値とすることができる、1である00111オペレータを循環しながらそのリスト上で動作する、またはベース10 7。

使用法

   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

説明

^~`(%~)`*`(-~)`+/@(|.@,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

Python 2、81 67 64バイト

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

入力はフロートの配列です。Ideoneでテストします。

使い方

'*+-*/*'[i::5]選択文字列のすべての5番目の文字は、インデックス1つで始まるIので、この収率**場合、I = 0、+場合I = 1の、-場合I = 2、*場合iは、3 =及び/場合、私は4 =。文字列の長さは6なので、i> 5の場合、式は空の文字列を生成します。

変数iを10に初期化します。各番号のN個の入力配列に、我々は、文字列構築r<op>=n、exec実行します。

最初は、i = 10で<op>、空の文字列もそうであり、rをで初期化しr+=nます。各ステップの後、iで5を法としてiをインクリメントしますi=-~i%5。次のステップで適切な演算子を取得します。

すべての入力番号が処理され、rを出力すると、目的の出力が保持されます。

Matlab- 95 91 85バイト/オクターブ-81バイト

入力は次のような形式です：a = ['1' '2' '3' '4' '5'];、これが「整数/小数で配列を表す文字列」でカバーされていることを望みます。それ以外の場合は、さらに2 num2strが必要です。

すべての中間結果がコンソールに出力されます。これにより、セミコロンが節約されます。a(1)が実行されるため、その値はに保存されansます。もちろんans、コードでの使用は悪い習慣です。

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

Octave '+-*/^'(mod(i+2,5)+1)でも動作し、さらに4バイトを節約します。AdámとLuis Mendoに感謝します。

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

変更ログ：

• 可能な場合はスペースを削除しました
• オクターブソリューションを追加
• strcat（）を[]に置き換えました

Mathematica、67 66 65バイト

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

インデックスを保持Foldする変数iを使用した単純な。

CJam、18バイト

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

入力はフロートの配列です。オンラインでお試しください！

使い方

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.

R、87 78 70バイト

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

オンラインでお試しください！

ハスケル-74

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

テストケース：

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

おそらくもっと短いかもしれません。ただし、Haskellの無限リストと高次関数のサポートにより、直接的なソリューションは非常に快適になります。のバージョンは^ :: Double -> Double -> Doubleゴルフに適していますが、見つけられませんでした。ありがたいことに、私は完全なラムダを必要としなかったので、無意味なスタイルで数バイト削り取られました。

PowerShell v2 +、124バイト

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

PowerShellには^or **演算子がないため、長いので、別のケースを考慮して.NET呼び出しを使用する必要があります。

入力$nを配列として受け取り、出力$oを最初の桁に設定します。次に.count、配列のをチェックし、それが1より大きい限り、を入力しifます。それ以外の場合は、スキップしifます。

if配列内でループし、1..$y|%{...}各反復で$o新しい値、別のif/elseステートメントの結果にリセットします。カウンター$i++が4に等しいモジュロ-5でない限り（つまり、^オペレーターの位置にない場合）、$o適切なシンボル'+-*/'[$x]と入力配列内の次の数字を使用して連結します$n[$_]。それをiex（のエイリアスInvoke-Expressionおよびに類似したeval）にパイプし、それをに再保存し$oます。^演算子を使用している場合はにいるelseので、[math]::Pow()呼び出しを実行すると、その結果がに再​​び保存され$oます。

どちらの場合でも$o、パイプラインに出力し、暗黙的に出力して終了します。

さび、123、117のバイト

元の回答：

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

愚かな長いメソッド名^^

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

食べない

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

Perl 6の、 70の68 65   62バイト

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

説明：

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

技術的に* + *は、Whatever lambdaですが、実質的には、中置数字の加算を処理するサブルーチンのセットの&[+]略です&infix:<+>。
そのように書く方法は少なくとも私が持っているもの（*×*または* * *and * ** *）と同じくらい長いので、乗算またはべき乗には使用しませんでした

テスト：

ideone.comでテストします
（Perl 6のspectestの公式リリースの1年半前ではないRakudoバージョンにアップグレードした後）

#! /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

Python 3、88 93バイト

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

それはずっと短くなり始めましたが、その後、演算子の優先順位は私を打ち負かしました、そして私はたくさんの括弧を含めなければなりませんでした...

Oracle PL / SQL、275 254バイト

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;

データは、タイプのT列Nで呼び出されるテーブルに挿入する必要がありますNUMBER

使用法：

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;

出力：

-1055,356943846277162152071601242992595623

275バイトバージョン：

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;

Java 8、173 172 167 138 137 118 113バイト

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

説明：

ここで試してみてください。

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

いくつかのコツによって@Willmoreのアプローチを23〜174バイト減らすことができます（php 5.6以降が必要です）。最も節約できるのは、不要な括弧（-10バイト）を削除することです。

関数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）;}

ただし、**演算子の代わりに演算子pow()を使用するevalと、操作に配列を使用することもできます。そしてさらにいくつかのトリックで...

PHP> = 5.6、82バイト

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

コマンドラインパラメータからリストを取得します。で実行するphp -nr '<code>'か、オンラインで試してください。

古いバージョン、161157151145144140137117バイト

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

最も効果的なゴルフは、前の結果を配列からシフトした後、最初の要素に直接中間結果を書き込むことから来ました。

壊す

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
}

テストスイート

$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>';

PHP、135 130バイト

ありがとう、@ titus、-5バイト、さらに0件の大文字と小文字の修正！

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

オンラインでお試しください！

ゴルファーが少ない：

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

array_reduce（）がこのために機能することを本当に応援していましたが、現在の最低のPHPスコアを上回るには文字数が多すぎます。

とにかく誰かが何か提案がある場合に備えて投稿してください！

Brachylog、68バイト

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

それは長い…ですが、評価述語を使用しません。

説明

• 主な述語

  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
  

• 述語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:
  

IBM PC 8087 FPU、 66 82バイト

IBM PCのIntel 8087数学コプロセッサーのみを計算に使用します。

オフラインでお試しください！（DOSBoxなどで）。80年代に使用していたすべてのLotus 1-2-3スプレッドシート以外に、古いPCの退屈した8087チップを使いましょう。

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

未ゴルフ（組み立てなし）：

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

出力：

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

入力はPROC（x86が関数に最も相当する）を介して行われ、BXはメモリ内のWORD配列へのポインタであり、CXはその中のアイテムの数であり、結果をSTに返します。

*注意：関数の実際のコードは 6682バイト。もちろん、コンソールに浮動小数点数を書き込むためのコード（クックブックコード）は83バイトです。テストプログラムとデータは183215バイト、.COM実行可能ファイル 305 合計380バイト。

APL（Dyalog Unicode）、29 27 バイト^SBCS

匿名の暗黙の接頭辞関数。これ*はAPLの累乗であることに注意してください。

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

オンラインでお試しください！

APLは右から左に実行されるため、挿入された操作の引数の順序を逆にして、式全体を逆にすることができます。Postfixは⍨引数を逆にします。数値と演算の完全なシャッフルを行った後は、単に反転、平坦化、および評価する必要があります。

≢{…の}⊢ カウントと実際の数値を⍺and として次の関数を呼び出します⍵。

 '⍨' このキャラクター

 '+-×÷*',¨ これらの各文字をその先頭に追加します。 ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

 ⍺⍴ 周期的に左引数（数字の数）を使用するRというeshape

 ⌽ 逆

 ⍕ フラット文字列としてフォーマット

 3↓先頭の3文字（スペースと記号、および⍨）をドロップ

 ⍎ APLコードとして実行

Japt、16バイト

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

オンラインでお試しください！

説明：

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

c＃、238、202バイト

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

C＃のソリューションが見つからなかったので、1つあげます。これは私の最初のcodegolfです。「2か月前」にc＃で書き始めました（Javaはある程度知っていますが）。

スタックを使用します

未ゴルフケースとテストケース

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

出力：

0
539
-1055,35694384628
256
1
-16
-3
-99

PHP、206、198、197のバイト

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

非ゴルフ

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

PHPでは、c＃answer（202 bytes）:)に似たロジック。