Chúng ta hãy sử dụng bốn phép toán cơ bản, cộng +, nhân *, trừ -và chia /(float, không phải số nguyên).

Trình tự của Stewie được định nghĩa như sau:

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.

Thử thách:

Lấy hai số nguyên không âm ( x(1), x(2)) và một số nguyên dương Nlàm đầu vào.

x(1)và x(2)sẽ là hai số đầu tiên của chuỗi của bạn và Nsẽ là độ dài của chuỗi bạn phải xuất. (Bạn có thể chọn để có danh sách dựa trên 0, trong trường hợp đó Nsẽ nhỏ hơn một chiều dài).

• Bạn không thể cho rằng x(2) >= x(1).
• Nsẽ luôn là >2nếu dựa trên 1, ( >1nếu dựa trên 0).
• Bạn không phải xử lý chia cho các lỗi không.
  • Lưu ý trường hợp thử nghiệm thứ 2. Bạn sẽ không nhận được 0, 1, và N=6là đầu vào, vì điều đó sẽ dẫn đến chia cho 0, nhưng bạn phải hỗ trợ 0, 1và N=5.
• Giả sử chỉ có đầu vào hợp lệ sẽ được đưa ra.
• Đầu vào và đầu ra có thể ở bất kỳ định dạng thuận tiện nào, nhưng bạn phải hỗ trợ ít nhất 3 chữ số sau các dấu thập phân nếu đầu ra không phải là số nguyên.

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

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 byte

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

Đầu vào có định dạng: N(dựa trên 0) x(1), x(2)(dưới dạng chuỗi); Tất cả cách nhau bởi dòng mới.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm (mã được sửa đổi một chút; các chuỗi đầu ra được phân tách bằng một dòng trống).

Giải trình

MATL không có evalchức năng phù hợp , nhưng U( str2num) có thể đánh giá các biểu thức số với các toán tử infix.

Mỗi thuật ngữ mới được tính toán và đẩy lên ngăn xếp, giữ nguyên các điều khoản trước đó. Toàn bộ ngăn xếp được in ở cuối.

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

Haskell, 69 68 64 byte

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

x1và x2được lấy làm danh sách. Ví dụ sử dụng: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Sự lười biếng làm cho nó có thể xác định một danh sách đệ quy vô hạn trong đó chúng ta lấy n phần tử đầu tiên.

Haskell, 66 byte

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

Cách tiếp cận khác nhau, hơi dài. Để lập luận là N, x2, x1. Ví dụ sử dụng: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Định nghĩa 4 chức năng a, b, cvà dtrong đó có hai đối số y, x và thực hiện một danh sách bằng cách đặt xtrước một cuộc gọi đến chức năng tiếp theo với ynhư là đối số thứ hai và x op ylà người đầu tiên. Ví dụ a:: a y x = x : (b (x+y) y), bphép nhân : b y x = x : (c (x*y) y), v.v.

Chỉnh sửa: @Michael Klein đã lưu một byte trong biến thể thứ 1 ( #). May mắn thay, tôi cũng tìm thấy một byte cho biến thể thứ hai, vì vậy cả hai đều có cùng độ dài một lần nữa.

Chỉnh sửa II: @Zgarb tìm thấy 2 byte trong phiên bản thứ hai để lưu và I 4 trong phiên bản đầu tiên, vì vậy chúng không còn có cùng độ dài.

ES6 (Javascript), 79, 67, 65 byte

CẬP NHẬT

• trừ 2 byte, bằng cách bắt đầu bằng i = 2, như được đề xuất bởi @ETH Productstions
• Đã lưu 3 byte, nhờ lời khuyên tuyệt vời từ @Neil!

Chơi gôn

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

Kiểm tra

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, ...]

Python 3, 90 80 74 byte

xnor có lẽ sẽ đến và phá hủy giải pháp này ...

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

Hàm sửa đổi danh sách được truyền cho nó. Sử dụng như thế này:

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

Hãy thử trên repl.it!

-6 byte nhờ Đồng

Perl 6 ,  75 71  61 byte

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

Kiểm tra nó

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

Kiểm tra nó

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

Kiểm tra nó

Mở rộng:

{ # 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

  ]
}

Toán học, 68 byte

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

Chỉ lẻn vào vị trí thứ 3! Hàm không tên của ba đối số, sử dụng toán tử unary helper ±sao cho ±nchính xác là phần tử thứ n x (n) của chuỗi Stewie. Hai đối số đầu tiên là x (1) và x (2) và đối số thứ ba là N chỉ ra x (N) mà chúng ta xuất ra.

Thực hiện trực tiếp, sử dụng phép tính mod-4 để chọn hàm nhị phân nào sẽ áp dụng cho hai thuật ngữ trước. Chọn chức năng nhị phân chính xác, đó là những gì 1##[#-#2,#/#2,+##]giúp với, sử dụng một vài trong số các thủ thuật chơi gôn Mathicala thú vị này .

