지난번에 복제본이 아닌 쉬운 것을 생각해 내려고했을 때 너무 어려워졌습니다. 그래서 이번에는 새로 온 사람들도 시도 할 수있는 것이기를 바랍니다.

입력:

정수 / 소수가 포함 된 배열 / 목록입니다. 또는 정수 / 소수를 가진 배열을 나타내는 문자열입니다.

산출:

숫자를 반복하고 다음 5 개의 수학 피연산자를이 순서대로 적용하십시오.

• 추가 ( +);
• 빼기 ( −);
• 곱셈 ( *또는 ×또는 ·);
• 실수 / 계산 부 ( /또는 ÷);
• 지수 ( ^또는 **).

(참고 : 괄호 안의 기호는 설명으로 추가 된 것입니다. 프로그래밍 언어가 예제와 수학 연산을 위해 완전히 다른 기호를 사용하는 경우에는 물론 완전히 허용됩니다.)

목록의 끝에 도달 할 때까지 계속 진행 한 다음 합계 결과를 제공하십시오.

도전 규칙 :

• 0 ( n ^ 0)으로 지수화 하면 1이됩니다 (이것도 적용됩니다 0 ^ 0 = 1).
• 0 ( n / 0)으로 나누는 테스트 사례는 없으므로 해당 사례에 대해 걱정할 필요가 없습니다.
• 배열에 하나의 숫자 만 포함 된 경우 결과로 반환합니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수가있는 기능 / 방법, 전체 프로그램을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.

테스트 사례 :

[1,2,3,4,5] -> 0
-> 1 + 2 = 3
  -> 3 - 3 = 0
    -> 0 * 4 = 0
      -> 0 / 5 = 0 

[5,12,23,2,4,4,2,6,7] -> 539
-> 5 + 12 = 17
  -> 17 - 23 = -6
    -> -6 * 2 = -12
      -> -12 / 4 = -3
        -> -3 ^ 4 = 81
          -> 81 + 2 = 83
            -> 83 - 6 = 77
              -> 77 * 7 -> 539

[-8,50,3,3,-123,4,17,99,13] -> -1055.356...
-> -8 + 50 = 42
  -> 42 - 3 = 39
    -> 39 * 3 = 117
      -> 117 / -123 = -0.9512...
        -> -0.9512... ^ 4 = 0.818...
          -> 0.818... + 17 = 17.818...
            -> 17.818... - 99 -> -81.181...
              -> -81.181... * 13 = -1055.356...

[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256
-> 2 + 2 = 4
  -> 4 - 2 = 2
    -> 2 * 2 = 4
      -> 4 / 2 = 2
        -> 2 ^ 2 = 4
          -> 4 + 2 = 6
            -> 6 - 2 = 4
              -> 4 * 2 = 8
                -> 8 / 2 = 4
                  -> 4 ^ 2 = 16
                    -> 16 + 2 = 18
                      -> 18 - 2 = 16
                        -> 16 * 2 = 32
                          -> 32 / 2 = 16
                            -> 16 ^ 2 = 256

[1,0,1,0,1,0] -> 1
-> 1 + 0 = 1
  -> 1 - 1 = 0
    -> 0 * 0 = 0
      -> 0 / 1 = 0
        -> 0 ^ 0 = 1

[-9,-8,-1] -> -16
  -> -9 + -8 = -17
    -> -17 - -1 = -16

[0,-3] -> -3
  -> 0 + -3 = -3

[-99] -> -99

젤리 , 13 바이트

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

“+_×÷*”ṁṖ⁸żFV  Main link. Argument: A (list of integers)

“+_×÷*”        Yield the list of operations as a string.
        Ṗ      Yield A popped, i.e., with its last element removed.
       ṁ       Mold; reshape the string as popped A.
               This repeats the characters of the string until it contains
               length(A)-1 characters.
         ⁸ż    Zipwith; pairs the integers of A with the corresponding characters.
           F   Flatten the result.
            V  Eval the resulting Jelly code.
               Jelly always evaluates left-to-right (with blatant disregard towards
               the order of operations), so this returns the desired result.

자바 스크립트 ES7 49 바이트

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

Dom Hastings 덕분에 9 바이트 절약, Leaky Nun 덕분에 6 바이트 절약

새로운 지수 연산자를 사용합니다.

하스켈, 76 65 64 62 바이트

다른 2 바이트를 제거 한 @Damien에게 감사드립니다 =)

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

