The Kata Fibonacci tak terbatas adalah tertentu, urutan yang tak terbatas digit biner, yang dihitung dengan Rangkaian diulang kata-kata biner yang terbatas.

Mari kita mendefinisikan bahwa kata Fibonacci-jenis urutan (atau FTW urutan ) adalah setiap urutan ⟨W _n ⟩ yang terbentuk sebagai berikut.

• Mulai dengan dua array acak angka biner. Mari kita panggil array ini W _-1 dan W ₀ .

• Untuk setiap n> 0 , misalkan W _n ≔ W _n-1 ∥ W _n-2 , di mana ∥ menunjukkan penggabungan.

Konsekuensi dari definisi rekursif adalah bahwa W _n selalu awalan W _{n + 1} dan, karena itu, semua W _k sehingga k> n . Dalam arti, ini berarti urutan ⟨W _n ⟩ konvergen untuk kata yang tak terbatas.

Secara formal, misalkan W _∞ menjadi satu-satunya susunan tak hingga sehingga W _n adalah awalan W _∞ untuk semua n ≥ 0 .

Kami akan menyebut kata tak terbatas yang dibentuk oleh proses di atas sebagai FTW tak terbatas .

Tugas

Tulis sebuah program atau fungsi yang menerima dua kata biner W _-1 dan W ₀ sebagai input dan mencetak W _∞ , mematuhi aturan berikut, tambahan, berikut:

• Anda dapat menerima kata-kata dalam urutan apa pun; sebagai dua array, array array, dua string, sebuah array string, atau string tunggal dengan pembatas pilihan Anda.

• Anda dapat mencetak digit kata tak terbatas baik tanpa pembatas atau dengan pembatas yang konsisten antara setiap pasangan digit yang berdekatan.

• Untuk semua tujuan, asumsikan kode Anda tidak akan pernah kehabisan memori, dan bahwa tipe datanya tidak meluap.

  Secara khusus, ini berarti bahwa setiap output ke STDOUT atau STDERR yang merupakan hasil dari crash akan diabaikan.

• Jika saya menjalankan kode Anda di komputer saya (Intel i7-3770, 16 GiB RAM, Fedora 21) selama satu menit dan mengirimkan hasilnya wc -c, harus mencetak setidaknya satu juta digit W _dig untuk (W _-1 , W ₀ ) = (1, 0) .

• Aturan standar kode-golf berlaku.

Contoh

Misalkan W _-1 = 1 dan W ₀ = 0 .

Kemudian W ₁ = 01 , W ₂ = 010 , W ₃ = 01001 , W ₄ = 01001010 … dan W _∞ = 010010100100101001010… .

Ini adalah yang kata Fibonacci tak terbatas.

Uji kasus

Semua kasus uji berisi 1.000 digit pertama FTW tak terbatas.

Input:  1 0
Output: 0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001

Input:  0 01
Output: 0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001

Input:  11 000
Output: 0001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100000011000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000000110001100000011000110000001100000011000110000001100011000000110000001100011000000110000001100011000000110001100000011000000110001100000011000110000001100000011

Input:  10 010
Output: 0101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010

Input:  101 110
Output: 1101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101

Pyth, 8 byte

u,peGsGQ

Masukan dalam formulir "W-1", "W0".

Bukti penyelesaian:

$ time pyth -cd 'u,peGsGQ' <<< '"1", "0"' 2>/dev/null | head -c1000000 > /dev/null

real    0m0.177s
user    0m0.140s
sys 0m0.038s

Bukti kebenaran:

Ini adalah seri yang dihasilkan secara internal. Itu dicetak dalam rangkaian oleh program.

[0, 10, 010, 10010, 01010010, 1001001010010,...]

Bandingkan dengan yang berikut, dicetak dalam penggabungan, yang hanya berupa string yang ditambahkan ke string sebelumnya pada setiap langkah:

[0, 1, 0, 01, 010, 01001, 01001010, 0100101001001, ...]

Kami ingin membuktikan ini setara.

Jelas, mereka sama melalui beberapa langkah pertama. Mari kita bandingkan setelah sedikit:

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

