Pazartesi Mini Golf: Her Pazartesi yayınlanan (umarım!) Bir dizi kısa kod golf mücadelesi.

Ünlü Fibonacci sekansıyla aynı yöntem kullanılarak bir Fibonacci benzeri sekans elde edilir ; yani, her bir F (n) sayısı , sıradaki önceki iki sayıyı ekleyerek ( F (n) = F (n-1) + F (n-2) ) veya sonraki iki sayıyı ( F) çıkartarak bulunur. (n) = F (n + 2) - F (n + 1) ). Ana fark, bu dizilerin herhangi iki sayıyla başlayabilmesidir. Bu dizilerin sıfır dizinlenmesi tartışmalıdır, ancak şimdilik bu kuralı kullanacağız:

• Bir Fibonacci benzeri dizideki 0 sayısı, önceki numaradan daha küçük olan son sayıdır.

Bir örnek olarak, Fibonacci dizisi şu şekilde yazılabilir 1, 0, 1, 1, 2, 3, 5..., bu yüzden dizideki 0 sayısı yalnızdır 0.

Meydan okuma

Bu zorluğun amacı, herhangi bir formatta üç tam sayı alan bir program veya işlev yazmaktır:

• A ve B , bir dizi oluşturmaya başlamak için iki sayı.
• N , elde edilen dizinin çıktısının uzunluğu.

Ve 0'dan başlayarak dizinin ilk N sayısını çıkarır.

ayrıntılar

• A , B ve N , görünüşte ayrıldıkları sürece, herhangi bir sıra ve biçimde alınabilir. Farklı bir sipariş / format kullanıyorsanız, lütfen ne olduğunu belirtin.
• A , B ve N'nin her zaman pozitif tamsayılar olduğunu varsayabilirsiniz .
• N'nin 100'den fazla olmadığını ve ortaya çıkan dizinin içermeyeceğini varsayabilirsiniz x >= 2^31.
• Eğer bir daha büyük olan B , daha sonra B dizisinde 0. sayıdır.
• Çıktı boşluk, virgül ve / veya yeni satırlarla ayrılmalıdır.
• Arkadaki bir boşluk veya satır izin verilmekte, fakat olmayan bir arka virgül.

Test-vakalar

Örnek 1:

8 13 10

8 13Bir öncekinden daha büyük bir sayı bulana kadar geriye doğru çalışarak , elde ederiz 13 8 5 3 2 1 1 0 1. Böylece, 0bu dizideki 0 sayısıdır. Bundan yola çıkarak, 09 üyeyi çıkarıyoruz :

0 1 1 2 3 5 8 13 21 34

Örnek 2:

23 37 5

Yine 0ncı sayıyı bulmak için geriye doğru çalışıyoruz 37 23 14 9 5 4 1 3. Bu sefer 0 sayısı 1, bu yüzden sonraki 4 üyeyle birlikte yazdırıyoruz:

1 4 5 9 14

Örnek 3:

4 3 8

Bununla, 0ncı sayıyı bulmak için geriye doğru çalışmak zorunda değiliz, çünkü şunlardan 3daha küçük 4:

3 7 10 17 27 44 71 115

Örnek 4:

29 47 11

Sonuç:

1 3 4 7 11 18 29 47 76 123 199

puanlama

Bu kod-golf , bayt cinsinden geçerli en kısa koddur. Tiebreaker daha önce gönderilen gönderilere gider. Kazanan gelecek Pazartesi, 28 Eylül'de seçilecek. İyi şanslar!

Düzenleme: Kazanan, @Jakube'a tebrikler, Pyth'i 23 bayt için kullanıyor !

Pyth, 23 bayt

AQWgHGA,-HGG)VvwHA,H+GH

Çevrimiçi deneyin: Gösteri veya Test Paketi

Oldukça sıradışı Pyth programlama tarzı. Bazen fonksiyonel programlamanın olumsuz yönleri vardır.

Açıklama:

AQWgHGA,-HGG)VvwHA,H+GH  Q = input list of the two starting numbers
AQ                       G, H = Q (unpacking Q)
  WgHG                   while H >= G:
      A,-HGG                G, H = [H - G, G]
            )            end while
              vw         read a number from input
             V           for N in range(^):
                H           print H
                 A,H+GH     G, H = [H, G + H]

