無限フィボナッチ列は、特定の有限バイナリワードの繰り返し連結することによって計算される二進数の無限配列です。

私たちは、その定義できフィボナッチ型単語列（又はFTW配列が）任意の配列である ⟨W _N ⟩次のように形成されています。

• 2桁の2つの任意の配列の開始。これらの配列をW _-1およびW ₀と呼びましょう。

• それぞれについてN> 0、ましょうW _N ≔W _N-1 ∥W _N-2 、∥は連結を意味します。

再帰的な定義の結果、W _nは常にW _{n + 1の}プレフィックスであり、したがってすべてのW _k k> nとなるような。意味で、この手段配列⟨W _N ⟩無限ワードに収束します。

正式に、聞かせてWが_∞ようにのみ無限アレイでWが_Nの接頭辞であるW _∞すべてのためのn≥0 。

上記のプロセスで形成された無限の単語を無限FTWと呼びます。

仕事

2つのバイナリワード受け入れプログラムまたは機能書き込みW _-1及びW _0を入力とし、印刷W _∞を以下、追加のルールを遵守し、：

• 任意の順序で単語を受け入れることができます。2つの配列、配列の配列、2つの文字列、文字列の配列、または選択した区切り文字を持つ単一の文字列として。

• 区切り文字なしで、または隣接する数字の各ペア間に一貫した区切り文字を使用して、無限ワードの数字を印刷できます。

• すべての目的で、コードがメモリ不足にならず、そのデータ型がオーバーフローしないと仮定します。

  特に、これは、クラッシュの結果であるSTDOUTまたはSTDERRへの出力が無視されることを意味します。

• 1分とパイプに、その出力のため、私は私のマシン上でコードを実行した場合（インテルi7-3770、16ジブRAM、Fedoraの21） wc -c、それは、少なくとも百万数字を印刷する必要がありW _∞について（W _-1、W ₀） =（1、0）。

• 標準のコードゴルフ規則が適用されます。

例

レッツW _-1 = 1およびW ₀ = 0。

次に、W ₁ = 01、W ₂ = 010、W ₃ = 01001、W ₄ = 01001010 ...とW _∞ = 010010100100101001010 ...。

これは、無限のフィボナッチ列。

テストケース

すべてのテストケースには、無限FTWの最初の1,000桁が含まれています。

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バイト

u,peGsGQ

フォームに入力し"W-1", "W0"ます。

完了の証明：

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

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

正当性の証明：

以下は、内部的に生成されたシリーズです。プログラムによって連結されて印刷されます。

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

連結して印刷された次のコードと比較してください。これは、各ステップで前の文字列に追加された文字列です。

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

これらが同等であることを証明したいと思います。

明らかに、それらは最初のいくつかのステップで同じです。それらを少し比較してみましょう：

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

文字列のペアが交互に次の形式であることがわかります。

01a 10b
a10 b01

ここで、aとbは0と1の任意のシーケンスです。シーケンスを少し続けて、帰納によって永遠に続くことを証明しましょう：

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

2ステップ後、それは正しい形式です。

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

2ステップ後、それは正しい形式です。

したがって、帰納法では、文字列は連結されると常に一致します。

Haskell、15バイト

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

infix関数%は無限の文字列を生成しますが、Haskellはそのようにクールであるため、Haskellは永遠に出力します。

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

再帰的なアイデアは、Zgarbのソリューションに似ています。書き込みf機能のために%、そして+文字列の連結のために、それが実装されています。

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

無限の出力文字列はで始まりw、残りはフィボナッチシフトされた文字列の結果でありw、v+w。

これは、1分間に100万文字を生成しても問題ありません。

Haskell、31バイト

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

これは、#2つの文字列を取り、無限の文字列を返すinfix関数を定義します。使用法：

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

「1」と「0」で定義されたシーケンスの100万番目の要素を照会すると、オンラインインタープリターでさえ1秒未満で結果を出力します。

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

説明

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.

基本的に、私たちはそれを知ってw#v == v#(v++w)おり、でw#v始まり、vこれらの事実を使用して結果を定義します。Haskellは遅延しているため、これは「魔法のように」機能するだけです。

ピップ、8バイト

ねえ、Pythと結ばれた！

(fOba.b)

xnorのHaskell answerから借りた単純な再帰的定義。明確にするためにスペースを追加しました：

(f Ob a.b)

Pipのすべてのプログラムは暗黙的な関数であり、コマンドライン引数を引数として（をa介して変数に割り当てられますe）、戻り値を出力します。Oはオペランドを出力して返す演算子であるため、ここで最初に発生するのは2番目の引数です（末尾の改行はありません）。

