所述无限斐波纳契字是一个特定的二进制数字，其通过有限二进制字重复级联计算无限序列。

让我们定义一个斐波那契型字序列（或FTW序列）是任何序列 ⟨W _Ñ ⟩其如下形成。

• 开始使用两个任意的二进制数字数组。让我们将这些数组称为W _-1和W ₀。

• 对于每个N> 0，让W¯¯ _Ñ ≔w ^ _n-1个 ∥w ^ _N-2 ，其中∥表示级联。

递归定义的一个后果是，w ^ _Ñ总是的前缀w ^ _{n + 1个}，因此，所有的w ^ _ķ使得K>Ñ。在某种意义上，这意味着序列⟨W _Ñ ⟩收敛到一个无限的字。

形式上，让W¯¯ _∞是唯一的无限阵列使得W¯¯ _Ñ是的前缀W¯¯ _∞所有Ñ≥0 。

我们将由上述过程形成的任何无限词称为无限FTW。

任务

写接受两个二进制字的程序或函数w ^ _-1和w ^ ₀作为输入，并打印W¯¯ _∞，由下面的，额外的，遵守规则：

• 您可以按任何顺序接受这些词；作为两个数组，一个数组数组，两个字符串，一个字符串数组或一个带有您选择的定界符的单个字符串。

• 您可以在每对相邻数字之间不使用分隔符或使用一致的分隔符来打印无限单词的数字。

• 出于所有目的，假定您的代码将永远不会耗尽内存，并且其数据类型不会溢出。

  特别是，这意味着由于崩溃而导致的任何STDOUT或STDERR输出都将被忽略。

• 如果我在我的机器上运行的代码（英特尔i7-3770，16吉布RAM，Fedora的21），一分钟和管道的输出wc -c，它必须打印至少100万位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，其余部分为Fibonacci移位的字符串w和的结果v+w。

一分钟内生成一百万个字符没有问题。

Haskell，31个字节

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

这定义了一个#包含两个字符串并返回一个无限字符串的infix函数。用法：

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

如果我查询“ 1”和“ 0”定义的序列的第百万个元素，那么即使在线解释器也可以在不到一秒钟的时间内打印出结果：

> 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个字节

嘿，和佩斯绑在一起！

(fOba.b)

从xnor的Haskell答案借来的简单递归定义。为了清楚起见添加了空格：

(f Ob a.b)

Pip中的每个程序都是一个隐式函数，它将命令行args作为其参数（a通过分配给变量e）并输出其返回值。O是输出并返回其操作数的运算符，因此此处发生的第一件事是显示第二个参数（无尾随换行符）。

现在，(f x y)Pip中受Lisp启发的语法是一个函数调用，等效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秒，此时该程序已打印出超过十亿位的数字。

此迭代解决方案速度稍快，占用的内存更少，但只占用了一个字节：

W1Sba.:Ob

CJam，12 11个字节

llL{@_o+_}h

这将两个单词以相反的顺序放在单独的行上，例如

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∞三次-首先在运行循环时递增，然后在⍣≡定点运算符最终返回时，作为整个表达式的结果两次。

它不是很快，但是足够快。在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

纯扑，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 ₀。这最初要求打印W ₂。然后循环：调用打印W ₁，使完整的输出W ₂ W ₁为W ₃。然后，它调用打印W ₂，从而输出完整的Wv[1]v[2]p(4)p(3)p(4)₄等。性能比我以前的回答要好一些：我在一分钟内看到1875034112值。

C，81（lang）

我认为值得跟上的是与上述方法完全不同的方法，尽管它的得分更差。

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，可以使用或不使用特殊的命令行选项。启用优化后，它不会中断。

它不适用于其他编译器。

您可以按任何顺序接受这些词；作为两个数组，一个数组数组，两个字符串，一个字符串数组或一个带有您选择的定界符的单个字符串。

我接受字符串格式的单词作为命令行参数。

您可以在每对相邻数字之间不使用分隔符或使用一致的分隔符来打印无限单词的数字。

我使用换行符作为一致的分隔符。

出于所有目的，假定您的代码将永远不会耗尽内存，并且其数据类型不会溢出。

特别是，这意味着由于崩溃而导致的任何STDOUT或STDERR输出都将被忽略。

我无法进入s。在某些时候，这肯定必须以段错误或访问冲突结束。s碰巧被放置在数据段的末尾，因此它不应破坏其他变量并在该段错误之前提供错误的输出。希望。

如果我在我的机器上运行的代码（英特尔i7-3770，16吉布RAM，Fedora的21），一分钟和管道的输出wc -c，它必须打印至少100万位w ^ _∞为（W _-1，W ₀） =（1，0）。

使用进行测试，使用{ ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c编译程序时，在一分钟内在我的机器上得到1816784896位，-O3当使用优化禁用时，一分钟内得到1596678144位。

无高尔夫球，无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个字节，加上1 -E代替-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上，我测试了它的“W的至少100万的数字_∞通过重定向到一个文件输出运行它，大约59秒后杀死它，然后运行的GnuWin32的要求” wc -L，其中印刷701408733。

更新：

该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)'

毫无疑问，它可以进一步打下去，但我现在不知道该怎么做。

进一步更新：

丹尼斯通过使用-a（因此将其读取<>以删除sub）并重新分配print在redo块末尾传递给的参数来剃除五个字节：

具有-ane和从中读取<>（两个输入都在一行上，以空格分隔，以相反的顺序）；48 + 2个字节：

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

并且，基于此，我又剃了一个字节（与上面相同，但现在输入的顺序正确）；47 + 2个字节：

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

雷克斯 48

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

ftw.rex
执行程序ftw.rex 0 1

当前无法测试性能，因为我使用了在线编译器进行编写。“永久”可以替换为任何数字，其中打印的ftw数字为（数字+ 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"，例如问题中的示例。

没有在线解释器，因为无限循环是不好的。缓冲输出使我获得了很多字节。:(感谢Dennis指出每行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

对于以下内容的元解释是，在这个时间点上，我们有两个数字，后跟没有分隔的字符串“ 0”和“ 1”。如果W ₀和W _-1的长度分别是a和b，则堆栈前部的两个数字分别是<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)

与我的Haskell答案相同的递归思想，只是打印了前缀，因为Python无法处理无限字符串。

通过将字符串作为endPython 3中的参数，使用Sp3000的技巧来打印无空格

Perl，32个字节

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

将shebang数为2，则输入来自stdin，空格分隔为W ₀，W _-1。在〜15ms处输出1MB的时间，其中大部分可以归因于解释器的启动。

样品用量

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

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

Prolog，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'）

尚未找到删除多余写入的方法。
如果我知道该怎么做，应该可以对此进行改进。