무한 피보나치 워드는 특정 유한 이진 워드의 반복 연결하여 계산 이진수의 무한 시퀀스이다.

우리는 것을 정의 할 피보나치 형 단어 시퀀스 (또는 FTW 시퀀스 ) 임의의 시퀀스이다 ⟨W _N ⟩ 다음과 같이 형성된다.

• 2 개의 임의의 이진수 배열로 시작합니다. 우리가 이러한 배열 부르 자 W _-1 과 W ₀ .

• 각각의 n> 0에 대해 , W _n ≔ W _n-1 ∥ W _n-2로 하자. 여기서 ∥는 연결을 나타낸다.

재귀 정의의 결과는 즉 W _N 항상의 접두사 W _{, N + 1} , 따라서, 모든 W _K 되도록 N> K . 어떤 의미에서,이 수단 시퀀스 ⟨W _N ⟩ 무한 워드로 수렴.

형식적하자 W가 _∞ 되도록 단지 무한 배열이 W가 _N 의 접두어 W _∞ 모든 N ≥ 0 .

위의 과정으로 형성된 무한 단어를 무한 FTW 라고 부릅니다 .

태스크

두 개의 이진 단어 W _-1 및 W ₀ 을 입력으로 받아들이고 W _∞를 인쇄 하고 다음과 같은 추가 규칙을 준수 하는 프로그램 또는 함수를 작성하십시오 .

• 어떤 순서로든 단어를 받아 들일 수 있습니다. 두 개의 배열, 배열의 배열, 두 개의 문자열, 문자열의 배열 또는 선택한 구분 기호가있는 단일 문자열.

• 구분자없이 또는 인접한 각 쌍의 쌍 사이에 일관된 구분자를 사용하여 무한 단어의 숫자를 인쇄 할 수 있습니다.

• 모든 목적을 위해 코드에 메모리가 부족하지 않으며 데이터 유형이 오버플로되지 않는다고 가정하십시오.

  특히 이는 충돌의 결과 인 STDOUT 또는 STDERR에 대한 출력이 무시됨을 의미합니다.

• 내 기계 (Intel i7-3770, 16 GiB RAM, Fedora 21)에서 1 분 동안 코드를 실행하고 출력을으로 파이프하면 (W _-1 , W ₀ )에 대해 wc -c최소 백만 자릿수의 W _∞ 를 인쇄해야합니다 = (1, 0) 입니다.

• 표준 코드 골프 규칙이 적용됩니다.

예

W _-1 = 1 이고 W ₀ = 0 이라고하자 .

이어서 W ₁ = 01 , W ₍₂₎ = 010 , W ₍₃₎ = 01001 , W ₄ = 01,001,010 ... 및 W _∞ = 010,010,100,100,101,001,010 ... .

이다 무한 피보나치 단어입니다.

테스트 사례

모든 테스트 사례에는 무한 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 단계 후에 올바른 형식입니다.

따라서 유도에 의해 문자열은 항상 한 번 연결됩니다.

하스켈, 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.

분당 백만 개의 문자를 생성하는 데 아무런 문제가 없습니다.

하스켈, 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"으로 정의 된 시퀀스의 백만 번째 요소를 쿼리하면 온라인 인터프리터 조차도 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 바이트

이봐, 피스와 묶여!

(fOba.b)

xnor의 Haskell answer 에서 빌린 간단한 재귀 정의 . 명확성을 위해 공백이 추가 된 경우 :

(f Ob a.b)

