Từ Fibonacci vô hạn là một chuỗi cụ thể, vô hạn các chữ số nhị phân, được tính bằng cách ghép lặp lại các từ nhị phân hữu hạn.

Hãy để chúng tôi xác định rằng một từ dãy Fibonacci-type (hoặc chuỗi FTW ) là bất kỳ chuỗi ⟨W _n ⟩ mà được hình thành như sau.

• Bắt đầu với hai mảng tùy ý của các chữ số nhị phân. Chúng ta hãy gọi các mảng này là W _-1 và W ₀ .

• Đối với mỗi n> 0 , chúng ta hãy W _n ≔ W _n-1 ∥ W _n-2 , nơi ∥ biểu thị nối.

Một hệ quả của định nghĩa đệ quy là W _n luôn là tiền tố của W _{n + 1} và do đó, trong tất cả các W _k sao cho k> n . Trong một nghĩa nào đó, phương tiện này chuỗi ⟨W _n ⟩ hội tụ đến một từ vô hạn.

Chính thức, chúng ta hãy W _∞ là mảng chỉ vô hạn mà W _n là tiền tố của W _∞ cho tất cả n ≥ 0 .

Chúng tôi sẽ gọi bất kỳ từ vô hạn nào được hình thành bởi quá trình trên là FTW vô hạn .

Bài tập

Viết một chương trình hoặc chức năng chấp nhận hai chữ nhị phân W _-1 và W ₀ như là đầu vào và in W _∞ , tuân thủ những điều sau, bổ sung, quy tắc:

• Bạn có thể chấp nhận các từ theo thứ tự bất kỳ; như hai mảng, một mảng các mảng, hai chuỗi, một chuỗi các chuỗi hoặc một chuỗi với một dấu phân cách bạn chọn.

• Bạn có thể in các chữ số của từ vô hạn mà không có dấu phân cách hoặc có dấu phân cách nhất quán giữa mỗi cặp chữ số liền kề.

• Đối với tất cả các mục đích, giả sử rằng mã của bạn sẽ không bao giờ hết bộ nhớ và các loại dữ liệu của nó không bị tràn.

  Cụ thể, điều này có nghĩa là bất kỳ đầu ra nào cho STDOUT hoặc STDERR là kết quả của sự cố sẽ bị bỏ qua.

• Nếu tôi chạy mã của bạn trên máy của mình (Intel i7-3770, RAM 16 GiB, Fedora 21) trong một phút và chuyển đầu ra của nó sang wc -c, nó phải in ít nhất một triệu chữ số W _∞ cho (W _-1 , W ₀ ) = (1, 0) .

• Tiêu chuẩn quy tắc golf-golf áp dụng.

Thí dụ

Đặt W _-1 = 1 và W ₀ = 0 .

Khi đó W ₁ = 01 , W ₂ = 010 , W ₃ = 01001 , W ₄ = 01001010 , và W _∞ = 010010100100101001010 .

Đây là những Fibonacci từ vô hạn.

Các trường hợp thử nghiệm

Tất cả các trường hợp thử nghiệm chứa 1.000 chữ số đầu tiên của FTW vô hạn.

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

Bình thường, 8 byte

u,peGsGQ

Đầu vào theo mẫu "W-1", "W0".

Bằng chứng hoàn thành:

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

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

Bằng chứng về sự đúng đắn:

Đây là loạt như được tạo ra trong nội bộ. Nó được in trong sự kết hợp của chương trình.

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

So sánh với các mục sau, được in theo cách ghép, đơn giản là chuỗi được thêm vào chuỗi trước đó trên mỗi bước:

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

Chúng tôi muốn chứng minh những điều này là tương đương.

Rõ ràng, chúng giống nhau thông qua một vài bước đầu tiên. Hãy so sánh chúng sau một lát:

010
  010

10010
  01001

01010010
  01001010

1001001010010
  0100101001001

Chúng ta thấy rằng các cặp chuỗi là xen kẽ của các hình thức:

01a 10b
a10 b01

Trong đó a và b là các chuỗi tùy ý trên 0 và 1. Hãy tiếp tục trình tự một chút, để chứng minh là tiếp tục mãi mãi bằng cảm ứng:

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

2 bước sau, nó là hình thức chính xác.

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

2 bước sau, nó là hình thức chính xác.

Vì vậy, bằng cách cảm ứng, các chuỗi luôn khớp một khi được nối.

Haskell, 15 byte

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

Hàm infix %tạo ra một chuỗi vô hạn, mà Haskell in mãi mãi vì Haskell rất tuyệt như thế.

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

