Son kez, kopya olmayan kolay bir şey bulmaya çalıştım, bu çok zor oldu. Umarım bu sefer yeni gelenlerin de deneyebileceği bir şey.

Giriş:

Tamsayı / ondalık basamaklı bir dizi / liste. (Veya, tamsayı / ondalık sayı içeren bir diziyi temsil eden bir dize.)

Çıktı:

Rakamlar arasında dolaşın ve aşağıdaki beş matematiksel operayı bu sıraya göre uygulayın:

• Ekleme ( +);
• Çıkarma ( −);
• Çarpma ( *veya ×veya ·);
• Reel / Hesaplayıcı Bölümü ( /veya ÷);
• Üfleme ( ^veya **).

(NOT: Parantez arasındaki semboller sadece açıklama olarak eklenmiştir. Programlama diliniz matematiksel işlem için örneklerden tamamen farklı bir sembol kullanıyorsa, bu elbette tamamen kabul edilebilir.)

Listenin sonuna ulaşana kadar devam edin ve ardından toplamın sonucunu verin.

Meydan okuma kuralları:

• 0 ( n ^ 0) ile üstelleştirme 1 ile sonuçlanmalıdır (bu aynı zamanda geçerlidir 0 ^ 0 = 1).
• 0 ( n / 0) 'a göre bölünme için test durumu yoktur , bu nedenle o uç durum için endişelenmenize gerek yoktur.
• Dizi sadece tek bir sayı içeriyorsa, sonuç olarak döndürürüz.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem ile uygun parametreler, tam programlar kullanabilirsiniz. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.

Test durumları:

