Usemos las cuatro operaciones básicas, suma +, multiplicación *, resta -y división /(flotante, no entero).

La secuencia de Stewie se define de la siguiente manera:

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.

Reto:

Tome dos enteros no negativos ( x(1), x(2)) y un entero positivo Ncomo entrada.

x(1)y x(2)serán los dos primeros números de su secuencia, y Nserá la longitud de la secuencia que debe generar. (Puede elegir tener la lista basada en 0, en cuyo caso Nserá una menor que la longitud).

• No puedes asumir eso x(2) >= x(1).
• Nsiempre será >2si está basado en 1 ( >1si está basado en 0).
• No tiene que manejar la división por cero errores.
  • Tenga en cuenta el segundo caso de prueba. No obtendrá 0, 1, y N=6como entrada, ya que eso dará como resultado la división por cero, pero debe admitir 0, 1y N=5.
• Suponga que solo se dará una entrada válida.
• La entrada y la salida pueden estar en cualquier formato conveniente, pero debe admitir al menos 3 dígitos después de los puntos decimales si la salida no es entera.

Casos de prueba:

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

La entrada está en el formato: N(basado en 0) x(1), x(2)(como cadenas); todo separado por nuevas líneas.

Pruébalo en línea! O verificar todos los casos de prueba (código ligeramente modificado; secuencias de salida separadas por una línea en blanco).

Explicación

MATL no tiene una evalfunción adecuada , pero U(str2num ) puede evaluar expresiones numéricas con operadores infijos.

Cada nuevo término se calcula y se empuja a la pila, manteniendo los términos anteriores. Toda la pila se imprime al final.

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)

x1y x2se toman como una lista. Ejemplo de uso: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

La pereza hace posible definir una lista recursiva infinita donde tomamos los primeros n elementos.

Haskell, 66 bytes

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

Enfoque diferente, un poco más largo. Orden de los argumentos es N, x2, x1. Ejemplo de uso: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Define las 4 funciones a, b, cy dque toman dos argumentos y, x y hacer una lista poniendo xen frente de una llamada a la función siguiente con ycomo segundo argumento y x op ycomo el primero. Por ejemplo aes: a y x = x : (b (x+y) y), bhace multiplicación: b y x = x : (c (x*y) y), etc.

Editar: @Michael Klein guardó un byte en la primera variante ( #). Afortunadamente, también encontré un byte para la segunda variante, por lo que ambos tienen la misma longitud nuevamente.

Edición II: @Zgarb encontró 2 bytes en la segunda versión para guardar, y 4 en la primera, por lo que ya no tienen la misma longitud.

ES6 (Javascript), 79, 6765 bytes

ACTUALIZAR

• menos 2 bytes, comenzando con i = 2, como lo sugiere @ETHProductions
• ¡Guardado 3 bytes, gracias a los excelentes consejos de @Neil!

Golfed

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

Prueba

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

Pitón 3, 90 80 74 bytes

xnor probablemente va a venir y destruir esta solución ...

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

La función modifica la lista que se le pasa. Usar así:

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

Prueba en repl.it!

-6 bytes gracias a Copper

Perl 6 ,  75 71  61 bytes

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

Pruébalo

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

Pruébalo

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

Pruébalo

Expandido:

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

Apenas se coló en el 3er lugar! Función sin nombre de tres argumentos, que utiliza un operador unario auxiliar ±tal que ±nes exactamente el enésimo elemento x (n) de la secuencia Stewie. Los primeros dos argumentos son x (1) yx (2), y el tercer argumento es el N que indica qué x (N) sacamos.

Implementación directa, utilizando un cálculo de mod-4 para elegir qué función binaria aplicar a los dos términos anteriores. Escoger la función binaria correcta, que es lo que 1##[#-#2,#/#2,+##]ayuda, utiliza algunos de estos divertidos trucos de golf de Mathematica .

05AB1E , 21 19 18 bytes

La entrada se toma en el orden N (basado en 0), x (2) , x (1) .
Guardado 1 byte gracias a carusocomputing .

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

Pruébalo en línea!

Explicación

 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

Construimos iterativamente la pila con el último elemento de la secuencia en la parte superior, manteniendo todos los elementos anteriores en orden.
Luego envolvemos la pila en una lista al final para mostrar todos los valores a la vez.

Lisp común, 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)))

No es realmente competitivo, pero me gusta cómo se expresa de forma bastante natural:

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

Ignoramos los errores al calcular R, lo que hace que R (y luego B) posiblemente tome el valor NIL. Eso permite generar el resultado actual incluso si el siguiente valor no está definido. Luego, eventualmente el ciclo fallará, pero eso está dentro de las reglas.

Pruebas

Nombramos la función Fy verificamos que los valores esperados sean aproximadamente iguales a los probados.