Pip의 모든 프로그램은 명령 줄 인수를 인수로 인수로 사용하고 (을 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 초가 걸리며이 시점에서 10 억 자리 이상이 인쇄됩니다.

이 반복 솔루션은 1 바이트의 비용으로 약간 더 빠르며 적은 메모리를 소비합니다.

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 _∞ 3을 인쇄 한 다음 ⍣≡고정 점 연산자가 마지막으로 반환 될 때 전체 표현식의 결과로 두 배가됩니다 .

매우 빠르지는 않지만 충분히 빠릅니다. 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
$ 

매스 매 티카, 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 ₀ 으로 제공되어야 v[1]하고 v[2]. 처음에는 W ₂p(4) 인쇄를 호출 합니다 . 그런 다음 루프 : 그것은 호출 인쇄 (W) ₁ 전체 출력하고, W ₂ W ₁ 이고, W ₍₃₎ . 그런 다음 W ₂ 인쇄 를 호출 하여 완전한 출력 Wp(3)p(4)₄ 등. 성능이 이전 답변보다 약간 낫습니다. 1 분 안에 1875034112 값이 표시됩니다.

C, 81 (클랑)

이것은 점수가 더 나빠도 위와는 완전히 다른 접근법입니다.

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범위를 벗어났습니다. 이것은 반드시 어떤 시점에서 segfault 또는 액세스 위반으로 끝나야합니다. s데이터 세그먼트의 끝에 배치되므로 다른 변수를 방해해서는 안되며 segfault 전에 잘못된 출력을 제공해서는 안됩니다. 잘만되면

내 기계 (Intel i7-3770, 16 GiB RAM, Fedora 21)에서 1 분 동안 코드를 실행하고 출력을으로 파이프하면 (W _-1 , W ₀ )에 대해 wc -c최소 백만 자릿수의 W _∞ 를 인쇄해야합니다 = (1, 0) 입니다.

를 사용하여 테스트 { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c하면 프로그램이로 컴파일 될 때 1 분에 1816784896 자릿수가 1 분에 1816784896 자리가 -O3되고 최적화가 diabled 인 컴파일 된 경우 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];
    }
  }
}

자바 스크립트 (53 바이트)

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

입력은 숫자가 아닌 문자열이어야합니다 ( '0'단지 아니라 0).

펄 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를 실행하여 701408733을 인쇄 하여 "최소 1 백만 자리의 W _∞ "요구 사항을 wc -L테스트했습니다.

최신 정보:

OP는이 답변에 대한 의견에서 W _∞ 앞의 추가 출력이 위의 자격을 박탈 한다는 것을 분명히 밝혔습니다 . 대신 W _∞ 만 인쇄하는 55 바이트 솔루션이 있습니다 .

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) print를 사용하고 redo블록 끝에 전달 된 매개 변수를 다시 할당 하여 5 바이트를 면도했습니다 .

포함 -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}

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

온라인 컴파일러를 사용하여 작성했기 때문에 현재 성능을 테스트 할 수 없습니다. "영원한"은 인쇄 된 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)).

파이썬 2, 67 바이트

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

쉼표로 구분 된 문자열 쌍으로 입력을 승인합니다. "1","0"문제의 예를 들어 .

무한 루프가 나쁘기 때문에 온라인 인터프리터가 없습니다. 버퍼링 된 출력으로 인해 많은 바이트를 얻었습니다. :( 라인 당 1 자리 숫자가 유효하다는 점을 지적 해 Dennis에게 감사합니다.

내 (상당히 더 약한) 머신 타이밍 :

$ 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 answer 직접 번역입니다 . 이는 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} 과 Wi _i 를 연결하여 형성되는 단어 , 즉 W _{i + 1} + W _i 는 2 * W _{i + 1} - W _{i와 같습니다} . 따라서 다음 코드는 스택을 복제하고 (2 * W _{i + 1} ) 상단에서 튀어 나옵니다.<a>(- 요소 W_내가 ), 다음을 대체<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:")

파이썬 3, 32

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

내 Haskell 답변 과 동일한 재귀 아이디어파이썬이 무한 문자열을 처리 할 수 ​​없기 때문에 접두사가 인쇄되는 것을 제외하고는 입니다.

endPython 3에서 문자열을 인수 로 사용하여 공백없이 인쇄하기 위해 Sp3000의 트릭을 사용했습니다.

펄, 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...

프롤로그, 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')

추가 쓰기를 제거하는 방법을 찾지 못했습니다.
내가 그것을하는 방법을 알아 내면 이것을 개선 할 수 있어야합니다.