คำฟิโบน่าชีไม่มีที่สิ้นสุดเป็นลำดับที่ไม่สิ้นสุดของเลขฐานสองซึ่งคำนวณโดยการต่อคำซ้ำของคำไบนารี จำกัด

ให้เรากำหนดว่าลำดับคำ Fibonacci ประเภท (หรือลำดับ FTW ) เป็นลำดับใด ๆ ⟨W _n ⟩ที่เกิดขึ้นดังต่อไปนี้

• เริ่มต้นด้วยสองอาร์เรย์ของเลขฐานสองโดยอำเภอใจ ขอให้เราโทรอาร์เรย์เหล่านี้W _-1และW 0

• สำหรับแต่ละn> 0ให้W _n ≔ W _n-1 ∥ W _n-2โดยที่∥หมายถึงการต่อกัน

เป็นผลมาจากความหมายก็คือว่า recursive W _nอยู่เสมอเป็นคำนำหน้าของW _{1 + n}และดังนั้นทุกW _kดังกล่าวว่าk> n ในความหมายนี่หมายถึงลำดับ⟨W _n ⟩แปรเปลี่ยนเป็นคำที่ไม่สิ้นสุด

เป็นทางการให้W _∞เป็นอาเรย์ที่ไม่มีที่สิ้นสุดเท่านั้นซึ่งW _nเป็นคำนำหน้าของW _∞สำหรับn n 0ทั้งหมด

เราจะเรียกคำอนันต์ใด ๆ ที่เกิดขึ้นจากกระบวนการข้างต้นอนันต์ FTW

งาน

เขียนโปรแกรมหรือฟังก์ชั่นที่ยอมรับคำฐานสองคำW _-1และW ₀เป็นอินพุตและพิมพ์W _∞โดยปฏิบัติตามกฎเพิ่มเติมต่อไปนี้:

• คุณอาจยอมรับคำพูดในลำดับใด ๆ เป็นสองอาร์เรย์อาร์เรย์ของอาร์เรย์สองสตริงอาร์เรย์ของสตริงหรือสตริงเดี่ยวที่มีตัวคั่นที่คุณเลือก

• คุณสามารถพิมพ์ตัวเลขของคำที่ไม่มีที่สิ้นสุดทั้งที่ไม่มีตัวคั่นหรือด้วยตัวคั่นที่สอดคล้องกันระหว่างแต่ละคู่ของตัวเลขที่อยู่ติดกัน

• สำหรับวัตถุประสงค์ทั้งหมดสมมติว่ารหัสของคุณจะไม่มีหน่วยความจำไม่เพียงพอและประเภทข้อมูลนั้นไม่ล้น

  โดยเฉพาะนี่หมายความว่าเอาต์พุตใด ๆ ไปยัง STDOUT หรือ STDERR ที่เป็นผลลัพธ์ของความล้มเหลวจะถูกละเว้น

• ถ้าฉันเรียกใช้รหัสของคุณบนเครื่องของฉัน (Intel i7-3770, 16 GiB RAM, Fedora 21) เป็นเวลาหนึ่งนาทีและไพพ์เอาท์พุทwc -cมันจะต้องพิมพ์อย่างน้อยหนึ่งล้านหลักของW _∞สำหรับ(W _-1 , W ₀ ) = (1, 0)

• ใช้กฎมาตรฐานของกอล์ฟ

ตัวอย่าง

Let W _-1 = 1และW ₀ = 0

จากนั้นW ₁ = 01 , W ₂ = 010 , W ₃ = 01001 , W ₄ = 01001010 ... และW _∞ = 010010100100101001010 … .

นี่คือคำที่ไม่สิ้นสุด Fibonacci

กรณีทดสอบ

กรณีทดสอบทั้งหมดมี 1,000 หลักแรกของ FTW ที่ไม่มีที่สิ้นสุด

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 เป็นลำดับโดยพลการใน 0s และ 1s ลองลำดับต่อไปสักหน่อยเพื่อพิสูจน์ว่าเป็นไปอย่างต่อเนื่องโดยการเหนี่ยวนำ:

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

ความคิด recursive จะคล้ายกับวิธีการแก้ปัญหาของ Zgarb การเขียนfสำหรับฟังก์ชั่น%และ+สำหรับการต่อสตริงจะใช้:

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

สตริงเอาท์พุทอนันต์เริ่มต้นด้วยwและส่วนที่เหลือของมันคือผลการสตริง Fibonacci ขยับและwv+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 ขี้เกียจ "น่าอัศจรรย์" นี้ใช้ได้

