Sonsuz Fibonacci kelime spesifik, sınırlı bir ikili tekrarlanan kelimeler birleştirme ile hesaplanmıştır ikili rakamlar, sonsuz dizisidir.

Bize bu tanımlayalım Fibonacci tipi kelime dizisi (veya FTW sekansı ) herhangi bir dizisidir ⟨W _n ⟩ aşağıdaki şekilde oluşturulur.

• İkili basamaktan oluşan iki rasgele diziyle başlayın. Bu dizilere W _-1 ve W ₀ diyelim .

• Her n> 0 için , W _n W _n-1 ∥ W _{n-2 olsun} , burada aten birleştirme anlamına gelir.

Yinelemeli tanımının bir sonucu olduğunu W _{, n} , her zaman bir önek olan W _{, n + 1} ve bu nedenle, her bir W, _k , öyle ki , n> k . Bir anlamda, bu araçlar dizisi ⟨W _n ⟩ sonsuz kelime yakınsamaktadır.

Biçimsel olarak, izin W _∞ bu şekilde sadece sonsuz dizidir W _{, n} bir önek olan W _∞ tüm n ≥ 0 .

Yukarıdaki süreç tarafından oluşturulan sonsuz kelimeyi sonsuz FTW olarak adlandırırız .

Görev

İki ikili kelime kabul eden bir program ya da işlev Yazın B _-1 ve W, ₀ giriş ve baskılar gibi B _∞ sonra ilave kuralına göre uyan:

• Kelimeleri herhangi bir sırayla kabul edebilirsiniz; iki dizi, bir dizi, iki dizi, bir dizi veya tercih ettiğiniz sınırlayıcıya sahip bir dizi.

• Sınırsız sözcüğün basamaklarını, sınırlayıcı olmadan veya bitişik basamakların her biri arasında tutarlı bir sınırlayıcıyla yazdırabilirsiniz.

• Tüm amaçlar için, kodunuzun hiçbir zaman belleğinin tükenmeyeceğini ve veri türlerinin taşmadığını varsayalım.

  Özellikle bu, bir çarpma sonucu olan STDOUT veya STDERR'ye yapılan herhangi bir çıkışın göz ardı edileceği anlamına gelir.

• Kodunuzu makinemde (Intel i7-3770, 16 GiB RAM, Fedora 21) bir dakika çalıştırıp çıkışını boruya yazdıysam, wc -cen az bir milyon hanelik W _∞ (W _-1 , W ₀ ) _basmalıdır . = (1, 0) .

• Standart kod-golf kuralları geçerlidir.

Örnek

Let W _-1 = 1 ve W, ₀ = 0 .

Sonra W ₁ = 01 , W ₂ = 010 , W, ₃ = 01.001 , W ₄ = 01001010 ... ve W _∞ = 010010100100101001010 ... .

Bu sonsuz Fibonacci sözcüğü.

Test durumları

Tüm test durumları sonsuz FTW'nin ilk 1000 basamağını içerir.

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 bayt

u,peGsGQ

Formdaki giriş "W-1", "W0".

Tamamlama belgesi:

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

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

Doğruluk kanıtı:

İşte dahili olarak üretilen seri. Program tarafından birleştirilerek basılmıştır.

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

Her adımda bir önceki dizgiye eklenen dize olan, birleşik olarak basılmış aşağıdakilerle karşılaştırın:

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

Bunların eşdeğer olduğunu kanıtlamak istiyoruz.

Açıkçası, ilk birkaç adımda aynılar. Biraz sonra onları karşılaştıralım:

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

Dizi çiftlerinin dönüşümlü olarak formlardan oluştuğunu görüyoruz:

01a 10b
a10 b01

A ve b'nin 0 ve 1'lerdeki rastgele diziler olduğu yerler. Dizinin bir kısmı için devam edelim, ispatla sonsuza dek sürdüğünü kanıtlamak için:

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

2 adım sonra doğru biçimdedir.

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

2 adım sonra doğru biçimdedir.

Dolayısıyla indüksiyonla, dizgiler her zaman birleştikten sonra eşleşir.

Haskell, 15 bayt

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

İnfix işlevi %, Haskell'ın böyle soğuk olması nedeniyle, Haskell'in sonsuza dek yazdırdığı sonsuz bir dize üretir.

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

Özyinelemeli fikir Zgarb'ın çözümüne benziyor . Yazma fişlevi için %, ve +karakter dizisi birleştirme için ise uyguladığı:

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