05AB1E , 21 19 18 byte

Đầu vào được lấy theo thứ tự N (dựa trên 0), x (2) , x (1) .
Đã lưu 1 byte nhờ tính toán carusocomputing .

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

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

Giải trình

 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

Chúng tôi lặp đi lặp lại xây dựng ngăn xếp với phần tử mới nhất trong chuỗi trên cùng, trong khi giữ tất cả các phần tử trước đó theo thứ tự.
Sau đó, chúng tôi bọc ngăn xếp trong một danh sách ở cuối để hiển thị tất cả các giá trị cùng một lúc.

Lisp thông thường, 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)))

Không thực sự cạnh tranh, nhưng tôi thích cách nó được thể hiện khá tự nhiên:

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

Chúng tôi bỏ qua các lỗi khi tính toán R, điều này làm cho R (và sau đó B) có thể lấy giá trị NIL. Điều đó cho phép xuất kết quả hiện tại ngay cả khi giá trị tiếp theo không được xác định. Sau đó, cuối cùng vòng lặp sẽ thất bại, nhưng đó là trong các quy tắc.

Xét nghiệm

Chúng tôi đặt tên cho hàm Fvà xác minh rằng các giá trị dự kiến ​​xấp xỉ bằng giá trị được kiểm tra.

(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

Lý do cho phép thử gần đúng là vì các giá trị được tính toán chính xác hơn một chút so với yêu cầu; ở đây, cho (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 byte

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

Đôi khi dccâu trả lời có thể siêu dài, và đôi khi chúng có thể siêu ngắn. Tất cả chỉ phụ thuộc vào thử thách trong tầm tay như trường hợp của nhiều ngôn ngữ khác. Dù sao, điều này nhắc nhở đầu vào dòng lệnh một chỉ mục được phân tách bằng dấu cách của 3 số nguyên, x(1), x(2), Nkhi gọi và xuất từng phần tử của chuỗi trên các dòng riêng biệt với đầu ra không nguyên chứa 5 chữ số sau dấu thập phân.

Ví dụ: 6 3 25kết quả đầu vào trong đầu ra sau:

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

Perl, 62 + 3 ( -placờ) = 65 byte

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

Sử dụng:

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

Ruby, 79 byte

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

Tôi nghi ngờ điều này rất xa so với tối ưu (và tôi chưa nhìn vào các câu trả lời khác), nhưng dù sao nó cũng rất vui.

Tôi muốn có một số niềm vui với Enumerable#cycle, nhưng thật đáng buồn, đó là 4 nhân vật ít hơn để sử dụng %4.

C ++ 14, 118 byte

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

Như lambda không tên sửa đổi đầu vào của nó. Yêu cầu vphải là một vector<double>hoặcvector<float> .

Ungolfed và cách sử dụng:

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

mã máy x86-64, 34 byte

Quy ước gọi = x86-64 Hệ thống V x32 ABI (thanh ghi đối số với con trỏ 32 bit ở chế độ dài).

Chữ ký hàm là void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. Hàm nhận các giá trị hạt x0 và x1 trong hai phần tử đầu tiên của mảng và mở rộng chuỗi ra ít nhất N nhiều phần tử. Bộ đệm phải được đệm ra thành 2 + N-round-up-to-next-multi-of-4. (tức là 2 + ((N+3)&~3), hoặc chỉ N + 5).

Yêu cầu bộ đệm đệm là lắp ráp bình thường cho các chức năng có hiệu suất cao hoặc được SIMD hóa, và vòng lặp không được kiểm soát này là tương tự, vì vậy tôi không nghĩ rằng nó uốn cong quy tắc quá xa. Người gọi có thể dễ dàng (và nên) bỏ qua tất cả các yếu tố đệm.

Truyền x0 và x1 dưới dạng một hàm arg chưa có trong bộ đệm sẽ chỉ tiêu tốn của chúng tôi 3 byte (cho một movlps [rdi], xmm0hoặc movups [rdi], xmm0), mặc dù đây sẽ là một quy ước gọi không chuẩn vì System V truyền struct{ float x,y; };vào hai thanh ghi XMM riêng biệt.

Đây là objdump -drw -Mintelđầu ra với một chút định dạng để thêm ý kiến

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

Việc triển khai tham chiếu C này biên dịch (với gcc -Os) thành mã tương tự. gcc chọn chiến lược tương tự tôi đã làm, chỉ giữ một giá trị trước đó trong một thanh ghi.

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

Tôi đã thử nghiệm với các cách khác, bao gồm cả phiên bản x87 hai đăng ký có mã như:

; 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

Bạn sẽ làm theo cách này nếu bạn muốn tăng tốc (và SSE không có sẵn)

Đặt các tải từ bộ nhớ bên trong vòng lặp thay vì một lần vào mục nhập có thể có ích, vì chúng ta chỉ có thể lưu trữ các kết quả phụ và div không theo thứ tự, nhưng vẫn cần hai hướng dẫn FLD để thiết lập ngăn xếp khi nhập.

Tôi cũng đã thử sử dụng toán vô hướng SSE / AVX (bắt đầu bằng các giá trị trong xmm0 và xmm1), nhưng kích thước lệnh lớn hơn là sát thủ. Sử dụng addps(vì đó là 1B ngắn hơn addss) giúp một chút. Tôi đã sử dụng tiền tố AVX VEX cho các hướng dẫn không giao hoán, vì VSUBSS chỉ dài hơn một byte so với SUBPS (và có cùng độ dài với SUBSS).

; 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

Đã thử nghiệm với khai thác thử nghiệm này:

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

Biên dịch với nasm -felfx32 -Worphan-labels -gdwarf2 golf-stewie-sequence.asm &&
gcc -mx32 -o stewie -Og -g golf-stewie-sequence.c golf-stewie-sequence.o

Chạy trường hợp thử nghiệm đầu tiên với ./stewie 8 1 3

Nếu bạn chưa cài đặt thư viện x32, hãy sử dụng nasm -felf64và để lại gcc bằng mặc định -m64. Tôi đã sử dụng mallocthay vì float seqbuf[seqlen+8](trên ngăn xếp) để có được một địa chỉ thấp mà không phải thực sự xây dựng như x32.

Sự thật thú vị: YASM có một lỗi: nó sử dụng rel32 jcc cho nhánh vòng lặp, khi mục tiêu nhánh có cùng địa chỉ với ký hiệu toàn cục.

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

lắp ráp để ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 byte

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

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

Japt , 20 byte

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

Thử nó

Bash, 224 byte (KHÔNG CÓ CUỘC THI)

Một triển khai rất lớn trong BASH .

Thực hiện nhiệm vụ hoàn toàn theo nghĩa đen và thực hiện mọi thứ trong một đường ống liên tục, không có bất kỳ cấu trúc dòng điều khiển hoặc đệ quy không kiểm soát nào.

Đầu vào

$ 1, $ 2 - các yếu tố ban đầu

$ 3 - kích thước chuỗi mục tiêu

Chơi gôn

{ 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

Ít chơi gôn

{ 
 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

Kiểm tra

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

Giai đoạn đường ống

Tạo bảng chỉ số phần tử + op, cho mỗi phần tử chuỗi đầu ra (mỗi phần tử trên một dòng):

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

Sử dụng sed để chuyển đổi nó thành một chương trình bc tuyến tính :

...
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];
...

đưa cái này cho bc và để nó làm tất cả công việc

Pyth - 20 byte

Xuất tất cả nchi phí cho tôi.

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

Không làm việc trực tuyến vì eval.

Ceylon, 195 byte

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;

Định dạng và nhận xét:

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

Ví dụ sử dụng:

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

Ví dụ đầu ra:

[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]

Ví dụ thứ hai cho thấy làm thế nào điều này sẽ xử lý chia cho số không. Ví dụ cuối cùng cho thấy các kết quả sai lệch một chút tùy thuộc vào loại số học (và làm tròn) mà người ta đang sử dụng ... Tôi nghĩ rằng số học dấu phẩy động 64 bit của Ceylon gần hơn một chút so với những gì được đăng trong câu hỏi .

Clojure, 99 byte

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

Phiên bản này đẹp hơn để sử dụng trong thực tế nhưng có 110 byte:

(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])))))

Tôi đã gặp sự cố khi thực hiện chức năng lặp và một chuỗi hoạt động theo chu kỳ nên tôi phải sử dụng bộ đếm thay thế. Cũng đã thử sử dụng bảng chuyển đổi FSM như{+ * * - - / / +} nhưng tôi không thể ép nó thành ít mã hơn.

Có thể được biểu thị như một hàm ẩn danh

Chưa chơi gôn:

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

Phải được gọi với số float như (f 6.0 3.0 25)nếu không bạn nhận được số hữu tỷ. Ngoài ra, việc lặp lại có thể được bắt đầu từ [a (float b) 0]đó mang lại một số ký tự phụ.

Octave , 91 byte

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

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

Một số sân gôn:

• Không có dấu ngoặc đơn cho lần đầu tiên eval cuộc gọi
• Không có kết nối cho lần đầu tiên eval cuộc gọi
• Phân công nội tuyến của *-/+ (không thể có trong MATLAB)
• Kết hợp 'và" để tránh thoát các dấu nháy đơn (không thể có trong MATLAB)
• Lưu trữ n=@num2strvì nó được sử dụng hai lần (không thể có trong MATLAB)