Pip, 8 ไบต์

เฮ้ผูกกับ Pyth!

(fOba.b)

นิยาม recursive ตรงไปตรงมาที่ยืมมาจากXNOR คำตอบของ ด้วยการเพิ่มช่องว่างเพื่อความชัดเจน:

(f Ob a.b)

ทุกโปรแกรมใน Pip เป็นฟังก์ชั่นโดยนัยที่รับบรรทัดคำสั่งเป็นอาร์กิวเมนต์ (กำหนดให้กับตัวแปรaผ่านe) และพิมพ์ค่าส่งคืน Oเป็นโอเปอเรเตอร์ที่ส่งออกแล้วส่งคืนตัวถูกดำเนินการดังนั้นสิ่งแรกที่เกิดขึ้นที่นี่คืออาร์กิวเมนต์ที่สองจะปรากฏขึ้น (sans ต่อท้ายบรรทัดใหม่)

ตอนนี้ไวยากรณ์ที่ได้แรงบันดาลใจจากเสียงกระเพื่อม(f x y)ใน Pip คือการเรียกใช้ฟังก์ชันซึ่งเทียบเท่ากับf(x,y)ในภาษา C-like 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

ใช้เวลาประมาณ 30 วินาทีบนเครื่อง Ubuntu ของฉันเพื่อให้โปรแกรมเข้าถึงความลึกของการเรียกซ้ำสูงสุด ณ จุดนี้มันพิมพ์ออกมาที่ไหนสักแห่งบนหลักพันล้าน

โซลูชันที่วนซ้ำนี้เร็วขึ้นเล็กน้อยและใช้หน่วยความจำน้อยกว่าในราคาไบต์เดียว:

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}

ว้าว verbose ตามค่าเริ่มต้น 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 _∞สามครั้งแรกเพิ่มขึ้นในขณะที่ทำงานห่วงแล้วสองครั้งเป็นผลมาจากการแสดงออกทั้งเมื่อ⍣≡ผู้ประกอบการ fixpoint ในที่สุดผลตอบแทน

มันไม่เร็วมาก แต่เร็วพอ ใน 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 วินาทีฉันมี 100 ล้านหลัก:

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

นี้เป็นเครื่องพิมพ์ recursive ค่อนข้างตรงไปตรงมาดำเนินการเป็นฟังก์ชั่นที่ซ้อนกัน (ส่วนขยายของ GNU C ไม่ได้รับการสนับสนุนจากเสียงดังกราว) เพื่อหลีกเลี่ยงการผ่านvรอบ p(n)พิมพ์W _n-2ที่W _-1และW ₀จะต้องให้ในและv[1] v[2]ในขั้นต้นนี้เรียกp(4)พิมพ์W 2 จากนั้นก็ loops: มันเรียกp(3)พิมพ์W ₁ทำให้การส่งออกที่สมบูรณ์W ₂ W ₁ซึ่งเป็นW 3 จากนั้นเรียกใช้p(4)เพื่อพิมพ์W ₂ทำให้เอาต์พุตสมบูรณ์W₄ฯลฯ ประสิทธิภาพดีกว่าคำตอบก่อนหน้าเล็กน้อย: ฉันเห็นค่า 1875034112 ในหนึ่งนาที

C, 81 (เสียงดังกราว)

นี่เป็นวิธีการที่แตกต่างอย่างสิ้นเชิงจากด้านบนที่ฉันรู้สึกว่าคุ้มค่าต่อการติดตาม

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

สิ่งนี้มีพฤติกรรมที่ไม่ได้กำหนดไว้ทุกประเภทเพื่อความสนุกสนานเป็นหลัก มันทำงานร่วมกับ clang 3.6.2 บน Linux และกับ clang 3.5.2 บน Cygwin สำหรับกรณีทดสอบในคำถามโดยมีหรือไม่มีตัวเลือกบรรทัดคำสั่งพิเศษ จะไม่แตกเมื่อเปิดใช้งานการปรับให้เหมาะสม

มันไม่ทำงานกับคอมไพเลอร์อื่น ๆ

คุณอาจยอมรับคำพูดในลำดับใด ๆ เป็นสองอาร์เรย์อาร์เรย์ของอาร์เรย์สองสตริงอาร์เรย์ของสตริงหรือสตริงเดี่ยวที่มีตัวคั่นที่คุณเลือก

ฉันยอมรับคำว่าเป็นอาร์กิวเมนต์บรรทัดคำสั่งในรูปแบบสตริง