Sonsuz çıktı dizesi ile başlar wve geri kalanı Fibonacci kaydırmalı dizgelerin sonucudur wve v+w.

Bunun bir dakika içinde milyon karakter üretme sorunu yoktur.

Haskell, 31 bayt

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

Bu, #iki dize alan ve sonsuz bir dize döndüren bir infix işlevini tanımlar . Kullanımı:

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

"1" ve "0" ile tanımlanan dizinin milyonuncu elemanını sorgularsam, çevrimiçi tercüman bile sonucu bir saniyeden kısa bir sürede yazdırır:

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

açıklama

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.

Temel olarak, bunu biliyoruz w#v == v#(v++w)ve w#vbaşlıyoruz vve bu gerçekleri sonucu tanımlamak için kullanıyoruz. Haskell tembel olduğundan, bu "sihirli" sadece işe yarıyor.

Pip, 8 bayt

Hey, Pyth ile bağlı!

(fOba.b)

Anlaşılır özyinelemeli tanım, xnor'ın Haskell'in cevabından ödünç alındı . Netlik için boşluk eklenmiş olarak:

(f Ob a.b)

Pip içinde her program (değişkenlere atanan bağımsız değişkenler olarak komut satırı bağımsız değişken alır örtülü bir fonksiyonudur ayoluyla e) ve geri dönüş değeri basar. Ooperandını çıkaran ve sonra döndüren bir işleçtir, bu yüzden burada olan ilk şey ikinci argüman görüntülenir (newline izler).

Şimdi, Pip'deki Lisp-ilham sözdizimi , C benzeri dillere (f x y)eşdeğer bir işlev çağrısıdır f(x,y). fDeğişken akım fonksiyonu belirtir - bu durumda, en üst düzey programında. Böylece, program, yinelemeli kendisini çağıran bve a.byeni argümanlar olarak.

Bu yaklaşımın çok hızlı olduğunu görmek beni şaşırttı:

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

Ubuntu makinemde programın maksimum tekrarlama derinliğine ulaşması yaklaşık 30 saniye sürüyor, bu noktada bir basamaktan fazla basılıyor.

Bu yinelemeli çözüm biraz daha hızlıdır ve bir bayt pahasına daha az bellek depolar:

W1Sba.:Ob

CJam, 12 11 bayt

llL{@_o+_}h

Bu, iki kelimeyi ayrı sıralarda, örneğin ters sırada alır.

0
1

verir

0100101001001010010100100101001...

açıklama

Buradaki fikir, saf sözcüğü saf bir şekilde oluşturmaktır (mevcut sözcüğü hatırlayarak ve bir önceki kelimeyi ekleyerek) ve bunu yaparken, sadece eklediklerimizi basarız (önceden basılmış olan öneki tekrarlamamak için) . Başlangıç ​​noktasını ayrı ayrı ele almak zorunda kalmaktan kaçınmak için, boş bir kelimeden başlıyoruz; öyle ki W ₀ , eklediğimiz (ve yazdırdığımız) ilk şeydir.

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 Bayt

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

_{Edit - Umm, daha $e.substring($b.length)yeni bir araya geldikten sonra yazmak $ave $bbirlikte yazmak sadece $a... derp.}

Vay, ayrıntılı. PowerShell, varsayılan olarak, bir şeyi her çıktığınızda yeni bir satır çıkaracaktır. Gerçekten bununla baş etmenin tek yolu write-host -n(kısa -NoNewLine) ve bu kesinlikle burada uzunluğu öldürür.

Esasen, dizisi boyunca bu yinelediğinden bina $e"geçerli" W olarak _n biz gittikçe. Bununla birlikte, dizinin yerine sonsuz sözcüğü oluşturmak istediğimizden, $aönceki döngümüzde doldurulan eki yazdırmak için önceki değişkenlerimizden yararlanırız . Sonra değişkenlerimizi bir sonraki tur için ayarlıyoruz ve döngüyü tekrarlıyoruz. Bunun, girişin dizge olarak açıkça sınırlandırılmasını beklediğini, aksi takdirde +operatörün birleştirme yerine aritmetik olarak kullanıldığını unutmayın.

Örnek:

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

APL, 24 18

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

Xnor'ın formülasyonunu kullanmak birkaç karakterden kurtulmasına izin verdi.

                 ⍞  ⍝ 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).