Ý tưởng đệ quy tương tự như giải pháp của Zgarb . Viết fcho hàm %và +để nối chuỗi, nó thực hiện:

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

Chuỗi đầu ra vô hạn bắt đầu bằng w, và phần còn lại của chuỗi là kết quả cho các chuỗi thay đổi Fibonacci wvà v+w.

Điều này không có vấn đề gì khi tạo ra một triệu ký tự trong một phút.

Haskell, 31 byte

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

Điều này xác định một hàm infix #có hai chuỗi và trả về một chuỗi vô hạn. Sử dụng:

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

Nếu tôi truy vấn phần tử thứ một triệu của chuỗi được xác định bởi "1" và "0", ngay cả trình thông dịch trực tuyến cũng in kết quả trong chưa đầy một giây:

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

Giải trình

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.

Về cơ bản, chúng tôi biết điều đó w#v == v#(v++w)và w#vbắt đầu với v, và sử dụng những sự thật này để xác định kết quả. Vì Haskell lười biếng, "điều kỳ diệu" này chỉ hoạt động.

Pip, 8 byte

Này, gắn liền với Pyth!

(fOba.b)

Định nghĩa đệ quy đơn giản mượn từ câu trả lời Haskell của xnor . Với không gian được thêm vào cho rõ ràng:

(f Ob a.b)

Mỗi chương trình trong Pip là một hàm ẩn lấy dòng lệnh lập luận làm đối số của nó (được gán cho các biến aqua e) và in giá trị trả về của nó. Olà một toán tử xuất ra và sau đó trả về toán hạng của nó, vì vậy điều đầu tiên xảy ra ở đây là đối số thứ hai được hiển thị (sans trailing newline).

Bây giờ, cú pháp lấy cảm hứng từ Lisp (f x y)trong Pip là một lệnh gọi hàm, tương đương với f(x,y)các ngôn ngữ giống như C. Các fbiến liên quan đến chức năng hiện nay - trong trường hợp này, chương trình cấp cao nhất. Do đó, chương trình gọi đệ quy chính nó bvà a.bnhư là các đối số mới.

Tôi đã rất ngạc nhiên khi thấy rằng phương pháp này rất nhanh:

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

Mất khoảng 30 giây trên máy Ubuntu của tôi để chương trình đạt được độ sâu đệ quy tối đa, tại thời điểm đó, nó đã được in ra ở đâu đó trên một tỷ chữ số.

Giải pháp lặp này nhanh hơn một chút và chiếm ít bộ nhớ hơn, với chi phí là một byte:

W1Sba.:Ob

CJam, 12 11 byte

llL{@_o+_}h

Điều này có hai từ trên các dòng riêng biệt, theo thứ tự ngược lại, ví dụ

0
1

cho

0100101001001010010100100101001...

Giải trình

Ý tưởng là xây dựng từ một cách ngây thơ (bằng cách nhớ từ hiện tại và nối thêm từ trước đó vào đó) và trong khi chúng tôi thực hiện điều đó, chúng tôi in bất cứ điều gì chúng tôi vừa thêm vào (để không lặp lại tiền tố đã được in) . Để tránh phải xử lý điểm bắt đầu một cách riêng biệt, chúng tôi bắt đầu từ một từ trống, sao cho W ₀ là điều đầu tiên chúng tôi nối (và in).

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 byte

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

_{Chỉnh sửa - Umm, viết ra $e.substring($b.length)sau khi chúng tôi vừa nối $avà $bcùng nhau tương đương với viết ra chỉ $a... derp.}

Wow, dài dòng. Theo mặc định, PowerShell sẽ phun ra một dòng mới mỗi khi bạn xuất thứ gì đó. Thực sự là cách duy nhất để giải quyết vấn đề đó là write-host -n(viết tắt của -NoNewLine), và điều đó hoàn toàn giết chết chiều dài ở đây.

Về cơ bản, lặp này thông qua trình tự, xây dựng $elà "hiện tại" W _n khi chúng ta đi. Tuy nhiên, vì chúng tôi muốn xây dựng từ vô hạn thay vì chuỗi, chúng tôi tận dụng các biến trước đó để in ra hậu tố $ađược điền trong vòng lặp trước của chúng tôi. Sau đó, chúng tôi thiết lập các biến của chúng tôi cho vòng tiếp theo và lặp lại vòng lặp. Xin lưu ý rằng điều này hy vọng đầu vào được phân định rõ ràng dưới dạng chuỗi, nếu không thì +toán tử sẽ được sử dụng cho số học thay vì nối.

Thí dụ:

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

APL, 24 18

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

Sử dụng công thức của xnor cho phép cạo sạch một vài ký tự.

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