Kita melihat bahwa pasangan string bergantian bentuk:

01a 10b
a10 b01

Di mana a dan b adalah urutan arbitrer pada 0s dan 1s. Mari kita lanjutkan urutannya sebentar, untuk membuktikan terus berlanjut dengan induksi:

01a   10b   10b01a   10b01a10b
  a10   b01   a10b01   b01a10b01

2 langkah kemudian, itu adalah bentuk yang benar.

10b   01a   01a10b   01a10b01a
  b01   a10   b01a10   a10b01a10

2 langkah kemudian, itu adalah bentuk yang benar.

Jadi dengan induksi, senar selalu cocok sekali digabung.

Haskell, 15 byte

v%w=w++w%(v++w)

Fungsi infix %menghasilkan string tanpa batas, yang dicetak Haskell selamanya karena Haskell keren seperti itu.

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

Ide rekursif mirip dengan solusi Zgarb . Menulis funtuk fungsi %, dan +untuk penggabungan string, ia mengimplementasikan:

f(v,w) = w + f(w,v+w)

String output tak terbatas dimulai dengan w, dan sisanya adalah hasil untuk string Fibonacci-shifted wdan v+w.

Ini tidak masalah menghasilkan sejuta karakter dalam satu menit.

Haskell, 31 byte

w#v=v++drop(length v)(v#(v++w))

Ini mendefinisikan fungsi infix #yang mengambil dua string dan mengembalikan string yang tak terbatas. Pemakaian:

> let w#v=v++drop(length v)(v#(v++w)) in "11"#"000"
"000110000001100011000000110000...

Jika saya kueri elemen juta urutan yang ditentukan oleh "1" dan "0", bahkan penerjemah online mencetak hasilnya dalam waktu kurang dari satu detik:

> let w#v=v++drop(length v)(v#(v++w)) in ("1"#"0") !! 1000000
'0'

Penjelasan

w#v=                             -- The result of w#v is
    v++                          -- v concatenated to
                      v#(v++w)   -- the infinite word v#(v++w),
       drop(length v)            -- with the first v characters dropped.

Pada dasarnya, kita tahu itu w#v == v#(v++w)dan w#vmulai dengan v, dan menggunakan fakta-fakta ini untuk menentukan hasilnya. Karena Haskell malas, ini "ajaib" hanya berfungsi.

Pip, 8 byte

Hei, diikat dengan Pyth!

(fOba.b)

Definisi rekursif langsung yang dipinjam dari jawaban Hasnell xnor . Dengan ruang yang ditambahkan untuk kejelasan:

(f Ob a.b)

Setiap program di Pip adalah fungsi implisit yang mengambil argumen command-line sebagai argumennya (ditugaskan untuk variabel amelalui e) dan mencetak nilai kembalinya. Oadalah operator yang mengeluarkan dan kemudian mengembalikan operan, sehingga hal pertama yang terjadi di sini adalah argumen kedua ditampilkan (tanpa jejak baris baru).

Sekarang, sintaks Lisp-terinspirasi (f x y)dalam Pip adalah panggilan fungsi, setara dengan f(x,y)dalam bahasa seperti C The fvariabel mengacu pada fungsi saat ini - dalam hal ini, program tingkat atas. Dengan demikian, program secara rekursif menyebut dirinya dengan bdan a.bsebagai argumen baru.

Saya terkejut menemukan bahwa pendekatan ini sangat cepat:

dlosc@dlosc:~$ time pip -e '(fOba.b)' 1 0 2>/dev/null | head -c1000000 > /dev/null

real    0m0.217s
user    0m0.189s
sys     0m0.028s

Diperlukan sekitar 30 detik pada mesin Ubuntu saya untuk program mencapai kedalaman rekursi maksimum, di mana saat itu telah dicetak di suatu tempat lebih dari satu miliar digit.

Solusi iteratif ini sedikit lebih cepat dan lebih sedikit memori, dengan biaya satu byte:

W1Sba.:Ob

CJam, 12 11 byte

llL{@_o+_}h

Ini mengambil dua kata pada baris yang terpisah, dalam urutan yang berlawanan, misalnya

0
1

memberi

