Senjata Instruksi Matematika

44

Terakhir kali ketika saya mencoba untuk membuat sesuatu yang mudah yang bukan duplikat, akhirnya menjadi terlalu sulit .. Jadi mudah-mudahan kali ini memang sesuatu yang bisa dicoba juga oleh pendatang baru.

Memasukkan:

Array / daftar dengan bilangan bulat / desimal. (Atau string yang mewakili array dengan bilangan bulat / desimal.)

Keluaran:

Lingkari angka-angka dan terapkan lima operan matematika berikut dalam urutan ini:

  • Tambahan ( +);
  • Pengurangan ( );
  • Perkalian ( *atau ×atau ·);
  • Divisi Nyata / Kalkulator ( /atau ÷);
  • Eksponensial ( ^atau **).

(CATATAN: Simbol antara tanda kurung hanya ditambahkan sebagai klarifikasi. Jika bahasa pemrograman Anda menggunakan simbol yang sama sekali berbeda untuk operasi matematika dari contoh, maka tentu saja itu benar-benar dapat diterima.)

Teruskan sampai Anda mencapai akhir daftar, dan kemudian berikan hasil penjumlahan tersebut.

Aturan tantangan:

  • Eksponensial dengan 0 ( n ^ 0) harus menghasilkan 1 (ini juga berlaku untuk 0 ^ 0 = 1).
  • Tidak ada test case untuk pembagian dengan 0 ( n / 0), jadi Anda tidak perlu khawatir tentang case-edge.
  • Jika array hanya berisi satu nomor, kami mengembalikannya sebagai hasilnya.

Aturan umum:

  • Ini adalah , jadi jawaban tersingkat dalam byte menang.
    Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
  • Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat, program lengkap. Panggilanmu.
  • Celah default tidak diperbolehkan.
  • Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.

Kasus uji:

[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
sumber
Bukan pembagian bilangan bulat?
Leaky Nun
@ LeakyNun No. Mungkin saya harus mengubah input ke daftar dengan desimal, bukan bilangan bulat karena pembagian (dan uji kasus 3)?
Kevin Cruijssen
Apakah ini di kotak pasir?
Bálint
9
Dalam matematika, ada dua "aturan" yang saling bertentangan:, n ^ 0 = 1tapi 0 ^ n = 0. Konflik diselesaikan dengan menetapkan n != 0kedua aturan, tetapi kemudian tidak 0 ^ 0terdefinisi. Namun, ada banyak hal yang cocok dengan matematika jika 0 ^ 0didefinisikan 1. Lihat Wikipedia untuk beberapa detail.
Mego
1
@ Bálint Aturan menyatakan bahwa tidak akan pernah ada input yang valid dengan pembagian dengan nol. Anda tidak perlu khawatir tentang kasing tepi itu.
Mego

Jawaban:

7

Jelly , 13 byte

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

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

“+_×÷*”ṁṖ⁸ż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
sumber
Bagus, itu 8 byte-count lebih rendah dari Pyke , yang saat ini memimpin.
Kevin Cruijssen
3
Tidak ada yang mengalahkan Dennis. Tidak pernah.
Biru
1
Hanya sebuah pertanyaan: apakah itu benar-benar dihitung sebagai 13 byte dengan semua karakter non-ascii?
Xavier Dury
3
@ XavierDury Ya. The byte link dalam lead header halaman kode Jelly ini sendiri, yang mengkodekan 256 karakter Jelly mengerti sebagai byte tunggal masing-masing.
Dennis
@ Dennis Terima kasih atas ketepatannya!
Xavier Dury
19

Javascript ES7 49 byte

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

Disimpan 9 byte berkat Dom Hastings, disimpan 6 berkat Leaky Nun

Menggunakan operator eksponensial baru.

Bálint
sumber
@ LeakyNun bukankah itu hanya menghasilkan Infinity, bukan kesalahan?
Dom Hastings
Coba gunakan eval mungkin lebih pendek
Downgoat
@Upgoat Ini dulu menggunakan eval, kemudian Leaky Nun menunjukkan kepada saya, bahwa lebih baik, melakukannya seperti ini
Bálint
@ Bálint Anda, seperti, menggunakan begitu banyak, koma?
R
1
@ EᴀsᴛᴇʀʟʏIʀᴋ Non-penutur asli. Bálint sering melakukan itu. Tata bahasa Inggris konyol di saat-saat terbaik.
wizzwizz4
11

Haskell, 76 65 64 62 byte

Terima kasih kepada @Damien karena menghapus dua byte =)

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