Retina , 65 54 bayt

+`(1*),\1(1*)
$2,$1
+`(1*)(,1*);1\B
$1$2$2$1;
^1*,|;1
<empty>

Burada <empty>boş bir takip çizgisi var. Kodu, -sbayrakla birlikte tek bir dosya olarak çalıştırın .

Giriş formatı

A,B;N

burada eğer sayılar olan tekli temsil . Çıktı aynı zamanda virgülle ayrılmış bir listedir. Örneğin:

8 13 10

olabilir

11111111,1111111111111;1111111111

ve verim

,1,1,11,111,11111,11111111,1111111111111,111111111111111111111,1111111111111111111111111111111111

açıklama

+`(1*),\1(1*)
$2,$1

İlk olarak, azaltmak Ave B0þ ve -1st elemana. +Ya Normal ifade eşlemeyi durdurur veya ikame dizesini değiştirmez kadar bu regex ikame tekrar tutmak için Retina söyler. Regex yakalar Aolan grupta 1 içine (1*)ve sonra emin olur Bbüyüklüğünde en az olduğu Ayakalarken B-Aile \1(1*)bu Döngü sonlanır kez grup 2'de içine bu kontrolü sağlar A>B.

Değişim , eşleşmeyi ayarlayarak basitçe A,Bdevreye girer .B-A,A$2,$1

+`(1*)(,1*);1\B
$1$2$2$1;

Şimdi, dizgede istenen çıktının ilk sayısını çoktan aldık (daha önce kurtulmamız gereken öncekinin yanı sıra). Bir çekerken bu ikame şimdi son iki sayının toplamı olarak başka bir numara ekler 1dan N. Çünkü zaten bir numaramız var, bunun sadece olmasını istiyoruz N-1. Bunu \B, hala en azından ;11dizenin sonunda olmasını sağlayarak yaparız . Dizinin son iki değerini çağırırsak Cve Dsonra regex Cgrup 1 ve ,Dgrup iki olarak yakalanır. Bunları geri yazarız $1$2. Sonra da $2$1hangisine tercüme edildiğini yazıyoruz ,D+C. Not biz yok tek geri yazma 1eşleşen bizN, böylece azaltıyor.

^1*,|;1
<empty>

Son olarak, biz de evlerde artık olarak, dizinin -1st elemanın kurtulmak gerekir ;1dan Nbiz sadece ya olanların eşleşen ve boş dize ile değiştirerek yapın.

Python 2, 93 87 67 61 60 bayt

i,j,l=input()
while j/i:i,j=j-i,i
exec"i,j=j,i+j;print i;"*l

Girdiyi alır (değişmez python listesi olarak [8,10,13])

0 terim çalışır

Ardından, uzunluğa ulaşılana kadar ilaveler sırasını yazdırır

CJam, 26 23 bayt

Dennis'e 3 byte kaydettiğin için teşekkürler.

q~{_@\-_g)}g\@{_@+_p}*t

Sırayla girdi alır N B A(herhangi bir beyaz boşlukla ayrılır). Sonucu yeni satırlarla ayrılmış bir liste olarak yazdırır ve hata ile sonlandırır .

Burada test et.

açıklama

Bu, 0ncı elementi bulurken bir adım daha ileri gider. Yani, değerlerden biri negatif olduğunda sona erer.

q~      e# Read and evaluate input, pushing N, B and A on the stack.
{       e# do while...
  _@\-  e#   B, A = A, B-A
  _W>   e#   Check if A is still non-negative.
}g
\@      e# Reorder N B A into A B N.
{       e# Run the following N times...
  _@+   e#   A, B = B, A+B
  _p    e#   Print B.
}*
t       e# The last A, B are still on the stack. We remove them by trying to
        e# execute a ternary operator: it pops the first two values but then
        e# terminates the program with an error, because there is no third value.

Labirent , 58 54 49 46 44 bayt

İki bayttan tasarruf sağlayan bitsel olumsuzlama önerdiğiniz için Sp3000'e teşekkürler.

??#"{=
  ;  -
