25

অসীম ফিবানচি শব্দ একটি নির্দিষ্ট, বাইনারি সংখ্যা, যা সসীম বাইনারি শব্দের পুনরাবৃত্তি সংযুক্তকরণের দ্বারা গণনা করা হয় অসীম ক্রম।

আমাদের সংজ্ঞায়িত করে এমন একটি যাক ফিবানচি-টাইপ শব্দ ক্রম (অথবা FTW এর ক্রম ) কোন ক্রম ⟨W _এন ⟩ যে নিম্নরূপ গঠিত হয়।

বাইনারি অঙ্কের দুটি স্বেচ্ছাসেবী অ্যারের সাথে শুরু করুন। আসুন আমরা এই অ্যারেগুলিকে ডাব্লু _-1 এবং ডাব্লু ₀ বলি ।
প্রতিটি এন> 0 এর জন্য ডাব্লু _এন ≔ ডাব্লু _{এন -1} ∥ ডব্লু _{এন -2} , যেখানে ∥ সংমিশ্রণকে বোঝায়।

পুনরাবৃত্ত সংজ্ঞাটির ফলাফল হ'ল ডাব্লু _এন সর্বদা ডাব্লু _{এন + 1 এর} উপসর্গ এবং তাই ডব্লু _কে এরকম কে> এন এর একটি । এক অর্থে, এর অর্থ ক্রম ⟨W _n ⟩ অসীম শব্দ র দিকে এগোয়।

আনুষ্ঠানিকভাবে, ডাব্লু _∞ কে একমাত্র অসীম অ্যারে হতে দিন যে ডাব্লু _n সমস্ত n ≥ 0 এর জন্য ডাব্লু _{∞ এর} উপসর্গ হয় is ।

উপরের প্রক্রিয়া দ্বারা গঠিত যেকোন অসীম শব্দটিকে আমরা কল করব an অসীম এফটিডব্লু বলব ।

কার্য

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা ডাব্লু _-1 এবং ডাব্লু ₀ দুইটি বাইনারি শব্দের ইনপুট হিসাবে গ্রহণ করে এবং ডাব্লু _∞ প্রিন্ট করে, নিম্নলিখিত, অতিরিক্ত, নিয়ম মেনে চলবে:

আপনি কোনও ক্রমে শব্দগুলি গ্রহণ করতে পারেন; দুটি অ্যারে, অ্যারের অ্যারে, দুটি স্ট্রিং, স্ট্রিংগুলির একটি অ্যারে বা আপনার পছন্দসই একটি ডিলিমিটার সহ একক স্ট্রিং string
আপনি সীমাহীন শব্দের অঙ্কগুলি সীমানা ছাড়াই বা সংলগ্ন অঙ্কের প্রতিটি জোড়ার মধ্যে একটি ধারাবাহিক ডিলিমিটার সহ মুদ্রণ করতে পারেন।
সমস্ত উদ্দেশ্যে, ধরে নিন যে আপনার কোডটি কখনই মেমরির বাইরে চলে যাবে না এবং এর ডেটা প্রকারগুলি উপচে পড়বে না।

বিশেষত এর অর্থ হ'ল STDOUT বা STDERR এর যে কোনও আউটপুট ক্র্যাশ হওয়ার ফলে তা উপেক্ষা করা হবে।
যদি আমার মেশিনে আপনার কোড চালানো (ইন্টেল i7-3770, 16 GiB র্যাম, ফেডোরা 21) এক মিনিট এবং নল তার আউটপুট জন্য wc -c, এটা অন্তত এক মিলিয়ন ডিজিটের প্রিন্ট আবশ্যক ডব্লিউ _∞ জন্য (ওয়াট _-1 , পঃ ₀ ) = (1, 0) ।
স্ট্যান্ডার্ড কোড-গল্ফ বিধি প্রযোজ্য।

উদাহরণ

যাক ডব্লিউ _-1 = 1 এবং ডব্লিউ ₀ = 0 ।

তারপরে ডাব্লু ₁ = 01 , ডাব্লু ₂ = 010 , ডাব্লু ₃ = 01001 , ডাব্লু ₄ = 01001010 … এবং ডাব্লু _∞ = 010010100100101001010… ।

এই অসীম ফিবানচি শব্দ।

পরীক্ষার মামলা

সমস্ত পরীক্ষার ক্ষেত্রে অসীম এফটিডাব্লুয়ের প্রথম 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

