Lần trước khi tôi cố gắng đưa ra một thứ dễ dàng không phải là một bản sao, nó đã trở nên quá khó khăn .. Vì vậy, hy vọng lần này nó thực sự là thứ mà những người mới có thể thử.

Đầu vào:

Một mảng / danh sách với số nguyên / số thập phân. (Hoặc một chuỗi đại diện cho một mảng với số nguyên / số thập phân.)

Đầu ra:

Lặp lại các số và áp dụng năm toán hạng toán học sau theo thứ tự sau:

• Ngoài ra ( +);
• Phép trừ ( −);
• Phép nhân ( *hoặc ×hoặc ·);
• Bộ phận Thực / Máy tính ( /hoặc ÷);
• Lũy thừa ( ^hoặc **).

(LƯU Ý: Các ký hiệu giữa dấu ngoặc đơn chỉ được thêm vào để làm rõ. Nếu ngôn ngữ lập trình của bạn sử dụng ký hiệu hoàn toàn khác cho hoạt động toán học so với các ví dụ, thì điều đó hoàn toàn có thể chấp nhận được.)

Tiếp tục cho đến khi bạn đạt đến cuối danh sách, và sau đó đưa ra kết quả của tổng.

Quy tắc thử thách:

• Số mũ bằng 0 ( n ^ 0) sẽ dẫn đến 1 (điều này cũng áp dụng cho 0 ^ 0 = 1).
• Không có trường hợp kiểm tra nào cho phép chia cho 0 ( n / 0), vì vậy bạn không phải lo lắng về trường hợp cạnh đó.
• Nếu mảng chỉ chứa một số duy nhất, chúng ta sẽ trả về kết quả đó.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.

Các trường hợp thử nghiệm:

[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

Thạch , 13 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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

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

Đã lưu 9 byte nhờ vào Dom Hastings, lưu thêm 6 byte nhờ Leaky Nun

Sử dụng toán tử lũy thừa mới.

Haskell, 76 65 64 62 byte

Cảm ơn @Damien đã xóa hai byte khác =)

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

Điều này sử dụng cái >>mà ở đây chỉ nối thêm danh sách [(+),...]vào length vthời gian của chính nó . Phần còn lại vẫn hoạt động giống như các phiên bản cũ.

Phiên bản cũ:

Các giải pháp này sử dụng các danh sách vô hạn, vì cycle[...]chỉ cần lặp lại danh sách đã cho vô hạn. Sau đó, về cơ bản nó sẽ zipphù hợp với danh sách các số và chúng tôi chỉ fold( giảm các ngôn ngữ khác) danh sách được nén qua lambda, áp dụng các toán tử cho phần tử danh sách tích lũy / hiện tại.

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 byte

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

Hãy thử nó ở đây!

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

Haskell, 61 byte

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

Tạo một loạt các phép biến đổi trong một danh sách, như trong [thêm 1, thêm 2, trừ 3, ...], bắt đầu bằng 2 phép cộng vì chúng ta bắt đầu bằng 0 trong lần đầu tiên. Tiếp theo, chúng tôi thực hiện những gì tôi gọi là Danh sách ứng dụng Fold, hoặc Foldl (flip id), áp dụng một danh sách các từ đồng âm trong chuỗi. Điều này bắt đầu bằng 0, thêm giá trị ban đầu, sau đó thực hiện tất cả các phép biến đổi được tính toán ở trên để có kết quả cuối cùng.

Lưu ý rằng (flip id) giống như (\ x y-> yx), chỉ ngắn hơn.

Sử dụng mẫu:

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

TSQL 116 115 88 byte

Nhờ gợi ý của Ross Presser, tôi đã có thể chơi golf này xuống tới 88 ký tự

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

Dùng thử trực tuyến

Pyth, 27 26 25 byte

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

Bộ thử nghiệm.

Pyth sử dụng ký hiệu tiền tố: 1+2được viết là +1 2(không gian cần thiết để tách các số).