Ini menggunakan >>yang di sini hanya menambahkan daftar [(+),...]ke length vwaktu itu sendiri . Selebihnya masih berfungsi masih sama dengan versi lama.

Versi lama:

Solusi ini menggunakan daftar yang tidak terbatas, karena cycle[...]hanya mengulangi daftar yang diberikan tanpa batas. Maka pada dasarnya akan zipdiedit dengan daftar angka, dan kami hanya fold( mengurangi dalam bahasa lain) daftar zip melalui lambda, yang menerapkan operator ke elemen daftar akumulator / saat ini.

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[(+),(-),(*),(/),(**)]))
cacat
sumber
Anda dapat mengganti siklus dengan: v >>
Damien
@ Damen Terima kasih banyak!
flawr
Hm foldl(&)u$zipWith(&)v(flip<$>v>>[…]),?
Bergi
@Bergi Jujur saya tidak bisa membaca apa yang dilakukan lagi =) Ngomong-ngomong, kita perlu importuntuk &, jadi itu akan lebih lama lagi, tapi terima kasih lagi!
flawr
@ flawr: Sebenarnya ide saya sama dengan apa yang diposting Lazersmoke sebagai jawaban , saya hanya belum membacanya. Saya mengerti ketika mencoba menyederhanakan lamda Anda dengan sesuatu seperti uncurry. Tidak berhasil, tetapi saya perhatikan Anda harus dapat menyimpan byte lain dengan menggunakan $bukan tanda kurung.
Bergi
8

Pyke, 22 21 byte

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

Coba di sini!

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

Haskell, 61 Bytes

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

Membuat serangkaian transformasi dalam daftar, seperti pada [tambah 1, tambah 2, kurangi 3, ...], dimulai dengan 2 tambahan karena kita mulai dengan 0 di flip. Selanjutnya, kita melakukan apa yang saya sebut Daftar Aplikasi Lipat, atau foldl (flip id), yang menerapkan daftar homomorfisme secara seri. Ini dimulai dengan nol, menambahkan nilai awal, kemudian melakukan semua transformasi yang dihitung di atas untuk mendapatkan hasil akhir.

Perhatikan bahwa (flip id) sama dengan (\ x y-> yx), hanya lebih pendek.

Penggunaan sampel:

f = foldl(flip id)0.zipWith flip((+):cycle[(+),(-),(*),(/),(**)])
f [1,2,3,4,5] -- Is 0.0
Lazersmoke
sumber
Alih-alih flip id, Anda bisa menggunakannya &. Atau flip($). Wow, saya tidak pernah menyadari($) = id
Bergi
1
@Bergi: &didefinisikan dalam Data.Function, jadi Anda perlu importjuga. Mungkin beberapa penerjemah online mengimpornya secara default, tetapi kemudian Anda harus menentukan yang mana yang Anda gunakan.
nimi
7

TSQL 116 115 88 byte

Berkat saran Ross Presser, saya dapat melakukan golf hingga 88 karakter

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

Cobalah online

