Monday Mini-Golf: Serangkaian tantangan kode-golf pendek , diposting (mudah-mudahan!) Setiap hari Senin.

Sebuah Fibonacci seperti urutan diperoleh dengan menggunakan metode yang sama seperti yang terkenal deret Fibonacci ; yaitu, setiap angka F (n) ditemukan dengan menambahkan dua angka sebelumnya dalam urutan ( F (n) = F (n-1) + F (n-2) ), atau dengan mengurangi dua angka berikutnya ( F (n) = F (n + 2) - F (n + 1) ). Perbedaan utama adalah bahwa urutan ini dapat dimulai dengan dua angka. Pengindeksan nol urutan ini dapat diperdebatkan, tetapi untuk sekarang, kita akan menggunakan aturan ini:

• Angka 0 dalam urutan seperti Fibonacci adalah angka terakhir yang lebih kecil dari angka sebelumnya.

Sebagai contoh, deret Fibonacci dapat ditulis sebagai 1, 0, 1, 1, 2, 3, 5..., sehingga angka ke-0 dalam deret itu adalah satu-satunya 0.

Tantangan

Tujuan dari tantangan ini adalah untuk menulis program atau fungsi yang menggunakan tiga bilangan bulat, dalam format apa pun:

• A dan B , dua angka untuk mulai menghasilkan urutan.
• N , panjang urutan yang dihasilkan ke keluaran.

Dan menampilkan nomor N pertama dari urutan, mulai dari tanggal 0.

Detail

• A , B , dan N dapat diambil dalam urutan dan format apa pun, selama keduanya terlihat terpisah. Jika Anda menggunakan urutan / format yang berbeda, harap tentukan apa itu.
• Anda dapat mengasumsikan bahwa A , B , dan N selalu bilangan bulat positif.
• Anda dapat berasumsi bahwa N tidak lebih dari 100, dan urutan yang dihasilkan tidak akan mengandung x >= 2^31.
• Jika A lebih besar dari B , maka B adalah angka ke-0 dalam urutan.
• Output harus dipisahkan oleh spasi, koma, dan / atau baris baru.
• Ruang trailing atau baris baru diizinkan, tetapi bukan koma jejak.

Kasus uji

Contoh 1:

8 13 10

Bekerja mundur dari 8 13sampai kita menemukan angka yang lebih besar dari yang sebelumnya, kita dapatkan 13 8 5 3 2 1 1 0 1. Jadi, 0adalah angka ke-0 dalam urutan ini. Bekerja maju dari ini, kami mencetak 0dan 9 anggota berikutnya:

0 1 1 2 3 5 8 13 21 34

Contoh 2:

23 37 5

Sekali lagi bekerja mundur untuk menemukan nomor 0, kami temukan 37 23 14 9 5 4 1 3. Angka 0 kali ini 1, jadi kami mencetaknya, bersama dengan 4 anggota berikutnya:

1 4 5 9 14

Contoh 3:

4 3 8

Dengan ini, kita tidak harus bekerja mundur untuk menemukan angka ke-0, karena 3lebih kecil dari 4:

3 7 10 17 27 44 71 115

Contoh 4:

29 47 11

Hasil:

1 3 4 7 11 18 29 47 76 123 199

Mencetak gol

Ini adalah kode-golf , jadi kode terpendek yang valid dalam byte menang. Tiebreaker pergi ke pengajuan diposting sebelumnya. Pemenang akan dipilih Senin depan, 28 Sep. Semoga beruntung!

Sunting: Selamat kepada pemenang Anda, @ Jakube, menggunakan Pyth untuk 23 byte yang luar biasa !

Pyth, 23 byte

AQWgHGA,-HGG)VvwHA,H+GH

Cobalah online: Demonstrasi atau Test Suite

Gaya pemrograman Pyth yang tidak biasa. Terkadang pemrograman fungsional memiliki kelemahan.

Penjelasan:

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 byte

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

Di sini, <empty>merupakan garis trailing kosong. Jalankan kode sebagai satu file dengan -sbendera.

Format input adalah

A,B;N

di mana nomor tersebut direpresentasikan dalam unary . Outputnya adalah daftar yang dipisahkan koma, juga di unary. Contohnya:

8 13 10

akan menjadi

11111111,1111111111111;1111111111

dan hasil

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

Penjelasan

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

Pertama, kita mengurangi Adan Bke elemen 0 dan -1. The +memberitahu Retina terus mengulangi substitusi regex ini sampai baik regex berhenti cocok atau substitusi tidak memodifikasi string. Regex menangkap Ake dalam grup 1 dengan (1*), dan kemudian memastikan bahwa Bsetidaknya sebesar Asaat menangkap B-Adengan \1(1*)ke dalam grup 2. Ini memastikan bahwa loop ini berakhir sekali A>B.

