Dört temel işlemi, toplama +, çarpma *, çıkarma -ve bölme /(kayan, tamsayı değil) kullanalım .

Stewie'nin dizisi şöyle tanımlanır:

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.

Meydan okuma:

İki negatif olmayan tamsayı ( x(1), x(2)) ve Ngiriş olarak bir pozitif tamsayı alın .

x(1)ve x(2)dizinizin ilk iki numarası Nolacak ve çıkmanız gereken dizinin uzunluğu olacaktır. (Listenin 0 tabanlı olmasını seçebilirsiniz, bu durumda Nuzunluktan bir tane daha az olacaktır).

• Bunu kabul edemezsin x(2) >= x(1).
• Nher zaman >21 tabanlıysa ( >10 tabanlıysa) olacaktır.
• Bölmeyi sıfır hatayla işlemeniz gerekmez.
  • 2. test durumuna dikkat edin. Sen almazsınız 0, 1ve N=6girdi olarak, o sıfıra bölme neden olacağından, ancak desteklemesi gerekir 0, 1ve N=5.
• Yalnızca geçerli girdi verileceğini varsayalım.
• Giriş ve çıkış uygun herhangi bir biçimde olabilir, ancak çıkış tam sayı değilse, ondalık noktalardan sonra en az 3 basamak desteklemelisiniz.

Test durumları:

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 bayt

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

Giriş biçiminde: N(0 tabanlı) x(1),, x(2)(dizge olarak); hepsi yeni satırlarla ayrılmış.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın (hafifçe değiştirilmiş kod; boş bir satırla ayrılmış çıktı dizileri).

açıklama

MATL uygun bir evalişleve sahip değildir , ancak U( str2num), infix operatörleri ile sayısal ifadeleri değerlendirebilir.

Her yeni terim hesaplanır ve önceki terimleri koruyarak yığına itilir. Tüm yığın sonunda yazdırılır.

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 bayt

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

x1ve x2bir liste olarak alınır. Kullanım örneği: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Tembellik, ilk n öğesini aldığımız sonsuz bir özyinelemeli liste tanımlamayı mümkün kılar.

Haskell, 66 bayt

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

Farklı yaklaşım, biraz daha uzun. Argüman emirdir N, x2, x1. Kullanım örneği: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Tanımlar 4 fonksiyonlar a, b, cve diki argüman alır y, x ve koyarak bir listesini yapmak xile bir sonraki işleve yapılan çağrının önüne yikinci argüman olarak ve x op yilk olarak. Örneğin a:: a y x = x : (b (x+y) y), bçarpma: b y x = x : (c (x*y) y)vb.