t-clausen.dk
sumber
1
1 byte lebih sedikit: membutuhkan tabel input untuk dinamai T bukan @y. Solusi PL / SQL memiliki ini, jadi mengapa tidak TSQL.
Ross Presser
@RossPresser ya tentu saja. bagaimana saya bisa melewatkan itu. Tidak mungkin di tautan tes, tidak ada izin untuk membuat tabel, dan itu hanya akan berjalan dengan benar pertama kali pada database. Tapi apa bedanya saat karakter bisa bermain golf. Terima kasih atas petunjuk Anda, peningkatan Anda telah ditambahkan
t-clausen.dk
Golf 12 byte lain: gunakan PILIH alih-alih bersarang IIF, meninggalkan satu IIF untuk kasus i = 1. Dengan izin Anda, saya akan mengedit jawabannya.
Ross Presser
jawaban diedit. Inilah tautan coba-coba - Saya anonim sehingga tidak memiliki nama setelahnya: data.stackexchange.com/stackoverflow/query/edit/499612
Ross Presser
1
@RossPresser Saya tidak tahu MEMILIH. memasukkan saran Anda dan memutarnya sedikit lebih jauh
t-clausen.dk
6

Pyth, 27 26 25 byte

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

Suite uji.

Pyth menggunakan notasi awalan: 1+2ditulis sebagai +1 2(ruang yang diperlukan untuk memisahkan angka).

Oleh karena itu, untuk testcase pertama, ungkapannya adalah (((1+2)-3)*4)/5, yang dalam notasi awalan, akan ditulis sebagai /*-+ 1 2 3 4 5.

Dalam Pyth, pembagian float cbukan /, jadi itu menjadi c*-+ 1 2 3 4 5.

Juga, dalam Pyth, -100ditulis sebagai _100gantinya.

Oleh karena itu, untuk kasus tes ketiga, yang ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), menjadi: *-+^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.

Sejarah

Biarawati Bocor
sumber
Kamu cepat! Sepertinya saya berhasil membuat tantangan yang lebih mudah. Atau Anda hanya bagus. ;)
Kevin Cruijssen
1
Karena ini mirip dengan ini .
Leaky Nun
2
24 byte
Maltysen
6

Sebenarnya, 23 byte

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

Cobalah online!

Sebenarnya menggunakan notasi postfix untuk matematika, dan operator yang hanya pernah mengambil dua argumen (seperti operator untuk penambahan, pengurangan, perkalian, pembagian, dan eksponensial) tidak melakukan apa-apa ketika hanya ada satu elemen di stack. Dengan demikian, mengubah input menjadi kode Sebenarnya adalah semudah membalikkan input, memformatnya sebagai angka, dan menambahkan operasi. Kemudian, kode yang dihasilkan dapat dieksekusi, memberikan output yang diinginkan.

Penjelasan:

;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

Contoh kode yang diterjemahkan untuk input 1,2,3,4,5:

:5:4:3:2:1?+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ+-*/ⁿ
Mego
sumber
3
Sukai
3
s/Actually uses postfix notation/Actually actually uses postfix notation/
Leaky Nun
5

J, 40 byte

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

Menemukan jumlah nilai yang diperlukan untuk menggunakan kelipatan 5 operator, daripada pembalut dengan nilai identitas operator tersebut. Secara berurutan, +adalah 0, -adalah 0, *adalah 1, %adalah 1, dan ^adalah 1, yang dapat berupa nilai bit 00111, atau 7 pada basis 10. Kemudian beroperasi pada daftar tersebut saat bersepeda melalui operator.

Pemakaian

   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

Penjelasan

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

Python 2, 81 67 64 byte

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

Input adalah array float. Uji di Ideone .

Bagaimana itu bekerja

'*+-*/*'[i::5]memilih setiap karakter kelima string, dimulai dengan satu di indeks i , jadi ini menghasilkan **jika i = 0 , +jika i = 1 , -jika i = 2 , *jika i = 3 dan /jika i = 4 . Karena string memiliki panjang 6 , ekspresi akan menghasilkan string kosong jika i> 5 .

Kami menginisialisasi variabel i hingga 10 . Untuk setiap angka n dalam array input, kami membangun string r<op>=n, yang execdijalankan.

Awalnya, i = 10 , begitu <op>juga string kosong, dan itu menginisialisasi r dengan r+=n. Setelah setiap langkah, kami menambah i modulo 5 dengan i=-~i%5, sehingga langkah selanjutnya akan mengambil operator yang tepat.