ফিবোনাচি-টাইপের শব্দ এফটিডাব্লু!

— সীড্রাস

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

যেখানে a এবং b 0s এবং 1s তে নির্বিচারে ক্রম রয়েছে। আসুন কিছুটা ধারাবাহিকতা অব্যাহত রাখি, প্রমাণ করার জন্য অন্তর্ভুক্তির মাধ্যমে চিরকাল অব্যাহত রয়েছে:

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, যা "ভুল" কনটেনটেশন অর্ডার। আমি মনে করি এটি সমতুল্য হয়ে উঠেছে, তবে আমি কোনও প্রমাণ

— হাজির করিনি

16

হাস্কেল, 15 বাইট

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

ইনফিক্স ফাংশনটি %একটি অসীম স্ট্রিং তৈরি করে, যা হাস্কেল চিরকালের জন্য মুদ্রণ করে কারণ হাস্কেল এর মতো দুর্দান্ত is

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

এটি একটি ইনফিক্স ফাংশন সংজ্ঞায়িত করে #যা দুটি স্ট্রিং নেয় এবং অসীম স্ট্রিং দেয় returns ব্যবহার:

> 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করি এবং ফলাফলটি সংজ্ঞায়িত করতে এই তথ্যগুলি ব্যবহার করি। হাস্কেল যেহেতু অলস, তাই এই "ম্যাজিকালি" ঠিক কাজ করে।

— Zgarb
সূত্র

5

পিপ, 8 বাইট

আরে, পাইথের সাথে বাঁধা!

(fOba.b)

এক্সনোরের হাস্কেল উত্তর থেকে ধার করা সোজাসুজি পুনরাবৃত্ত সংজ্ঞা । স্পেসির সাথে স্পষ্টতার জন্য যুক্ত হয়েছে:

(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... ডের্প লেখার সমতুল্য ।}

বাহ, ভার্বোস। পাওয়ারশেল, ডিফল্টরূপে, প্রতিবার কোনও কিছু আউটপুট দেওয়ার সময় একটি নতুন লাইন ছড়িয়ে দেবে। এটির কাছাকাছি যাওয়ার একমাত্র উপায় হ'ল write-host -n(সংক্ষিপ্ত -NoNewLine), এবং এটি এখানে দৈর্ঘ্যকে একেবারে মেরে ফেলে।

মূলত, এই ক্রমটি পুনরাবৃত্তি হয়, $e"চলতি" ডব্লু _এন হিসাবে আমরা যাই building তবে, যেহেতু আমরা সিকোয়েন্সের পরিবর্তে অসীম শব্দটি তৈরি করতে চাইছি, তাই আমরা আমাদের পূর্বের লুপগুলিতে উপস্থাপিত প্রত্যয়টি মুদ্রণের জন্য আমাদের পূর্বের ভেরিয়েবলগুলি ব্যবহার করি $a। তারপরে আমরা পরবর্তী চলার জন্য আমাদের ভেরিয়েবল সেটআপ করি এবং লুপটি পুনরাবৃত্তি করি। মনে রাখবেন যে এটি প্রত্যাশা করে যে ইনপুটটি স্ট্রিং হিসাবে স্পষ্টভাবে বিস্মৃত হবে, অন্যথায় +অপারেটর কনটেনটেশনের পরিবর্তে পাটিগণিতের জন্য ব্যবহৃত হবে।

উদাহরণ:

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

— AdmBorkBork
সূত্র

3

এপিএল, 24 18

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

এক্সনোরের ফর্মুলেশন ব্যবহার করে কয়েকটি অক্ষর শেভ করার অনুমতি দেওয়া হয়েছে।

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

অসীম সময়ে একটি অসীম মেশিনে এটি লুপটি চালানোর সময় প্রথমে ডাব্লু _∞ তিনবার ⍣≡incre প্রথম বার্ষিকভাবে মুদ্রণ করে এবং ফিক্সপয়েন্ট অপারেটর অবশেষে ফিরে আসার পরে পুরো অভিব্যক্তির ফলস্বরূপ দ্বিগুণ হয় ।

এটি খুব দ্রুত নয় তবে যথেষ্ট দ্রুত। জিএনইউ এপিএলে:

$ 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
সূত্র

দুটি অসীম সংখ্যা। ওও +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++));}

