25

अनंत फाइबोनैचि शब्द एक विशिष्ट, बाइनरी अंकों है, जो परिमित द्विआधारी शब्द का बार-बार संयोजन से गणना कर रहे हैं के अनंत अनुक्रम है।

हमें परिभाषित करें कि एक फाइबोनैचि-प्रकार शब्द अनुक्रम (या FTW अनुक्रम ) किसी भी अनुक्रम nW _n follows है जो निम्नानुसार बनता है।

बाइनरी अंकों के दो मनमाने सरणियों के साथ। आइए हम इन सरणियों को डब्ल्यू _-1 और डब्ल्यू _{0 कहते हैं} ।
प्रत्येक के लिए n> 0 , चलो डब्ल्यू _एन ≔ डब्ल्यू _n-1 ∥ डब्ल्यू _n-2 , जहां ∥ को दर्शाता है संयोजन।

पुनरावर्ती परिभाषा का एक परिणाम यह है कि W _n हमेशा W _{n + 1} का एक उपसर्ग होता है और इसलिए, सभी W _{k का} ऐसा k> n होता है । एक अर्थ में, इसका अर्थ है अनुक्रम ⟨W _n means एक अनंत शब्द में परिवर्तित होता है।

औपचारिक रूप से, W _∞ केवल अनंत सरणी है जैसे कि W _n , सभी n ≥ 0 के लिए W _∞ का उपसर्ग है ।

हम उपरोक्त प्रक्रिया द्वारा गठित किसी भी अनंत शब्द को अनंत FTW कहेंगे ।

कार्य

एक प्रोग्राम या फ़ंक्शन लिखें जो दो बाइनरी शब्दों को डब्ल्यू _-1 और डब्ल्यू ₀ को इनपुट के रूप में स्वीकार करता है और डब्ल्यू _{∞ को} प्रिंट करता है, निम्नलिखित, अतिरिक्त, नियमों का पालन करता है:

आप किसी भी क्रम में शब्दों को स्वीकार कर सकते हैं; दो सरणियों के रूप में, सारणियों की एक सरणी, दो तार, तार की एक सरणी या अपनी पसंद के सीमांकक के साथ एक स्ट्रिंग।
आप अनंत शब्द के अंकों को किसी सीमांकक के बिना या समीपवर्ती अंकों के प्रत्येक जोड़े के बीच एक सुसंगत सीमांकक के साथ मुद्रित कर सकते हैं।
सभी उद्देश्यों के लिए, मान लें कि आपका कोड कभी भी मेमोरी से बाहर नहीं जाएगा, और यह कि इसके डेटा प्रकार अतिप्रवाह नहीं हैं।

विशेष रूप से, इसका मतलब है कि क्रैश या एसटीडीआरआर के किसी भी आउटपुट जो क्रैश का परिणाम है, को अनदेखा किया जाएगा।
अगर मैं अपने मशीन पर अपने कोड चलाने (इंटेल i7-3770, 16 GiB रैम, फेडोरा 21) एक मिनट और पाइप इसके उत्पादन के लिए wc -c, इसके बारे में कम से कम एक लाख अंक प्रिंट डब्ल्यू _∞ के लिए (डब्ल्यू _-1 , डब्ल्यू ₀ ) = (१, ०) ।
मानक कोड-गोल्फ नियम लागू होते हैं।

उदाहरण

चलो डब्ल्यू _-1 = 1 और डब्ल्यू ₀ = 0 ।

फिर डब्ल्यू ₁ = 01 , डब्ल्यू ₂ = 010 , डब्ल्यू ₃ = 01001 , डब्ल्यू ₄ = 01,001,010 ... और डब्ल्यू _∞ = 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

— डेनिस
स्रोत

10

फाइबोनैचि-प्रकार शब्द FTW!

— साद्रुस

14

पायथ, 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

जहां ए और बी 0 और 1 एस पर मनमाना क्रम हैं। आइए एक सा के लिए अनुक्रम जारी रखें, यह साबित करने के लिए हमेशा के लिए जारी रखा जाता है:

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

2 चरणों के बाद, यह सही रूप है।

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

2 चरणों के बाद, यह सही रूप है।

इसलिए प्रेरण द्वारा, तार हमेशा एक बार संघनित हो जाते हैं।

— isaacg
स्रोत

14

वर्किंग कोड लिखने के लिए +1 जिसे आप नहीं समझते हैं।

— सेलेओ

2