Düzenleme: @Michael Klein 1. varyantında ( #) bir bayt kaydetti . Neyse ki, ikinci değişken için bir bayt da buldum, bu yüzden ikisi de yine aynı uzunlukta.

Düzenleme II: @Zgarb ikinci sürümde 2 bayt buldu, ilk önce I 4, bu yüzden artık aynı uzunlukta değiller.

ES6 (Javascript), 79, 67, 65 bayt

GÜNCELLEŞTİRME

• @ETHProductions tarafından önerildiği gibi, eksi 2 bayt, i = 2 ile başlayarak
• @Neil'den gelen mükemmel tavsiyeler sayesinde 3 bayt kaydedildi!

golfed

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

Ölçek

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 bayt

Xnor muhtemelen bu çözümü gelip yok edecek.

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

İşlev, kendisine iletilen listeyi değiştirir. Bunun gibi kullanın:

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

Tekrar dene!

Copper sayesinde -6 bayt

Perl 6 ,  75 71  61 bayt

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

Dene

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

Dene

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

Dene

Expanded:

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

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

Ancak üçüncü sırada gizlice! Bir yardımcı tekli operatör kullanan üç parametreyle Unnamed fonksiyonu, ±bu tür ±ntam Stewie dizisinin inci elemanı x (n). İlk iki argüman x (1) ve x (2) 'dir ve üçüncü argüman N'i çıkardığımızı gösteren N'dir.

Önceki iki terime hangi ikili fonksiyonun uygulanacağını seçmek için bir mod-4 hesaplama kullanarak doğrudan uygulama. Yardımcı olan doğru ikili işlevi seçmek, bu eğlenceli Mathematica golf oyunlarından1##[#-#2,#/#2,+##] birkaçını kullanır .

05AB1E , 21 19 18 bayt

Giriş N (0 tabanlı), x (2) , x (1) sırasına göre alınır . Carusocomputing
sayesinde 1 bayt kaydedildi .

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

Çevrimiçi deneyin!

açıklama

 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

Önceki tüm öğeleri sırayla tutarken, sıradaki en son öğeye sahip yığını yinelemeli olarak oluştururuz.
Daha sonra tüm değerleri bir kerede görüntülemek için yığını bir listedeki listeye sarın.

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

Rekabetçi değil ama doğal olarak ifade edilmesini seviyorum:

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

R'yi hesaplarken hataları görmezden geliriz, bu da R'yi (ve sonra B'yi) NIL değerini alır. Bu, bir sonraki değer tanımsız olsa bile mevcut sonucun çıktısını almayı sağlar. Daha sonra, sonunda döngü başarısız olur, ancak bu kuralların içinde.

Testler

Fonksiyonu adlandırır Fve beklenen değerlerin test edilene yaklaşık olarak eşit olduğunu doğrularız.

(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

Yaklaşık testin nedeni, hesaplanan değerlerin gerekenden biraz daha kesin olmasıdır; burada, için (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 bayt

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

Ara sıra dc cevaplar çok uzun, bazen çok kısa olabilir. Hepsi, diğer birçok dilde olduğu gibi eldeki zorluğa bağlıdır. Neyse, bu, 3 ayrı tam sayıdan oluşan, boşlukla ayrılmış bir indeksli komut satırı girişini ister ve çağrıldıktan x(1), x(2), Nsonra, dizinin her bir elemanını, onluk noktadan sonra 5 hane içeren tam sayı olmayan çıktılara sahip ayrı satırlara verir.

Örneğin, giriş 6 3 25aşağıdaki çıktıyla sonuçlanır:

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 ( -plabayrak) = 65 bayt

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

Kullanımı:

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

Ruby, 79 bayt

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

Bunun optimal olmaktan çok uzak olduğundan şüpheleniyorum (ve henüz diğer cevaplara bakmadım), ama yine de eğlenceli.

Ben biraz eğlenmek istedim Enumerable#cycle, ama ne yazık ki, sadece 4 karakter kullanmak daha az %4.

C ++ 14, 118 bayt

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

Adsız lambda girişini değiştirir. Olması vgereken bir vector<double>veyavector<float> .

Ungolfed ve kullanım:

#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 makine kodu, 34 bayt

Arama kuralları = x86-64 Sistem V x32 ABI (uzun modda 32-bit işaretçilerle kayıt yapın).

İşlev imzası void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. İşlev, dizinin ilk iki öğesindeki x0 ve x1 tohum değerlerini alır ve diziyi en az N ek öğeye genişletir. Tampon 2 + N-yuvarlatılmış yukarı-yukarı-çoklu-4'e kadar doldurulmalıdır. (yani 2 + ((N+3)&~3), veya sadece N + 5).

Dolgulu tamponların kullanılması, yüksek performanslı veya SIMD vektörlü fonksiyonlar için montajda normaldir ve bu kontrolsüz döngü benzerdir, bu yüzden kuralları çok fazla bükdüğünü sanmıyorum. Arayan tüm dolgu elemanlarını kolayca görmezden gelebilir (ve etmelidir).

Tampon içinde zaten bir işlev arg x0 ve x1 geçen bize (a sadece 3 bayt mal olacak movlps [rdi], xmm0ya da movups [rdi], xmm0bu standart dışı bir çağrı kuralı olacaktır, ancak sistem V geçtiği için,)struct{ float x,y; }; iki ayrı XMM kaydında .

Bu, objdump -drw -Mintelyorum eklemek için biraz biçimlendirme çıktı

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

Bu C referans uygulaması, gcc -Osbenzer bir kodu (ile ) derler . gcc, bir kayıtta sadece bir önceki değeri tutmakla aynı stratejiyi seçti.

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

Gibi kod olan iki register x87 sürümü de dahil olmak üzere diğer yolları denedim:

; 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

Hız için gidiyor olsaydınız, bu şekilde yapardınız (ve SSE mevcut değildi).

Yükleri bellekten bir kez giriş yerine bir döngü yerine koymak yardımcı olabilir, çünkü alt ve div sonuçlarını sıra dışı olarak kaydedebildik, ancak yığının girişini ayarlamak için iki FLD komutuna ihtiyacı var.

Ayrıca SSE / AVX skaler matematiğini kullanmayı denedim (xmm0 ve xmm1'deki değerlerden başlayarak), ancak daha büyük komut boyutu katildir. Kullanılması addps(1B'den kısa olduğundan addss) küçük bir parçaya yardımcı olur. Değişken olmayan talimatlar için AVX VEX öneklerini kullandım, çünkü VSUBSS SUBPS'den sadece bir byte daha uzun (ve SUBSS ile aynı uzunlukta).

; 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

Bu test kablo demeti ile test edilmiştir:

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

İle derleyin nasm -felfx32 -Worphan-labels -gdwarf2 golf-stewie-sequence.asm &&
gcc -mx32 -o stewie -Og -g golf-stewie-sequence.c golf-stewie-sequence.o

İlk test senaryosunu çalıştırın. ./stewie 8 1 3

Yüklü x32 kitaplığınız yoksa nasm -felf64, varsayılanı kullanarak gcc'yi kullanın ve bırakın -m64. Kullandığım mallocyerine float seqbuf[seqlen+8]aslında x32 olarak inşa etmek zorunda kalmadan düşük adresini almak için (yığın).

Eğlenceli gerçek: YASM bir hataya sahip: şube hedefi global bir sembolle aynı adrese sahipken, döngü dalı için bir rel32 jcc kullanır.

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

için toplanır ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 bayt

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

Çevrimiçi deneyin!

Japt , 20 bayt

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

Dene

Bash, 224 bayt (YARIŞMA YOK)

BASH’da çok büyük bir uygulama .

Tam anlamıyla görevi üstlenir ve herhangi bir kutsal kontrol akış yapısı veya özyineleme olmadan her şeyi tek bir kesintisiz boruda yapar.

Giriş

1 $, 2 $ - ilk öğe

3 $ - hedef sıra boyutu

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

Daha az 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

Ölçek

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

Boru Hattı Aşamaları

Her çıkış dizisi öğesi için (satır başına bir tane), bir öğe indeks tablosu + op oluşturun:

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

Bunu doğrusal bc programına dönüştürmek için sed komutunu kullanın :

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

bunu bc ye besleyin ve tüm işi yapmasına izin verin

Pyth - 20 bayt

Tüm çıktıların nbana maliyeti var.

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

Eval of cuz çevrimiçi çalışmaz.

Seylan, 195 bayt

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;

Biçimlendi ve yorumlandı:

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

Örnek kullanım:

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

Örnek çıktı:

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

İkinci örnek bunun bölmeyi sıfıra nasıl idare edeceğini gösteriyor. Son örnek, sonuçların hangi tür aritmetik (ve yuvarlama) birinin kullanıldığına bağlı olarak biraz sapma gösterdiğini gösteriyor ... Sanırım Ceylon'un 64 bitlik kayan nokta aritmetiği, soruna ne konulduğundan biraz daha yakındır. .

Clojure, 99 bayt

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

Bu sürüm pratikte kullanmak daha hoş ancak 110 bayt var:

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

Yinelenen işlevi ve döngüsel işlem sırasını değiştirirken sorun yaşadım, bunun yerine bir sayaç kullanmak zorunda kaldım. Ayrıca bir FSM geçiş tablosu kullanarak denedim{+ * * - - / / +} ancak daha az koda sıkıştırmamıştım.

Anonim bir işlev olarak ifade edilebilir

Un-golfed:

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

(f 6.0 3.0 25)Aksi gibi rasyonel sayıları almak gibi yüzen ile çağrılmalıdır . Alternatif olarak, [a (float b) 0]bazı ekstra karakterler getiren yineleme başlatılabilir .

Octave , 91 bayt

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

Çevrimiçi deneyin!

Bazı golf sporları:

• İlk evalarama için parantez yok
• İlk evalarama için birleştirme yok
• Satır içi atama *-/+(MATLAB'da mümkün değil)
• Kombine 've" kesme işareti çıkışlarından kaçınmak için (MATLAB'da mümkün değildir)
• n=@num2strİki kez kullanıldığından saklamak (MATLAB’da mümkün değil)