Do đó, đối với testcase đầu tiên, biểu thức sẽ là (((1+2)-3)*4)/5, trong ký hiệu tiền tố, sẽ được viết là /*-+ 1 2 3 4 5.

Trong Pyth, phân chia float là cthay vì /, vì vậy nó trở thành c*-+ 1 2 3 4 5.

Ngoài ra, trong Pyth, -100được viết như _100thay thế.

Do đó, đối với trường hợp thử nghiệm thứ ba, đó là ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), nó trở thành : *-+^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.

Lịch sử

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

Trên thực tế, 23 byte

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

Hãy thử trực tuyến!

Trên thực tế sử dụng ký hiệu hậu tố cho toán học và các toán tử chỉ bao giờ lấy hai đối số (chẳng hạn như các toán tử để cộng, trừ, nhân, chia và lũy thừa) không làm gì khi chỉ có một phần tử trên ngăn xếp. Do đó, biến đầu vào thành mã thực tế cũng đơn giản như đảo ngược đầu vào, định dạng nó dưới dạng số và nối thêm các thao tác. Sau đó, mã kết quả có thể được thực thi, đưa ra đầu ra mong muốn.

Giải trình:

;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

Ví dụ về mã dịch cho đầu vào 1,2,3,4,5 :

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

Julia, 53 50 byte

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

Hãy thử trực tuyến!

J, 40 byte

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

Tìm số lượng giá trị cần thiết để sử dụng bội số của 5 toán tử, hơn các bảng có giá trị nhận dạng của các toán tử đó. Theo thứ tự, +là 0, -là 0, *là 1, %là 1 và ^là 1, có thể là một giá trị bit00111 hoặc 7 trong cơ sở 10. Sau đó, hoạt động trên danh sách đó trong khi đạp xe qua các toán tử.

Sử dụng

   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

Giải trình

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

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

Đầu vào là một mảng của phao. Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

'*+-*/*'[i::5]chọn mỗi ký tự thứ năm của chuỗi, bắt đầu bằng ký tự ở chỉ số i , do đó, điều này mang lại **nếu i = 0 , +nếu i = 1 , -nếu i = 2 , *nếu i = 3 và /nếu i = 4 . Vì chuỗi có độ dài 6 , biểu thức sẽ mang lại một chuỗi trống nếu i> 5 .

Chúng tôi khởi tạo biến i thành 10 . Đối với mỗi số n trong mảng đầu vào, chúng tôi xây dựng chuỗi r<op>=n, trong đóexec thực thi.

Ban đầu, i = 10 , <op>chuỗi trống cũng vậy và nó khởi tạo r với r+=n. Sau mỗi bước, chúng tôi tăng i modulo 5 với i=-~i%5, vì vậy bước tiếp theo sẽ lấy ra toán tử thích hợp.

Khi tất cả các số đầu vào đã được xử lý và chúng tôi in r , giữ đầu ra mong muốn.

Matlab - 95 91 85 byte / Octave - 81 byte

Đầu vào ở dạng như vậy: a = ['1' '2' '3' '4' '5']; , tôi hy vọng điều này được bao phủ bởi "chuỗi đại diện cho một mảng với số nguyên / số thập phân", ngoài ra còn có 2 num2str cần thiết.

Mọi kết quả trung gian đều được in ra bàn điều khiển vì điều đó giúp tôi tiết kiệm một số dấu chấm phẩy. a(1)được thực thi để giá trị của nó được lưu vào ans. Tất nhiên sử dụng anstrong mã là thực hành xấu.

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

Trong Octave, '+-*/^'(mod(i+2,5)+1)cũng hoạt động, giúp tiết kiệm thêm 4 byte, cảm ơn Adám và Luis Mendo:

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

Thay đổi:

• Xóa không gian nếu có thể
• thêm giải pháp Octave
• thay thế strcat () bằng []

Toán học, 67 66 65 byte

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

Đơn giản Foldvới một biến igiữ chỉ số.

CJam, 18 byte

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

Đầu vào là một mảng của phao. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

Haskell - 74

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

Các trường hợp thử nghiệm:

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

