더하기 +, 곱하기 *, 빼기 -및 나누기 /(정수가 아닌 부동 수)의 네 가지 기본 연산을 사용합니다 .

Stewie의 순서 는 다음과 같이 정의됩니다.

x = [x(1), x(2)]    // Two initial numbers (one indexed)
x(3) = x(1) + x(2)
x(4) = x(2) * x(3)
x(5) = x(3) - x(4)
x(6) = x(4) / x(5)
x(7) = x(5) + x(6)
... and so on.

도전:

음수가 아닌 정수 ( x(1), x(2)) 2 개와 양수 N를 입력으로 사용하십시오.

x(1)그리고 x(2)시퀀스의 첫 두 숫자가되고 N출력해야하는 시퀀스의 길이가됩니다. (0부터 시작하도록 목록을 선택할 수 있으며,이 경우 N길이보다 1이 작습니다).

• 당신은 그것을 가정 할 수 없습니다 x(2) >= x(1).
• N항상 >21 기반이면 (>1 경우 (0 경우)입니다.
• 0으로 나누기 오류를 처리 할 필요는 없습니다.
  • 두 번째 테스트 사례를 참고하십시오. 당신은받지 않습니다 0, 1, 및 N=6입력으로, 즉 0으로 분열의 원인이되므로,하지만 당신은 지원해야 0, 1하고 N=5.
• 유효한 입력 만 제공한다고 가정합니다.
• 입력 및 출력은 편리한 형식 일 수 있지만 출력이 정수가 아닌 경우 소수점 다음에 3 자리 이상을 지원해야합니다.

테스트 사례 :

1 3
8
1, 3, 4, 12, -8, -1.5, -9.5, 14.25

0 1
5
0, 1, 1, 1, 0     // N=6 would give division by zero error. You don't need to handle that case.

1 0
9
1, 0, 1, 0, 1, 0, 1, 0, 1

6 3
25
6, 3, 9, 27, -18, -1.5, -19.5, 29.25, -48.75, -0.6, -49.35, 29.61, -78.96, -0.375, -79.335, 29.7506, -109.086, -0.272727, -109.358, 29.825, -139.183, -0.214286, -139.398, 29.8709, -169.269

MATL , 19 18 17 바이트

q:"y'+*-/'@)hyhUV

입력 형식은 N(0 기반) x(1),, x(2)(문자열); 모두 줄 바꿈으로 구분됩니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오. (약간 수정 된 코드, 빈 줄로 구분 된 출력 시퀀스)를 확인하십시오.

설명

MATL에는 적절한 eval기능이 없지만 U(str2num )는 중위 연산자를 사용하여 숫자 표현식을 평가할 수 있습니다.

각각의 새로운 용어는 이전 용어를 유지하면서 계산되어 스택으로 푸시됩니다. 전체 스택이 끝에 인쇄됩니다.

q          % Implicitly input N (0-based). Subtract 1
:"         % Repeat that many times
  y        %   Duplicate x(n-1), where n is the number of already computed terms
           %   In the first iteration, which corresponds to n=2, this implicitly 
           %   inputs x(1) and x(2) as strings (and then duplicates x(1))
  '+*-/'   %   Push this string
  @)       %   Push iteration number and apply as modular index into the string. 
           %   So this gives '+' in the first iteration, '*' in the second etc
  h        %   Concatenate horizontally. This gives a string of the form
           %   '*x(n-1)+', where '+' is the appropriate operator 
  &y       %   Duplicate x(n)
  hh       %   Concatenate horizontally. This gives a string of the form
           %   'x(n-1)+x(n)'
  U        %   Convert to number. This evaluates the string
  V        %   Convert back to string. This is the new term, x(n+1)
           % Implicitly end loop and display stack

하스켈, 69 68 64 바이트

x#n=take n$x++zipWith3 id(cycle[(+),(*),(-),(/)])(x#n)(tail$x#n)