>>여기서는 목록 [(+),...]을 자체 length v시간에 추가 하는 것을 사용합니다 . 나머지는 여전히 이전 버전과 동일하게 작동합니다.

이전 버전 :

이 솔루션 cycle[...]은 주어진 목록을 무한 반복하는 것처럼 무한 목록을 사용 합니다. 그 다음은 기본적으로 도착 zip번호 목록과 에드, 우리는 fold( 감소 어큐뮬레이터 / 현재 목록 요소에 연산자를 적용 람다를 통해 압축 된 목록을 다른 언어로).

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

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

f l=foldl(\x(y,f)->f x y)(head l)(zip(drop 1l)(cycle[(+),(-),(*),(/),(**)]))

파이크, 22 21 바이트

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

여기 사용해보십시오!

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

하스켈, 61 바이트

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

[add 1, add 2, subtract 3, ...]에서와 같이 겹침에서 0으로 시작하므로 2 개의 덧셈으로 시작하여 목록에 일련의 변환을 작성합니다. 그런 다음 List Application Fold 또는 foldl (flip id)이라고 부르는 작업을 수행합니다. 이것은 0으로 시작하고 초기 값을 더한 다음 위의 모든 계산 된 변환을 수행하여 최종 결과를 얻습니다.

(플립 id)는 (\ x y-> yx)와 동일하며 더 짧습니다.

샘플 사용법 :

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

TSQL 116 115 88 바이트

Ross Presser 제안 덕분에 88 자까지 골프를 칠 수있었습니다.

-- In Try-it code, this must be DECLARE @y TABLE 
CREATE TABLE T(a real, i int identity)
INSERT T values(5),(12),(23),(2),(4),(4),(2),(6),(7)

DECLARE @ REAL SELECT @=CHOOSE(i%5+1,@/a,ISNULL(POWER(@,a),a),@+a,@-a,@*a)FROM T
PRINT @

온라인으로 사용해보십시오

Pyth, 27 26 25 바이트

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

테스트 스위트.

Pyth는 접두사 표기법을 사용합니다. 1+2는 +1 2(숫자를 구분하는 데 필요한 공간 )으로 작성됩니다 .