এটি মোটামুটি সোজা সরল recursive প্রিন্টার, vপ্রায় পাশ কাটিয়ে যাওয়া এড়ানোর জন্য একটি নেস্টেড ফাংশন (একটি জিএনইউ সি এক্সটেনশন ক্ল্যাং দ্বারা সমর্থিত নয়) হিসাবে প্রয়োগ করা হয়। ডাব্লু _n-2p(n) মুদ্রণ করে , যেখানে ডাব্লু _-1 এবং ডাব্লু ₀ অবশ্যই এবং এর মধ্যে সরবরাহ করা উচিত । এটি প্রাথমিকভাবে ডাব্লু ₂ মুদ্রণ কল করে । এরপরে এটি লুপ হয়: এটি ডাব্লু ₁ কে মুদ্রণ করতে কল করে , সম্পূর্ণ আউটপুট W ₂ W তৈরি করেv[1]v[2]p(4)p(3)₁ , যা ডব্লিউ ₃ । এটি তখন ডাব্লু ₂p(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.5.2 ঝাঁকুনির সাথে, বিশেষ কমান্ড-লাইন অপশন সহ বা ছাড়াই কাজ করে। অপ্টিমাইজেশন সক্ষম করা থাকলে এটি ভঙ্গ হয় না।

এটি অন্যান্য সংকলকগুলির সাথে কাজ করে না।

আপনি কোনও ক্রমে শব্দগুলি গ্রহণ করতে পারেন; দুটি অ্যারে, অ্যারের অ্যারে, দুটি স্ট্রিং, স্ট্রিংগুলির একটি অ্যারে বা আপনার পছন্দসই একটি ডিলিমিটার সহ একক স্ট্রিং string

আমি শব্দগুলি স্ট্রিং ফর্ম্যাটে কমান্ড-লাইন আর্গুমেন্ট হিসাবে গ্রহণ করি।

আপনি সীমাহীন শব্দের অঙ্কগুলি সীমানা ছাড়াই বা সংলগ্ন অঙ্কের প্রতিটি জোড়ার মধ্যে একটি ধারাবাহিক ডিলিমিটার সহ মুদ্রণ করতে পারেন।

আমি ধারাবাহিক ডিলিমিটার হিসাবে নিউলাইন ব্যবহার করি।

সমস্ত উদ্দেশ্যে, ধরে নিন যে আপনার কোডটি কখনই মেমরির বাইরে চলে যাবে না এবং এর ডেটা প্রকারগুলি উপচে পড়বে না।

বিশেষত এর অর্থ হ'ল STDOUT বা STDERR এর যে কোনও আউটপুট ক্র্যাশ হওয়ার ফলে তা উপেক্ষা করা হবে।

আমি sসীমার বাইরে অ্যাক্সেস । এটি অবশ্যই একটি সময়ে অবশ্যই সেগফ্ল্ট বা অ্যাক্সেস লঙ্ঘনের মাধ্যমে শেষ হবে। sডেটা বিভাগের শেষে স্থাপন করা হয়, সুতরাং এটি অন্যান্য ভেরিয়েবলগুলি ক্লোবার না করা এবং সেগফল্টের আগে ভুল আউটপুট দেওয়া উচিত নয়। আশা রাখি,।

যদি আমার মেশিনে আপনার কোড চালানো (ইন্টেল i7-3770, 16 GiB র্যাম, ফেডোরা 21) এক মিনিট এবং নল তার আউটপুট জন্য wc -c, এটা অন্তত এক মিলিয়ন ডিজিটের প্রিন্ট আবশ্যক ডব্লিউ _∞ জন্য (ওয়াট _-1 , পঃ ₀ ) = (1, 0) ।

ব্যবহার করে পরীক্ষা করে { ./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 মুদ্রণ করে প্রতারণা করে তা 3000 বছর ধরে ডাব্লু∞ প্রিন্টিংয়ে সঠিক কাজ করবে। আমি এটির উন্নতি করতে পারি কিনা তা আমি দেখব। :)

— এইচডিভি

@ ডেনিস আমি এটিকে প্রোগ্রামের জন্য একই সংখ্যক বাইটের সাথে কাজ করতে পরিচালিত করেছিলাম, তবে এটি জিসিসির সাথে সুনির্দিষ্ট করে তুলছি এবং এর পরিষ্কার পরিচ্ছন্নতা আর নেই। আমি আরও কোড যুক্ত না করে নিজের pমধ্যে বারবার কল করার যুক্তিটি কীভাবে রাখব তা আমি দেখছি না p, তবে যদি আমি কোনও উপায় খুঁজে পাই তবে আমি আবার সম্পাদনা করব।

— এইচডিভি

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, যা 701408733 মুদ্রিত হয়েছিল।

হালনাগাদ:

ওপি এই উত্তরের একটি মন্তব্যে (এবং সম্ভবত আমার যেভাবেই বোঝা উচিত ছিল) স্পষ্ট করে দিয়েছিলেন যে ডাব্লু-এর পূর্ববর্তী অতিরিক্ত আউটপুট _{উপরেরটিকে} অযোগ্য ঘোষণা করে। সুতরাং পরিবর্তে এখানে একটি 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) এবং প্যারামিটারটি পুনরায় স্বাক্ষর 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}