[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

Jöle , 13 bayt

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

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

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

Dom Hastings sayesinde 9 bayt kurtarıldı, Leaky Nun sayesinde 6 başka kaydetti

Yeni üs taşıma işlecini kullanır.

Haskell, 76 65 64 62 bayt

Başka bir iki baytı silmek için @Damien'e teşekkürler =)

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

Bu >>, listeyi sadece [(+),...]kendi length vzamanlarına ekleyenleri kullanır . Gerisi hala eski sürümleri ile aynı çalışır.

Eski versiyonlar:

Bu çözümler sonsuz listeleri kullanır, çünkü cycle[...]verilen listeyi sonsuzca tekrarlar. Sonra temelde zipsayılar listesiyle ediniyor ve sadece fold( diğer dillerde azaltıyoruz ) sıkıştırılmış listeyi işleçleri akümülatör / geçerli liste elemanına uygulayan bir lambda üzerinden alıyoruz .

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

Pyke, 22 21 bayt

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

Burada dene!

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

Haskell, 61 Bayt

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

[Ekle 1, ekle 2, çıkarma 3, ...] gibi bir listede bir dizi dönüşüm oluşturur, 2 ekleme ile başlar, çünkü katlamada 0 ile başlarız. Daha sonra, seri halinde bir homomorfizm listesi uygulayan Liste Uygulama Katmanı ya da foldl (flip id) dediğim şeyi yaparız. Bu sıfır ile başlar, başlangıç ​​değerini ekler, ardından son bir sonuç elde etmek için yukarıdaki tüm hesaplanmış dönüşümleri yapar.

(Çevirme kimliğinin) (\ x y-> yx) ile aynı olduğunu, sadece daha kısa olduğunu unutmayın.

Örnek kullanım:

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

TSQL 116 115 88 bayt

Ross Presser önerisi sayesinde bunu 88 karaktere kadar yapabildim.

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

Çevrimiçi deneyin

Pyth, 27 26 25 bayt

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

Test odası.

Pyth önek notasyonunu kullanır: 1+2şöyle yazılır +1 2(sayıları ayırmak için gereken alan).

Bu nedenle, ilk test senaryosu için ifade (((1+2)-3)*4)/5, ön ek notasyonunda olduğu gibi yazılacaktır /*-+ 1 2 3 4 5.

Pyth'te, şamandıra bölünme cyerine /, öyle olur c*-+ 1 2 3 4 5.

Ayrıca, Pyth'de bunun yerine -100yazılmıştır _100.

Bu nedenle, üçüncü bir test durumu için ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), o olur: *-+^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.

Tarih

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

Aslında, 23 bayt

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

Çevrimiçi deneyin!

Aslında matematik için postfix notasyonu kullanır ve yalnızca iki argüman alan operatörler (toplama, çıkarma, çarpma, bölme ve üs alma için operatörler gibi) yığında yalnızca bir öğe olduğunda hiçbir şey yapmaz. Bu nedenle, girişi Aslında koda çevirmek, girişi ters çevirmek, sayısal olarak biçimlendirmek ve işlemleri eklemek kadar basittir. Ardından, istenen kod istenen çıktıyı vererek çalıştırılabilir.

Açıklama:

;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

Girdi için çevrilmiş kod örneği 1,2,3,4,5:

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

Julia, 53 50 bayt

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

Çevrimiçi deneyin!

J, 40 bayt

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

Bu operatörlerin kimlik değerlerine sahip pedlerden ziyade, 5 işlecin çoğunu kullanmak için gereken değerlerin sayısını bulur. Sırasıyla +, 0, -0, *1, 1, %1 ve ^1, bu değer bit 00111, ya da 10 bazında 7 olabilir. Ardından operatörler arasında dolaşırken bu listede çalışır.

kullanım

   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

açıklama

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

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

Giriş, bir yüzer dizisidir. İdeone üzerinde test et .

Nasıl çalışır

'*+-*/*'[i::5]seçer dize her beşinci karakter, dizin ile başlayan ve i bu verimler nedenle, **eğer i = 0 , +eğer i = 1 = , -eğer ı 2 = , *eğer i 3 = ve /eğer i = 4 . Dize 6 uzunluğa sahip olduğundan, i> 5 ise ifade boş bir dizge verir .

Biz değişken başlatmak i için 10 . Her numara için, n , giriş dizisinde, biz dizi oluşturmak r<op>=nolan, execyürütür.

Başlangıçta, i = 10 , <op>boş dize de öyle, ve r ile başlıyor r+=n. Her adımdan sonra, i modulo 5 ile artarız i=-~i%5, böylece bir sonraki adım uygun operatörü alır.

Tüm giriş numaraları işlendiğinde ve istenen çıktının bulunduğu r'yi basarız.

Matlab - 95 91 85 bayt / Octave - 81 bayt

Girdi, bu şekildedir: a = ['1' '2' '3' '4' '5'];umarım bu, "tamsayı / ondalık sayı içeren bir diziyi temsil eden dize" ile kaplıdır, aksi halde ayrıca 2 num2str gerekir.

Her ara sonuç konsola yazdırılıyor çünkü bu durum beni noktalı virgüllerden kurtarıyor. a(1)yürütülür, böylece değeri kaydedilir ans. Ayrıca elbette anskod kullanmak kötü bir uygulamadır.

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

Octave olarak, '+-*/^'(mod(i+2,5)+1)başka bir 4 bayt, teşekkür Adem ve Luis Mendo kazandırır, çalışır:

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

Değişiklikler:

• Mümkünse kaldırılan alanlar
• Octave çözümü eklendi
• [] ile değiştirilen strcat ()

Mathematica, 67 66 65 bayt

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

Dizini tutan Foldbir değişken ile basit i.

CJam, 18 bayt

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

Giriş, bir yüzer dizisidir. Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

Haskell - 74

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

Test durumları:

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

Muhtemelen daha kısa olabilirdi; Haskell'in sonsuz listeleri ve daha üst düzey işlevleri desteklemesi, doğrudan çözümü oldukça keyifli hale getiriyor. Bir sürümü ^ :: Double -> Double -> Doublegolf oynamak için daha iyi olurdu, ama bir tane bulamadım. Neyse ki, tam bir lambdaya ihtiyacım yoktu, bu yüzden anlamsız stil birkaç byte tıraş oldu.

PowerShell v2 +, 124 bayt

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

Çünkü, PowerShell'in bir operatörü ^veya **operatörü olmadığı için ayrı bir durum için hesaba katmalı ve bir .NET çağrısı kullanmalıyız.

Girdiyi $ndizi olarak alır, çıktımızı $oilk basamak olarak ayarlar . Sonra .countdiziyi kontrol ettik ve girdiğimizden büyük olduğu sürece if. Aksi takdirde atlarız if.

İçinde ifdizgiyi 1..$y|%{...}ve her yinelemeyi tekrarladığımızda $o, başka bir if/elseifadenin sonucu olarak yeni bir değere ayarladık . Yani uzun bizim sayaç olarak $i++değil modül-5 eşit 4 etmektir (yani biz değiliz ^, biz sadece almak operatörü) $ove uygun sembolü ile bitiştirmek '+-*/'[$x]ve giriş dizideki bir sonraki numara $n[$_]. Bunu iex( Invoke-Expressionbuna benzer ve benzer şekilde eval) yönlendiriyoruz ve bu yeniden kaydedildi $o. Eğer ^operatörün üzerindeysek, biz de varız else, bu yüzden bir [math]::Pow()çağrı yaparız ve bu sonuç tekrar kaydedilir $o.

Her iki durumda da, basitçe $oçıkış örtülü olarak boru hattına çıktı ve çıkış yaparız .

Pas, 123 , 117 bayt

Orijinal cevap:

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

aptal uzun yöntem isimleri ^^ ahh çok daha iyi

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

Perl 6 ,  70 68 65   62 bayt

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

Açıklama:

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

Teknik * + *olarak bir Whatever lambda'dır, ancak efektif sayısal eklemeyi işleyen alt yordamlar kümesi &[+]için kısa olan ile aynıdır &infix:<+>.
Bunu çarpma veya üstelleştirme için kullanmadım, çünkü onları bu şekilde yazma yolları, sahip olduğum sürece ( *×*veya * * *ve * ** *)

Ölçek:

İdeone.com adresinde test edin
( Perl 6 spektrumunun resmi yayınlanmasından bir buçuk yıl öncesine kadar Rakudo sürümüne yükselttikten sonra )

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

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

Çok daha kısa olmaya başladı ama sonra operatör önceliği beni yendi ve çok parantez içermeliydi ...

Oracle PL / SQL, 275 254 Bayt

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;

Veriler , tip Tsütunlarla adlandırılan bir tabloya eklenmelidir.NNUMBER

Kullanımı:

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;

Çıktı:

-1055,356943846277162152071601242992595623

275 Bayt sürümü:

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 bayt

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çıklama:

Burada dene.

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

Birkaç püf noktası @ Willmore'un yaklaşımını 23 ila 174 byte azaltabilir (php 5.6 veya üstü gerekir). En fazla tasarruf sağlayan kısım gereksiz parantezleri çıkarmaktır (-10 bytes).

f ($ a) işlevi {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);} dönüş sonu ($ a);}