0100101001001010010100100101001...

Penjelasan

Idenya adalah untuk membangun kata secara naif (dengan mengingat kata saat ini dan menambahkan yang sebelumnya ke dalamnya) dan sementara kami melakukan itu, kami mencetak apa pun yang kami tambahkan (agar tidak mengulangi awalan yang sudah dicetak) . Untuk menghindari keharusan menangani titik awal secara terpisah, kita mulai dari kata kosong, sehingga W ₀ adalah hal pertama yang kita tambahkan (dan cetak).

ll    e# Read the two lines separately.
L     e# Push an empty string.
{     e# Infinite loop...
  @   e#   Pull up the previous FTW.
  _o  e#   Print it.
  +_  e#   Append it to the current FTW and duplicate it.
}h

PowerShell, 97 76 Bytes

param($a,$b)write-host -n $b;while(1){write-host -n $a;$e=$b+$a;$a=$b;$b=$e}

_{Sunting - Umm, menulis $e.substring($b.length)setelah kami baru saja bergabung $adan $bbersama sama dengan menulis hanya $a... derp.}

Wow, verbose. PowerShell akan, secara default, mengeluarkan baris baru setiap kali Anda mengeluarkan sesuatu. Sungguh satu-satunya cara untuk menyiasatinya adalah dengan write-host -n(kependekan -NoNewLine), dan itu benar-benar membunuh panjangnya di sini.

Pada dasarnya, ini berulang melalui urutan, membangun $esebagai "saat" W _n saat kita pergi. Namun, karena kami ingin membuat kata tak terbatas alih-alih urutannya, kami memanfaatkan variabel sebelumnya untuk mencetak akhiran $ayang terisi di loop sebelumnya. Kemudian kita mengatur variabel kita untuk putaran berikutnya dan mengulangi loop. Perhatikan bahwa ini mengharapkan input untuk secara eksplisit dibatasi sebagai string, jika tidak +operator akan digunakan untuk aritmatika alih-alih penggabungan.

Contoh:

PS C:\Tools\Scripts\golfing> .\infinite-ftw.ps1 "111" "000"
0001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110000001110001110000001110001110000001110000001110001110000001110000 ...

APL, 24 18

{(,/⌽⍵),⊂⍞←↑⍵}⍣≡⍞⍞

Menggunakan formulasi xnor diizinkan untuk memangkas beberapa karakter.

                 ⍞  ⍝ Read W₋₁ as a character string.
                ⍞   ⍝ Read W₀.
{            }⍣≡    ⍝ Apply the following function repeatedly until fixpoint:
                    ⍝ It takes a pair of strings (A B),
         ⍞←↑⍵       ⍝ prints A
 (,/⌽⍵),⊂  ↑⍵       ⍝ and returns (BA A).

Pada mesin infinite dalam waktu tak terbatas itu sebenarnya akan mencetak W _∞ tiga kali — pertama secara bertahap saat menjalankan loop, dan kemudian dua kali sebagai hasil dari seluruh ekspresi ketika ⍣≡operator fixpoint akhirnya kembali.

Ini tidak terlalu cepat tetapi cukup cepat. Di GNU APL:

$ printf '%s\n' '{(,/⌽⍵),⊂⍞←↑⍵}⍣≡⍞⍞' 1 0 | apl -s | head -c 100
0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010$
$ time printf '%s\n' '{(,/⌽⍵),⊂⍞←↑⍵}⍣≡⍞⍞' 1 0 | apl -s | head -c 1000000 >/dev/null
    0m3.37s real     0m2.29s user     0m1.98s system

Bash murni, 58

a=$1
b=$2
printf $b
for((;;)){
printf $a
t=$b
b+=$a
a=$t
}

Saya kehabisan memori sebelum 1 menit, tetapi memiliki banyak digit saat itu - setelah 10 detik saya memiliki 100 juta digit:

$ ./ftw.sh 1 0 | head -c100
0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010ubuntu@ubuntu:~$ 
$ { ./ftw.sh 1 0 & sleep 10 ; kill $! ; } | wc -c
102334155
$ 

Mathematica, 56 byte

