Utilisons les quatre opérations de base, addition +, multiplication *, soustraction -et division /(flottant, pas entier).

La séquence de Stewie est définie comme suit:

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.

Défi:

Prenez deux entiers non négatifs ( x(1), x(2)) et un entier positif Ncomme entrée.

x(1)et x(2)sera les deux premiers nombres de votre séquence, et Nsera la longueur de la séquence que vous devez sortir. (Vous pouvez choisir d'avoir la liste sur la base de 0, auquel casN elle sera inférieure de un à la longueur).

• Vous ne pouvez pas supposer que x(2) >= x(1) .
• N sera toujours >2 si basé sur 1, ( >1si basé sur 0).
• Vous n'avez pas à gérer la division par zéro erreur.
  • Notez le 2ème cas de test. Vous n'obtiendrez pas 0, 1, et N=6en entrée, car cela entraînera une division par zéro, mais vous devez prendre en charge 0, 1et N=5.
• Supposons que seule une entrée valide sera donnée.
• L'entrée et la sortie peuvent être dans n'importe quel format pratique, mais vous devez prendre en charge au moins 3 chiffres après les décimales si la sortie n'est pas entière.

Cas de test:

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 octets

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

L'entrée est au format: N(basé sur 0) x(1),,x(2) (sous forme de chaînes); tous séparés par des retours à la ligne.

Essayez-le en ligne! Ou vérifiez tous les cas de test (code légèrement modifié; séquences de sortie séparées par une ligne vierge).

Explication

MATL n'a pas de evalfonction appropriée , mais U(str2num ) peut évaluer des expressions numériques avec des opérateurs d'infixe.

Chaque nouveau terme est calculé et poussé dans la pile, en conservant les termes précédents. La pile entière est imprimée à la fin.

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 octets

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

x1et x2sont considérés comme une liste. Exemple d'utilisation: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

La paresse permet de définir une liste récursive infinie où l'on prend les n premiers éléments.

Haskell, 66 octets

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

Approche différente, légèrement plus longue. Ordre argument est N, x2, x1. Exemple d'utilisation: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Définit 4 fonctions a, b, cet dqui prennent deux arguments y, x et faire une liste en mettant xen face d'un appel à la fonction suivante avec ycomme second argument et x op yque le premier. Par exemple aest: a y x = x : (b (x+y) y), bfait la multiplication:b y x = x : (c (x*y) y) , etc.

Edit: @Michael Klein a enregistré un octet dans la 1ère variante ( #). Heureusement, j'ai également trouvé un octet pour la deuxième variante, donc les deux ont à nouveau la même longueur.

Edit II: @Zgarb a trouvé 2 octets dans la deuxième version à enregistrer, et I 4 dans la première, ils ne sont donc plus de la même longueur.

ES6 (Javascript), 79, 67, 65 octets

MISE À JOUR

• moins 2 octets, en commençant par i = 2, comme suggéré par @ETHProductions
• Enregistré 3 octets, grâce aux excellents conseils de @Neil!

Golfé

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

Tester

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 octets

xnor va probablement venir détruire cette solution ...

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

La fonction modifie la liste qui lui est transmise. Utilisez comme ceci:

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

Essayez repl.it!

-6 octets grâce au cuivre

Perl 6 ,  75 71  61 octets

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

Essaye-le

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

Essaye-le

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

Essaye-le

Étendu:

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

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

À peine glissé en 3e place! Fonction sans nom de trois arguments, qui utilise un opérateur unaire auxiliaire ±tel que ±nc'est exactement le nième élément x (n) de la séquence de Stewie. Les deux premiers arguments sont x (1) et x (2), et le troisième argument est le N indiquant quel x (N) nous produisons.

Implémentation directe, en utilisant un calcul mod-4 pour choisir la fonction binaire à appliquer aux deux termes précédents. Choisir la bonne fonction binaire, ce qui est 1##[#-#2,#/#2,+##]utile, utilise quelques-unes de ces amusantes astuces de golf Mathematica .

05AB1E , 21 19 18 octets

L'entrée est prise dans l'ordre N (basé sur 0), x (2) , x (1) .
1 octet enregistré grâce à carusocomputing .

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

Essayez-le en ligne!

Explication

 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

Nous construisons de manière itérative la pile avec le dernier élément de la séquence en haut, tout en gardant tous les éléments précédents en ordre.
Ensuite, nous enveloppons la pile dans une liste à la fin pour afficher toutes les valeurs à la fois.

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

Pas vraiment compétitif, mais j'aime comment cela s'exprime tout naturellement:

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

Nous ignorons les erreurs lors du calcul de R, ce qui fait que R (puis B) peut éventuellement prendre la valeur NIL. Cela permet de sortir le résultat actuel même si la valeur suivante n'est pas définie. Ensuite, la boucle finira par échouer, mais c'est dans les règles.

Les tests

Nous nommons la fonction Fet vérifions que les valeurs attendues sont approximativement égales à celle testée.

(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 raison du test approximatif est que les valeurs calculées sont un peu plus précises que nécessaire; ici, pour (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)

cc, 112 110 108 octets

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

parfois dc réponses peuvent être super longues, et parfois elles peuvent être super courtes. Tout dépend du défi à relever, comme c'est le cas avec de nombreuses autres langues. Quoi qu'il en soit, cela invite à une entrée de ligne de commande à un index séparé par un espace de 3 entiers, x(1), x(2), Nlors de l'appel, et génère chaque élément de la séquence sur des lignes distinctes avec des sorties non entières contenant 5 chiffres après la virgule décimale.

Par exemple, l'entrée 6 3 25donne la sortie suivante:

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 ( -plaindicateur) = 65 octets

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

En utilisant:

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

Rubis, 79 octets

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

Je soupçonne que c'est très loin d'être optimal (et je n'ai pas encore regardé les autres réponses), mais c'est quand même amusant.

Je voulais m'amuser Enumerable#cycle, mais malheureusement, c'est 4 caractères de moins à utiliser %4.

C ++ 14, 118 octets

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

Comme lambda sans nom modifiant son entrée. Nécessite vd'être un vector<double>ouvector<float> .

Non golfé et utilisation:

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

code machine x86-64, 34 octets

Convention d'appel = x86-64 System V x32 ABI (registre args avec pointeurs 32 bits en mode long).

La signature de la fonction est void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. La fonction reçoit les valeurs de départ x0 et x1 dans les deux premiers éléments du tableau et étend la séquence à au moins N éléments supplémentaires. Le tampon doit être complété à 2 + N-arrondi au multiple de 4 suivant. (c'est à dire2 + ((N+3)&~3) - , ou juste N + 5).

L'assemblage de tampons rembourrés est normal en assemblage pour les fonctions haute performance ou vectorisées SIMD, et cette boucle déroulée est similaire, donc je ne pense pas que cela déforme trop les règles. L'appelant peut facilement (et devrait) ignorer tous les éléments de remplissage.

Passer x0 et x1 en tant que fonction arg ne se trouvant pas déjà dans le tampon ne nous coûterait que 3 octets (pour a movlps [rdi], xmm0ou movups [rdi], xmm0), bien que ce soit une convention d'appel non standard puisque System V passe struct{ float x,y; };dans deux registres XMM distincts.

Ceci est objdump -drw -Mintelproduit avec un peu de mise en forme pour ajouter des commentaires

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

Cette implémentation de référence C compile (avec gcc -Os) un code quelque peu similaire. gcc choisit la même stratégie que moi, de garder une seule valeur précédente dans un registre.

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

J'ai expérimenté d'autres façons, y compris une version x87 à deux registres qui a du code comme:

; 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

Vous le feriez de cette façon si vous optez pour la vitesse (et SSE n'était pas disponible)

Mettre les charges de la mémoire à l'intérieur de la boucle au lieu d'une fois à l'entrée aurait pu aider, car nous pouvions simplement stocker les résultats sub et div dans le désordre, mais il a toujours besoin de deux instructions FLD pour configurer la pile à l'entrée.

J'ai également essayé d'utiliser les mathématiques scalaires SSE / AVX (en commençant par les valeurs de xmm0 et xmm1), mais la plus grande taille d'instruction est mortelle. L'utilisation addps(puisque c'est 1B plus court que addss) aide un tout petit peu. J'ai utilisé les préfixes AVX VEX pour les instructions non commutatives, car VSUBSS n'est qu'un octet de plus que SUBPS (et la même longueur 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

Testé avec ce harnais de test:

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

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

Exécutez le premier cas de test avec ./stewie 8 1 3

Si vous n'avez pas de bibliothèques x32 installées, utilisez nasm -felf64et laissez gcc en utilisant la valeur par défaut -m64. J'ai utilisé à la mallocplace de float seqbuf[seqlen+8](sur la pile) pour obtenir une adresse basse sans avoir à construire en tant que x32.

Fait amusant: YASM a un bug: il utilise un jcc rel32 pour la branche de boucle, lorsque la cible de branche a la même adresse qu'un symbole 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

s'assemble pour ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 octets

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

Essayez-le en ligne!

Japt , 20 octets

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

Essayez-le

Bash, 224 octets (PAS DE CONCOURS)

Une implémentation extrêmement importante dans BASH .

Prend la tâche tout à fait littéralement et fait tout dans un tuyau continu, sans aucune structure de flux de contrôle impie ou récursivité.

Contribution

$ 1, $ 2 - éléments initiaux

3 $ - taille de séquence cible

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

Moins de 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

Tester

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

Étapes du pipeline

Générez un tableau d'indices d'élément + op, pour chaque élément de séquence de sortie (un par ligne):

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

Utilisez sed pour le convertir en un programme bc linéaire :

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

alimenter cela à bc et le laisser faire tout le travail

Pyth - 20 octets

Sortir tout nme coûte.

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

Ne fonctionne pas en ligne cuz d'eval.

Ceylan, 195 octets

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;

Formaté et commenté:

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

Exemple d'utilisation:

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

Exemple de sortie:

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

Le deuxième exemple montre comment cela gérerait la division par zéro. Le dernier exemple montre que les résultats divergent un peu selon le type d'arithmétique (et d'arrondi) que l'on utilise ... Je pense que l'arithmétique à virgule flottante 64 bits de Ceylan est un peu plus proche de ce qu'elle devrait être que de ce qui a été publié dans la question .

Clojure, 99 octets

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

Cette version est plus agréable à utiliser dans la pratique mais a 110 octets:

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

J'ai eu du mal à fusionner la fonction itérée et une séquence cyclique d'opérations, j'ai donc dû utiliser un compteur à la place. A également essayé d'utiliser une table de transition FSM comme{+ * * - - / / +}J'ai mais je n'ai pas pu la compresser en moins de code.

Pourrait être exprimé comme une fonction anonyme

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

Doit être appelé avec des flotteurs comme (f 6.0 3.0 25)sinon vous obtenez des nombres rationnels. Alternativement, l'itération peut être démarrée à partir de [a (float b) 0]laquelle apporte quelques caractères supplémentaires.

Octave , 91 octets

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

Essayez-le en ligne!

Quelques golfs:

• Pas de parenthèses pour le premier eval appel
• Aucune concaténation pour le premier eval appel
• Affectation en ligne de *-/+ (impossible dans MATLAB)
• Combiné 'et" pour éviter d'échapper aux apostrophes (impossible dans MATLAB)
• Stockage n=@num2strcar il est utilisé deux fois (pas possible dans MATLAB)