Mari kita gunakan empat operasi dasar, penambahan +, perkalian *, pengurangan -dan pembagian /(float, not integer).

Urutan Stewie didefinisikan sebagai berikut:

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.

Tantangan:

Ambil dua bilangan bulat non-negatif ( x(1), x(2)), dan satu bilangan bulat positif Nsebagai input.

x(1)dan x(2)akan menjadi dua angka pertama dari urutan Anda, dan Nakan menjadi panjang urutan yang harus Anda keluarkan. (Anda dapat memilih untuk memiliki daftar berbasis 0, dalam hal ini Nakan menjadi kurang dari panjang daftar).

• Anda tidak dapat menganggap itu x(2) >= x(1).
• Nakan selalu menjadi >2jika berbasis 1, ( >1jika berbasis 0).
• Anda tidak harus menangani pembagian dengan kesalahan nol.
  • Catat test case ke-2. Anda tidak akan mendapatkan 0, 1, dan N=6sebagai masukan, karena itu akan menghasilkan pembagian dengan nol, tetapi Anda harus mendukung 0, 1dan N=5.
• Asumsikan hanya input yang valid yang akan diberikan.
• Input dan output dapat dalam format apa pun yang nyaman, tetapi Anda harus mendukung setidaknya 3 digit setelah titik desimal jika outputnya bukan bilangan bulat.

Kasus uji:

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

Input dalam format: N(berbasis 0) x(1),, x(2)(sebagai string); semua dipisahkan oleh baris baru.

Cobalah online! Atau verifikasi semua kasus uji (kode yang sedikit dimodifikasi; urutan keluaran dipisahkan oleh baris kosong).

Penjelasan

MATL tidak memiliki evalfungsi yang tepat , tetapi U( str2num) dapat mengevaluasi ekspresi numerik dengan operator infiks.

Setiap istilah baru dihitung dan didorong ke tumpukan, menjaga ketentuan sebelumnya. Seluruh tumpukan dicetak di bagian akhir.

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)

x1dan x2diambil sebagai daftar. Contoh penggunaan: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Kemalasan memungkinkan untuk mendefinisikan daftar rekursif yang tak terbatas di mana kita mengambil elemen n pertama.

Haskell, 66 byte

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

Pendekatan berbeda, sedikit lebih lama. Agar argumen adalah N, x2, x1. Contoh penggunaan: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Mendefinisikan 4 fungsi a, b, cdan dyang mengambil dua argumen y, x dan membuat daftar dengan menempatkan xdi depan sebuah panggilan ke fungsi berikutnya dengan ysebagai argumen kedua dan x op ysebagai yang pertama. Sebagai contoh aadalah: a y x = x : (b (x+y) y), bapakah perkalian: b y x = x : (c (x*y) y), dll

Sunting: @Michael Klein menyimpan byte dalam varian pertama ( #). Untungnya saya juga menemukan satu byte untuk varian kedua, sehingga keduanya memiliki panjang yang sama lagi.

Sunting II: @Zgarb menemukan 2 byte di versi kedua untuk disimpan, dan I 4 di pertama, sehingga tidak lagi sama panjangnya.

ES6 (Javascript), 79, 67, 65 byte

MEMPERBARUI

• minus 2 byte, dengan memulai dengan i = 2, seperti yang disarankan oleh @ETHProductions
• Disimpan 3 byte, berkat saran luar biasa dari @Neil!

Golf

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

Uji

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 mungkin akan datang dan menghancurkan solusi ini ...

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

Fungsi memodifikasi daftar yang diteruskan ke sana. Gunakan seperti ini:

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

Coba di repl.it!

-6 byte berkat Tembaga

Perl 6 ,  75 71  61 byte

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

Menguji

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

Menguji

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

Menguji

Diperluas:

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

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

Nyaris menyelinap ke posisi ke-3! Fungsi tiga argumen yang tidak disebutkan namanya, yang menggunakan operator unary helper ±sedemikian rupa sehingga ±npersis elemen ke-n x (n) dari urutan Stewie. Dua argumen pertama adalah x (1) dan x (2), dan argumen ketiga adalah N yang menunjukkan x (N) yang kita hasilkan.

Implementasi langsung, menggunakan perhitungan mod-4 untuk memilih fungsi biner mana yang akan diterapkan pada dua istilah sebelumnya. Memilih fungsi biner yang benar, yang 1##[#-#2,#/#2,+##]membantu, menggunakan beberapa trik golf Mathematica yang menyenangkan ini .

05AB1E , 21 19 18 byte

Input diambil dalam urutan N (berbasis-0), x (2) , x (1) .
Disimpan 1 byte berkat carusocomputing .

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

Cobalah online!

Penjelasan

 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

Kami membangun tumpukan berulang dengan elemen terbaru dalam urutan di atas, sambil menjaga semua elemen sebelumnya dalam urutan.
Kemudian kami membungkus tumpukan dalam daftar di bagian akhir untuk menampilkan semua nilai sekaligus.

Common Lisp, 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)))