मेरा मानना है कि आपका 8 बाइट सॉल्यूशन काम करता है क्योंकि यह शुरू होता है, W0लेकिन प्रिंट करने के बजाय W1इसे प्रिंट करता है W-1 || W0, जो कि "गलत" सहमति आदेश है। मुझे लगता है कि यह समान होने के लिए काम करता है, लेकिन मैं एक सबूत के साथ नहीं आया हूं ...

— FryAmTheEggman

16

हास्केल, 15 बाइट्स

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

इन्फिक्स फ़ंक्शन %एक अनंत स्ट्रिंग का उत्पादन करता है, जो हास्केल हमेशा के लिए प्रिंट करता है क्योंकि हास्केल इस तरह से ठंडा होता है।

>> "1"%"0"
"010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001001010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001001010010100100101001001010010100100101001010010010100100101001010010010100100101

पुनरावर्ती विचार जगरब के समाधान के समान है । fसमारोह के लिए लेखन %, और +स्ट्रिंग संघनन के लिए, यह लागू होता है:

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

अनंत आउटपुट स्ट्रिंग के साथ शुरू होता है w, और इसका शेष फाइबोनैचि-शिफ्ट किए गए स्ट्रिंग्स के लिए परिणाम है wऔर v+w।

इससे एक मिनट में एक लाख वर्ण बनाने में कोई समस्या नहीं है।

— XNOR
स्रोत

9

हास्केल, 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#vv

— Zgarb
स्रोत

5

पिप, 8 बाइट्स

अरे, पायथ से बंधे!

(fOba.b)

Xnor के हास्केल उत्तर से सीधी पुनरावर्ती परिभाषा उधार ली गई है । स्पष्टता के लिए जोड़े गए स्थानों के साथ:

(f Ob a.b)

पिप में प्रत्येक कार्यक्रम एक निहित कार्य है जो कमांड-लाइन आर्ग्स को उसके तर्कों (जिसके aमाध्यम से चर के लिए सौंपा गया e) के रूप में लेता है और उसके रिटर्न मूल्य को प्रिंट करता है। Oएक ऑपरेटर है जो आउटपुट करता है और फिर अपने ऑपरेंड को लौटाता है, इसलिए पहली बात जो यहां होती है वह है दूसरा तर्क प्रदर्शित किया जाता है (बिना समय रेखा के अनुगामी)।

अब, (f x y)पिप में लिस्प-प्रेरित सिंटैक्स एक फ़ंक्शन कॉल है, f(x,y)जो सी-जैसी भाषाओं के बराबर है । 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 सेकंड लगते हैं, जिस बिंदु पर यह एक अरब अंकों से कहीं अधिक मुद्रित हुआ है।

यह पुनरावृत्त समाधान थोड़ा तेज है और एक बाइट की कीमत पर कम मेमोरी को हॉग करता है:

W1Sba.:Ob

— DLosc
स्रोत

4

सीजेएम, 12 11 बाइट्स

llL{@_o+_}h

यह दो शब्दों को अलग-अलग रेखाओं पर, विपरीत क्रम में, उदाहरण के लिए लेता है

0
1

देता है

0100101001001010010100100101001...

व्याख्या

यह विचार भयावह रूप से शब्द का निर्माण करना है (वर्तमान शब्द को याद करके और इसे पिछले एक को जोड़कर) और जब हम ऐसा कर रहे हैं, तो हम जो कुछ भी हम कहते हैं उसे प्रिंट करते हैं (पहले से ही छपे हुए उपसर्ग को दोहराने के लिए नहीं) । शुरुआती बिंदु को अलग से संभालने से बचने के लिए, हम एक खाली शब्द से शुरू करते हैं, जैसे कि डब्ल्यू ₀ पहली चीज है जिसे हम जोड़ते हैं (और प्रिंट करते हैं)।

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

— मार्टिन एंडर
स्रोत

3

पॉवरशेल, 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जैसा कि हम जाते हैं "वर्तमान" डब्ल्यू _{एन के} रूप में निर्माण । हालांकि, जब से हम अनुक्रम के बजाय अनंत शब्द का निर्माण करना चाहते हैं, हम अपने पिछले चर को $aहमारे पिछले लूप में आबादी वाले प्रत्यय को प्रिंट करने के लिए लाभ उठाते हैं । फिर हम अगले गो-राउंड के लिए अपने चर सेट करते हैं और लूप दोहराते हैं। ध्यान दें कि यह इनपुट स्पष्ट रूप से तार के रूप में सीमांकित होने की उम्मीद करता है, अन्यथा +ऑपरेटर को संघनन के बजाय अंकगणित के लिए उपयोग किया जाता है।

उदाहरण:

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

— AdmBorkBork
स्रोत

3

एपीएल, २४ १ 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).