@"~~:}
~""
?
"}}:=
(   +
{{\!:

Giriş formatı B A N. Çıktı yeni satır ayrılmış bir listedir.

açıklama

(Biraz modası geçmiş. Temel fikir hala aynı, ancak şimdi kodun düzeni farklı.)

Bu, CJam cevabımla aynı fikri kullanıyor (bu yüzden krediler hala Dennis'e gidiyor): diziyi geri alırken negatif bir değer elde edene kadar durmayız (bu bizi dizinin -1 ve -2 öğeleriyle bırakır). Ardından, ilk değeri yazdırmadan önce bunları eklemeye başlarız .

Bu birkaç şık labirent golf hilesi kullanıyor. Bölümlerde kodu gözden geçirelim:

?"
}

IP, ?sağa doğru devam eder (okur A). On "bir çıkmaz vurur (no-op), yani yürütme, etrafında döner ?(okuma tekrar B). Son olarak, yardımcı yığına }taşınır B. Çıkmaz sokak naif bir bayttan tasarruf sağlar

?
?
}

Şimdi dizinin başlangıcını bulan döngü:

)(:{
"  -
" "`?...
=}""

)((Artışa eksiltme) no-op, ancak yığının üst (IP doğusunda döner şekilde) birleşme pozitif olduğundan emin olmak için gereklidir. :çiftleri A, {hareket B, ana yığına geri -hesaplar A-B. Gerçekten istediğimiz şey B-Aolsa da, `değeri olumsuzlar.

Bu şimdi dört yollu bir kavşaktır. Olumsuz sonuçlar için IP ?, okumaya Nve programın bir sonraki bölümüne geçme yönünde sola döner . Sonuç sıfırsa, IP güneye devam eder, köşede bir dönüş yapar ve döngüde kalır. Sonuç pozitifse, IP sağa döner (batı), köşeye döner ve başka bir sağa döner (tekrar batı) böylece döngü içinde kalır. Bunun negatif olanı negatif olmayan (veya pozitif olmayandan pozitif) değerlerden ayırmak için ortak bir kalıp olabileceğini düşünüyorum:

                v
                "
               """>negative
non-negative <"""

En azından bu dava için henüz daha kompakt / kullanışlı bir düzen bulamadım.

Her neyse, Anegatif olmasa da, döngü devam }eder A, yardımcı yığına geçer ve =değiştirir Ave B.

Bir kere Anegatif, ?okur Nve ikinci döngüye gireriz:

 }:=+:
 }   !
?"({{\

