Verwenden wir die vier Grundoperationen Addition +, Multiplikation *, Subtraktion -und Division /(float, nicht integer).

Stewies Sequenz ist wie folgt definiert:

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.

Herausforderung:

Nehmen Sie zwei nicht negative ganze Zahlen ( x(1), x(2)) und eine positive ganze Zahl Nals Eingabe.

x(1)und x(2)sind die beiden ersten Nummern Ihrer Sequenz und Ndie Länge der Sequenz, die Sie ausgeben müssen. (Sie können wählen, ob die Liste 0-basiert sein soll. In diesem Fall ist die Liste Num eins kürzer als die Länge).

• Das kann man nicht annehmen x(2) >= x(1).
• Nwird immer >21-basiert sein ( >1wenn 0-basiert).
• Sie müssen keine Division durch Null-Fehler verarbeiten.
  • Beachten Sie den 2. Testfall. Sie werden nicht 0, 1und N=6als Eingabe erhalten, da dies zu einer Division durch Null führt, aber Sie müssen 0, 1und unterstützen N=5.
• Angenommen, es wird nur eine gültige Eingabe gegeben.
• Die Eingabe und Ausgabe kann in einem beliebigen Format erfolgen, Sie müssen jedoch mindestens 3 Nachkommastellen unterstützen, wenn die Ausgabe nicht ganzzahlig ist.

Testfälle:

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 Bytes

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

Die Eingabe ist in dem Format: N(0-basiert), x(1), x(2)(als Zeichenkette); Alle durch Zeilenumbrüche getrennt.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle (leicht modifizierter Code; Ausgabesequenzen durch eine Leerzeile getrennt).

Erläuterung

MATL hat keine ordnungsgemäße evalFunktion, aber U( str2num) kann numerische Ausdrücke mit Infix-Operatoren auswerten.

Jeder neue Begriff wird berechnet und auf den Stapel verschoben, wobei die vorherigen Begriffe beibehalten werden. Der gesamte Stapel wird am Ende gedruckt.

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 Bytes

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

x1und x2werden als Liste genommen. Anwendungsbeispiel: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Durch Faulheit ist es möglich, eine unendliche rekursive Liste zu definieren, in der die ersten n Elemente verwendet werden.

Haskell, 66 Bytes

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

Anderer Ansatz, etwas länger. Argument Ordnung ist N, x2, x1. Anwendungsbeispiel: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Definiert 4 Funktionen a, b, cund ddie zwei Argumentey , x und um eine Liste zu machen , indem sie xvor einem Anruf an die nächste Funktion mit yals zweites Argument und x op ywie die erste. Zum Beispiel aist: a y x = x : (b (x+y) y), btut Multiplikation: b y x = x : (c (x*y) y)etc.