अनंत समय में एक अनंत मशीन पर यह वास्तव में डब्ल्यू _— तीन बार छपेगा - लूप को चलाने के दौरान पहली बार वृद्धिशील रूप से, और फिर दो बार पूरे अभिव्यक्ति के परिणामस्वरूप जब ⍣≡फिक्सपॉइंट ऑपरेटर अंततः लौटता है।

यह बहुत तेज नहीं है, लेकिन काफी तेज है। 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

— user46915
स्रोत

दो अनंत संख्या। OO +1

— एडिसन क्रम्प

मैं इसके बारे में नहीं जानता था ⍣≡; यह बहुत उपयोगी लगता है।

— lirtosiast

3

शुद्ध बैश, 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
$

— डिजिटल आघात
स्रोत

2

मैथेमेटिका, 56 बाइट्स

$IterationLimit=∞;#0[$Output~WriteString~#2;#2,#<>#2]&

— LegionMammal978
स्रोत

2

सी, 76 (जीसीसी)

main(c,v)char**v;{int p(n){n>2?p(n-1),p(n-2):puts(v[n]);}for(p(4);;p(c++));}

यह एक काफी सीधा पुनरावर्ती प्रिंटर है, जिसे पास होने से बचने के लिए एक नेस्टेड फ़ंक्शन (क्लैंग द्वारा समर्थित जीएनयू सी एक्सटेंशन नहीं) के रूप में लागू किया vगया है। p(n)प्रिंट W _n-2 , जहां W _-1 और W ₀ को अंदर v[1]और अंदर दिया जाना चाहिए v[2]। यह शुरू में डब्ल्यू ₂p(4) प्रिंट करने के लिए कहता है । फिर यह छोरों: यह डब्ल्यू ₁ को प्रिंट करने के लिए कहता है , जिससे पूरा आउटपुट डब्ल्यू ₂ डब्ल्यू _{1 है} , जो डब्ल्यू _{3 है} । यह तब W ₂ प्रिंट करने के लिए कहता है , जिससे पूरा आउटपुट W बनता हैp(3)p(4)_{4 हो जाता है} , आदि प्रदर्शन मेरे पहले के उत्तर से थोड़ा बेहतर है: मैं एक मिनट में 1875034112 मूल्यों को देख रहा हूं।

सी, 81 (क्लैंग)

यह ऊपर से एक पूरी तरह से अलग दृष्टिकोण है जो मुझे लगता है कि रखने के लायक है, भले ही यह बदतर स्कोर हो।

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

इसमें मुख्य रूप से मनोरंजन के लिए सभी प्रकार के अपरिभाषित व्यवहार हैं। यह लिनक्स पर 3.6.2 के साथ और विशेष कमांड लाइन विकल्पों के साथ या बिना प्रश्न में परीक्षण मामलों के लिए साइग्विन पर 3.5.2 क्लेंग के साथ काम करता है। जब अनुकूलन सक्षम होते हैं तो यह नहीं टूटता।

यह अन्य संकलक के साथ काम नहीं करता है।

आप किसी भी क्रम में शब्दों को स्वीकार कर सकते हैं; दो सरणियों के रूप में, सारणियों की एक सरणी, दो तार, तार की एक सरणी या अपनी पसंद के सीमांकक के साथ एक स्ट्रिंग।

मैं शब्दों को स्ट्रिंग प्रारूप में कमांड-लाइन तर्क के रूप में स्वीकार करता हूं।

आप अनंत शब्द के अंकों को किसी सीमांकक के बिना या समीपवर्ती अंकों के प्रत्येक जोड़े के बीच एक सुसंगत सीमांकक के साथ मुद्रित कर सकते हैं।

मैं निरंतर परिसीमन के रूप में नईलाइन का उपयोग करता हूं।

सभी उद्देश्यों के लिए, मान लें कि आपका कोड कभी भी मेमोरी से बाहर नहीं जाएगा, और यह कि इसके डेटा प्रकार अतिप्रवाह नहीं हैं।

विशेष रूप से, इसका मतलब है कि क्रैश या एसटीडीआरआर के किसी भी आउटपुट जो क्रैश का परिणाम है, को अनदेखा किया जाएगा।

मैं sसीमा से बाहर पहुंचता हूं । यह निश्चित रूप से सीगफॉल्ट या किसी बिंदु पर पहुंच उल्लंघन के साथ समाप्त होना चाहिए। sडेटा खंड के अंत में रखा जाना होता है, इसलिए इसे अन्य चर को क्लोब नहीं करना चाहिए और उस सेगफ़ॉल्ट से पहले गलत आउटपुट देना चाहिए। उम्मीद है कि।