Ketika semua nomor input telah diproses, dan kami mencetak r , yang menampung output yang diinginkan.

Dennis
sumber
5

Matlab - 95 91 85 byte / Oktaf - 81 byte

Input dalam bentuk seperti a = ['1' '2' '3' '4' '5'];ini:, saya harap ini ditutupi oleh "string yang mewakili array dengan bilangan bulat / desimal", kalau tidak ada 2 num2str yang diperlukan juga.

Setiap hasil antara dicetak untuk menghibur karena itu menyelamatkan saya beberapa titik koma. a(1)dieksekusi sehingga nilainya kemudian disimpan ke ans. Juga tentu saja menggunakan anskode adalah praktik yang buruk.

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

Di Octave, '+-*/^'(mod(i+2,5)+1)juga berfungsi, yang menyimpan 4 byte lagi, terima kasih Adám dan Luis Mendo:

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

Changelog:

  • Ruang yang terhapus jika memungkinkan
  • menambahkan solusi Octave
  • diganti strcat () dengan []
Lukas K.
sumber
Hai, selamat datang di PPCG! Inputnya bagus seperti itu, karena masih mudah dibedakan apa inputnya. Hmm, saya tidak pernah menggunakan Matlab, jadi mungkin saya mengatakan hal-hal bodoh di sini, tetapi tidak b = '+-*/^'bisa bermain golf ke b='+-*/^'dan for i = 2:length(a)ke for i=2:length(a)(menghilangkan spasi)? Juga, mungkin Tips untuk bermain golf di MATLAB mungkin menarik untuk Anda. :)
Kevin Cruijssen
Apakah '+-*/^'(mod(i+2,5)+1)valid
Adám
@ Adám Tidak, tapi mungkin di Octave
Luis Mendo
@ Adám: berfungsi di Octave, saya menambahkannya.
Lukas K.
4

Mathematica, 67 66 65 byte

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

Sederhana Folddengan variabel yang imemegang indeks.

LegionMammal978
sumber
Satu byte dapat disimpan dengan +##alih-alih#+#2
LLlAMnYP
4

CJam, 18 byte

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

Input adalah array float. Cobalah online!

Bagaimana itu bekerja

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
sumber
4

R , 87 78 70 byte

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

Cobalah online!

JayCe
sumber
pada titik tertentu saya benar-benar perlu belajar cara menggunakan do.call... Saya mungkin tidak seharusnya menganggap diri saya seorang programmer R sampai saya melakukannya!
Giuseppe
1
@Giuseppe Advanced Roleh Hadley Wickam adalah pantai yang bagus dibaca :)
JayCe
@Giuseppe terima kasih telah menunjukkan do.call- membuat saya sadar bahwa saya sedang mencari get.
JayCe
3

Haskell - 74

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

Kasus uji:

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

Mungkin bisa lebih pendek; Dukungan Haskell untuk daftar yang tak terbatas dan fungsi urutan yang lebih tinggi membuat solusi langsung cukup menyenangkan. Sebuah versi ^ :: Double -> Double -> Doubleakan lebih bagus untuk bermain golf, tetapi saya tidak dapat menemukannya. Untungnya, saya tidak perlu lambda penuh, jadi gaya tak berguna mencukur beberapa byte.

C. Quilley
sumber
2
Anda dapat tambahkan satu (+)ke daftar operator dan memulai foldldengan 0untuk pergi sepenuhnya pointfree dan menyimpan nama fungsi dan parameter: foldl(\x(o,y)->o x y)0.zip((+):cycle[(+),(-),(*),(/),(**)]).
nimi
3

PowerShell v2 +, 124 byte

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

Lama karena PowerShell tidak memiliki operator ^atau **, jadi kami harus menjelaskan kasus terpisah dan menggunakan panggilan NET.

Mengambil input $nsebagai array, menetapkan output kami $omenjadi digit pertama. Kami kemudian memeriksa .countarray, dan selama itu lebih besar dari yang kita masukkan if. Kalau tidak, kita lewati if.