Sonsuz zamanda sonsuz bir makinede aslında W _∞⍣≡ üçlü basardı ; ilk önce döngüyü çalıştırırken artımlı olarak, ardından sabit nokta operatörü nihayet döndüğünde tüm ifadenin bir sonucu olarak iki kez basardı.

Çok hızlı değil, yeterince hızlı. GNU APL’de:

$ 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

Saf bash, 58

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

1 dakikadan önce hafızam tükeniyor, ancak o zamana kadar çok sayıda basamak var - 10 saniye sonra 100 milyon basamak var:

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

Mathematica, 56 bayt

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

Bu, vdolaşmak zorunda kalmaktan kaçınmak için yuvalanmış bir işlev (clang tarafından desteklenmeyen bir GNU C uzantısı) olarak uygulanan oldukça basit bir özyinelemeli yazıcıdır . p(n)baskılar B _n-2 , burada W, _-1 ve W ₀ sağlanmalıdır v[1]ve v[2]. Bu başlangıçta W ₂p(4) yazdırmak için çağırır . Daha sonra, döngüler: bu aramaları baskı W ₁ tam çıktısını oluşturmak, W, _2'den B _{, 1} olan, W, ₃ . Daha sonra aramaları yazdırmak için W ₂ tam çıkış yapma Wp(3)p(4)₄ , vb. Performans önceki cevabımdan biraz daha iyi: Bir dakikada 1875034112 değer görüyorum.

C, 81 (klan)

Bu, yukarıdan tamamen farklı bir yaklaşım, daha kötü puanlar alsa da uymaya değer olduğunu düşünüyorum.

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

Bunun her türlü tanımlanmamış davranışı vardır, özellikle eğlence için. Özel komut satırı seçenekleri olsun veya olmasın, söz konusu test durumları için Linux'ta clang 3.6.2 ve Cygwin'de clang 3.5.2 ile çalışır. Optimizasyonlar etkinleştirildiğinde kırılmaz.

Diğer derleyicilerle çalışmaz.

Kelimeleri herhangi bir sırayla kabul edebilirsiniz; iki dizi, bir dizi, iki dizi, bir dizi veya tercih ettiğiniz sınırlayıcıya sahip bir dizi.

Kelimeleri dize biçiminde komut satırı argümanları olarak kabul ediyorum.

Sınırsız sözcüğün basamaklarını, sınırlayıcı olmadan veya bitişik basamakların her biri arasında tutarlı bir sınırlayıcıyla yazdırabilirsiniz.

Newline'ı tutarlı sınırlayıcı olarak kullanıyorum.

Tüm amaçlar için, kodunuzun hiçbir zaman belleğinin tükenmeyeceğini ve veri türlerinin taşmadığını varsayalım.

Özellikle bu, bir çarpma sonucu olan STDOUT veya STDERR'ye yapılan herhangi bir çıkışın göz ardı edileceği anlamına gelir.

sSınırlardan erişiyorum . Bu kesinlikle bir noktada bir segfault veya erişim ihlali ile bitmelidir. sveri bölümünün sonuna yerleştirildiği için, diğer değişkenleri engellememeli ve bu bölümden önce yanlış çıktı vermemelidir. İnşallah.

Kodunuzu makinemde (Intel i7-3770, 16 GiB RAM, Fedora 21) bir dakika çalıştırıp çıkışını boruya yazdıysam, wc -cen az bir milyon hanelik W _∞ (W _-1 , W ₀ ) _basmalıdır . = (1, 0) .