$IterationLimit=∞;#0[$Output~WriteString~#2;#2,#<>#2]&

C, 76 (gcc)

main(c,v)char**v;{int p(n){n>2?p(n-1),p(n-2):puts(v[n]);}for(p(4);;p(c++));}

Ini adalah printer rekursif yang cukup mudah, diimplementasikan sebagai fungsi bersarang (ekstensi GNU C tidak didukung oleh dentang) untuk menghindari keharusan berpindah v- pindah . p(n)mencetak W _n-2 , di mana W _-1 dan W ₀ harus disediakan di v[1]dan v[2]. Ini awalnya panggilan p(4)untuk mencetak W ₂ . Kemudian loop: itu panggilan p(3)untuk mencetak W ₁ , membuat output lengkap W ₂ W ₁ , yaitu W ₃ . Kemudian panggilan p(4)untuk mencetak W ₂ , membuat output lengkap W₄ , dll. Kinerja sedikit lebih baik daripada jawaban saya sebelumnya: Saya melihat nilai 1875034112 dalam satu menit.

C, 81 (dentang)

Ini adalah pendekatan yang sama sekali berbeda dari yang di atas yang saya rasa layak untuk dipertahankan, meskipun skornya lebih buruk.

s[],*p=s;main(c,v)char**v;{for(++v;;)for(puts(v[*++p=*++p!=1]);*p+1==*--p;++*p);}

Ini memiliki semua jenis perilaku yang tidak terdefinisi, terutama untuk bersenang-senang. Ini bekerja dengan dentang 3.6.2 di Linux dan dengan dentang 3.5.2 di Cygwin untuk kasus uji dalam pertanyaan, dengan atau tanpa opsi baris perintah khusus. Itu tidak rusak ketika optimisasi diaktifkan.

Itu tidak bekerja dengan kompiler lain.

Anda dapat menerima kata-kata dalam urutan apa pun; sebagai dua array, array array, dua string, sebuah array string, atau string tunggal dengan pembatas pilihan Anda.

Saya menerima kata-kata sebagai argumen baris perintah dalam format string.

Anda dapat mencetak digit kata tak terbatas baik tanpa pembatas atau dengan pembatas yang konsisten antara setiap pasangan digit yang berdekatan.

Saya menggunakan baris baru sebagai pembatas yang konsisten.

Untuk semua tujuan, asumsikan kode Anda tidak akan pernah kehabisan memori, dan bahwa tipe datanya tidak meluap.

Secara khusus, ini berarti bahwa setiap output ke STDOUT atau STDERR yang merupakan hasil dari crash akan diabaikan.

Saya mengakses di sluar batas. Ini pasti harus diakhiri dengan segfault atau pelanggaran akses di beberapa titik. skebetulan ditempatkan di akhir segmen data, sehingga tidak akan mengganggu variabel lain dan memberikan output yang salah sebelum segfault itu. Semoga.

Jika saya menjalankan kode Anda di komputer saya (Intel i7-3770, 16 GiB RAM, Fedora 21) selama satu menit dan mengirimkan hasilnya wc -c, harus mencetak setidaknya satu juta digit W _dig untuk (W _-1 , W ₀ ) = (1, 0) .