Trên một máy vô hạn trong thời gian vô hạn nó thực sự sẽ in W _∞ ba lần đầu tiên từng bước trong khi chạy vòng lặp, và sau đó gấp đôi so với kết quả của toàn bộ biểu hiện khi ⍣≡điều hành fixpoint cuối cùng lợi nhuận.

Nó không nhanh lắm nhưng đủ nhanh. Trong 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 tinh khiết, 58

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

Tôi hết bộ nhớ trước 1 phút, nhưng sau đó có rất nhiều chữ số - sau 10 giây tôi có 100 triệu chữ số:

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

Toán học, 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++));}

Đây là một máy in đệ quy khá đơn giản, được triển khai như một hàm lồng nhau (một phần mở rộng GNU C không được clang hỗ trợ) để tránh phải vượt qua v. p(n)in W _n-2 , trong đó W _-1 và W ₀ phải được cung cấp trong v[1]và v[2]. Điều này ban đầu gọi p(4)để in W ₂ . Sau đó, nó lặp lại: nó gọi p(3)để in W ₁ , tạo ra đầu ra hoàn chỉnh W ₂ W ₁ , đó là W ₃ . Sau đó, nó gọi p(4)để in W ₂ , tạo ra đầu ra hoàn chỉnh W₄ , v.v ... Hiệu suất tốt hơn một chút so với câu trả lời trước đây của tôi: Tôi đang thấy 1875034112 giá trị trong một phút.

C, 81 (tiếng kêu)

Đây là một cách tiếp cận hoàn toàn khác với những điều trên mà tôi cảm thấy đáng để theo kịp, mặc dù nó có điểm kém hơn.

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

Điều này có tất cả các loại hành vi không xác định, chủ yếu cho vui. Nó hoạt động với clang 3.6.2 trên Linux và với clang 3.5.2 trên Cygwin cho các trường hợp thử nghiệm trong câu hỏi, có hoặc không có tùy chọn dòng lệnh đặc biệt. Nó không bị hỏng khi tối ưu hóa được kích hoạt.

Nó không hoạt động với các trình biên dịch khác.

Bạn có thể chấp nhận các từ theo thứ tự bất kỳ; như hai mảng, một mảng các mảng, hai chuỗi, một chuỗi các chuỗi hoặc một chuỗi với một dấu phân cách bạn chọn.

Tôi chấp nhận các từ dưới dạng đối số dòng lệnh ở định dạng chuỗi.

Bạn có thể in các chữ số của từ vô hạn mà không có dấu phân cách hoặc có dấu phân cách nhất quán giữa mỗi cặp chữ số liền kề.

Tôi sử dụng dòng mới như là dấu phân cách nhất quán.

Đối với tất cả các mục đích, giả sử rằng mã của bạn sẽ không bao giờ hết bộ nhớ và các loại dữ liệu của nó không bị tràn.

Cụ thể, điều này có nghĩa là bất kỳ đầu ra nào cho STDOUT hoặc STDERR là kết quả của sự cố sẽ bị bỏ qua.

Tôi truy cập sngoài giới hạn. Điều này chắc chắn phải kết thúc bằng một segfault hoặc vi phạm truy cập tại một số điểm. stình cờ được đặt ở cuối đoạn dữ liệu, do đó, nó không nên ghi đè các biến khác và đưa ra đầu ra sai trước segfault đó. Hy vọng.

Nếu tôi chạy mã của bạn trên máy của mình (Intel i7-3770, RAM 16 GiB, Fedora 21) trong một phút và chuyển đầu ra của nó sang wc -c, nó phải in ít nhất một triệu chữ số W _∞ cho (W _-1 , W ₀ ) = (1, 0) .