अगर मैं अपने मशीन पर अपने कोड चलाने (इंटेल i7-3770, 16 GiB रैम, फेडोरा 21) एक मिनट और पाइप इसके उत्पादन के लिए wc -c, इसके बारे में कम से कम एक लाख अंक प्रिंट डब्ल्यू _∞ के लिए (डब्ल्यू _-1 , डब्ल्यू ₀ ) = (१, ०) ।

परीक्षण का उपयोग करते हुए { ./program 1 0 | tr -d '\n' & sleep 60; kill $!; } | wc -c, मुझे अपनी मशीन पर एक मिनट में 1816784896 अंक प्राप्त होते हैं, जब कार्यक्रम को संकलित किया गया था -O3, और 1596678144 जब इसे ऑप्टिमाइज़ेशन के साथ संकलित किया गया था।

स्पष्टीकरण के साथ अनगुल्ड, नो यूबी:

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

— HVD
स्रोत

s[]क्लैंग (बस इसे स्थापित) के साथ आपकी बुराई चाल अच्छी तरह से काम करती है। मुझे काफी आश्चर्य है कि यह वास्तव में काम करता है। सभी उद्देश्यों के लिए, मान लें कि आपका कोड कभी भी मेमोरी से बाहर नहीं जाएगा, और यह कि इसके डेटा प्रकार ओवरफ्लो नहीं होते हैं। दुर्भाग्य से, इसका मतलब है कि बस W97 को प्रिंट करना मान्य नहीं माना जाता है। क्या आप pपुनरावर्ती कॉल कर सकते हैं ? यह एक की आवश्यकता को समाप्त करेगा main।

— डेनिस

@ डेनिस वर्तमान दर पर उचित होने के लिए, वह संस्करण जो W97 को प्रिंट करके धोखा देता है, W 3000 को ∞ 3000 साल तक प्रिंट करने में सही काम करेगा। मैं देखूंगा कि क्या मैं उस पर सुधार कर सकता हूं। :)

— hvd 20

@ डेनिस मैं इसे कार्यक्रम के लिए एक ही नंबर के बाइट्स के साथ काम करने में कामयाब रहा, लेकिन इसे जीसीसी के लिए विशिष्ट बना दिया, और अब एक स्वच्छ कार्य नहीं कर रहा था। मैं कैसे बार-बार कॉल के तर्क डाल करने के लिए नहीं दिख रहा है pमें pऔर अधिक कोड जोड़ने के बिना ही, लेकिन अगर मैं एक रास्ता मिल कर मैं फिर से संपादित करेंगे।

— hvd

1

जावास्क्रिप्ट (53 बाइट्स)

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

इनपुट स्ट्रिंग होना चाहिए और संख्या नहीं ( '0'और सिर्फ नहीं 0)।

— Naouak
स्रोत

2

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! कोड गोल्फ चुनौतियों के लिए हमारे नियम कहते हैं कि, डिफ़ॉल्ट रूप से, सबमिशन पूर्ण कार्यक्रम या फ़ंक्शन होने चाहिए। जैसे, उन्हें किसी प्रकार के उपयोगकर्ता इनपुट को स्वीकार करना होगा; हार्डकॉकिंग इनपुट की अनुमति नहीं है। इसके अलावा, आपका कोड अनुक्रम Wn को प्रिंट करता है , इसकी सीमा नहीं।

— डेनिस

1

पर्ल 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)'

यह प्रिंट डब्ल्यू करने के लिए लगातार अनुमानों _∞ और इस प्रकार,, प्रिंट, उत्पादन के अपने अंतिम पंक्ति पर, डब्ल्यू आप काफी लंबे समय से इंतजार करता है, तो _∞ किसी भी वांछित लंबाई करने के लिए, के रूप में की आवश्यकता है। शब्द के अंक बिना परिसीमन के सम्‍मिलित होते हैं।

जब से मैं विंडोज पर हूँ, मैं "डब्ल्यू के कम से कम एक लाख अंक के लिए यह परीक्षण किया _∞ एक फ़ाइल पर पुनः निर्देशित उत्पादन के साथ यह चल रहा है और लगभग 59 सेकंड के बाद यह की मौत हो गई है, तो GnuWin32 की चलाकर आवश्यकता" wc -L, जो 701,408,733 छपी।

अद्यतन करें:

इस उत्तर पर एक टिप्पणी में ओपी ने स्पष्ट किया (और शायद मुझे वैसे भी एहसास होना चाहिए) कि अतिरिक्त उत्पादन पूर्व डब्ल्यू _ifies उपरोक्त को अयोग्य घोषित करता है। तो बजाय यहां एक 55-बाइट समाधान है कि प्रिंट केवल डब्ल्यू _∞ :

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) का उपयोग करके पांच बाइट्स का मुंडन किया :printredo

के साथ -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}

— msh210
स्रोत

1

REXX , 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) हैं।

मैंने प्रोलॉग में एक छोटा (गन्दा) समाधान भी लिखा। यह कैसे एक के साथ प्रदर्शन का परीक्षण करने के लिए पता नहीं था, लेकिन इसकी शायद वैसे भी अत्याचार।

f(A,B,C):-atom_concat(B,A,D),(C=D;f(B,D,C)).

:- C='0';C='1';(f(1,0,C)).

— Menplant
स्रोत

1

पायथन 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

— मै जाऊं
स्रोत

1

प्रश्न अंकों के बीच एक सुसंगत परिसीमन की अनुमति देता है। आप प्रत्येक अंक को एक अलग लाइन पर प्रिंट करके कम से कम 28 बाइट्स बचा सकते हैं।

— डेनिस

1

दलयोग एपीएल, 9

{⍵∇⍺,⍞←⍵}

यह एक ∇पुनरावर्ती कार्य को परिभाषित करने के लिए उपयोग करता है। यह इस xnor के पायथन 3 उत्तर का सीधा अनुवाद है । यह W ₀ को सही मानता है, और W को_W1 को इसके बाएं तर्क के है, दोनों को चरित्र वैक्टर होना चाहिए।

— user46915
स्रोत

1

मिन्कोलांग 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" s और "1" s स्ट्रिंग होती है, जिसमें कोई अलगाव नहीं होता है। की लंबाई तो डब्ल्यू ₀ और डब्ल्यू _-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) को दोहराता है_मैं ), और फिर जगह<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:")

— एलेंडिया स्ट्राटन
स्रोत

(नोट: इस एक मिनट में 1 लाख अंक नहीं पैदा करता ... केवल 0.5 लाख को देखते हुए यह स्वाभाविक रूप से एक अपेक्षाकृत धीमी गति से भाषा है कि, मुझे लगता है कि मैं एक छोटे से ढीला काटा जा सकता है: पी।।)

— El'endia Starman

1

अजगर 3, 32

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

मेरे हास्केल उत्तर के रूप में एक ही पुनरावर्ती विचार , उपसर्ग को छोड़कर मुद्रित किया जाता है क्योंकि पायथन अनंत तारों को संभाल नहीं सकता है।

endपायथन 3 में तर्क के रूप में स्ट्रिंग डालकर रिक्त स्थान के बिना प्रिंट करने के लिए Sp3000 से एक चाल का उपयोग किया

— XNOR
स्रोत

1

पर्ल, 32 बाइट्स

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

दो के रूप में कुटिया गिनती, इनपुट stdin से लिया जाता है, स्थान के रूप में अलग कर दिया डब्ल्यू ₀ , डब्ल्यू _-1 । ~ 15ms पर 1MB समय के लिए आउटपुट, जिनमें से अधिकांश को इंटरप्रेटर लॉन्च के लिए जिम्मेदार ठहराया जा सकता है।

नमूना उपयोग

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

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

— Primo
स्रोत

1

प्रोलॉग, 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')

अतिरिक्त लेखन को हटाने का एक तरीका नहीं है।
इस पर सुधार करने में सक्षम होना चाहिए अगर मुझे पता है कि यह कैसे करना है।

— Emigna
स्रोत

एक अनंत FTW

कार्य

उदाहरण

परीक्षण के मामलों

पायथ, 8 बाइट्स

हास्केल, 15 बाइट्स

हास्केल, 31 बाइट्स

व्याख्या

पिप, 8 बाइट्स

सीजेएम, 12 11 बाइट्स

व्याख्या

पॉवरशेल, 97 76 बाइट्स

उदाहरण:

एपीएल, २४ १ 18

शुद्ध बैश, 58

मैथेमेटिका, 56 बाइट्स

सी, 76 (जीसीसी)

सी, 81 (क्लैंग)

जावास्क्रिप्ट (53 बाइट्स)

पर्ल 5, 45 55 49 बाइट्स

अद्यतन करें:

आगे का अपडेट:

REXX , 48

पायथन 2, 67 बाइट्स

दलयोग एपीएल, 9

मिन्कोलांग 0.11 , 62 बाइट्स

व्याख्या

अजगर 3, 32

पर्ल, 32 बाइट्स

प्रोलॉग, 69 बाइट्स