Nó có thể ngắn hơn; Mặc dù vậy, sự hỗ trợ của Haskell cho các danh sách vô hạn và các hàm bậc cao hơn làm cho giải pháp trực tiếp khá dễ chịu. Một phiên bản ^ :: Double -> Double -> Doublesẽ đẹp hơn để chơi gôn, nhưng tôi không thể tìm thấy. Rất may, tôi không cần lambda đầy đủ, vì vậy phong cách vô nghĩa đã loại bỏ một vài byte.

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

Lâu vì PowerShell không có ^hoặc** nhà điều hành nhà điều hành, vì vậy chúng tôi phải tính đến một trường hợp riêng và sử dụng cuộc gọi .NET.

Lấy đầu vào $nlà một mảng, đặt đầu ra của chúng ta $othành chữ số đầu tiên. Sau đó chúng tôi kiểm tra .countmảng và miễn là nó lớn hơn một mảng chúng tôi nhập if. Nếu không, chúng tôi bỏ quaif .

Bên trong ifvòng lặp chúng ta đi qua mảng 1..$y|%{...}và mỗi lần lặp chúng ta đặt lại thành $omột giá trị mới, kết quả của một if/elsecâu lệnh khác . Chừng nào bộ đếm của chúng ta $i++không modulo-5 bằng 4 (nghĩa là chúng ta không ở ^nhà điều hành), chúng ta chỉ cần lấy $ovà ghép nó với ký hiệu thích hợp '+-*/'[$x]và số tiếp theo trong mảng đầu vào $n[$_]. Chúng tôi chuyển nó thành iex(bí danh Invoke-Expressionvà tương tự eval), và điều đó được lưu lại $o. Nếu chúng ta đang ở trên các ^nhà điều hành, chúng ta đang ở else, vì vậy chúng tôi thực hiện một [math]::Pow()cuộc gọi, và rằng kết quả được tái lưu lại vào $o.

Trong cả hai trường hợp, chúng tôi chỉ cần xuất ra $ođường ống và thoát, với đầu ra ẩn.

Rust, 123 , 117 byte

Câu trả lời gốc:

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

tên phương thức dài ngu ngốc ^^ ahh tốt hơn nhiều

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

vô dụng

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

Giải trình:

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

Về mặt kỹ thuật * + *là một lambda, nhưng thực sự giống như &[+]viết tắt &infix:<+>của tập hợp các chương trình con xử lý phép cộng số.
Tôi không sử dụng mà cho phép nhân hoặc lũy thừa là cách để viết chúng như thế là ít nhất chừng nào những gì tôi có ( *×*hoặc * * *và* ** * )

Kiểm tra:

Thử nghiệm nó trên ideone.com
(sau khi nâng cấp lên một Rakudo phiên bản đó không phải là từ một năm rưỡi trước khi phát hành chính thức của Perl 6 spectests )

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

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

Nó bắt đầu ngắn hơn nhiều nhưng ưu tiên nhà điều hành đã đánh bại tôi và tôi phải bao gồm rất nhiều dấu ngoặc đơn ...

Oracle PL / SQL, 275 254 byte

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;

Dữ liệu phải được chèn vào một bảng được gọi Tvới một cột NkiểuNUMBER

Sử dụng:

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;

Đầu ra:

-1055,356943846277162152071601242992595623

Phiên bản 275 byte:

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

Giải trình:

Hãy thử nó ở đây.

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

Một vài thủ thuật có thể làm giảm cách tiếp cận @ Willmore của 23s xuống còn 23 byte (yêu cầu php 5.6 trở lên). Phần tiết kiệm nhất là loại bỏ các dấu ngoặc đơn không cần thiết (-10 byte).

hàm f ($ a) {while (tính ($ a)> 1) {$ l = mảng_shift ($ a); $ r = mảng_shift ($ a); mảng_unshift ($ a, ($ j = $ i ++% 5) ? ($ $ = $ l + $ r);} kết thúc trả lại ($ a);}

Nhưng sử dụng **toán tử thay vì pow()cũng cho phép sử dụng evalvới một mảng cho các hoạt động; và với một vài thủ thuật nữa ...

PHP> = 5,6, 82 byte

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

lấy danh sách từ các tham số dòng lệnh. Chạy với php -nr '<code>'hoặc thử trực tuyến .

phiên bản cũ, 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];}