Tidak benar-benar kompetitif, tetapi saya suka bagaimana ini diungkapkan secara alami:

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

Kami mengabaikan kesalahan saat menghitung R, yang membuat R (dan kemudian B) mungkin mengambil nilai NIL. Itu memungkinkan untuk menampilkan hasil saat ini bahkan jika nilai berikutnya tidak ditentukan. Kemudian, pada akhirnya loop akan gagal, tetapi itu ada dalam aturan.

Tes

Kami memberi nama fungsi Fdan memverifikasi bahwa nilai yang diharapkan kira-kira sama dengan yang diuji.

(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

Alasan untuk pengujian perkiraan adalah karena nilai yang dihitung sedikit lebih tepat dari yang dibutuhkan; di sini, untuk (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

Terkadang dcjawaban bisa sangat panjang, dan kadang-kadang bisa sangat pendek. Itu semua hanya tergantung pada tantangan yang dihadapi seperti halnya dengan banyak bahasa lainnya. Bagaimanapun, ini meminta input baris perintah yang diindeks satu ruang yang dipisahkan dari 3 bilangan bulat,, x(1), x(2), Npada saat doa, dan mengeluarkan setiap elemen dari urutan pada baris yang terpisah dengan output non-bilangan bulat yang mengandung 5 digit setelah titik desimal.

Misalnya, input 6 3 25menghasilkan output berikut:

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 ( -plabendera) = 65 byte

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

Menggunakan:

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}

Saya menduga ini sangat jauh dari optimal (dan saya belum melihat jawaban yang lain), tetapi tetap menyenangkan.

Saya ingin bersenang-senang dengan Enumerable#cycle, tapi sayangnya, ini hanya 4 karakter yang lebih sedikit untuk digunakan %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);}

Sebagai lambda tanpa nama memodifikasi inputnya. Harus vmenjadi vector<double>atau vector<float>.

Tidak digabungkan dan digunakan:

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

kode mesin x86-64, 34 byte

Konvensi Memanggil = x86-64 Sistem V x32 ABI (register args dengan pointer 32-bit dalam mode panjang).

Tanda tangan fungsi adalah void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. Fungsi menerima nilai-nilai seed x0 dan x1 dalam dua elemen pertama array, dan memperluas urutan ke setidaknya N elemen lebih banyak. Buffer harus diisi hingga 2 + N-dibulatkan ke atas-ke-kelipatan-4. (Yaitu 2 + ((N+3)&~3), atau hanya N + 5).

Membutuhkan buffer berlapis adalah normal dalam perakitan untuk kinerja tinggi atau fungsi vektor-SIMD, dan loop terbuka ini serupa, jadi saya tidak berpikir itu menekuk aturan terlalu jauh. Penelepon dapat dengan mudah (dan harus) mengabaikan semua elemen padding.

Melewati x0 dan x1 sebagai fungsi arg yang belum ada di buffer akan menghabiskan biaya hanya 3 byte (untuk a movlps [rdi], xmm0atau movups [rdi], xmm0), meskipun ini akan menjadi konvensi panggilan non-standar karena Sistem V melewati struct{ float x,y; };dua register XMM yang terpisah.

Ini adalah objdump -drw -Minteloutput dengan sedikit pemformatan untuk menambahkan komentar

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

Implementasi referensi C ini mengkompilasi (dengan gcc -Os) ke kode yang agak mirip. gcc memilih strategi yang sama dengan yang saya lakukan, yaitu hanya menyimpan satu nilai sebelumnya dalam register.

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

Saya melakukan percobaan dengan cara lain, termasuk versi x87 dua register yang memiliki kode seperti:

; 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

Anda akan melakukannya dengan cara ini jika Anda ingin kecepatan (dan SSE tidak tersedia)

Menempatkan beban dari memori di dalam loop alih-alih sekali pada entri mungkin bisa membantu, karena kita bisa saja menyimpan hasil sub dan div rusak, tetapi masih membutuhkan dua instruksi FLD untuk mengatur stack pada entri.

Saya juga mencoba menggunakan skalar matematika SSE / AVX (dimulai dengan nilai dalam xmm0 dan xmm1), tetapi ukuran instruksi yang lebih besar adalah pembunuh. Menggunakan addps(karena itu 1B lebih pendek dari addss) membantu sedikit. Saya menggunakan AVX VEX-awalan untuk instruksi non-komutatif, karena VSUBSS hanya satu byte lebih panjang dari SUBPS (dan panjang yang sama dengan 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

Diuji dengan test-harness ini:

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

Kompilasi dengan nasm -felfx32 -Worphan-labels -gdwarf2 golf-stewie-sequence.asm &&
gcc -mx32 -o stewie -Og -g golf-stewie-sequence.c golf-stewie-sequence.o

Jalankan test-case pertama dengan ./stewie 8 1 3

Jika Anda tidak menginstal pustaka x32, gunakan nasm -felf64dan biarkan gcc menggunakan default -m64. Saya menggunakan mallocalih-alih float seqbuf[seqlen+8](pada stack) untuk mendapatkan alamat rendah tanpa harus benar-benar membangun sebagai x32.

Fakta menyenangkan: YASM memiliki bug: ia menggunakan rel32 jcc untuk cabang loop, ketika target cabang memiliki alamat yang sama dengan simbol global.

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

berkumpul untuk ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 byte

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

Cobalah online!

Japt , 20 byte

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

Cobalah

Bash, 224 byte (TANPA KONTES)

Implementasi yang sangat besar di BASH .

Mengambil tugas secara harfiah, dan melakukan segalanya dalam satu pipa kontinu, tanpa struktur aliran kontrol atau rekursi yang tidak suci.

Memasukkan

$ 1, $ 2 - elemen awal

$ 3 - ukuran urutan target

Golf

{ 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

Kurang Golf

{ 
 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

Uji

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

Tahapan Pipa

Hasilkan tabel indeks elemen + op, untuk setiap elemen urutan output (satu per baris):

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

Gunakan sed untuk mengonversikan ini menjadi program linear 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];
...

beri makan ini ke bc dan biarkan ia melakukan semua pekerjaan

Pyth - 20 byte

Mengeluarkan semua nbiaya saya.

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

Tidak bekerja secara online karena 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;

Diformat dan dikomentari:

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

Contoh penggunaan:

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

Contoh output:

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

Contoh kedua menunjukkan bagaimana ini akan menangani pembagian dengan nol. Contoh terakhir menunjukkan bahwa hasil sedikit menyimpang tergantung pada jenis aritmatika (dan pembulatan) yang digunakan ... Saya pikir aritmatika floating point Ceylon 64 bit sedikit lebih dekat dengan apa yang seharusnya daripada apa yang diposting dalam pertanyaan. .

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

Versi ini lebih baik untuk digunakan dalam praktik tetapi memiliki 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])))))

Saya mengalami kesulitan mengacaukan fungsi yang berulang dan urutan operasi yang berulang sehingga saya harus menggunakan penghitung. Juga mencoba menggunakan tabel transisi FSM seperti {+ * * - - / / +}tetapi saya tidak bisa memerasnya ke kode yang lebih sedikit.

Dapat diekspresikan sebagai fungsi anonim

Tidak golf:

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

Harus dipanggil dengan pelampung seperti (f 6.0 3.0 25)jika Anda mendapatkan nomor rasional keluar. Atau, iterasi dapat dimulai dari [a (float b) 0]yang membawa beberapa karakter tambahan.

Oktaf , 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'

Cobalah online!

Beberapa golf:

• Tidak ada tanda kurung untuk evalpanggilan pertama
• Tidak ada rangkaian untuk evalpanggilan pertama
• Penugasan sebaris *-/+(tidak dimungkinkan dalam MATLAB)
• Dikombinasikan 'dan "untuk menghindari lolosnya tanda kutip (tidak mungkin di MATLAB)
• Menyimpan n=@num2strkarena digunakan dua kali (tidak mungkin di MATLAB)