— msh210
সূত্র

1

রেক্সএক্স , 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)।

প্রোলোগে আমি একটি ছোট (অগোছালো) সমাধানও লিখেছি। কীভাবে এটির সাথে পারফরম্যান্স পরীক্ষা করতে হবে তা অনুমান করে নি তবে এটি সম্ভবত অত্যাচারী।

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 বাইট সংরক্ষণ করতে পারেন।

— ডেনিস 18

1

ডায়ালগ এপিএল, ৯

{⍵∇⍺,⍞←⍵}

এটি ∇একটি পুনরাবৃত্তি ফাংশন সংজ্ঞায়িত করতে ব্যবহার করে। এটি এই এক্সনরের পাইথন 3 উত্তরের সরাসরি অনুবাদ । এটি ডাব্লু ₀ হিসাবে ডান হিসাবে এবং ডাব্লু ₋₁ এর বাম আর্গুমেন্ট হিসাবে লাগে , উভয়ই অক্ষর ভেক্টর হওয়া উচিত।

— user46915
সূত্র

1

মিনকোলাং 0.11 , 62 বাইট

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

এখানে চেষ্টা করুন। এর মাঝে একটি স্থান সহ ডাব্লু ₀ , ডাব্লু _-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>যাতে। শব্দ concatenating দ্বারা গঠিত ডব্লিউ _{আমি +1} এবং ডব্লিউ _আমি , অর্থাত্ ডব্লিউ _{আমি +1} + + ডব্লিউ _আমি , 2 * সমান ডব্লিউ _{আমি +1} - ওয়াট _আমি । সুতরাং নিম্নলিখিত কোডটি স্ট্যাকটিকে সদৃশ করে (2 * W _{i + 1} ), শীর্ষে উঠে যায়<a> উপাদান (- ডাব্লু_i ), এবং তারপরে প্রতিস্থাপন করে<a+b>এবং<a>তাদের উত্তরসূরীদের সাথে<a+2b>এবং<b>।

(                                       Open while loop (for calculation and output)
 $d                                     Duplicate the whole stack
   2[I2:g]                              Pull <a+b> and <a> from the middle of the stack
          Xx                            Dump the top <a> elements (and <a+b>)
            0c2*1c-                     Get <a+b> and <a>, then calculate
                                        2*<a+b> - <a> = <a+2b> = <a+b> + <b>
                   0g0g-                Get <a+b> and <a>, then subtract
                        d[icO]          Output as character the first <b> elements
                              0G0G      Move both to front
                                  1)    Infinite loop (basically, "while 1:")

— এল'ইনিয়া স্টারম্যান
সূত্র

(দ্রষ্টব্য: এই এক মিনিটের মধ্যে 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].$_

শেবাংকে দুটি হিসাবে গণনা করা, ইনপুট স্টিডিন থেকে নেওয়া হয়, স্থান ডাব্লু ₀ , ডাব্লু _-1 হিসাবে পৃথক করা হয় । 1 এমবি বারের জন্য আউটপুট 15 এমএম ডলারে, যার বেশিরভাগ দোভাষীর প্রবর্তনকে দায়ী করা যেতে পারে।

নমুনা ব্যবহার

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

উদাহরণ ইনপুট: পি ('1', '0')

অতিরিক্ত লিখন সরানোর কোনও উপায় খুঁজে পায়নি।
আমি কীভাবে এটি করতে পারি তা যদি এটির উন্নতি করতে সক্ষম হয়।

— Emigna
সূত্র