Việc chơi golf hiệu quả nhất đến từ việc viết kết quả trung gian trực tiếp đến phần tử đầu tiên - sau khi chuyển kết quả trước đó từ mảng.

phá vỡ

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
}

bộ kiểm tra

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

Cảm ơn @titus, -5 byte, cộng với 0 trường hợp sửa chữa!

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

Hãy thử trực tuyến!

Ít chơi gôn hơn:

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

Đã thực sự root để mảng_reduce () hoạt động cho việc này, nhưng yêu cầu quá nhiều ký tự để đánh bại số điểm PHP thấp nhất hiện tại.

Đăng nó dù thế nào trong trường hợp bất cứ ai có bất kỳ đề nghị!

Brachylog , 68 byte

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

Đó là dài nhưng nó không sử dụng vị ngữ đánh giá.

Giải trình

• Vị ngữ chính

  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
  

• Vị ngữ 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 byte

Chỉ sử dụng bộ đồng xử lý toán học Intel 8087 của IBM PC để tính toán.

Dùng thử nhé! (trong DOSBox hoặc bất cứ điều gì). Cung cấp cho con chip 8087 nhàm chán của PC cũ của bạn một cái gì đó, ngoài tất cả các bảng tính Lotus 1-2-3 mà bạn đã từng làm trong những năm 80.

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 (chưa được lắp ráp):

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

Đầu ra:

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

Đầu vào thông qua PROC (x86 tương đương với hàm), với BX là con trỏ tới một mảng WORD trong bộ nhớ và CX là số mục trong đó và trả về kết quả trong ST.

* Lưu ý: Mã thực tế cho chức năng là 6682 byte. Tất nhiên, mã chỉ để ghi một số dấu phẩy động vào bàn điều khiển (mã sách nấu ăn) là 83 byte. Chương trình thử nghiệm và dữ liệu là183215 byte, làm cho .COM thực thi được 304 Tổng cộng 380 byte.

APL (Dyalog Unicode) , 29 27 byte ^SBCS

Chức năng tiền tố bất thường. Lưu ý rằng đó *là lũy thừa trong APL.

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

Hãy thử trực tuyến!

Vì APL thực thi từ phải sang trái, chúng ta có thể đảo ngược thứ tự các đối số của các hoạt động được chèn và đảo ngược toàn bộ biểu thức. Postfix ⍨đảo ngược các đối số. Sau khi thực hiện một sự xáo trộn hoàn hảo về số lượng và hoạt động, chúng ta chỉ cần đảo ngược, làm phẳng và đánh giá:

≢{... }⊢ gọi hàm sau đây với tội danh và con số thực tế như ⍺và ⍵:

 '⍨' nhân vật này

 '+-×÷*',¨ chuẩn bị cho mỗi nhân vật này ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

 ⍺⍴ sử dụng các lập luận trái (đếm số) để theo chu kỳ r eshape rằng

 ⌽ đảo ngược

 ⍕ định dạng dưới dạng chuỗi phẳng

 3↓thả 3 ký tự hàng đầu (một khoảng trắng và ký hiệu và ⍨)

 ⍎ thực thi dưới dạng mã APL

Japt , 16 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Tôi không thấy bất kỳ giải pháp c # nào vì vậy tôi sẽ đưa ra một giải pháp. Đây là codegolf đầu tiên của tôi. Tôi đã bắt đầu viết bằng c # "hai tháng trước" (mặc dù tôi biết Java ở một mức độ nào đó).

Nó sử dụng Stack

Ungolfed và trường hợp thử nghiệm

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

Đầu ra:

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

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

Ung dung

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

Trong PHP, logic tương tự như câu trả lời c # của tôi ( 202 byte ) :).