(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

La razón de la prueba aproximada es porque los valores calculados son un poco más precisos de lo requerido; aquí, para (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

A veces dc respuestas pueden ser muy largas, y otras veces pueden ser muy cortas. Todo depende del desafío en cuestión, como es el caso con muchos otros idiomas. De todos modos, esto solicita una entrada de línea de comando indizada y separada por espacios de 3 enteros,x(1), x(2), N al invocar, y genera cada elemento de la secuencia en líneas separadas con salidas no enteras que contienen 5 dígitos después del punto decimal.

Por ejemplo, la entrada 6 3 25da como resultado la siguiente salida:

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 ( -plabandera) = 65 bytes

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

Utilizando:

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}

Sospecho que esto está muy lejos de ser óptimo (y aún no he visto las otras respuestas), pero de todos modos es divertido.

Quería divertirme un poco Enumerable#cycle, pero lamentablemente, son 4 caracteres menos para usar %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);}

Como lambda sin nombre modificando su entrada. Requiere vser un vector<double>ovector<float> .

Sin golf y uso:

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

Código de máquina x86-64, 34 bytes

Convención de llamada = x86-64 Sistema V x32 ABI (registro de argumentos con punteros de 32 bits en modo largo).

La firma de la función es void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. La función recibe los valores de inicialización x0 y x1 en los dos primeros elementos de la matriz, y extiende la secuencia a al menos N elementos más. El búfer debe rellenarse a 2 + N-redondeado-al-siguiente-múltiplo de 4. (es decir 2 + ((N+3)&~3), o solo N + 5).

Requerir buffers acolchados es normal en el ensamblaje para funciones de alto rendimiento o vectorizadas SIMD, y este bucle desenrollado es similar, por lo que no creo que esté doblando las reglas demasiado. La persona que llama puede ignorar fácilmente (y debería) ignorar todos los elementos de relleno.

Pasar x0 y x1 como una función arg que aún no está en el búfer nos costaría solo 3 bytes (para movlps [rdi], xmm0ao movups [rdi], xmm0), aunque esto sería una convención de llamada no estándar ya que el Sistema V pasastruct{ float x,y; }; en dos registros XMM separados.

Esto se objdump -drw -Mintelgenera con un poco de formato para agregar comentarios

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

Esta implementación de referencia C compila (con gcc -Os) un código algo similar. gcc elige la misma estrategia que yo, de mantener solo un valor anterior en un registro.

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

Experimenté con otras formas, incluida una versión x87 de dos registros que tiene un código como:

; 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

Lo haría de esta manera si fuera por la velocidad (y SSE no estuviera disponible)

Poner las cargas de la memoria dentro del bucle en lugar de una vez en la entrada podría haber ayudado, ya que podríamos almacenar los resultados sub y div fuera de orden, pero aún necesita dos instrucciones FLD para configurar la pila en la entrada.

También intenté usar las matemáticas escalares SSE / AVX (comenzando con valores en xmm0 y xmm1), pero el tamaño de instrucción más grande es asesino. Usar addps(ya que es 1B más corto que addss) ayuda un poco. Utilicé los prefijos AVX VEX para instrucciones no conmutativas, ya que VSUBSS es solo un byte más largo que SUBPS (y la misma longitud que 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

Probado con este arnés de prueba:

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

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

Ejecute el primer caso de prueba con ./stewie 8 1 3

Si no tiene instaladas bibliotecas x32, use nasm -felf64y deje gcc usando el predeterminado -m64. Usé en malloclugar de float seqbuf[seqlen+8](en la pila) para obtener una dirección baja sin tener que construir realmente como x32.

Dato curioso: YASM tiene un error: utiliza un rel32 jcc para la rama de bucle, cuando el objetivo de la rama tiene la misma dirección que un símbolo 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

se ensambla para ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 bytes

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

Pruébalo en línea!

Japt , 20 bytes

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

Intentalo

Bash, 224 bytes (SIN CONCURSO)

Una implementación tremendamente grande en BASH .

Toma la tarea literalmente y hace todo en una tubería continua, sin estructuras de flujo de control impías o recursividad.

Entrada

$ 1, $ 2 - elementos iniciales

$ 3 - tamaño de secuencia objetivo

Golfed

{ 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

Menos 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

Prueba

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

Etapas de la tubería

Genere una tabla de índices de elementos + op, para cada elemento de secuencia de salida (uno por línea):

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

Use sed para convertir esto en un programa lineal 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];
...

alimenta esto a bc y deja que haga todo el trabajo

Pyth - 20 bytes

La salida de todos nme cuesta.

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

No funciona en línea porque de eval.

Ceilán, 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;

Formateado y comentado:

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

Ejemplo de uso:

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

Salida de ejemplo:

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

El segundo ejemplo muestra cómo esto manejaría la división por cero. El último ejemplo muestra que los resultados se desvían un poco dependiendo del tipo de aritmética (y redondeo) que uno esté usando ... Creo que la aritmética de coma flotante de 64 bits de Ceylon está un poco más cerca de lo que debería ser que lo publicado en la pregunta .

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

Esta versión es más agradable de usar en la práctica pero tiene 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])))))

Tuve problemas para activar la función iterada y una secuencia cíclica de operaciones, así que tuve que usar un contador en su lugar. También intenté usar una tabla de transición FSM como{+ * * - - / / +} pero no pude exprimirla a menos código.

Podría expresarse como una función anónima

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

Debe llamarse con flotadores, (f 6.0 3.0 25)ya que de lo contrario obtendrá números racionales. Alternativamente, la iteración podría iniciarse a partir de lo [a (float b) 0]cual trae algunos caracteres adicionales.

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

Pruébalo en línea!

Algunos campos de golf:

• Sin paréntesis para el primero eval llamada
• No hay concatenaciones para el primero eval llamada
• Asignación en línea de *-/+ (no es posible en MATLAB)
• Combinado 'y" para evitar escapar de los apóstrofes (no es posible en MATLAB)
• Almacenamiento n=@num2strya que se usa dos veces (no es posible en MATLAB)