x1그리고 x2목록으로 가져옵니다. 사용 예 : [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

게으름으로 인해 처음 n 개의 요소를 취하는 무한 재귀 목록을 정의 할 수 있습니다.

하스켈, 66 바이트

(h%g)y x=x:g(h x y)y
a=(+)%b
b=(*)%c
c=(-)%d
d=(/)%a
(.a).(.).take 

약간 다른 접근법. 인수의 순서는 N, x2, x1. 사용 예 : ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

4 개 기능 정의 a, b, c및 d두 개의 인수를 y, x 그리고 넣어 목록을 작성 x하여 다음 함수에 대한 호출 앞에 y두 번째 인수로 및x op y 제있다. 예를 들어 a다음과 같습니다 a y x = x : (b (x+y) y), b곱셈을 수행합니다b y x = x : (c (x*y) y) 등

편집 : @ Michael Klein은 첫 번째 변형 ( #)에 바이트를 저장했습니다 . 운 좋게도 두 번째 변형에 대해 1 바이트를 찾았으므로 둘 다 동일한 길이를 갖습니다.

편집 II : @Zgarb는 저장할 두 번째 버전에서 2 바이트를 찾았고 첫 번째 버전에서 I 4를 찾았으므로 더 이상 같은 길이가 아닙니다.

ES6 (자바 스크립트) 79, 67, 65 바이트

최신 정보

• @ETHProductions에서 제안한대로 i = 2로 시작하여 2 바이트 빼기
• @Neil의 훌륭한 조언 덕분에 3 바이트가 절약되었습니다!

골프

S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"-/+*"[i%4]+a[i-1]))):a

테스트

S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"-/+*"[i%4]+a[i-1]))):a

>S(8,[1,3])
Array [ 1, 3, 4, 12, -8, -1.5, -9.5, 14.25 ]

>S(5,[0,1])
Array [ 0, 1, 1, 1, 0 ]

>S(9,[1,0])
Array [ 1, 0, 1, 0, 1, 0, 1, 0, 1 ]

>S(25,[6,3])
Array [ 6, 3, 9, 27, -18, -1.5, -19.5, 29.25, -48.75, -0.6, ...]

파이썬 3, 90 80 74 바이트

xnor는 아마도이 솔루션을 찾아서 파괴 할 것입니다 ...

def F(s,n,i=2):
 while i<n:s+=eval('%s'*3%(s[-2],'-/+*'[i%4],s[-1])),;i+=1

이 함수는 전달 된 목록을 수정합니다. 다음과 같이 사용하십시오.

s = [1,3] 
F(s,8)

repl.it 에보십시오!

구리 덕분에 -6 바이트

펄 6 ,  75 71  61 바이트

->\a,\b,\c{$_=[|(&[+],&[*],&[-],&[/])xx*];(a,b,{.shift.($^a,$^b)}...*)[^c]}

그것을 테스트

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

그것을 테스트

{($^a,$^b,{(&[+],&[*],&[-],&[/])[$++%4]($^a,$^b)}...*)[^$^c]}

그것을 테스트

넓히는:

{ # bare block lambda with placeholder parameters ｢$a｣ ｢$b｣ ｢$c｣

  # generate sequence
  (
    # initialize sequence
    $^a, # declare and use first argument
    $^b, # second argument

    {  # bare block lambda with two placeholder parameters ｢$a｣ ｢$b｣

      (

        &[+], &[*], &[-], &[/] # the four operators

      )[             # index into the list of operators

         $++        # increment (++) an anonymous state variable ($)
         % 4        # modulo 4

      ]( $^a, $^b ) # and use it on the previous two values in sequence

    }

    ...  # repeat that until

    *    # indefinitely

  )[     # take only

    ^    # upto and excluding:     ( Range object )
    $^c  # third argument

  ]
}

Mathematica, 68 바이트

(±1=#;±2=#2;±n_:=1##[#-#2,#/#2,+##][[n~Mod~4]]&[±(n-2),±(n-1)];±#3)&

간신히 3 위를 차지했습니다! 헬퍼 단항 연산자를 사용하여 세 개의 인자의 이름 기능 ±되도록 ±n정확하게 스튜 시퀀스의 n 번째 원소 X (N)이다. 처음 두 인수는 x (1)과 x (2)이며 세 번째 인수는 출력하는 x (N)을 나타내는 N입니다.

mod-4 계산을 사용하여 이전 두 항에 적용 할 이진 함수를 선택하는 직접 구현. 1##[#-#2,#/#2,+##]도움이 되는 올바른 이진 함수를 선택하면 이러한 재미있는 Mathematica 골프 트릭을 사용 합니다.

05AB1E , 21 19 18 바이트

입력은 N (0 기반), x (2) , x (1) 순서로 수행 됩니다. 카루소 컴퓨팅
덕분에 1 바이트 절약 .

GUDXsX"/+*-"Nè.V})

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