Edit: @Michael Klein hat in der 1. Variante ( #) ein Byte gespeichert . Zum Glück habe ich auch ein Byte für die zweite Variante gefunden, also haben beide wieder die gleiche Länge.

Edit II: @Zgarb hat 2 Bytes in der zweiten Version zum Speichern gefunden und I 4 in der ersten, sodass sie nicht mehr die gleiche Länge haben.

ES6 (Javascript), 79, 6765 Bytes

AKTUALISIEREN

• minus 2 Bytes, beginnend mit i = 2, wie von @ETHProductions vorgeschlagen
• 3 Bytes gespart, dank exzellenter Ratschläge von @Neil!

Golf gespielt

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

Prüfung

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 Bytes

xnor wird wahrscheinlich kommen und diese Lösung zerstören ...

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

Die Funktion ändert die an sie übergebene Liste. Verwenden Sie wie folgt:

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

Versuchen Sie es mit repl.it!

-6 Bytes dank Kupfer

Perl 6 ,  75 71  61 Bytes

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

Probier es aus

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

Probier es aus

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

Probier es aus

Erweitert:

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

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

Kaum auf den 3. Platz geschlichen! Unbenannte Funktion von drei Argumenten, die einen Hilfsoperator verwendet ±, der ±ngenau das n-te Element x (n) der Stewie-Sequenz ist. Die ersten beiden Argumente sind x (1) und x (2), und das dritte Argument ist das N, das angibt, welches x (N) wir ausgeben.

Direkte Implementierung unter Verwendung einer Mod-4-Berechnung zur Auswahl der Binärfunktion, die auf die beiden vorherigen Terme angewendet werden soll. Bei der Auswahl der richtigen Binärfunktion, die 1##[#-#2,#/#2,+##]hilfreich ist, werden einige dieser unterhaltsamen Mathematica-Golftricks verwendet .

05AB1E , 21 19 18 Bytes

Die Eingabe erfolgt in der Reihenfolge N (0-basiert), x (2) , x (1) .
1 Byte dank Carusocomputing eingespart .

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

Probieren Sie es online!

Erläuterung

 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

Wir erstellen iterativ den Stapel mit dem neuesten Element in der Sequenz oben, während alle vorherigen Elemente in der richtigen Reihenfolge bleiben.
Dann wickeln wir den Stack am Ende in eine Liste, um alle Werte auf einmal anzuzeigen.

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

Nicht wirklich konkurrenzfähig, aber ich mag, wie es ganz natürlich ausgedrückt wird:

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

Wir ignorieren Fehler bei der Berechnung von R, wodurch R (und dann B) möglicherweise den NIL-Wert annehmen. Dies ermöglicht die Ausgabe des aktuellen Ergebnisses, auch wenn der nächste Wert undefiniert ist. Dann schlägt die Schleife möglicherweise fehl, aber das entspricht den Regeln.

Tests

Wir benennen die Funktion Fund stellen sicher, dass die erwarteten Werte in etwa den getesteten entsprechen.

(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

Der Grund für den ungefähren Test ist, dass die berechneten Werte etwas genauer sind als erforderlich. hier für (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 bytes

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

Manchmal sind die dcAntworten sehr lang und manchmal sehr kurz. Es kommt nur auf die jeweilige Herausforderung an, wie es bei vielen anderen Sprachen der Fall ist. Auf jeden Fall werden Sie aufgefordert, eine durch Leerzeichen getrennte, einseitig indizierte Befehlszeileneingabe von 3 ganzen Zahlen einzugeben.x(1), x(2), N jeden Fall werden Sie beim Aufruf zur aufgefordert, und jedes Element der Sequenz wird in separaten Zeilen mit nicht ganzzahligen Ausgaben ausgegeben, die 5 Nachkommastellen enthalten.

Die Eingabe 6 3 25führt beispielsweise zu folgender Ausgabe:

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 ( -plaFlag) = 65 Bytes

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

Verwenden von:

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

Ruby, 79 Bytes

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

Ich vermute, dass dies alles andere als optimal ist (und ich habe mir die anderen Antworten noch nicht angesehen), aber es macht trotzdem Spaß.

Ich wollte ein bisschen Spaß haben Enumerable#cycle, aber leider sind es 4 Zeichen weniger, die ich nur verwenden kann %4.

C ++ 14, 118 Bytes

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

Als unbenanntes Lambda modifiziert es seine Eingabe. Muss vein vector<double>oder sein vector<float>.

Ungolfed und Nutzung:

#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-Maschinencode, 34 Byte

Aufrufkonvention = x86-64 System V x32 ABI (Registerargumente mit 32-Bit-Zeigern im ).

Die Funktionssignatur ist void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. Die Funktion empfängt die Startwerte x0 und x1 in den ersten beiden Elementen des Arrays und erweitert die Sequenz auf mindestens N weitere Elemente. Der Puffer muss auf 2 + N aufgerundet auf das nächste Vielfache von 4 aufgefüllt werden. (dh 2 + ((N+3)&~3)oder nur N + 5).

Das Erfordernis von gepolsterten Puffern ist beim Zusammenbau von Hochleistungs- oder SIMD-vektorisierten Funktionen normal, und diese entrollte Schleife ist ähnlich, sodass ich nicht denke, dass sie die Regeln zu sehr verbiegt. Der Aufrufer kann (und sollte) problemlos alle Auffüllelemente ignorieren.

Das Übergeben von x0 und x1 als eine Funktion arg, die nicht bereits im Puffer enthalten ist, würde uns nur 3 Byte kosten (für ein movlps [rdi], xmm0oder movups [rdi], xmm0), obwohl dies eine nicht standardmäßige Aufrufkonvention wäre, da System V übergibtstruct{ float x,y; }; zwei separate XMM-Register .

Dies wird objdump -drw -Mintelmit ein wenig Formatierung ausgegeben, um Kommentare hinzuzufügen

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

Diese C-Referenzimplementierung kompiliert (mit gcc -Os) zu etwas ähnlichem Code. gcc wählt die gleiche Strategie wie ich, nur einen vorherigen Wert in einem Register zu behalten.

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

Ich habe mit anderen Methoden experimentiert, einschließlich einer x87-Version mit zwei Registern und folgendem Code:

; 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

Sie würden es auf diese Weise tun, wenn Sie auf Geschwindigkeit aus sind (und SSE nicht verfügbar war)

Das Einfügen der Ladevorgänge aus dem Speicher in die Schleife anstelle eines einmaligen Eintrags hätte möglicherweise geholfen, da wir die Sub- und Div-Ergebnisse nur in einer nicht ordnungsgemäßen Reihenfolge speichern konnten, aber immer noch zwei FLD-Anweisungen zum Einrichten des Stacks beim Eintrag erforderlich sind.

Ich habe auch versucht, SSE / AVX-Skalarmathematik zu verwenden (beginnend mit Werten in xmm0 und xmm1), aber die größere Anweisungsgröße ist umwerfend. Verwenden von addps(da das 1B kürzer ist als addss) hilft ein kleines bisschen. Ich habe AVX VEX-Präfixe für nicht kommutative Anweisungen verwendet, da VSUBSS nur ein Byte länger als SUBPS ist (und dieselbe Länge wie SUBSS hat).

; 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

Getestet mit diesem Testgeschirr:

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

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

Führen Sie den ersten Testfall mit aus ./stewie 8 1 3

Wenn Sie keine x32-Bibliotheken installiert haben, verwenden Sie nasm -felf64und lassen Sie gcc mit der Standardeinstellung -m64. Ich habe mallocanstelle von float seqbuf[seqlen+8](auf dem Stapel) verwendet, um eine niedrige Adresse zu erhalten, ohne sie tatsächlich als x32 erstellen zu müssen.

Unterhaltsame Tatsache: YASM hat einen Fehler: Es verwendet einen rel32-JCC für den Loop-Zweig, wenn das Zweigziel dieselbe Adresse wie ein globales Symbol hat.

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

baut auf ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 Bytes

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

Probieren Sie es online!

Japt , 20 Bytes

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

Versuch es

Bash, 224 Bytes (KEIN WETTBEWERB)

Eine enorm große Implementierung in BASH .

Übernimmt die Aufgabe im wahrsten Sinne des Wortes und erledigt alles in einer durchgehenden Pipe, ohne unheilige Kontrollflussstrukturen oder Rekursionen.

Eingang

$ 1, $ 2 - Anfangselemente

$ 3 - Zielsequenzgröße

Golf gespielt

{ 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

Weniger 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

Prüfung

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

Pipeline-Phasen

Generieren Sie eine Tabelle mit Elementindizes + op für jedes Ausgabesequenzelement (eines pro Zeile):

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

Verwenden Sie sed , um dies in ein lineares bc- Programm umzuwandeln :

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

füttere das bc und lass es den ganzen Job machen

Pyth - 20 Bytes

Alle nAusgaben kosten mich.

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

Funktioniert nicht online, da eval.

Ceylon, 195 Bytes

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;

Formatiert und kommentiert:

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

Anwendungsbeispiel:

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

Beispielausgabe:

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

Das zweite Beispiel zeigt, wie dies mit der Division durch Null umgehen würde. Das letzte Beispiel zeigt, dass die Ergebnisse ein bisschen abweichen, je nachdem, welche Art von Arithmetik (und Rundung) verwendet wird ... Ich denke, dass die 64-Bit-Gleitkomma-Arithmetik von Ceylon etwas näher ist, als in der Frage angegeben .

Clojure, 99 Bytes

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

Diese Version ist in der Praxis besser zu benutzen, hat aber 110 Bytes:

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

Ich hatte Probleme, die iterierte Funktion und eine zyklische Abfolge von Operationen zu verwischen, sodass ich stattdessen einen Zähler verwenden musste. Auch versucht mit einer FSM-Übergangstabelle wie{+ * * - - / / +}Ich habe aber ich konnte sie nicht auf weniger Code komprimieren.

Könnte als anonyme Funktion ausgedrückt werden

Nicht golfen:

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

Muss mit floats heißen wie (f 6.0 3.0 25)sonst bekommt man rationale Zahlen raus. Alternativ könnte die Iteration gestartet werden, [a (float b) 0]die einige zusätzliche Zeichen bringt.

Oktave , 91 Bytes

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

Probieren Sie es online!

Einige Golfplätze:

• Keine Klammern beim ersten evalAufruf
• Keine Verkettungen beim ersten evalAufruf
• Inline-Zuordnung von *-/+(in MATLAB nicht möglich)
• Kombiniert 'und" um ein Entkommen der Apostrophe zu vermeiden (in MATLAB nicht möglich)
• Speichern, n=@num2strda es zweimal verwendet wird (in MATLAB nicht möglich)