คุณสามารถพิมพ์ตัวเลขของคำที่ไม่มีที่สิ้นสุดทั้งที่ไม่มีตัวคั่นหรือด้วยตัวคั่นที่สอดคล้องกันระหว่างแต่ละคู่ของตัวเลขที่อยู่ติดกัน

ฉันใช้บรรทัดใหม่เป็นตัวคั่นที่สอดคล้องกัน

สำหรับวัตถุประสงค์ทั้งหมดสมมติว่ารหัสของคุณจะไม่มีหน่วยความจำไม่เพียงพอและประเภทข้อมูลนั้นไม่ล้น

โดยเฉพาะนี่หมายความว่าเอาต์พุตใด ๆ ไปยัง STDOUT หรือ STDERR ที่เป็นผลลัพธ์ของความล้มเหลวจะถูกละเว้น

ฉันเข้าถึงอย่างsไม่ จำกัด สิ่งนี้จะต้องจบลงด้วย segfault หรือการละเมิดการเข้าถึงในบางจุด sเกิดขึ้นเพื่อวางไว้ที่ส่วนท้ายของข้อมูลดังนั้นจึงไม่ควรปิดบังตัวแปรอื่น ๆ และให้ผลลัพธ์ที่ไม่ถูกต้องก่อนที่ segfault นั้น หวังว่า.

ถ้าฉันเรียกใช้รหัสของคุณบนเครื่องของฉัน (Intel i7-3770, 16 GiB RAM, Fedora 21) เป็นเวลาหนึ่งนาทีและไพพ์เอาท์พุทwc -cมันจะต้องพิมพ์อย่างน้อยหนึ่งล้านหลักของW _∞สำหรับ(W _-1 , W ₀ ) = (1, 0)

การทดสอบโดยใช้{ ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -cฉันได้รับ 1816784896 หลักในหนึ่งนาทีบนเครื่องของฉันเมื่อโปรแกรมถูกคอมไพล์ด้วย-O3และ 1596678144 เมื่อมันถูกคอมไพล์ด้วยการเพิ่มประสิทธิภาพ diabled

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 ไบต์บวก 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 _∞ " โดยเรียกใช้ด้วยเอาต์พุตที่เปลี่ยนเส้นทางไปยังไฟล์และฆ่ามันหลังจากนั้นประมาณ 59 วินาทีจากนั้นเรียกใช้ GnuWin32 wc -Lซึ่งพิมพ์ 701408733

ปรับปรุง:

สหกรณ์ชี้แจงในความคิดเห็นในคำตอบนี้ (และอาจจะฉันควรจะได้ตระหนักแล้ว) ว่าการส่งออกพิเศษก่อน W _∞ disqualifies ดังกล่าวข้างต้น ดังนั้นแทนที่จะเป็นโซลูชันขนาด 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}

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

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 นี้หลาม 3 คำตอบ มันใช้ W ₀ถูกต้องและ W ₋₁เป็นอาร์กิวเมนต์ซ้ายของมันทั้งคู่ควรเป็นเวกเตอร์อักขระ

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>ตามลำดับนั้น คำที่เกิดขึ้นจาก concatenating W _{i + 1}และW _ฉันคือW _{i + 1} + W _ฉันเท่ากับ 2 * W _{i + 1} - Wฉัน ดังนั้นรหัสต่อไปนี้จะทำซ้ำสแต็ก (2 * W _{ฉัน + 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:")

Python 3, 32

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

แนวคิดแบบเรียกซ้ำเช่นเดียวกับคำตอบ Haskellของฉันยกเว้นคำนำหน้าจะถูกพิมพ์เพราะ Python ไม่สามารถจัดการกับสตริงที่ไม่มีที่สิ้นสุด

ใช้เคล็ดลับจาก Sp3000 เพื่อพิมพ์โดยไม่มีช่องว่างโดยใส่สตริงเป็นendอาร์กิวเมนต์ใน Python 3

Perl, 32 ไบต์

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

นับ shebang เป็นสองเข้ามาจาก stdin พื้นที่แยกเป็นW ₀ , W -1 เอาต์พุตสำหรับ 1MB ครั้งที่ ~ 15ms ซึ่งส่วนใหญ่สามารถนำมาประกอบกับการเปิดตัวล่าม

ตัวอย่างการใช้งาน

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

ยังไม่พบวิธีลบการเขียนพิเศษ
น่าจะสามารถปรับปรุงเรื่องนี้ได้ถ้าฉันเข้าใจวิธีการทำเช่นนั้น