Substitusi berubah A,Bmenjadi hanya B-A,Adengan mengatur pertandingan $2,$1.

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

Sekarang kita sudah mendapatkan jumlah pertama dari output yang diperlukan dalam string (dan juga yang sebelumnya, yang kita harus singkirkan nanti). Substitusi ini sekarang menambahkan nomor lain sebagai jumlah dari dua angka terakhir saat mengambil 1dari N. Karena kami sudah memiliki satu nomor, kami hanya ingin ini terjadi N-1. Kami melakukan ini dengan memastikan \Bbahwa masih ada setidaknya ;11di akhir string. Jika kita memanggil dua nilai terakhir dari urutan Cdan D, maka regex menangkap Cke grup 1 dan ,Dke grup dua. Kami menulis kembali dengan mereka $1$2. Kemudian kami juga menulis $2$1yang diterjemahkan menjadi ,D+C. Perhatikan bahwa kami tidak menulis kembali single yang 1cocok dengan kamiN, dengan demikian mengurangi itu.

^1*,|;1
<empty>

Akhirnya, kita perlu menyingkirkan elemen -1 urutan, serta sisa ;1dari N, yang kita lakukan dengan mencocokkan salah satu dari mereka dan menggantinya dengan string kosong.

Python 2, 93 87 67 61 60 byte

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

Mendapat input (sebagai daftar python literal [8,10,13])

Berfungsi pada istilah 0

Kemudian cetak urutan penambahan sampai panjangnya tercapai

CJam, 26 23 byte

Terima kasih kepada Dennis karena telah menghemat 3 byte.

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

Mengambil input secara berurutan N B A(dipisahkan oleh ruang putih apa pun). Mencetak hasilnya sebagai daftar yang dipisahkan baris baru dan berakhir dengan kesalahan .

Uji di sini.

Penjelasan

Ini selangkah lebih maju ketika menemukan elemen ke-0. Artinya, itu berakhir setelah salah satu nilai negatif.

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.

Labyrinth , 58 54 49 46 44 byte

Terima kasih kepada Sp3000 untuk menyarankan penggunaan negasi bitwise, yang menghemat dua byte.

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

Format input adalah B A N. Outputnya adalah daftar yang dipisahkan oleh baris baru.

Penjelasan

(Agak ketinggalan jaman. Ide dasarnya masih sama, tetapi tata letak kodenya berbeda sekarang.)

Ini menggunakan ide yang sama dengan jawaban CJam saya (jadi kredit masih masuk ke Dennis): ketika melacak kembali urutan kita tidak berhenti sampai kita mendapatkan nilai negatif (yang membuat kita dengan elemen urutan ke-1 dan -2). Kemudian, kami mulai menambahkannya sebelum mencetak nilai pertama.

Ini menggunakan beberapa trik golf Labyrinth yang bagus. Mari kita lihat kode di bagian:

?"
}

IP mulai di sebelah ?kanan (yang berbunyi A). Pada "(tanpa-op) itu menemui jalan buntu, jadi berbalik, menjalankan ?lagi (membaca B). Terakhir, }pindah Bke tumpukan bantu. Jalan buntu menyimpan byte di atas yang naif

?
?
}

Sekarang loop yang menemukan awal urutan:

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