Di dalam ifkita loop melalui array 1..$y|%{...}dan setiap iterasi kita atur ulang $oke nilai baru, hasil dari if/elsepernyataan lain . Selama penghitung kita $i++tidak modulo-5 sama dengan 4 (yaitu, kita tidak di ^operator), kita cukup mengambil $odan menggabungkannya dengan simbol yang sesuai '+-*/'[$x]dan angka berikutnya dalam array input $n[$_]. Kami menyalurkannya ke iex(alias untuk Invoke-Expressiondan mirip dengan eval), dan itu akan disimpan kembali ke $o. Jika kita berada di ^operator, kita berada di else, jadi kami melaksanakan [math]::Pow()panggilan, dan bahwa hasil mendapat re-disimpan kembali ke dalam $o.

Dalam kedua kasus tersebut, kami cukup output $oke pipa dan keluar, dengan output implisit.

AdmBorkBork
sumber
3

Rust, 123 , 117 byte

Jawaban asli:

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

nama metode panjang yang bodoh ^^ ahh jauh lebih baik

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)
        }
    )
}
bergerigis
sumber
3

Perl 6 ,  70 68 65   62 byte

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

Penjelasan:

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

Secara teknis * + *adalah lambda Apapun, tetapi secara efektif sama dengan &[+]yang merupakan kependekan &infix:<+>dari subrutin yang menangani penambahan angka infiks.
Saya tidak menggunakannya untuk perkalian atau eksponensial sebagai cara untuk menulis mereka seperti itu setidaknya selama apa yang saya miliki ( *×*atau * * *dan * ** *)

Uji:

Mengujinya di ideone.com
(setelah mereka meningkatkan ke versi Rakudo yang tidak dari satu setengah tahun sebelum rilis resmi dari tontonan Perl 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
sumber
51 byte
Jo King
3

Python 3, 88 93 byte

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

Awalnya jauh lebih pendek tapi kemudian operator diutamakan mengalahkan saya dan saya harus memasukkan banyak tanda kurung ...

MSeifert
sumber
3

Oracle PL / SQL, 275 254 Bytes

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

Data harus dimasukkan dalam tabel yang disebut Tdengan kolom NtipeNUMBER

Pemakaian:

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;

Keluaran:

-1055,356943846277162152071601242992595623

275 Bytes versi:

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
sumber
3

Java 8, 173 172 167 138 137 118 113 byte

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

Penjelasan:

Coba di sini.

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
sumber
2
Karena, Anda tahu, java.1.5 kali lebih lama dari jawaban terpanjang saat ini .... yang ada di SQL
Bálint
1
Anda dapat mengubah double r=a[0];ke double r=a[0],b;untuk menyimpan beberapa byte.
Leaky Nun
1
@ LeakyNun Awalnya saya punya float, tapi tidak ada Math.powuntuk mengapung, maka dari itu double. Terima kasih untuk ,b. Dan dengan i++<a.lengthsaya mendapatkan ArrayOutOfBoundsException di b=a[i];(kecuali saya melakukannya i++<a.length-1, yang satu byte lebih lama, bukan lebih pendek).
Kevin Cruijssen
1
Anda dapat mengubah == 4ke > 3dan == 0ke < 1. Saya tidak yakin tapi saya pikir Anda bisa menghemat sedikit dengan membuat variabel untuk i % 5.
Frozn
1
Saya pikir Anda dapat mengubah semuanya menjadi gabungan dari beberapa negara. Dalam semua perbandingan, Anda dapat menggunakan <xtrik ini, mengecilkan seluruh fungsi menjadi 137 karakter.
Frozn
3

Beberapa trik dapat mengurangi pendekatan @ Willmore sebesar 23 hingga 174 byte (membutuhkan php 5.6 atau lebih baru). Bagian yang paling hemat adalah menghapus tanda kurung yang tidak perlu (-10 byte).

fungsi 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);} pengembalian kembali ($ a);}