Bunun Npozitif olduğunu biliyoruz , bu yüzden sola dönüş (IP) olan IP'ye güvenebiliriz. Döngü gövdesi şimdi basitçe:

}}:=+:!\{{(

İfadeyle: Her iki hareket Nve Ayardımcı yığına. Çoğaltın B, kopyayı değiştirin ve diğer kopyaya Aekleyin . Geçerli değerini yazdırmak için tekrar çoğaltın . Yeni bir satır yazdır. Taşıyın ve ana yığına geri getirin ve azaltın .ABBBNN

Olumluyken N, IP, döngüyü sürdürerek sağa (kuzey) dönecektir. Bir kez Nsıfıra ulaştığında, kod oldukça süslü bir şekilde sona erer:

IP düz devam ediyor (batı). ?Çalışır başka tamsayı okumak için, ama aslında iter böylece biz zaten, EOF ulaştınız 0yerine. `bunu ihmal etmeye çalışır, ama bu hala sıfır. Böylece IP hala batıya doğru hareket ediyor, köşede bir dönüş yapıyor ve ardından @programı sonlandıran aşağı doğru ilerlemeye devam ediyor .

Ben yer verebilir acaba @üç çevirerek (şu anda 3 boşluk karakterlerini maliyeti) daha ucuz konumda "etrafında `bileşik no-op (gibi içine )(), ama henüz o iş yapmak mümkün olmamıştır.

C, 105 102 100 bayt

main(a,b,n,t){for(scanf("%d%d%d",&a,&b,&n);t=b-a,t>=0;a=t)b=a;for(;n--;b=t)t=a+b,printf("%d ",a=b);}

2 baytlık golf oynamak için @ C0deH4cker'a teşekkürler!

Ideone'da çevrimiçi olarak deneyin .

Matlab / Octave, 115 125 bayt

function x=f(x,n)
while x(2)>=x(1)
x=[abs(x(1)-x(2)) x];end
x=x([2 1]);for k=1:n-1
x=[x(1)+x(2) x];end
x=x(n:-1:1);

İşlev olarak adlandırılmalıdır f([8 13],10).

Örnek (Matlab):

>> f([8 13],10)
ans =
     0     1     1     2     3     5     8    13    21    34

Veya çevrimiçi deneyin (Octave) .

Haskell, 67 65 56 bayt

a#b|a>b=b:scanl(+)(a+b)(a#b)|1>0=(b-a)#a
n%a=take n.(a#)

Önerileriniz için @nimi 'e teşekkürler

Bu %, formatta çağrılan üçlü bir ek fonksiyonunu tanımlar (n%a)b, örneğin:

> (10%8)13
[0,1,1,2,3,5,8,13,21,34]

açıklama

İkili infix fonksiyonu #ilk satırda tanımlanmış, iki tam sayı alır ave bsonsuz döner Fibonacci benzeri dizisi ave bbirbirini takip eden elemanlar olarak ortaya çıkar.

a#b                                       -- Define a#b:
   |a>b=                                  -- if a>b, then a#b is
        b:                                -- the sequence that starts with b and
          scanl(+)     (a#b)              -- continues with the sums of prefixes of a#b
                  (a+b)                   -- plus the additional term a+b;
                            |1>0=(b-a)#a  -- otherwise, it's (b-a)#a.

Fonksiyon %basitçe ilk nelemanlarını alır a#b.

> <>, -V = 32 bayt için 33 31 + 1

&:{:@(?v:}-$&
-1;!?:&<$+{oan::$&

Ondalık sayıların ayrıştırılması> <> için önemsiz olduğundan, giriş -v kullanılarak yığına basılmalıdır.

Açıklama:

Her bir işlem grubundan sonra yığını temsil edeceğim. [F (n), F (n + 1), N] ile başlar

İlk satırlar, seriden 0ncı terimine kadar gider:

& removes N from the stack to put it into a register. [F(n), F(n+1)]
:{:@ move the stack and duplicate items to get [F(n+1), F(n), F(n+1), F(n)]
(?v compares the two top items of the stack and branch to the second line if F(n+1) < F(n) [F(n+1), F(n)]
:} move the stack and duplicate its top to get [F(n), F(n+1), F(n)]
- substracts the two top items and put the result on top of the stack [F(n), F(n+1) - F(n)]
$ switchs the top two values of the stack. [F(n+1) - F(n), F(n)]
& retrieve the value from the register. iteration complete, since [F(n+1) - F(n), F(n), N] can also be read as [F(n-1), F(n), N]

İkinci satır, N terimlerini yazana kadar seriye gider:

< changes the code pointer direction to the left [F(0), F(-1)]
& retrieves the stored value back from the stack [F(0), F(-1), N]
:?!; copies N to compare it to 0, stops if it is [F(0), F(-1), N]
1- decreases it [F(0), F(-1), N-1]
& stores it back [F(0), F(-1)]
$:: makes the stack [F(-1), F(0), F(0), F(0)]
n{ prints the top of the stack then left shifts it [F(0), F(0), F(-1)]
ao displays a line feed (ascii character 0x0a) [F(0), F(0), F(-1)]
+ adds the two top values [F(0), F(-1) + F(0)]
$ switch the two top values. iteration complete since [F(-1) + F(0), F(0)] which can be read as [F(1), F(0)]

Java, 113 78 76 bayt

Kredi bu cevapta kullandığım algoritmayı sağlamak için ETHProduction'a gidiyor .

(a,b,n)->{for(;a<=b;b-=a)a=b-a;for(;n-->0;b+=a,a=b-a)System.out.println(b);}

Burada dene .

Açıklama:

(a,b,n)->{
    for (;a<=b;b=b-a)a=b-a;  //Compute previous terms while a <= b
    for (;n-->0;b=a+b,a=b-a) //Compute and print next terms while n > 0
    System.out.println(b);   //Print term
}

Orijinal yaklaşım, 113 93 bayt

Daha fazla golfy görünüyor;)

String a(int a,int b,int n){return n<0?a+" "+a(b,a+b,n+1):n>0?a>b?a(b,a+b,-n):a(b-a,a,n):"";}

Denemek Burada .

Açıklama:

String a(int a, int b, int n){
    return 
    n < 0 ?                           //If n < 0
        a + " " + a(b, a + b, n + 1)  //Return a + next terms and increment n.
    :                                 //Else
        n > 0 ?                       //If n > 0
            a > b ?                   //If a > b
                a(b, a + b, -n)       //Negate n and return terms.
            :                         //If a <= b
                a(b - a, a, n)        //Generate previous term.
        :                             //If n == 0
            ""                        //Return nothing.
    ;
}

Javascript (ES6), 83 73 63 bayt

Bu maks. Göreceğiz.

(a,b,n)=>{while(a<=b)b-=a=b-a;for(;n--;console.log(a=b-a))b+=a}

Ungolfed:

function f(a,b,n) {
  // repeat until we find the 0th item...
  while (a <= b) {  // if a = 5, b = 8:
    a = b - a;      // a = (8 - 5) = 3
    b = b - a;      // b = (8 - 3) = 5
  }
  // repeat n times...
  while (n-- > 0) { // if a = 5, b = 8:
    b += a;         // b = (8 + 5) = 13
    a = b - a;      // a = (13 - 5) = 8
    console.log(a); // print out each item
  }
}

Mathematica 112

Sonunda golf olacak

z[a_, b_, n_] := (
  f[0] := Min[a, b];
  f[1] := Max[a, b];
  f[x_] := f[x - 1] + f[x - 2];
  f /@ Range[n]
  )

CJam, 40 bayt

l~:A;{_@_@)<}{_@\-\}w\{A(:A0>}{_p_@+}w\;

Bebek adımları. Bu şimdiye kadarki ilk CJam programım, bu yüzden çalıştığı için gurur duyuyorum.

Örneklerle aynı biçimde girdi alır.

Şimdi { ... }*yapıyı kullanarak onu 33 byte'a indirebileceğimi gördüm .

l~:A;{_@_@)<}{_@-z\}w\A{_p_@+}*;;

Yığını temizlemek ve bir hata üretmek için üçlü operatörü kullanarak bir tane daha azaltabilirim.

Ruby, 141 bayt

def u a,b,n,z=""
n<1 ? z.chop : u(b,a+b,n-1,z+"#{a} ")
end 
def d a,b,z=0
a.abs>b ? z : d(b-a,a,[a,b]) 
end 
def f a,b,n
x,y=d a,b 
u x,y,n
end 

infaz

f işlevi istenen çıktıyı üretir, bağımsız değişken isimleri sorudaki değişken isimleri ile eşleşir

f(8,13,10) # returns => "0 1 1 2 3 5 8 13 21 34"

Akıllıca bir şey yok:

• u ( yukarı) ) işlevi, özyineleme kullanarak a, b ile başlayan fibonacci dizisindeki n öğelerini hesaplar.
• d ( aşağı) ) işlevi, özyinelemeyi kullanarak iki uç öğesinde verilen 0 ve 1 öğelerini bulur
• f ( fibonacci ) işlevi ikisini bir araya getirir

Mathematica, 59 bayt

If[#>#2,LinearRecurrence[{1,1},#2+{0,#},#3],#0[#2-#,#,#3]]&

Ruby, 81 75 73

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{b=c+a;c,a=a,b;p b}

Range.map ile for-loop değiştirilirken 6 Bayt kısaldı

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{p b=c+a;c,a=a,b}

Print deyimini taşıyarak 2 bayt daha kaydedildi

Pyke, 24 bayt (rekabet etmeyen)

DA/IDA-],X_r)QVDsRe
R]);

Burada dene!

Jöle , 14 bayt

Ḋ;_/Ɗ>/¿+⁹С/Ṗ

Çevrimiçi deneyin!

Ortak Lisp, 91 bayt

(lambda(a b n)(do((x a(- y x))(y b x))((> x y)(dotimes(k n)(print y)(psetf y(+ y x)x y)))))

Çevrimiçi deneyin!