The )((increment-decrement) adalah no-op, tapi itu perlu untuk memastikan bahwa atas tumpukan positif pada persimpangan (seperti bahwa IP berubah timur). :duplikat A, {bergerak Bkembali ke tumpukan utama, -menghitung A-B. Apa yang sebenarnya kita inginkan adalah B-A, jadi `meniadakan nilai.

Sekarang ini adalah persimpangan empat arah. Untuk hasil negatif, IP mengambil belokan kiri ke arah ?, membaca Ndan pindah ke bagian selanjutnya dari program. Jika hasilnya nol, IP terus bergerak ke selatan, mengambil belokan di sudut, dan tetap di loop. Jika hasilnya positif, IP mengambil belok kanan (barat), belok di sudut, dan belok kanan lagi (barat lagi) sehingga juga tetap di loop. Saya pikir ini mungkin menjadi pola umum, untuk membedakan nilai-nilai negatif dari non-negatif (atau positif dari non-positif):

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

Setidaknya saya belum bisa menemukan tata letak yang lebih ringkas / berguna untuk kasus ini.

Pokoknya, sementara Anon-negatif, loop berlanjut, }bergerak Ake stack bantu dan =swap Adan B.

Begitu Anegatif, ?baca Ndan kita pindah ke loop kedua:

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

Kami tahu itu Npositif, sehingga kami dapat mengandalkan IP untuk belok kiri (utara). Tubuh loop sekarang cukup:

}}:=+:!\{{(

Dengan kata lain: memindahkan keduanya Ndan Ake tumpukan bantu. Gandakan B, tukar salinan dengan Adan tambahkan Ake salinan lain dari B. Gandakan lagi untuk mencetak nilai saat ini B. Cetak baris baru. Pindah Bdan Nkembali ke tumpukan utama dan pengurangan N.

Meskipun Npositif, IP akan mengambil belok kanan (utara) melanjutkan loop. Setelah Nmencapai nol, kode berakhir dengan cara yang agak mewah:

IP terus bergerak lurus ke depan (barat). The ?mencoba untuk membaca bilangan bulat lain, tapi kami sudah mencapai EOF, sehingga benar-benar mendorong 0gantinya. `mencoba meniadakan itu, tapi itu masih nol. Jadi IP masih bergerak ke barat, mengambil belokan di sudut, dan kemudian terus bergerak ke bawah ke @yang menghentikan program.

Aku ingin tahu apakah saya bisa menempatkan @di posisi yang lebih murah (itu saat ini biaya 3 karakter spasi) dengan memutar tiga "sekitar `menjadi senyawa no-ops (seperti )(), tapi saya belum mampu membuat pekerjaan itu belum.

C, 105 102 100 byte

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

Terima kasih kepada @ C0deH4cker untuk bermain golf 2 byte!

Cobalah online di Ideone .

Matlab / Oktaf, 115 125 byte

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

Fungsi ini harus disebut sebagai f([8 13],10).

Contoh (Matlab):

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

Atau coba online (Oktaf) .

Haskell, 67 65 56 byte

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

Terima kasih kepada @nimi untuk saran

Ini mendefinisikan fungsi infiks ternary %, yang dipanggil dalam format (n%a)b, misalnya:

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

Penjelasan

Fungsi infiks biner #, yang didefinisikan pada baris pertama, mengambil dua bilangan bulat adan bdan mengembalikan terbatas Fibonacci seperti urutan di mana adan bterjadi seperti elemen berturut-turut.

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.

Fungsi ini %hanya mengambil nelemen pertama dari a#b.

> <>, 33 31 +1 untuk -v = 32 byte

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

Input harus didorong pada stack menggunakan -v karena parsing angka desimal adalah non-sepele di> <>.

Penjelasan:

Saya akan mewakili tumpukan setelah setiap (kelompok) operasi. Dimulai dengan [F (n), F (n + 1), N]

Baris pertama menuju seri ke 0:

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

Baris kedua naik seri sampai telah mencetak ketentuan N:

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

Kredit diberikan ke ETHproduksi untuk menyediakan algoritma yang saya gunakan dalam jawaban ini.

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

Coba di sini .

Penjelasan:

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

Pendekatan asli, 113 93 byte

Terlihat lebih golf;)

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):"";}

Cobalah di sini .

Penjelasan:

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 byte

Ini mungkin golf hingga maks. Kita lihat saja nanti.

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

Tidak Terkumpul:

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

Akankah golf akhirnya

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 byte

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

Langkah kecil. Ini adalah program CJam pertama saya, jadi saya bangga ini bekerja sama sekali.

Dibutuhkan input dalam bentuk yang sama seperti dalam contoh.

Saya sekarang melihat saya bisa menguranginya menjadi 33 byte menggunakan { ... }*konstruk.

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

Dan saya bahkan bisa menguranginya dengan satu lagi dengan menggunakan operator ternary untuk membersihkan tumpukan dan menghasilkan kesalahan.

Ruby, 141 byte

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 

Eksekusi

Fungsi f menghasilkan output yang diinginkan, nama argumen cocok dengan nama variabel dari pertanyaan

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

Tidak ada yang pintar:

• Fungsi u ( atas ) menghitung n elemen dalam urutan fibonacci yang dimulai dengan a, b menggunakan rekursi
• Fungsi d ( turun ) menemukan elemen ke-0 dan ke-1 yang diberikan dua elemen ujung menggunakan rekursi
• Fungsi f ( fibonacci ) menyatukan keduanya

Mathematica, 59 byte

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}

Disingkat 6 Bytes saat mengganti for-loop dengan range.map

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}

Menyimpan 2 byte lainnya dengan memindahkan pernyataan cetak

Pyke, 24 byte (tidak bersaing)

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

Coba di sini!

Jelly , 14 byte

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

Cobalah online!

Gangguan Umum, 91 byte

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

Cobalah online!