설명

 G                   # for N in [0 ... n-1] do:
  U                  # save top element of stack in X
   D                 # duplicate top of stack
    X                # push X
     s               # swap top 2 elements on stack
      X              # push X
       "/+*-"Nè      # index into the string with the current iteration number
               .V    # evaluate
                 }   # end loop
                  )  # wrap stack in list

이전의 모든 요소를 ​​순서대로 유지하면서 시퀀스의 최신 요소를 사용하여 스택을 반복적으로 빌드합니다.
그런 다음 스택을 마지막에 목록으로 묶어 모든 값을 한 번에 표시합니다.

커먼 리스프, 158

(lambda(x y n)(loop repeat n for a = x then b for b = y then r for o in '#1=(+ * - / . #1#)for r =(ignore-errors(funcall o a b))collect(coerce a'long-float)))

실제로 경쟁적이지는 않지만 나는 그것이 자연스럽게 표현되는 방식을 좋아합니다.

(lambda (x y n)
  (loop 
    repeat n
    for a = x then b
    for b = y then r
    for o in '#1=(+ * - / . #1#)
    for r = (ignore-errors (funcall o a b))
    collect (coerce a 'long-float)))

R을 계산할 때 오류를 무시하므로 R (및 B)은 NIL 값을 가질 수 있습니다. 다음 값이 정의되지 않은 경우에도 현재 결과를 출력 할 수 있습니다. 그러면 결국 루프가 실패하지만 규칙 안에 있습니다.

테스트

함수의 이름을 지정하고 F예상 값이 테스트 된 값과 대략 같은지 확인합니다.

(loop
  for (args expected)
    in
  '(((1 3 8)
     (1 3 4 12 -8 -1.5 -9.5 14.25))

    ((0 1 5)
     (0 1 1 1 0))

    ((1 0 9)
     (1 0 1 0 1 0 1 0 1))

    ((6 3 25)
     (6 3 9 27 -18 -1.5 -19.5 29.25 -48.75 -0.6 -49.35 29.61 -78.96 -0.375 -79.335 29.7506 -109.086 -0.272727 -109.358 29.825 -139.183 -0.214286 -139.398 29.8709 -169.269)))

  for result = (apply #'f args)
  always (every (lambda (u v) (< (abs (- u v)) 0.001)) result expected))

=> T

근사 테스트의 이유는 계산 된 값이 필요한 것보다 약간 더 정확하기 때문입니다. 여기에 (f 6 3 25):

(6.0d0 3.0d0 9.0d0 27.0d0 -18.0d0 -1.5d0 -19.5d0 29.25d0 -48.75d0 -0.6d0
 -49.35d0 29.61d0 -78.96d0 -0.375d0 -79.335d0 29.750625d0 -109.085625d0
 -0.2727272727272727d0 -109.35835227272727d0 29.825005165289255d0
 -139.18335743801654d0 -0.21428571428571427d0 -139.39764315230224d0
 29.870923532636194d0 -169.26856668493843d0)

DC, 112 (110) 108 바이트

5k?sarfsmsn[pSnla1-Sa]sh[lmlndSm]sv[lvx/lhx]sb[lvx+lhx]sc[lvx*lhx]sd[lvx-lhx]se[lcx2la>d2la>e2la>b2la>j]dsjx

때로는 dc답변이 너무 길고 때로는 너무 짧을 수도 있습니다. 그것은 다른 많은 언어들과 마찬가지로 당면한 문제에 달려 있습니다. 어쨌든, 이것은 공백으로 분리 된 3 개의 정수로 된 명령 행 입력을 요구합니다.x(1), x(2), N 호출시 하고 소수점 이하 5 자리를 포함하는 정수가 아닌 출력으로 시퀀스의 각 요소를 별도의 줄에 출력합니다.

예를 들어, 입력 6 3 25결과는 다음과 같습니다.

6
3
9
27
-18
-1.50000
-19.50000
29.25000
-48.75000
-.60000
-49.35000
29.61000
-78.96000
-.37500
-79.33500
29.75062
-109.08562
-.27272
-109.35834
29.82420
-139.18254
-.21428
-139.39682
29.86995
-169.26677

펄, 62 + 3 (-pla 플래그) = 65 바이트

push@F,eval$F[-2].qw(* - / +)[$_%4].$F[-1]for 3..pop@F;$_="@F"

사용 :

perl -plae 'push@F,eval$F[-2].qw(* - / +)[$_%4].$F[-1]for 3..pop@F;$_="@F"' <<< '1 3 8'

루비, 79 바이트

->(b,c,d){a=[b,c];(d-2).times{|i|a<<a[i].send(%i{+ * - /}[i%4],a[i+1]).to_f};a}

나는 이것이 최적에서 멀리 떨어져 있다고 생각하지만 (아직 다른 대답을 보지 않았다) 그럼에도 불구하고 재미있다.

나는 약간의 재미를 갖고 싶었지만 Enumerable#cycle슬프게도 그냥 사용할 수있는 4자가 적습니다 %4.

C ++ 14, 118 바이트

[](auto&v,int N){for(int i=0;++i<N-1;){auto p=v.rbegin(),q=p+1;v.push_back(i%4?i%4<2?*q+*p:i%4<3?*q**p:*q-*p:*q/ *p);}

이름을 바꾸지 않은 람다는 입력을 수정합니다. 필요가 v될 수있는 vector<double>나vector<float> .

언 골프 및 사용법 :

#include<iostream>
#include<vector>

auto f=
[](auto&v,int N){
  for(int i=0; ++i<N-1;){
    auto p=v.rbegin(),q=p+1;
    v.push_back(
      i%4 ?
        i%4<2 ? *q+*p : 
          i%4<3 ? *q**p : *q-*p
      : *q/ *p
    );
  }
};

int main(){
  std::vector<double> v={1,3};
  f(v,8);
  for (auto x:v) std::cout << x << ", ";
  std::cout << "\n";
}

x86-64 기계 코드, 34 바이트

호출 규칙 = x86-64 System V x32 ABI (긴 모드에서 32 비트 포인터로 인수 등록).

함수 서명은입니다 void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. 이 함수는 배열의 처음 두 요소에서 x0 및 x1 시드 값을 수신하고 시퀀스를 N 개 이상의 요소로 확장합니다. 버퍼는 2 + N 반올림에서 다음 배수로 채워 져야합니다. (즉2 + ((N+3)&~3) , N + 5).

패딩 된 버퍼를 요구하는 것은 고성능 또는 SIMD 벡터화 기능을위한 어셈블리에서 일반적이며이 언롤 된 루프는 비슷하기 때문에 규칙을 너무 세게 구부리고 있다고 생각하지 않습니다. 호출자는 모든 패딩 요소를 쉽게 무시할 수 있습니다.

아직 버퍼에없는 함수 arg로 x0과 x1을 전달하면 3 바이트 만 소요됩니다 ( movlps [rdi], xmm0또는movups [rdi], xmm0struct{ float x,y; }; 가 두 개의 개별 XMM 레지스터를 통과하므로 비표준 호출 규칙이 되더라도 )의 .

이다 objdump -drw -Mintel주석을 추가하는 포맷의 비트와 함께 출력

0000000000000100 <stewie_x87_1reg>:
       ;; load inside the loop to match FSTP at the end of every iteration
       ;; x[i-1] is always in ST0
       ;; x[i-2] is re-loaded from memory
 100:   d9 47 04                fld    DWORD PTR [rdi+0x4]
 103:   d8 07                   fadd   DWORD PTR [rdi]
 105:   d9 57 08                fst    DWORD PTR [rdi+0x8]
 108:   83 c7 10                add    edi,0x10            ; 32-bit pointers save a REX prefix here

 10b:   d8 4f f4                fmul   DWORD PTR [rdi-0xc]
 10e:   d9 57 fc                fst    DWORD PTR [rdi-0x4]

 111:   d8 6f f8                fsubr  DWORD PTR [rdi-0x8]
 114:   d9 17                   fst    DWORD PTR [rdi]

 116:   d8 7f fc                fdivr  DWORD PTR [rdi-0x4]
 119:   d9 5f 04                fstp   DWORD PTR [rdi+0x4]

 11c:   83 ee 04                sub    esi,0x4
 11f:   7f df                   jg     100 <stewie_x87_1reg>
 121:   c3                      ret    

0000000000000122 <stewie_x87_1reg.end>:
## 0x22 = 34 bytes

이 C 참조 구현은 (와 함께 gcc -Os) 다소 유사한 코드로 컴파일합니다 . gcc는 레지스터에 이전 값 하나만 유지하는 것과 동일한 전략을 선택합니다.

void stewie_ref(float *seq, unsigned Nterms)
{
    for(unsigned i = 2 ; i<Nterms ; ) {
        seq[i] = seq[i-2] + seq[i-1];       i++;
        seq[i] = seq[i-2] * seq[i-1];       i++;
        seq[i] = seq[i-2] - seq[i-1];       i++;
        seq[i] = seq[i-2] / seq[i-1];       i++;
    }
}

다음과 같은 코드가있는 2 레지스터 x87 버전을 포함하여 다른 방법으로 실험했습니다.

; part of loop body from untested 2-register version.  faster but slightly larger :/
; x87 FPU register stack    ;       x1, x2   (1-based notation)
fadd    st0, st1            ; x87 = x3, x2
fst     dword [rdi+8 - 16]  ; x87 = x3, x2

fmul    st1, st0            ; x87 = x3, x4
fld     st1                 ; x87 = x4, x3, x4
fstp    dword [rdi+12 - 16] ; x87 = x3, x4
; and similar for the fsubr and fdivr, needing one fld st1

속도가 빠르면 (SSE를 사용할 수 없다면)이 방법을 사용하십시오

sub와 div 결과를 순서대로 저장할 수는 있지만 엔트리에 스택을 설정하려면 두 개의 FLD 명령어가 필요하기 때문에 한 번에 입력하지 않고 루프 내에서 메모리에서로드를 넣는 것이 도움이 될 수 있습니다.

또한 SSE / AVX 스칼라 수학 (xmm0 및 xmm1의 값으로 시작)을 사용해 보았지만 더 큰 명령 크기는 킬러입니다. 사용하면 addps(즉,의보다 짧은 1B 때문에 addss) 조금의 도움이됩니다. VSUBSS는 SUBPS보다 1 바이트 길고 (SUBSS와 길이는 같기 때문에) 비 환산 명령어에 AVX VEX- 접두사를 사용했습니다.

; untested.  Bigger than x87 version, and can spuriously raise FP exceptions from garbage in high elements
addps   xmm0, xmm1      ; x3
movups  [rdi+8 - 16], xmm0
mulps   xmm1, xmm0      ; xmm1 = x4,  xmm0 = x3
movups  [rdi+12 - 16], xmm1
vsubss  xmm0, xmm1, xmm0      ; not commutative.  Could use a value from memory
movups  [rdi+16 - 16], xmm0
vdivss  xmm1, xmm0, xmm1      ; not commutative
movups  [rdi+20 - 16], xmm1

이 테스트 하네스로 테스트했습니다.

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

int main(int argc, char**argv)
{
    unsigned seqlen = 100;
    if (argc>1)
        seqlen = atoi(argv[1]);
    float first = 1.0f, second = 2.1f;
    if (argc>2)
        first = atof(argv[2]);
    if (argc>3)
        second = atof(argv[3]);

    float *seqbuf = malloc(seqlen+8);  // not on the stack, needs to be in the low32
    seqbuf[0] = first;
    seqbuf[1] = second;

    for(unsigned i=seqlen ; i<seqlen+8; ++i)
        seqbuf[i] = NAN;

    stewie_x87_1reg(seqbuf, seqlen);
//  stewie_ref(seqbuf, seqlen);
    for (unsigned i=0 ; i< (2 + ((seqlen+3)&~3) + 4) ; i++) {
        printf("%4d: %g\n", i, seqbuf[i]);
    }

    return 0;
}

와 컴파일 nasm -felfx32 -Worphan-labels -gdwarf2 golf-stewie-sequence.asm &&
gcc -mx32 -o stewie -Og -g golf-stewie-sequence.c golf-stewie-sequence.o

첫 번째 테스트 사례를 실행하여 ./stewie 8 1 3

x32 라이브러리가 설치되어 있지 않은 경우 nasm -felf64gcc를 사용하고 기본값을 사용하여 그대로 두십시오 -m64. 실제로 x32로 빌드하지 않고도 낮은 주소를 얻기 위해 (스택에서) malloc대신 사용 했습니다 float seqbuf[seqlen+8].

재미있는 사실 : YASM에는 버그가 있습니다. 분기 대상이 전역 심볼과 동일한 주소를 가질 때 루프 분기에 rel32 jcc를 사용합니다.

global stewie_x87_1reg
stewie_x87_1reg:
   ;; ended up moving all prologue code into the loop, so there's nothing here
.loop:

...
sub    esi, 4
jg     .loop

에 조립 ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 바이트

λ£"-/+*"Nè.V

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

Japt , 20 바이트

@OxVs2n)q"-/+*"gY}hV

시도 해봐

배쉬, 224 바이트 (NO CONTEST)

BASH 에서 엄청나게 큰 구현입니다 .

문자 그대로 작업을 수행하고 부실하게 제어 흐름 구조 또는 재귀없이 하나의 연속 파이프에서 모든 작업을 수행합니다.

입력

$ 1, $ 2-초기 요소

$ 3-대상 시퀀스 크기

골프

{ echo "a[0]=$1;a[1]=$2;a[0];a[1]";paste <() <(seq 2 $[$3-1]) <(seq 0 $[$3-3]) <(printf '%.0s+*-/' `seq $[$3/4]`|fold -1|head -$[$3-2]) <(seq 1 $[$3-2]);}|sed -r '1 ! s/(.+)\s(.+)\s(.+)\s(.)/a[\1]=a[\2]\3a[\4];a[\1];/'|bc -l

덜 골프

{ 
 echo "a[0]=$1;a[1]=$2;a[0];a[1]";
 paste <() <(seq 2 $[$3-1]) <(seq 0 $[$3-3]) <(printf '%.0s+*-/' `seq $[$3/4]`|fold -1|head -$[$3-2]) <(seq 1 $[$3-2]);
}\
|sed -r '1 ! s/(.+)\s(.+)\s(.+)\s(.)/a[\1]=a[\2]\3a[\4];a[\1];/' \
|bc -l

테스트

>./stewie.sh 1 3 8
1
3
4
12
-8
-1.50000000000000000000
-9.50000000000000000000
14.25000000000000000000

파이프 라인 단계

각 출력 시퀀스 요소 (한 줄에 하나씩)에 대해 요소 색인 + op 테이블을 생성하십시오.

...
2   0   +   1
3   1   *   2
4   2   -   3
5   3   /   4
6   4   +   5
7   5   *   6
...

sed 를 사용 하여 이것을 선형 bc 프로그램 으로 변환하십시오 .

...
a[2]=a[0]+a[1];a[2];
a[3]=a[1]*a[2];a[3];
a[4]=a[2]-a[3];a[4];
a[5]=a[3]/a[4];a[5];
a[6]=a[4]+a[5];a[6];
a[7]=a[5]*a[6];a[7];
...

이것을 BC에 먹이고 모든 일을하게하십시오.

Pyth-20 바이트

모든 것을 출력하는 n데 비용이 듭니다.

u+Gvj@"+*-/"H>2GttEQ

eval의 온라인 퀴즈가 작동하지 않습니다.

실론, 195 바이트

Float[]s(Integer a,Integer b,Integer n)=>loop([a.float,b.float,[Float.divided,Float.plus,Float.times,Float.minus].cycled.rest])(([x,y,o])=>[y,(o.first else nothing)(x)(y),o.rest]).take(n)*.first;

형식화 및 의견 :

// Print the first n entries of the Stewies sequence with given starting entries.
//
// Question:  http://codegolf.stackexchange.com/q/101145/2338
// My answer: http://codegolf.stackexchange.com/a/101251/2338

// Declare a function `s` which takes three integers, and returns a tuple
// of floats. (The more common syntax for the return value is [Float*],
// but Float[] is shorter.)
Float[] s(Integer a, Integer b, Integer n)
       // it is implemented by evaluating the following expression for each call.
         =>
        // start a loop with ...
        loop([
              // ... float versions of the integers, and ...
              a.float, b.float,
              // ... an infinite sequence of the four operators, ever repeating.
              // I needed the `.rest` here so the whole thing gets a {...*} type
              // instead of {...+}, which doesn't fit to what o.rest returns.
              // Each operator has the type Float(Float)(Float), i.e. you apply
              // it twice to one float each to get a Float result.
              [Float.divided, Float.plus, Float.times, Float.minus].cycled.rest])
               // in each iteration of the loop, map the triple of two numbers
               // and a sequence of operators to a triple of ... 
            (([x, y, o]) => [
               // the second number, 
                y,
               //the result of the first operator with both numbers
               // (using this "else nothing" here to convince the
               //  compiler that o.first is not null),
                   (o.first else nothing)(x)(y),
               // and the sequence of operators without its first element.
               // (that one unfortunately has a {...*} type, i.e. a possibly
               //  empty sequence.)
                                                 o.rest])
            // now we got an infinite sequence of those triples.
            // We just want the first n of them ...
                .take(n)
            // and of each triple just the first element.
            // (The *. syntax produces a tuple, non-lazily.
            //  We could also have used .map((z) => z.first)
            //  or .map(Iterable.first) or .map((z) => z[0]), each of
            //  which would return a (lazy) sequence, but they all would be
            //  longer.)
                *.first;

사용법 예 :

shared void run() {
    print(s(1, 3, 8));
    print(s(0,1,11));
    print(s(1,0,9));
    print(s(6, 3, 29));
}

출력 예 :

[1.0, 3.0, 4.0, 12.0, -8.0, -1.5, -9.5, 14.25]
[0.0, 1.0, 1.0, 1.0, 0.0, Infinity, Infinity, Infinity, NaN, NaN, NaN]
[1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]
[6.0, 3.0, 9.0, 27.0, -18.0, -1.5, -19.5, 29.25, -48.75, -0.6, -49.35, 29.61, -78.96000000000001, -0.37499999999999994, -79.33500000000001, 29.750625, -109.08562500000001, -0.2727272727272727, -109.35835227272727, 29.825005165289255, -139.18335743801651, -0.2142857142857143, -139.39764315230224, 29.870923532636194, -169.26856668493843, -0.17647058823529413, -169.44503727317374, 29.90206540114831, -199.34710267432206]

두 번째 예는 이것이 0으로 나누는 방법을 보여줍니다. 마지막 예는 어떤 종류의 산술 (및 반올림)이 사용 중인지에 따라 결과가 약간 벗어난다는 것을 보여줍니다 ... 실론의 64 비트 부동 소수점 산술은 질문에 게시 된 것보다 조금 더 가깝다고 생각합니다 .

클로저, 99 바이트

#(let[ops[+ * - /]](take %3(map first(iterate(fn[[a b i]][b((ops i)a b)(mod(inc i)4)])[%1 %2 0]))))

이 버전은 실제로 사용하는 것이 좋지만 110 바이트입니다.

(defn f[a b n](let[ops[+ * - /]](take n(map first(iterate(fn[[a b i]][b((ops i)a b)(mod(inc i)4)])[a b 0])))))

반복되는 함수와 주기적 작업 시퀀스를 퍼지하는 데 어려움이 있었으므로 대신 카운터를 사용해야했습니다. 또한 다음과 같은 FSM 전이 테이블을 사용해 보았습니다.{+ * * - - / / +} 더 적은 코드로 압축 할 수 없었습니다.

익명 함수로 표현 될 수 있음

언 골프 :

(defn f [a b n]
  (let [ops [+ * - /]]
    (->> [a b 0]
         (iterate (fn [[a b i]]
                    [b
                     ((ops i) a b)
                     (mod (inc i) 4)]))
         (map first)
         (take n))))

(f 6.0 3.0 25)그렇지 않으면 합리적인 숫자를 얻는 것처럼 수레와 함께 호출해야합니다 . 또는 반복을 시작하여 [a (float b) 0]추가 문자를 가져올 수 있습니다 .

옥타브 , 91 바이트

@(x,n)eval 'for i=3:n,x(i)=eval([(n=@num2str)(x(i-2)),"*-/+"(mod(i,4)+1),n(x(i-1))]);end,x'

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

일부 골프 :

• 첫 번째 괄호 없음 eval 통화에
• 첫 번째 연결이 없습니다 eval 통화에
• 인라인 할당 *-/+ (MATLAB에서는 불가능)
• 결합 '및" 아포스트로피 (MATLAB에서 가능하지 않음) 탈출 방지하기 위해
• n=@num2str두 번 사용되므로 저장 (MATLAB에서는 불가능)