さて、Lispにヒントを得た構文 (f x y) Pipのは関数呼び出しであり、f(x,y)Cのような言語と同等です。fこの場合には、トップレベルのプログラム-変数は、現在の関数を指します。したがって、プログラムは、新しい引数を使用bしa.bて、自身を再帰的に呼び出します。

このアプローチが非常に高速であることを知って私はうれしい驚きを覚えました。

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マシンでは、プログラムが最大再帰深度に達するのに約30秒かかります。この時点で、10億桁以上のどこかに出力されます。

この反復ソリューションはわずかに高速であり、1バイトのコストでメモリを消費します。

W1Sba.:Ob

CJam、12 11バイト

llL{@_o+_}h

これは、2つの単語を別々の行に、逆の順序で取ります。たとえば、

0
1

与える

0100101001001010010100100101001...

説明

（現在の単語を覚えて、前の単語を追加することで）単語を単純に構築し、その間、追加したものをすべて印刷します（既に印刷されたプレフィックスを繰り返さないため） 。開始点を個別に処理する必要を回避するために、W ₀が最初に追加（および印刷）されるように、空の単語から開始します。

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バイト

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

_{編集-うーん、$e.substring($b.length)私たちが連結$aして$b一緒にした後に書き出すことは、ちょうど書き出すことと同等です$a ... derpです。}

うわー、冗長。PowerShellは、デフォルトで、何かを出力するたびに改行を吐き出します。本当にそれを回避する唯一の方法はwrite-host -n、-NoNewLine）であり、それはここで長さを絶対に殺します。

基本的に、これはシーケンスを反復処理$eし、「現在の」W _nとして構築します。ただし、シーケンスではなく無限の単語を作成したいので、以前の変数を活用$aして、以前のループで生成されたサフィックスを出力します。次に、次のラウンドの変数を設定し、ループを繰り返します。これは入力が文字列として明示的に区切られることを期待していることに注意してください。そうでない場合、+演算子は連結ではなく算術に使用されます。

例：

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

APL、24 18

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

xnorの定式化を使用すると、少数の文字を削ることができます。

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

無限時間の無限マシンでは、実際には_W∞を 3回印刷します。最初はループの実行中にインクリメンタルに、次に⍣≡フィックスポイント演算子が最終的に戻るときに式全体の結果として2回印刷します。

それほど高速ではありませんが、十分に高速です。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、58

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

私は1分前に​​メモリを使い果たしましたが、それまでに十分な桁を持っています-10秒後に私は1億桁を持っています：

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

Mathematica、56バイト

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

これはかなり簡単な再帰プリンターであり、入れ子になった関数（clangでサポートされていないGNU C拡張）として実装されており、回避する必要がありませんv。p(n)印刷物W _N-2 、W _-1およびW _0はで提供されなければならないv[1]とv[2]。これは最初にW _2のp(4)印刷を呼び出します。その後、ループします：W ₁を印刷するために呼び出し、完全な出力Wを作成しますp(3) ₂、W ₁で、 W _3を。次に、 W ₂p(4)印刷を呼び出します、て、完全な出力Wを作成します₄、など。パフォーマンスは、以前の回答よりもわずかに優れています：1分で1875034112の値が表示されます。

C、81（clang）

これは上記とはまったく異なるアプローチであり、スコアは悪くなりますが、維持する価値があると感じています。

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

これには、主に楽しみのために、あらゆる種類の未定義の動作があります。Linuxのclang 3.6.2およびCygwinのclang 3.5.2で、問題のテストケースに対して、特別なコマンドラインオプションの有無にかかわらず動作します。最適化が有効になっていても壊れません。

他のコンパイラでは機能しません。

任意の順序で単語を受け入れることができます。2つの配列、配列の配列、2つの文字列、文字列の配列、または選択した区切り文字を持つ単一の文字列として。

文字列形式のコマンドライン引数として単語を受け入れます。

区切り文字なしで、または隣接する数字の各ペア間に一貫した区切り文字を使用して、無限ワードの数字を印刷できます。

改行を一貫した区切り文字として使用します。

すべての目的で、コードがメモリ不足にならず、そのデータ型がオーバーフローしないと仮定します。

特に、これは、クラッシュの結果であるSTDOUTまたはSTDERRへの出力が無視されることを意味します。

s範囲外にアクセスします。これは、ある時点で必ずセグメンテーション違反またはアクセス違反で終了する必要があります。sたまたまデータセグメントの最後に配置されるため、他の変数を上書きして、そのセグメンテーション違反の前に誤った出力をしてはなりません。うまくいけば。