Pengujian menggunakan { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c, saya mendapatkan 1816784896 digit dalam satu menit di mesin saya ketika program dikompilasi -O3, dan 1596678144 ketika dikompilasi dengan optimisasi diaktifkan.

Ungolfed, no UB, dengan penjelasan:

#include <stdio.h>

// Instead of starting with -1 and 0, start with 0 and 1. I will use lowercase w for that,
// so that wx = W(x-1).

// Declare a variable length array of numbers indicating what has been printed.
// The length is indicated through a pointer just past the end of the values.
// The first element of the array is a special marker.
// [0 3 1] means that w3 w1 has been printed.
// The array is initialised to [0] meaning nothing has been printed yet.
int stack[99999];
int *ptr = stack + 1;

int main(int argc, char *argv[]) {
  ++argv; // Let argv[0] and argv[1] refer to w0 and w1.
  for(;;) {
    // Determine the word to print next, either 0 or 1.
    // If we just printed 1 that wasn't the end of a different word, we need to print 0 now.
    // Otherwise, we need to print 1.
    int word = ptr[-1] != 1;

    // Print the word, and mark the word as printed.
    puts(argv[word]);
    *ptr++ = word;

    // If we just printed w(x) w(x-1) for any x, we've printed w(x+1).
    while (ptr[-1] + 1 == ptr[-2]) {
      --ptr;
      ++ptr[-1];
    }
  }
}

Javascript (53 byte)

(a,c)=>{for(;;process.stdout.write(a))b=a,a=c,c=b+a;}

Input harus berupa string dan bukan angka ( '0'dan bukan hanya 0).

Perl 5, 45 55 49 byte

44 byte, ditambah 1 untuk -Ebukan-e

sub{$i=1;{say$_[++$i]=$_[$i].$_[$i-1];redo}}

Gunakan sebagai contoh

perl -E'sub{$i=1;{say$_[++$i]=$_[$i].$_[$i-1];redo}}->(1,0)'

Ini akan mencetak perkiraan berurutan ke W _∞ dan dengan demikian, jika Anda menunggu cukup lama, mencetak, pada baris keluaran terakhir, W _∞ dengan panjang yang diinginkan, seperti yang diperlukan. Digit kata digabungkan tanpa pembatas.

Karena aku pada Windows, saya diuji untuk "setidaknya satu juta digit W _∞ " persyaratan dengan menjalankan dengan output diarahkan ke file dan membunuh itu setelah sekitar 59 detik, kemudian menjalankan GnuWin32 ini wc -L, yang dicetak 701.408.733.

Memperbarui:

OP mengklarifikasi dalam komentar tentang jawaban ini (dan mungkin saya seharusnya menyadari juga) bahwa output tambahan sebelum W _∞ mendiskualifikasi hal di atas. Jadi alih-alih inilah solusi 55-byte yang hanya mencetak W _∞ :

sub{print$_[0];{print$_[1];unshift@_,$_[0].$_[1];redo}}

Digunakan dengan cara yang sama, tetapi dengan argumen dalam urutan terbalik , dan tidak memerlukan -E:

perl -e'sub{print$_[0];{print$_[1];unshift@_,$_[0].$_[1];redo}}->(0,1)'

Tidak diragukan lagi itu bisa di-golf lebih lanjut, tetapi saya tidak tahu bagaimana melakukannya sekarang.

Pembaruan lebih lanjut:

Dennis mencukur lima byte dengan menggunakan -a(membaca sehingga <>menghapus sub) dan menugaskan kembali parameter yang diteruskan ke printpada akhir redoblok:

Dengan -anedan membaca dari <>(kedua input pada satu baris, dipisahkan oleh ruang, dalam urutan terbalik); 48 + 2 byte:

$_=$F[0];{print;unshift@F,$F[0].($_=$F[1]);redo}

Dan, berdasarkan itu, saya mencukur satu byte lagi (sama seperti di atas, tetapi sekarang inputnya dalam urutan yang benar); 47 + 2 byte:

$_=$F[1];{print;push@F,$F[-1].($_=$F[-2]);redo}

REXX , 48

arg a b
do forever
b=a||b
say b
a=b||a
say a
end

ftw.rex
exec ftw.rex 0 1

Saat ini tidak dapat menguji kinerja karena saya menggunakan kompiler online untuk menulisnya. "Selamanya" dapat diganti dengan angka apa pun sebagaimana nomor ftw tercetak (angka + 2).

Saya juga menulis solusi kecil (berantakan) di Prolog. Tidak tahu bagaimana cara menguji kinerja dengan yang satu ini, tetapi mungkin itu mengerikan.

f(A,B,C):-atom_concat(B,A,D),(C=D;f(B,D,C)).

:- C='0';C='1';(f(1,0,C)).

Python 2, 67 byte

a,b=input()
print'\n'.join(b+a)
while 1:a,b=b,b+a;print'\n'.join(a)

Menerima input sebagai pasangan string yang dipisahkan koma:, "1","0"untuk contoh dalam pertanyaan.

Tidak ada juru bahasa online karena loop tak terbatas itu buruk. Buffered output membuat saya mendapatkan banyak byte. :( Terima kasih Dennis untuk menunjukkan bahwa 1 digit per baris valid.

Pengaturan waktu pada mesin saya (secara signifikan lebih lemah):

$ time python golf.py <<< '"1","0"' 2>/dev/null | head -c2000000 > /dev/null

real    0m1.348s
user    0m0.031s
sys     0m0.108s

Dyalog APL, 9

{⍵∇⍺,⍞←⍵}

Ini digunakan ∇untuk mendefinisikan fungsi rekursif. Ini adalah terjemahan langsung dari jawaban Python 3 xnor ini . Dibutuhkan W ₀ sebagai kanan, dan W ₋₁ sebagai argumen kirinya, keduanya harus vektor karakter.

Minkolang 0,11 , 62 byte

(od" "=,6&xI0G2@dO$I)I1-0G($d2[I2:g]Xx0c2*1c-0g0g-d[icO]0G0G1)

Coba di sini. Mengharapkan input dalam urutan W ₀ , W _-1 dengan spasi di antaranya.

Penjelasan

(                             Open while loop (for input-reading)
 od                           Read in character from input and duplicate
   " "=,                      0 if equal to " ", 1 otherwise
        6&                    Jump 6 characters if this is non-zero
          xI0G2@              Dump, push length of stack, move to front, and jump next two
                dO            Duplicate and output as character if 1
                  $I)         Close while loop when input is empty
                     I1-0G    Push length of stack - 1 and move it to the front

Meta-penjelasan untuk yang berikut adalah bahwa pada titik waktu ini, kita memiliki dua angka diikuti oleh string "0" dan "1" tanpa pemisahan. Jika panjang W ₀ dan W _-1 adalah adan b, masing-masing, maka dua angka di depan tumpukan yang <a+b>dan <a>, dalam urutan itu. Kata yang dibentuk dengan menggabungkan W _{i + 1} dan W _i , yaitu W _{i + 1} + W _i , sama dengan 2 * W _{i + 1} - W _i . Jadi kode berikut menduplikasi stack (2 * W _{i +1} ), muncul di bagian atas<a>elemen (- W _i ), dan kemudian menggantikan <a+b>dan <a>dengan penggantinya, <a+2b>dan <b>.

(                                       Open while loop (for calculation and output)
 $d                                     Duplicate the whole stack
   2[I2:g]                              Pull <a+b> and <a> from the middle of the stack
          Xx                            Dump the top <a> elements (and <a+b>)
            0c2*1c-                     Get <a+b> and <a>, then calculate
                                        2*<a+b> - <a> = <a+2b> = <a+b> + <b>
                   0g0g-                Get <a+b> and <a>, then subtract
                        d[icO]          Output as character the first <b> elements
                              0G0G      Move both to front
                                  1)    Infinite loop (basically, "while 1:")

Python 3, 32

def f(a,b):print(end=b);f(b,a+b)

Ide rekursif yang sama dengan jawaban Haskell saya , kecuali awalannya dicetak karena Python tidak dapat menangani string tanpa batas.

Menggunakan trik dari Sp3000 untuk mencetak tanpa spasi dengan meletakkan string sebagai endargumen di Python 3

Perl, 32 byte

#!perl -pa
$#F=3}for(@F){push@F,$F[-1].$_

Menghitung shebang sebagai dua, input diambil dari stdin, spasi dipisahkan sebagai W ₀ , W _-1 . Output untuk 1MB kali pada ~ 15 ms, yang sebagian besar dapat dikaitkan dengan peluncuran juru bahasa.

Contoh Penggunaan

$ echo 0 1 | perl inf-ftw.pl
0100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001...

$ echo 110 101 | perl inf-ftw.pl
1101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101101011101011101101011101101011101011101101011101011101101011101...

Prolog, 69 byte

q(A,B):-atom_concat(B,A,S),write(A),q(B,S).
p(A,B):-write(B),q(A,B).

Input contoh: p ('1', '0')

Belum menemukan cara untuk menghapus penulisan tambahan.
Harus bisa memperbaiki ini jika saya tahu bagaimana melakukannya.