Kiểm tra bằng cách sử dụng { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c, tôi nhận được 1816784896 chữ số trong một phút trên máy của mình khi chương trình được biên dịch -O3và 1596678144 khi được biên dịch với tối ưu hóa.

Ungolfed, không có UB, với lời giải thích:

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

Đầu vào phải là chuỗi và không phải số ( '0'và không chỉ 0).

Perl 5, 45 55 49 byte

44 byte, cộng thêm 1 cho -Ethay vì-e

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

Sử dụng như ví dụ

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

Xấp xỉ liên tiếp W in này _∞ và do đó, nếu bạn chờ đợi đủ lâu, bản in, trên dòng cuối cùng của đầu ra, W _∞ đến bất kỳ chiều dài mong muốn, theo yêu cầu. Các chữ số của từ được nối mà không có dấu phân cách.

Kể từ khi tôi đang trên Windows, tôi thử nghiệm nó cho "ít nhất một triệu chữ số của W _∞ " yêu cầu bằng cách chạy nó với sản lượng chuyển hướng đến một tập tin và giết chết nó sau khoảng 59 giây, sau đó chạy GnuWin32 của wc -L, mà in 701.408.733.

Cập nhật:

OP làm rõ trong một bình luận về câu trả lời này (và có lẽ tôi nên đã nhận ra anyway) rằng sản lượng thêm trước W _∞ không ÿ trên. Vì vậy, thay vì đây là một giải pháp 55-byte mà in chỉ W _∞ :

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

Được sử dụng theo cùng một cách, nhưng với các đối số theo thứ tự ngược lại và không yêu cầu -E:

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

Không nghi ngờ gì nó có thể được chơi gôn hơn nữa, nhưng tôi không thấy làm thế nào để làm điều đó ngay bây giờ.

Cập nhật thêm:

Dennis đã cạo năm byte bằng cách sử dụng -a(do đó đọc <>để loại bỏ sub) và gán lại tham số được truyền đến printở cuối redokhối:

Với -anevà đọc từ <>(cả hai đầu vào trên một dòng, được phân tách bằng dấu cách, theo thứ tự ngược lại); 48 + 2 byte:

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

Và, dựa vào đó, tôi đã cạo thêm một byte (giống như trên, nhưng bây giờ các đầu vào theo đúng thứ tự); 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 thực hiện
ftw.rex 0 1

Hiện tại không thể kiểm tra hiệu suất vì tôi đã sử dụng trình biên dịch trực tuyến để viết nó. "Mãi mãi" có thể được thay thế bằng bất kỳ số nào trong đó các số ftw được in là (số + 2).

Tôi cũng đã viết một giải pháp nhỏ (lộn xộn) trong Prolog. Không tìm ra cách kiểm tra hiệu năng với cái này nhưng dù sao thì nó cũng có thể tàn bạo.

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)

Chấp nhận đầu vào dưới dạng một cặp chuỗi được phân tách bằng dấu phẩy : "1","0", ví dụ trong câu hỏi.

Không có thông dịch viên trực tuyến vì các vòng lặp vô hạn là xấu. Đầu ra đệm làm cho tôi đạt được rất nhiều byte. :( Cảm ơn Dennis vì đã chỉ ra rằng 1 chữ số trên mỗi dòng là hợp lệ.

Thời gian trên máy (yếu hơn đáng kể) của tôi:

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

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

Thuốc nhuộm APL, 9

{⍵∇⍺,⍞←⍵}

Cái này dùng ∇để định nghĩa một hàm đệ quy. Đây là bản dịch trực tiếp câu trả lời Python 3 của xnor này . Nó nhận W ₀ là bên phải và W ₁ làm đối số bên trái của nó, cả hai nên là các vectơ ký tự.

Chồn 0,11 , 62 byte

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

Hãy thử nó ở đây. Yêu cầu đầu vào theo thứ tự W ₀ , W _-1 với khoảng trắng ở giữa.

Giải trình

(                             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

Giải thích tổng hợp cho những điều sau đây là tại thời điểm này, chúng ta có hai số theo sau là một chuỗi "0" s và "1" không có sự phân tách. Nếu độ dài của W ₀ và W _-1 là avà b, tương ứng, sau đó hai số ở phía trước của ngăn xếp là <a+b>và <a>, theo thứ tự đó. Từ được hình thành bằng cách ghép W _{i + 1} và W _i , tức là W _{i + 1} + W _i , bằng 2 * W _{i + 1} - W _i . Vì vậy, đoạn mã sau nhân đôi ngăn xếp (2 * W _{i + 1} ), bật ra khỏi đầu<a>các phần tử (- W _i ), và sau đó thay thế <a+b>và <a>với các thành công của chúng, <a+2b>và <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:")

Trăn 3, 32

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

Ý tưởng đệ quy tương tự như câu trả lời Haskell của tôi , ngoại trừ tiền tố được in vì Python không thể xử lý các chuỗi vô hạn.

Đã sử dụng một mẹo từ Sp3000 để in mà không có khoảng trắng bằng cách đặt chuỗi làm endđối số trong Python 3

Perl, 32 byte

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

Đếm shebang là hai, đầu vào được lấy từ stdin, khoảng cách được phân tách là W ₀ , W _-1 . Đầu ra cho 1MB lần ở tốc độ ~ 15ms, hầu hết có thể được quy cho khởi chạy trình thông dịch.

Sử dụng mẫu

$ 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).

Ví dụ nhập: p ('1', '0')

Không tìm thấy cách nào để xóa ghi thêm.
Có thể cải thiện điều này nếu tôi tìm ra cách để làm điều đó.