Testleri kullanarak { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c, program derlendiğinde makinemde bir dakikada 1816784896 hane -O3ve optimizasyon devre dışı bırakıldığında derleme 1596678144'ü alıyorum.

Ungolfed, UB yok, açıklama ile:

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

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

Girdi dizge olmalı ve sayı değil ( '0'sadece değil 0).

Perl 5, 45 55 49 bayt

44 bayt, artı 1 -Eyerine-e

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

Örneğin kullanın

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

Bu, W _∞'a arka arkaya yaklaşımlar basar ve bu nedenle, eğer yeterince beklerseniz, son çıktı satırına W _∞ basar. istenen herhangi bir uzunluğa, gerektiği şekilde . Kelimenin basamakları, sınırlayıcı olmadan birleştirilir.

Ben Windows üzerinde olduğum için, "W en az bir milyon basamağı için test _∞ sonra GnuWin32 koşu, bir dosyaya yönlendirilir çıkışı ile onu çalıştıran ve 59 ile ilgili saniye sonra onu öldürerek gereksinimi" wc -L, 701408733 baskılı hangi.

Güncelleştirme:

OP, bu cevaba yaptığı bir yorumda (ve muhtemelen yine de fark etmeliydim) açıkladı ki W _∞'dan önce gelen ekstra çıktı yukarıdakileri diskalifiye etti. Bu yüzden burada sadece W _∞ yazdıran 55 baytlık bir çözüm var :

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

Aynı şekilde kullanılır, ancak argümanlar ters sırada kullanılır ve gerektirmez -E:

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

Kuşkusuz daha da golf oynayabilir, ancak şu anda nasıl yapılacağını bilmiyorum.

Daha fazla güncelleme:

Dennis , bloğun sonunda geçen parametreyi kullanarak -a(böylece <>çıkarmak için okuma sub) kullanarak ve yeniden atayarak beş baytı tıraş printetti redo:

İle -aneve arasında okuma <>(her iki satırda bir giriş, boşlukla ayrılmış, ters sırada); 48 + 2 bayt:

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

Ve buna dayanarak, bir bayt daha fazla traş yaptım (yukarıdakiyle aynı, ancak şimdi girdiler doğru sırada); 47 + 2 bayt:

$_=$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 0

Şu anda performansı test edemiyorum çünkü yazmak için çevrimiçi bir derleyici kullandım. "Sonsuza kadar", basılı ftw numaralarının olduğu gibi herhangi bir numara ile değiştirilebilir (sayı + 2).

Ayrıca Prolog'da küçük (karışık) bir çözüm yazdım. Bununla performansını nasıl test edeceğimizi bilemedim ama yine de korkunç.

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 bayt

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

Girdiyi virgülle ayrılmış bir dizge çifti olarak kabul eder: "1","0" kabul eder: örneğin sorudaki.

Çevrimiçi tercüman yok, çünkü sonsuz döngüler kötü. Tamponlu çıktı çok fazla bayt kazanmamı sağladı. :( Satır başına 1 rakamın geçerli olduğunu belirttiğiniz için teşekkürler Dennis.

(Önemli ölçüde zayıf) makinemde zamanlama:

$ 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

{⍵∇⍺,⍞←⍵}

Bu ∇, özyinelemeli bir işlevi tanımlamak için kullanılır. Bu xnor'ın Python 3 cevabının doğrudan çevirisidir . Bu nedenle, W alır ₀ doğru olarak ve W _-1 sol bağımsız değişken olarak, her iki karakter vektörleri olmalıdır.

Minkolang 0.11 , 62 bayt

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

Burada dene. Aralarında boşluk olan W ₀ , W _-1 sırasındaki girişi bekler .

açıklama

(                             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

Aşağıdakiler için meta-açıklama, zamanın bu noktasında, iki sayıya ve ardından "0" s ve "1" s dizgelerine ayırma yapmamamızdır. Uzunlukları ise W ₀ ve W _-1 olan ave bdaha sonra istifin önünde iki sayı, sırası ile, <a+b>ve <a>bu sırayla,. Birleştirerek oluşturulan bir kelime W _{i + 1} ve W _i , örneğin, W, _{i + 1} + B _i , 2 * eşittir W _{i + 1} - W _i . Bu yüzden aşağıdaki kod yığını (2 * W _{i + 1} kopyalar. ) , üstten çıkar<a>(- elemanlar B _i ) ve sonra da yerine geçer <a+b>ve <a>bunların ardıllarında, <a+2b>ve <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)

Haskell cevabımla aynı özyinelemeli fikirPython'un sonsuz dizeleri işleyememesi nedeniyle, ön ekin basılması dışında .

endPython 3'te argümanı dizge olarak koyarak boşluk kullanmadan yazdırmak için Sp3000'den bir numara kullandık.

Perl, 32 bayt

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

Shebang'ı iki olarak sayarak girdi, stdin'den alınmış, W ₀ , W _-1 olarak ayrılmış alan . Birçoğu tercüman lansmanına atfedilebilen ~ 15ms'de 1 MB kez çıktı alın.

Örnek Kullanım

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

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

Prolog, 69 bayt

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

Örnek giriş: p ('1', '0')

Ekstra yazmayı kaldırmanın bir yolunu bulamadınız.
Bunu nasıl yapacağımı çözersem, bunu geliştirebilmeliyim.