Ancak **operatör yerine operatörün kullanılması işlemler için bir dizi pow()kullanmanıza izin verir eval; ve birkaç numara ile ...

PHP> = 5.6, 82 bayt

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

komut satırı parametrelerinden liste alır. Çevrimiçi olarak çalıştırın php -nr '<code>'veya deneyin .

eski sürüm, 161 157 151 145 144 140 137 117 bayt

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

En etkili golf, bir önceki sonucu diziden kaydırdıktan sonra, ara sonucu doğrudan ilk elemana yazmaktan geldi.

Yıkmak

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
}

test odası

$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 bayt

Teşekkürler @titus, -5 bayt, artı 0 case fix!

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

Çevrimiçi deneyin!

Daha az golf sahası:

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

Array_reduce () 'in bunun için çalışması gerçekten kök salıyordu, ancak mevcut en düşük PHP puanını geçememek için çok fazla karakter gerekiyor.

Herhangi bir öneriniz varsa yine de gönderme!

Brachylog , 68 bayt

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

Bu uzun… ama değerlendirme belirtisi kullanmıyor.

açıklama

• Ana tahmin

  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 tahmin et

  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 bayt

Hesaplamalar için yalnızca IBM PC'nin Intel 8087 matematik işlemcisini kullanır.

Çevrimdışı deneyin! (DOSBox veya her neyse). Eski PC'nize sıkılmış 8087 yongasını, 80'lerde yaptığınız tüm Lotus 1-2-3 e-tablolarının dışında yapacak bir şey yapın.

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 (birleştirilmemiş):

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

Çıktı:

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

Giriş, bir PROC (x86, bir fonksiyona en çok eşdeğer) yoluyla yapılır, BX, bellekteki bir WORD dizisine bir göstericidir ve CX içindeki öğelerin sayısıdır ve sonucu ST'ye döndürür.

* Not: İşlev için gerçek kod 6682 bayt. Tabii ki, sadece konsola kayan nokta sayısı yazma kodu (yemek kitabı kodu) 83 bayttır. Test programı ve verileri183215 bayt, yapım .COM yürütülebilir 305 Toplamda 380 bayt.

APL (Dyalog Unicode) , 29 27 bayt ^SBCS

Anomy tacit önek işlevi. *APL'de üstelleştirme olduğuna dikkat edin .

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

Çevrimiçi deneyin!

APL sağdan sola çalıştığından, eklenen işlemlerin argüman sırasını tersine çevirebilir ve ifadenin tamamını tersine çevirebiliriz. Postfix ⍨argümanları tersine çevirir. Mükemmel bir sayı ve işlem karışıklığını yaptıktan sonra, sadece geriye, düzleştirmeye ve değerlendirmeye ihtiyacımız var:

≢{... }⊢ olarak sayacağım ve fiili rakamlarla aşağıdaki işlevi çağırmak ⍺ve ⍵:

 '⍨' bu karakter

 '+-×÷*',¨ bu karakterlerin her birini buna hazırlayın; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

 ⍺⍴ döngüsel sol argüman (sayı saymak) kullanmak r eshape o

 ⌽ ters

 ⍕ düz dize olarak biçimlendir

 3↓baştaki 3 karakteri bırak (boşluk ve sembol ve ⍨)

 ⍎ APL kodu olarak çalıştır

Japt , 16 bayt

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

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

Herhangi bir c # çözümü görmedim, o yüzden bir tane vereceğim. Bu benim ilk kodlayıcım. Java'yı bir dereceye kadar tanıdığım halde , c # "iki ay önce" yazmaya başladım .

Stack kullanır

Ungolfed ve test durumları

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

Çıktı:

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

PHP, 206 , 198 , 197 bayt

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

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

PHP'de, c # cevabına benzer bir mantık var ( 202 bytes ) :).