Tetapi menggunakan **operator bukannya pow()juga memungkinkan untuk digunakan evaldengan array untuk operasi; dan dengan beberapa trik lagi ...

PHP> = 5,6, 82 byte

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

mengambil daftar dari parameter baris perintah. Jalankan dengan php -nr '<code>'atau coba online .

versi lama, 161 157 151 145 144 140 137 117 byte

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

Golf paling efektif berasal dari penulisan hasil antara langsung ke elemen pertama - setelah menggeser hasil sebelumnya dari array.

kerusakan

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 suite

$cases = array (
    0=>[1,2,3,4,5],
    539=>[5,12,23,2,4,4,2,6,7],
    '-1055.356...' => [-8,50,3,3,-123,4,17,99,13],
    256 => [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
    1 => [1,0,1,0,1,0],
    -16 => [-9,-8,-1],
    -3 => [0, -3],
    -99 => [-99]
);
echo '<table border=1><tr><th>values</th><th>expected</th><th>actual result</th></tr>';
foreach ($cases as $expect=>$a)
{
    $result=f($a);
    echo "<tr><td>[", implode(',',$a),"]</td><td>$expect</td><td>$result</td></tr>";
}
echo '</table>';
Titus
sumber
Bagus sekali. Anda dapat menghapus 3 byte lebih banyak dengan mengembalikan nilai terakhir sebagai array (ubah 'return $ a [0]' menjadi 'return $ a'), yang saya tidak lihat secara khusus melanggar aturan. :)
640KB
@gwaugh Imo If the array contains just a single number, we return that as the result.cukup jelas. Tapi terima kasih telah mengizinkan saya mengunjungi kembali ini.
Titus
Orang bisa membuat argumen semantik bahwa "itu" dalam kalimat dapat merujuk ke "array". Apapun, jawaban Anda sejauh ini adalah PHP terpendek. Sangat baik dilakukan, dan terima kasih lagi untuk petunjuk pada pengajuan saya lagi.
640KB
3

PHP ,135 130 byte

Terima kasih @titus, -5 byte, ditambah perbaikan 0 case!

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

Cobalah online!

Lebih sedikit golf:

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

Benar-benar rooting untuk array_reduce () berfungsi untuk ini, tetapi membutuhkan terlalu banyak karakter untuk mengalahkan skor PHP terendah saat ini.

Tetap mempostingnya kalau-kalau ada yang punya saran!

640KB
sumber
1
Pendekatan yang bagus; tapi saya rasa itu akan gagal setiap kali $chits 0. Simpan dua byte dengan fungsi anonim, bukan w. eval('$c'.['/','**','+','-','*'][$i++?$i%5:5].'=$x');return$c;lebih pendek enam byte dan harus menyelesaikan masalah nol.
Titus
@Titus terima kasih! Anda benar tentang case 0. Saya harus menambahkan kembali; setelah = $ x karena eval tidak akan berjalan tanpanya. Jika saya membuatnya menjadi fungsi anon, saya harus memiliki tugas variabel atau menjalankannya dalam kode tes, kan? Tidak ingin menyebut jumlah byte dipertanyakan. : D
640KB
2

Brachylog , 68 byte

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

Itu panjang ... tetapi tidak menggunakan predikat evaluasi.

Penjelasan

  • Predikat utama

    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
    
  • Predikat 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:
    
Fatalisasi
sumber
Beat you by 1̶ ̶b̶y̶t̶e̶ 2 byte;)
LegionMammal978
2

IBM PC 8087 FPU, 66 82 byte

Hanya menggunakan koprosesor matematika Intel 8087 IBM PC untuk perhitungan.

Cobalah offline! (dalam DOSBox atau apa pun). Berikan sesuatu pada chip 8087 bosan pada PC lama Anda, selain semua spreadsheet Lotus 1-2-3 yang biasa Anda lakukan di tahun 80-an.

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

Tidak disatukan (tidak dirangkai):

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

Keluaran:

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