따라서 첫 번째 테스트 케이스의 경우 표현식은 (((1+2)-3)*4)/5접두사 표기법으로로 표시됩니다 /*-+ 1 2 3 4 5.

Pyth에서는 float 나누기가 c대신 /이므로됩니다 c*-+ 1 2 3 4 5.

또한 Pyth에서는 대신 -100작성 _100됩니다.

따라서, 제 3 테스트 케이스에 대해 ((((((((-8+50)-3)*3)/-123)^4)+17)-99)*13), 그것을된다 : *-+^c*-+ _8 50 3 3 _123 4 17 99 13.

.v+>tlQ*lQ"^c*-+":jdQ\-\_
                  jdQ       Join input by space.
                 :   \-\_   Replace "-" with "_".
   >tlQ*lQ"^c*-+"           Generate the string "...^c*-+" of suitable length.
  +                         Join the two strings above.
.v                          Evaluate as a Pyth expression.

역사

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

실제로 23 바이트

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

온라인으로 사용해보십시오!

실제로 수학에는 접미사 표기법을 사용하고 스택에 요소가 하나만있을 때 두 인수 만 취하는 연산자 (더하기, 빼기, 곱하기, 나누기 및 지수 연산자)는 아무 것도 수행하지 않습니다. 따라서 입력을 실제 코드로 변환하는 것은 입력을 취소하고 숫자로 형식을 지정하고 작업을 추가하는 것만 큼 간단합니다. 그런 다음 결과 코드를 실행하여 원하는 출력을 얻을 수 있습니다.

설명:

;l"+-*/ⁿ"*@R':j':+'?o+ƒ
;l"+-*/ⁿ"*               repeat the operations a number of times equal to the length of the input
                            (since extraneous operations will be NOPs, there's no harm in overshooting)
          @R             reverse the input
            ':j          join on ":" (make a string, inserting ":" between every pair of elements in the list)
               ':+       prepend a ":" (for the first numeric literal)
                  '?o    append a "?"
                           (this keeps the poor numeric parsing from trying to gobble up the first + as part of the numeric literal, since ? isn't interpreted as part of the literal, and is a NOP)
                     +   append the operations string
                      ƒ  cast as a function and call it

입력을 위해 번역 된 코드의 예 1,2,3,4,5:

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

줄리아, 53 50 바이트

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

온라인으로 사용해보십시오!

J, 40 바이트

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

해당 연산자의 ID 값이있는 패드보다 5 연산자의 배수를 사용하는 데 필요한 값 수를 찾습니다. 순서 +는 0, -0, *1, %1, ^1이며 비트 값이 될 수있는 1 00111또는 기수 10의 경우 7입니다. 그런 다음 연산자를 순환하면서 해당 목록에서 작동합니다.

용법

   f =: ^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#)
   f 1 2 3 4 5
0
   f 5 12 23 2 4 4 2 6 7
539
   f _8 50 3 3 _123 4 17 99 13
_1055.36
   f 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
256
   f 1 0 1 0 1 0
1
   f _9 _8 _1
_16
   f 0 _3
_3
   f _99
_99

설명

^~`(%~)`*`(-~)`+/@(|.@,7#:~#&2)(5-5|4+#) Input: A
                                      #  Get length of A
                                    4+   Add four to it
                                  5|     Take it mod 5
                                5-       Find 5 minus its value, call it x
                           #&2           Create x copies of 2
                       7#:~              Convert 7 to base 2 and take the last x digits
                      ,                  Append those x digits to the end of A
                   |.@                   Reverse it, call it A'
^~                                       Power, reversed operators
    %~                                   Division, reversed operators
       *                                 Multiplication
         -~                              Subtraction, reversed operators
            +                            Addition
             /@                          Insert the previous operations, separated by `,
                                         into A' in order and cycle until the end
                                         Then evaluate the equation from right-to-left
                                         and return

파이썬 2, 81 67 64 바이트

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

입력은 float의 배열입니다. Ideone에서 테스트하십시오 .

작동 원리

'*+-*/*'[i::5]선택 캐릭터의 각 제 문자 인덱스에 하나 시작 난 이 산출되도록, **만약 I = 0 , +만약 i가 1 = , -만약 i가 2 = , *만약 I = 3 과 /경우 나 = 4 . 문자열의 길이는 6 이므로 i> 5 인 경우 표현식은 빈 문자열을 생성합니다 .

변수 i 를 10으로 초기화합니다 . 각 번호를 들어 N 입력 배열에서는 문자열을 구성 r<op>=n하는 exec이 실행한다.

처음에는 i = 10 이므로 <op>빈 문자열도 r 로 초기화 됩니다 r+=n. 각 단계 후에는 i를 사용 하여 i modulo 5 를 증가 i=-~i%5시키므로 다음 단계는 적절한 연산자를 검색합니다.

모든 입력 번호가 처리되면 원하는 출력을 보유하는 r 을 인쇄 합니다.

Matlab- 95 91 85 바이트 / 옥타브-81 바이트

입력 형식은 다음과 같습니다. a = ['1' '2' '3' '4' '5'];, "정수 / 소수로 배열을 나타내는 문자열"로 덮여 있기를 바랍니다. 그렇지 않으면 2 num2str이 추가로 필요합니다.

모든 중간 결과는 콘솔에 인쇄되므로 세미콜론이 절약됩니다. a(1)값이에 저장됩니다 ans. 물론 ans코드에서 사용 하는 것은 나쁜 습관입니다.

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

Octave에서는 '+-*/^'(mod(i+2,5)+1)Adám과 Luis Mendo 덕분에 또 다른 4 바이트를 절약 할 수 있습니다.

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

변경 로그:

• 가능한 경우 제거 된 공간
• Octave 솔루션 추가
• strcat ()을 []로 교체했습니다

Mathematica, 67 66 65 바이트

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

인덱스를 보유한 Fold변수로 간단 i합니다.

CJam, 18 바이트

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

입력은 float의 배열입니다. 온라인으로 사용해보십시오!

작동 원리

q~                  Read and evaluate all input.
  {             }*  Reduce:
   "+-*/#"            Push the string of operators.
          W           Push W (initially -1).
           ):W        Increment and save in W.
              =       Retrieve the character at that index.
               ~      Evaluate.

R , 87 78 70 바이트

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

온라인으로 사용해보십시오!

하스켈-74

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

테스트 사례 :

λ> f[1,2,3,4,5] -> 0.0
λ> f[5,12,23,2,4,4,2,6,7] -> 539.0
λ> f[-8,50,3,3,-123,4,17,99,13] -> -1055.356943846277
λ> f [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] -> 256.0

아마 더 짧을 수도 있습니다. 그러나 무한리스트와 고차 함수에 대한 Haskell의 지원은 직접 솔루션을 매우 즐겁게 만듭니다. ^ :: Double -> Double -> Double골프 버전이 더 좋았지 만 찾을 수 없었습니다. 고맙게도, 나는 완전한 람다가 필요하지 않았으므로 무의미한 스타일은 몇 바이트를 깎았습니다.

PowerShell v2 +, 124 바이트

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

PowerShell에는 ^또는 **연산자 가 없기 때문에 별도의 사례를 설명하고 .NET 호출을 사용해야합니다.

입력 $n을 배열로 받아서 출력 $o을 첫 번째 숫자로 설정합니다. 그런 다음 .count배열 을 확인하고 배열이 1보다 크면를 입력합니다 if. 그렇지 않으면를 건너 뜁니다 if.

내부에서 if우리는 배열 1..$y|%{...}과 각 반복을 반복 $o하여 다른 if/else문장 의 결과 인 새로운 값으로 재설정 합니다. 카운터 $i++가 모듈로 -5가 4와 같지 않은 한 (즉, 우리는 ^연산자 가 아닙니다 ) 입력 배열에서 $o적절한 기호 '+-*/'[$x]와 다음 숫자로 간단히 연결합니다 $n[$_]. 우리는 iex( Invoke-Expression와 별개로 eval) 파이프하고 다시 저장합니다 $o. 우리가에 있다면 ^운영자, 우리는에있어 else우리가 실행할 수 있도록, [math]::Pow()전화를하고, 그 결과로 다시 저장 등을 얻는다 $o.

두 경우 모두 $o파이프 라인으로 출력하고 출력을 암시 적으로 종료합니다.

녹, 123 , 117 바이트

원래 답변 :

fn a(v:&[f32])->f32{v.iter().skip(1).enumerate().fold(v[0],|s,(i,&x)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

멍청한 긴 메소드 이름 ^^ 아아 훨씬 좋아

fn f(v:&[f32])->f32{v[1..].iter().zip(0..).fold(v[0],|s,(&x,i)|match i%5{0=>s+x,1=>s-x,2=>s*x,3=>s/x,_=>s.powf(x)})}

언 골프

fn f(values : &[f32]) -> f32 {
    values[1..].iter().zip(0..)
    .fold(values[0], |state,(&x,i)|
        match i%5 {
            0=>state+x,
            1=>state-x,
            2=>state*x,
            3=>state/x,
            _=>state.powf(x)
        }
    )
}

펄 6 ,  70 68 65   62 바이트

{$/=[(|(&[+],&[-],&[*],&[/],&[**])xx*)];.reduce: {$/.shift.($^a,$^b)}}
{(@_ Z |(&[+],&[-],&[*],&[/],&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{(@_ Z |(*+*,*-*,&[*],*/*,&[**])xx*).flat.reduce: {&^b($^a,$^c)}}
{reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],*/*,&[**])xx*}

설명:

-> *@_ {
  reduce
    -> $a, &b, $c { b($a,$c) },

    flat       # flatten list produced from zip
      zip
        @_,    # input

        slip(  # causes the list of operators to flatten into the xx list

          # list of 5 infix operators
          &infix:<+>, &infix:<->, &infix:<*>, &infix:</>, &infix:<**>

        ) xx * # repeat the list of operators infinitely
}

기술적 * + *으로 Whatever 람다이지만 유효 숫자 추가를 처리하는 서브 루틴 세트에 &[+]대해 짧은 것과 동일 &infix:<+>합니다.
나는 그것을 곱하는 방법이 적어도 내가 가진 것 ( *×*또는 * * *및 * ** *) 만큼 길기 때문에 곱셈이나 지수에 이것을 사용하지 않았습니다.

테스트:

ideone.com 에서 테스트하십시오
( Perl 6 스펙 공식 출시 1 년 반 전이 아닌 Rakudo 버전으로 업그레이드 한 후 )

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,2,3,4,5] => 0,
  [5,12,23,2,4,4,2,6,7] => 539,
  [-8,50,3,3,-123,4,17,99,13] => -1055.35694385, # -2982186493/2825761
  [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2] => 256,
  [1,0,1,0,1,0] => 1,
  [-9,-8,-1] => -16,
  [0,-3] => -3,
  [-99] => -99,
);

plan +@tests;

my &code = {reduce {&^b($^a,$^c)},flat @_ Z |(*+*,*-*,&[*],&[/],&[**])xx*}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is code(@input), $expected, .gist
}

1..8
ok 1 - [1 2 3 4 5] => 0
ok 2 - [5 12 23 2 4 4 2 6 7] => 539
ok 3 - [-8 50 3 3 -123 4 17 99 13] => -1055.35694385
ok 4 - [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2] => 256
ok 5 - [1 0 1 0 1 0] => 1
ok 6 - [-9 -8 -1] => -16
ok 7 - [0 -3] => -3
ok 8 - [-99] => -99

파이썬 3, 88 93 바이트

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

훨씬 짧아지기 시작했지만 연산자 우선 순위가 저를 물리 쳤고 많은 괄호를 포함해야했습니다 ...

Oracle PL / SQL, 275254 바이트

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

유형 T의 열 N이 있는 테이블에 데이터를 삽입해야합니다.NUMBER

용법:

drop table t;
create table t (n number);
insert into t values (-8);
insert into t values (50);
insert into t values (3);
insert into t values (3);
insert into t values (-123);
insert into t values (4);
insert into t values (17);
insert into t values (99);
insert into t values (13);

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

산출:

-1055,356943846277162152071601242992595623

275 바이트 버전 :

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

자바 (8) 173 172 167 138 137 118 113 바이트

a->{double r=a[0],t;for(int i=1;i<a.length;r=new double[]{Math.pow(r,t),r+t,r-t,r*t,r/t}[i++%5])t=a[i];return r;}

설명:

여기에서 시도하십시오.

a->{                     // Method with double-array parameter and double return-type
  double r=a[0],         //  Result-double, starting at the first item of the input
         t;              //  Temp double
  for(int i=1;           //  Index-integer, starting at the second item
      i<a.length;        //  Loop over the input-array
      r=new double[]{    //    After every iteration, change `r` to:
         Math.pow(r,t),  //      If `i%5` is 0: `r^t`
         r+t,            //      Else-if `i%5` is 1: `r+t`
         r-t,            //      Else-if `i%5` is 2: `r-t`
         r*t,            //      Else-if `i%5` is 3: `r*t`
         r/t}[i++%5])    //      Else-if `i%5` is 4: `r/t`
                         //      And increase `i` by 1 afterwards with `i++`
    t=a[i];              //   Change `t` to the next item in the array
  return r;}             //  Return result-double

몇 가지 트릭으로 @Willmore의 접근 방식을 23에서 174 바이트까지 줄일 수 있습니다 (php 5.6 이상 필요). 가장 절약되는 부분은 불필요한 괄호 (-10 바이트)를 제거하는 것입니다.

함수 f ($ a) {while (count ($ a)> 1) {$ l = array_shift ($ a); $ r = array_shift ($ a); array_unshift ($ a, ($ j = $ i ++ % 5) ? ($ j == 1? $ l- $ r : ($ j == 2? $ l * $ r : ($ j == 3? $ l / $ r : $ l ** $ r))) : $ l + $ r);} 반납 종료 ($ a);}

그러나 **대신 연산자 pow()를 사용 eval하면 작업에 배열과 함께 사용할 수 있습니다 . 그리고 몇 가지 더 많은 트릭이 있습니다 ...

PHP> = 5.6, 82 바이트

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

명령 행 매개 변수에서 목록을 가져옵니다. 온라인으로 실행 php -nr '<code>'하거나 사용해보십시오 .

이전 버전, 161157151145144140137117 바이트

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

가장 효과적인 골프는 배열에서 이전 결과를 이동 한 후 중간 결과를 첫 번째 요소에 직접 작성하는 것입니다.

고장

function f($a)
{
    while(count($a)>1)  // while array has more than one element ...
        eval('$a[0]='                           // future first element :=
            . 'array_shift($a)'                 // = old first element (removed)
            . ['+','-','*','/','**'][$i++%5]    // (operation)
            .'$a[0];'                           // new first element (after shift)
        );
    return$a[0];        // return last remaining element
}

테스트 스위트

$cases = array (
    0=>[1,2,3,4,5],
    539=>[5,12,23,2,4,4,2,6,7],
    '-1055.356...' => [-8,50,3,3,-123,4,17,99,13],
    256 => [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],
    1 => [1,0,1,0,1,0],
    -16 => [-9,-8,-1],
    -3 => [0, -3],
    -99 => [-99]
);
echo '<table border=1><tr><th>values</th><th>expected</th><th>actual result</th></tr>';
foreach ($cases as $expect=>$a)
{
    $result=f($a);
    echo "<tr><td>[", implode(',',$a),"]</td><td>$expect</td><td>$result</td></tr>";
}
echo '</table>';

PHP ,135 130 바이트

@titus, -5 바이트 및 0 사례 수정에 감사드립니다!

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

온라인으로 사용해보십시오!

덜 골프 :

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

array_reduce ()가 실제로 작동하기 시작했지만 현재 가장 낮은 PHP 점수를 초과하려면 너무 많은 문자가 필요합니다.

누군가가 제안 사항이있는 경우 어쨌든 게시!

Brachylog , 68 바이트

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

길지만… 평가 술어를 사용하지 않습니다.

설명

• 주요 술어

  hI,                                  Unify I with the first element of the input
     ?bL,                              L is the input minus the first element
         1:+:-:*:/:^b                  Construct the list of predicates [+:-:*:/:^]
                     :L:I{...}.        Call predicate 1 with [[+:-:*:/:^]:L:I] as input
  

• 술어 1

  bhv?t.                               If the second element of Input is empty (i.e. L),
                                       unify Output with the last element of Input
  |                                    Or
  [O:L:I]                              Input = [O:L:I]
         h$(P,                         P is O circularly permutated to the left
              LbM,                     M is L minus the first element
                  OhA,                 A is the first element of O
                      Lh:Ir:A&         Call predicate A on [I:First element of L]
                              :M:Pr&.  Call predicate 1 recursively with P:M:
  

IBM PC 8087 FPU, 66 82 바이트

계산에는 IBM PC의 Intel 8087 수학 보조 프로세서 만 사용합니다.

오프라인으로 사용해보십시오! (DOSBox 등). 오래된 PC의 지루한 8087 칩에 80 년대에 사용했던 Lotus 1-2-3 스프레드 시트 이외의 다른 작업을 수행하십시오.

9bdf 0783 c302 499b de07 83c3 0249 e342 9bde 2783 c302 49e3 399b de0f 83c3 0249 
e330 9bde 3783 c302 49e3 2751 8b0f 9bd9 e883 f900 7413 9c7f 02f7 d99b d8c9 e2fb 
9d7d 069b d9e8 9bd8 f159 83c3 0249 e302 ebb5 c3

언 골프 (조립되지 않은) :

START: 
    ; RUN TESTS  
    MOV  BX, OFFSET TST     ; 5, 12, 23, 2, 4, 4, 2, 6, 7
    MOV  CX, CTST           ; input array length
    CALL WOMI               ; calculate sequence
    CALL PRINT_FLT          ; output to console

    MOV  BX, OFFSET TST1    ; 5, 12, 23, 2, 4, -4, 2, 6, 7
    MOV  CX, CTST1
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST2    ; -8, 50, 3, 3, -123, 4, 17, 99, 13
    MOV  CX, CTST2
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST3    ; 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
    MOV  CX, CTST3
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST4    ; 1,0,1,0,1,0
    MOV  CX, CTST4
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST5    ; -9, -8, -1
    MOV  CX, CTST5
    CALL WOMI
    CALL PRINT_FLT

    MOV  BX, OFFSET TST6    ; 0, -3
    MOV  CX, CTST6
    CALL WOMI
    CALL PRINT_FLT

    MOV  AX, 4C00H          ; exit to DOS
    INT  21H

;  TEST DATA

TST   DW  5, 12, 23, 2, 4, 4, 2, 6, 7
CTST  EQU ($-TST)/(SIZE TST)    ; count of items on list

TST1  DW  5, 12, 23, 2, 4, -4, 2, 6, 7
CTST1 EQU ($-TST1)/(SIZE TST1)  ; count of items on list

TST2  DW -8, 50, 3, 3, -123, 4, 17, 99, 13
CTST2 EQU ($-TST2)/(SIZE TST2)  ; count of items on list

TST3  DW 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
CTST3 EQU ($-TST3)/(SIZE TST3)  ; count of items on list

TST4  DW 1,0,1,0,1,0
CTST4 EQU ($-TST4)/(SIZE TST4)  ; count of items on list

TST5  DW -9, -8, -1
CTST5 EQU ($-TST5)/(SIZE TST5)  ; count of items on list

TST6  DW 0, -3
CTST6 EQU ($-TST6)/(SIZE TST6)  ; count of items on list

; 8087 exponent: ST(0) = ST(0) ^ EXP
FIEXP   MACRO   EXP
        LOCAL   REPEAT, DONE
        PUSH CX
        MOV  CX, EXP        ; Exponent is count for loop
        FLD1                ; load 1 into ST
        CMP  CX, 0          ; is exponent pos, neg or 0?
        JZ   DONE           ; exit (with value 1) if exponent is 0
        PUSHF               ; save result flags for later
        JG   REPEAT         ; if exp > 1 start calculation
        NEG  CX             ; make exponent positive for loop
REPEAT:
        FMUL ST(0), ST(1)   ; multiply ST0 = ST0 * ST1
        LOOP REPEAT
        POPF                ; retrieve flags from earlier
        JGE  DONE           ; if exponent was negative, divide 1 by result
        FLD1                ; push 1 into numerator
        FDIV ST(0), ST(1)   ; ST0 = 1 / ST1
DONE:
        POP  CX
        ENDM

; Function WOMI: (Weapons of Math Instruction)
; input: BX - address of start of input array
;       CX - length of input array
; output: ST - result on top of 8087 register stack
WOMI PROC
    FILD WORD PTR [BX]      ; load first item
    ADD  BX, 2              ; move to next
    DEC  CX
CALC:
    FIADD WORD PTR [BX]     ; add
    ADD  BX, 2              ; move to next
    DEC  CX                 ; decrement counter
    JCXZ OUTPUT             ; check if done

    FISUB WORD PTR [BX]     ; subtract
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIMUL WORD PTR [BX]     ; multiply
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIDIV WORD PTR [BX]     ; divide
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT

    FIEXP [BX]              ; exponent
    ADD  BX, 2
    DEC  CX
    JCXZ OUTPUT
    JMP CALC                ; start again

OUTPUT:
    RET 
WOMI ENDP

PRINT_FLT PROC
; print top of 8087 stack
; scaling: 14 digits, 4 decimal places
; input: BX = address of a TBYTE (BCD) output buffer
;       ST = value to display on top of 8087 stack  
    LEA   BX, BUFF                  ; set BX to BCD output buffer
    MOV   AH, 2
    MOV   WORD  PTR[BX], 10000      ; ten thousand (scale factor)
    FIMUL WORD  PTR[BX]             ; scale up by 10000
    FBSTP TBYTE PTR[BX]             ; store as BCD
    FWAIT                           ; sync 8088 and 8087
    TEST  BYTE  PTR[BX+9], 80H      ; check sign bit
    JE    PF_1                      ; 0, goto PF_1
    MOV   DL, '-'                   ; output '-'
    INT   21H
PF_1:
    ADD   BX, 8                     ; point to high byte
    MOV   CH, 7                     ; 14 digits before decimal point
    MOV   CL, 4                     ; 4 shifts (8 bytes / 2 = 4 = 1 nibble)
    MOV   DH, 2                     ; 2 times (8 bytes / 4)
PF_LOOP:
    MOV   DL, [BX]                  ; get BCD digits
    SHR   DL, CL                    ; move high digit to low nibble
    OR    DL, 30H                   ; convert to ASCII
    INT   21H
    MOV   DL, [BX]                  ; get byte again
    AND   DL, 0FH                   ; mask out high digit
    OR    DL, 30H                   ; convert to ASCII
    INT   21H                       ; output
    DEC   BX                        ; next byte
    DEC   CH                        ; decrement byte
    JG    PF_LOOP                   ; repeat if more bytes
    DEC   DH                        ; second time?
    JE    PF_DONE                   ; yes, done
    MOV   DL, '.'                   ; no, output decimal point
    INT   21H
    MOV   CH, 2                     ; 4 more digits after decimal point
    JMP   PF_LOOP                   ; go print digits
PF_DONE:
    MOV  DL, 0DH                    ; display newline CRLF
    MOV  AH, 2
    INT  21H
    MOV  DL, 0AH
    INT  21H
    RET 
PRINT_FLT ENDP

BUFF DT 0   ; output buffer for floating point digit string

_TEXT ENDS
END START

산출:

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

입력은 PROC (x86은 함수와 가장 유사)를 통해 이루어지며, BX는 메모리에있는 WORD 배열에 대한 포인터이고 CX는 항목 수이며 ST에 결과를 반환합니다.

* 참고 : 함수의 실제 코드는 6682 바이트 물론 콘솔에 부동 소수점 숫자를 쓰는 코드 (요리 코드)는 83 바이트입니다. 테스트 프로그램 및 데이터는183215 바이트, .COM 실행 파일 만들기 305 총 380 바이트

APL (Dyalog Unicode) , 29 27 바이트 ^SBCS

Animatemous Tacit 접두사 기능. 참고 *APL의 지수이다.

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

온라인으로 사용해보십시오!

APL은 오른쪽에서 왼쪽으로 실행되므로 삽입 된 연산의 인수 순서를 반대로하고 전체 표현식을 반대로 할 수 있습니다. Postfix는 ⍨인수를 반대로합니다. 숫자와 연산을 완벽하게 섞은 후에는 역전, 편 평화 및 평가 만하면됩니다.

≢{... }⊢ 등의 수와 실제 숫자와 함께 다음 함수를 호출 ⍺하고 ⍵:

 '⍨' 이 캐릭터

 '+-×÷*',¨ 이 문자들 각각 앞에 추가하십시오. ["+⍨","-⍨","×⍨","÷⍨","*⍨"]

 ⍺⍴ 주기적 좌측 인수 (숫자의 개수)를 사용하여 R eshape 그

 ⌽ 역

 ⍕ 플랫 문자열로 형식화

 3↓선행 3 자 (공백 및 기호 ⍨)

 ⍎ APL 코드로 실행

Japt , 16 바이트

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

온라인으로 사용해보십시오!

설명:

r@                  #Reduce the input list:
       "p+-*/"      # The list of functions to apply (offset by one due to the behavior of Z)
              gZ    # Choose the one at the current index, wrapping
  [  ]r             # Apply that function to:
   X                #  The result of the previous step
    Y               #  and the current number
                    #Implicitly return the result of the final step

c #, 238 , 202 바이트

double d(double[]a){Array.Reverse(a);var s=new Stack<double>(a);int i=0,j;while(s.Count>1){double l=s.Pop(),r=s.Pop();j=i++%5;s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l,r));}return s.Peek();}

나는 C # 솔루션을 보지 못했기 때문에 하나를 줄 것이다. 이것이 나의 첫 번째 코드 골프입니다. 나는 "2 개월 전에" C #으로 글을 쓰기 시작했다 .

스택을 사용합니다

Ungolfed 및 테스트 사례

using System;
using System.Collections.Generic;

class M 
{
    double d(double[]a) {
        Array.Reverse(a);
        var s = new Stack<double>(a);
        int i=0,j;
        while (s.Count>1)
        {
            double l=s.Pop(),r=s.Pop();
            j=i++%5;
            s.Push(j==0?l+r:j==1?l-r:j==2?l*r:j==3?l/r:Math.Pow(l, r));
        }
        return s.Peek();
    }

    public static void Main()
    {
        int[][] a = new int[][]{
            new int[]{1,2,3,4,5},
            new int[]{5,12,23,2,4,4,2,6,7},
            new int[]{-8,50,3,3,-123,4,17,99,13},
            new int[]{2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
            new int[]{1,0,1,0,1,0},
            new int[]{-9,-8,-1},
            new int[]{0,-3},
            new int[]{-99}
        };

        for (int i = 0; i < a.Length; i++)
        {
            Console.WriteLine(new M().d(Array.ConvertAll(a[i], e => Convert.ToDouble(e))));
        }
        Console.ReadKey();
    }
}

산출:

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

PHP, 206 , 198 , 197 바이트

function f($a){while(count($a)>1){$l=array_shift($a);$r=array_shift($a);array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));}return array_pop($a);}

언 골프

<?php

function f($a)
{
    while(count($a)>1)
    {
        $l = array_shift($a); $r = array_shift($a);
        array_unshift($a,($j=$i++%5)==0?($l+$r):($j==1?($l-$r):($j==2?($l*$r):($j==3?($l/$r):(pow($l,$r))))));
    }
    return array_pop($a);
}

echo f([1,2,3,4,5])."\n";
echo f([5,12,23,2,4,4,2,6,7])."\n";
echo f([-8,50,3,3,-123,4,17,99,13])."\n";
echo f([2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2])."\n";
echo f([1,0,1,0,1,0])."\n";
echo f([-9,-8,-1])."\n";
echo f([0,-3])."\n";
echo f([-99])."\n";

PHP에서 내 C # 답변 과 비슷한 논리 ( 202 바이트) ) :).