1分とパイプに、その出力のため、私は私のマシン上でコードを実行した場合（インテルi7-3770、16ジブRAM、Fedoraの21） wc -c、それは、少なくとも百万数字を印刷する必要がありW _∞について（W _-1、W ₀） =（1、0）。

を使用してテストする{ ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -cと、プログラムがでコンパイルされたときに1分で1816784896桁の数字が得-O3られ、最適化を無効にしてコンパイルされたときには1596678144が得られます。

Ungolfed、UBなし、説明付き：

#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バイト）

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

入力は数字ではなく文字列である必要があります（'0'単なるではありません0）。

Perl 5の、45の 55 49バイト

44バイト、プラスの-E代わりに1-e

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

例として使用

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

これにより、_W∞の逐次近似が出力されるため、十分に長く待つと、出力の最後の行に_W∞が必要な長さに出力されます。単語の数字は、区切り文字なしで連結されます。

私はWindowsを使用しているので、出力をファイルにリダイレクトして実行し、約59秒後にそれを強制終了し、GnuWin32'sを実行して701408733を実行することにより、「少なくとも100万桁の_W∞」要件についてwc -Lテストしました。

更新：

OPは、この回答に関するコメントで、_W∞に先行する余分な出力が上記の条件を満たさないことを明らかにしました（おそらく、とにかく私は気付いたはずです）。だからではなく、ここでは55バイトのソリューションは、印刷物ことだのみ W _∞：

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

同じ方法で使用しますが、引数の順序は逆で、必要ありません-E：

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

間違いなくそれはさらにゴルフすることができますが、私は今それを行う方法がわかりません。

さらに更新：

Dennisは、ブロックの最後に渡されたパラメーターを使用して-a（したがって<>、削除するために読み取りsub）、渡されたパラメーターを再割り当てして、5バイトを削りprintましたredo。

以下と-aneから読み出す<>（1行上の両方の入力、スペースで区切られ、逆の順序で）。48 + 2バイト：

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

そして、それに基づいて、もう1バイト削りました（上記と同じですが、入力は正しい順序になっています）。47 + 2バイト：

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

現在、オンラインコンパイラを使用して記述したため、パフォーマンスをテストできません。「forever」は、印刷されたftw番号が（number + 2）である任意の番号に置き換えることができます。

また、Prologで小さな（乱雑な）ソリューションを作成しました。これでパフォーマンスをテストする方法を考えていませんでしたが、とにかく恐ろしいことです。

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バイト

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

"1","0"質問の例では、入力を文字列のコンマ区切りペアとして受け入れます。

無限ループが悪いため、オンラインインタープリターはありません。 バッファリングされた出力により、多くのバイトが得られました。:(行ごとに1桁が有効であることを指摘してくれたデニスに感謝します。

私の（かなり弱い）マシンでのタイミング：

$ 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

{⍵∇⍺,⍞←⍵}

これは ∇は、再帰関数を定義するためにします。これは、このxnorのPython 3の回答を直接翻訳したものです。W ₀を右、W _-1を左の引数として取ります_。両方とも文字ベクトルでなければなりません。

Minkolang 0.11、62バイト

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

ここで試してみてください。W ₀の順序で入力を期待します、W _-1の間にスペースを入れます。

説明

(                             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

以下のメタ説明は、この時点で、2つの数値の後に「0」と「1」の文字列が続き、分離されていないことです。長場合W ₀及びW _-1であるaとb、スタックの正面に2つの番号は、それぞれ、<a+b>そして<a>そのために、。W _{i + 1}とW _iを連結することによって形成される単語、つまりW _{i + 1} + W _iは、2 * Wに _{I + 1} - W _I。したがって、次のコードはスタック（2 * W等しく、その後継者と一緒になります。 _{i + 1}）をし、先頭からポップします<a>要素（-W要素_I）、その後、置き換え<a+b><a><a+2b><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)

Pythonは無限の文字列を処理できないため、プレフィックスが出力されることを除いて、私のHaskell answerと同じ再帰的なアイデア。

endPython 3で文字列を引数として使用して、スペースなしで印刷するためにSp3000のトリックを使用しました

Perl、32バイト

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

シバンを2としてカウントすると、入力はstdinから取得され、スペースはW ₀、W _-1として区切られます。〜15msで1MB回出力します。そのほとんどはインタープリターの起動に起因します。

サンプルの使用法

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

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

プロローグ、69バイト

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

入力例： p（ '1'、 '0'）

余分な書き込みを削除する方法が見つかりませんでした。
私はそれを行う方法を見つけた場合、これを改善できるはずです。