Input adalah melalui PROC (x86 paling setara dengan fungsi), dengan BX menjadi pointer ke array WORD dalam memori, dan CX menjadi jumlah item di dalamnya dan mengembalikan hasilnya dalam ST.

* Catatan: Kode aktual untuk fungsi ini adalah 6682 byte Tentu saja, kode hanya untuk menulis angka floating point ke konsol (kode buku resep) adalah 83 byte. Program dan data pengujian adalah183215 byte, membuat .COM dapat dieksekusi 305 Total 380 byte.

640KB
sumber
1
Ini bagus! Saya telah menulis solusi yang serupa untuk x86-64 (linux) tapi saya belum sering bermain golf yang mungkin akan mengubah banyak logika di sekitar. Untuk perhitungan eksponen Anda, meskipun tes yang diberikan tidak menguji menerima eksponen negatif, saya merasa bahwa itu adalah bagian penting dari logika program, terutama karena sesederhana mendorong 1 ke st0 dan kemudian melakukan div antara st0 dan st1 (setidaknya pada x86 ini adalah dua instruksi).
Davey
Terima kasih @davey - poin yang sangat bagus! Saya telah memperbarui kode untuk menangani eksponen negatif dan menambahkan test case lain untuk itu.
640KB
2

APL (Dyalog Unicode) , 29 27 byte SBCS

Fungsi awalan diam-diam anomim. Perhatikan bahwa *ini adalah eksponensial dalam APL.

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

Cobalah online!

Karena APL mengeksekusi dari kanan ke kiri, kita bisa membalik urutan argumen dari operasi yang dimasukkan dan membalikkan seluruh ekspresi. Postfix membalikkan argumen. Setelah melakukan pengocokan angka dan operasi secara sempurna, kita hanya perlu membalikkan, meratakan, dan mengevaluasi:

≢{... }⊢ panggil fungsi berikut dengan hitungan dan angka aktual sebagai dan :

'⍨' karakter ini

'+-×÷*',¨ gantilah setiap karakter ini dengan itu; ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

⍺⍴ menggunakan argumen kiri (menghitung angka) untuk siklis r eshape yang

 membalikkan

 memformat sebagai string datar

3↓jatuhkan terdepan 3 karakter (spasi dan simbol dan )

 dieksekusi sebagai kode APL

Adm
sumber
2

Japt , 16 byte

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

Cobalah online!

Penjelasan:

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
sumber
Ah, sial, hanya mengerjakan ini sendiri, mencoba mencari tahu mengapa itu memberi saya hasil yang salah - saya melewatkan eksponensial fecking! : \
Shaggy
1

c #, 238 , 202 byte

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

Saya tidak melihat solusi c # jadi saya akan memberikan satu. Ini codegolf pertamaku. Saya mulai menulis di c # "dua bulan lalu" (meskipun saya tahu Jawa sampai batas tertentu).

Ini menggunakan Stack

Coba online!

Kasus yang tidak disatukan dan diuji

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

Keluaran:

0
539
-1055,35694384628
256
1
-16
-3
-99
nama tampilan
sumber
Hai, dan selamat datang di PPCG! Ini mungkin topik yang bagus untuk dilihat: Kiat untuk bermain golf kode di C # . Beberapa hal yang dapat diturunkan dalam kode Anda: spasi ( a, Double.Parse-> a,Double.Parse; while (s.Count-> while(s.Count; Pow(l, r)-> Pow(l,r)). Anda juga dapat menghapus int di depan j=dan meletakkannya di belakang int i=0,j;. Jawaban pertama yang bagus, dan sekali lagi selamat datang. :)
Kevin Cruijssen
@KevinCruijssen Hai! Ty! Spasi dihapus dan j dipindahkan seperti yang Anda sarankan :)
display_name
1

PHP, 206 , 198 , 197 byte

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

Coba online!

Tidak disatukan

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

Di PHP, logika mirip dengan jawaban c # saya ( 202 byte ) :).

nama tampilan
sumber