দ্রুততম মিনি-ফ্ল্যাক কুইন

26

মিনি-বিমানবিধ্বংসী কামান একটি উপসেট হয় ব্রেন-বিমানবিধ্বংসী কামান ভাষা, যেখানে <>, <...>এবং []অপারেশন অননুমোদিত করছে। কঠোরভাবে বলতে গেলে এটি অবশ্যই নিম্নলিখিত রেজেসের সাথে মেলে না :

.*(<|>|\[])

মিনি-ফ্লাক ব্রেন-ফ্ল্যাকের সবচেয়ে ছোট টিউরিংয়ের সম্পূর্ণ উপসেট।

একটু সময় আগে আমি একটি সুযোগ পেয়ে যান Quine মধ্যে মিনি-বিমানবিধ্বংসী কামান , কিন্তু এখনো খুব মহাবিশ্বের জীবদ্দশায় চালানোর মন্থর ছিল।

সুতরাং আপনার কাছে আমার চ্যালেঞ্জটি একটি দ্রুত কুইন তৈরি করা।

স্কোরিং

আপনার কোডটি স্কোর করতে আপনার কোডের @cyশেষে একটি পতাকা লাগান এবং পতাকাটি ব্যবহার করে রুবি ইন্টারপ্রেটারে ( এটি চেষ্টা করুন রুবি ইন্টারপ্রেটার ব্যবহার করে অনলাইনে চেষ্টা করুন ) -d। আপনার স্কোরটি STDERR এ নিম্নলিখিত হিসাবে মুদ্রণ করা উচিত:

@cy <score>

এটি আপনার প্রোগ্রামটি শেষ হওয়ার আগে চক্রের সংখ্যা এবং এটি রানের সমান। যেহেতু প্রতিটি চক্র আপনার স্কোর চালাতে প্রায় একই পরিমাণ সময় নেয় আপনার প্রোগ্রামটি চালানোর জন্য যে সময় লাগে তার সাথে সরাসরি সম্পর্কযুক্ত হওয়া উচিত।

যদি আপনার কুইন আপনার কম্পিউটারে যুক্তিসঙ্গতভাবে চালনার জন্য দীর্ঘ হয় তবে আপনি হাত দিয়ে চক্রের সংখ্যা গণনা করতে পারেন।

চক্রের সংখ্যা গণনা করা খুব কঠিন নয়। চক্রের সংখ্যা মনডের সংখ্যার চেয়ে 2 গুণ সমান এবং নীলদ চালিত সংখ্যার সমান। এটি প্রতিটি নীলাদকে একটি একক চরিত্রের সাথে প্রতিস্থাপন এবং মোট চলমান অক্ষরের সংখ্যা গণনা করার সমান।

উদাহরণ স্কোরিং

  • (()()()) স্কোর 5 কারণ এটিতে 1 টি মোনাদ এবং 3 টি নীলাদ রয়েছে।

  • (()()()){({}[()])} স্কোর ২৯, কারণ প্রথম অংশটি আগের মতো এবং স্কোর ৫ রয়েছে যখন লুপটিতে mon টি মোনাদ এবং ২ টি নীল্ড রয়েছে 8.. লুপটি 3 বার চালিত হয় তাই আমরা এর স্কোরটি 3 বার গণনা করি। 1*5 + 3*8 = 29

আবশ্যকতা

আপনার প্রোগ্রাম অবশ্যই ...

  • কমপক্ষে 2 বাইট থাকুন

  • -Aপতাকা ব্যবহার করে ব্রেইন-ফ্ল্যাકમાં কার্যকর হওয়ার সময় এর উত্স কোডটি মুদ্রণ করুন

  • রিজেক্সের সাথে মেলে না .*(<|>|\[])

পরামর্শ

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

  • [(...)]{}এবং (...)[{}]একই হিসাবে কাজ <...>কিন্তু সীমাবদ্ধ উত্স প্রয়োজনীয়তা ভঙ্গ করবেন না

  • কীভাবে এই চ্যালেঞ্জটির কাছে যেতে চান এমন কোনও ধারণা চাইলে আপনি ব্রেন-ফ্লাক এবং মিনি- ফ্ল্যাক কুইনগুলি পরীক্ষা করে দেখতে পারেন ।

restricted-source  quine  fastest-code  brain-flak 
— গম উইজার্ড
সূত্র
1
"বর্তমান সেরা" -> "কেবলমাত্র বর্তমান"
— হাইপারনিউটারিনো

উত্তর:

33

মিনি-ফ্লাক, 6851113 চক্র

প্রোগ্রাম (আক্ষরিক)

আমি জানি যে বেশিরভাগ লোকেরা সম্ভবত একটি মিনি-ফ্ল্যাক কুইন অপ্রিনিতযোগ্য অক্ষর এবং এমনকি বহু-বাইট অক্ষর (এনকোডিং প্রাসঙ্গিক করে তোলে) ব্যবহার করবে বলে আশা করে না। তবে এই কুইনটি এবং অপ্রিন্টেবলগুলি কুইনের আকারের (মিলিয়ন ইউটিএফ -8 এর 102646 বাইট হিসাবে এনকোড করা 93919 টি অক্ষর) মিলিয়ে প্রোগ্রামটিকে এই পোস্টে স্থান দেওয়া মোটামুটি কঠিন করে তোলে।

যাইহোক, প্রোগ্রামটি খুব পুনরাবৃত্ত, এবং যেমন, সত্যিই খুব কমপ্রেস করে । পুরো প্রোগ্রামটি আক্ষরিক অর্থে স্ট্যাক এক্সচেঞ্জ থেকে উপলভ্য, যাতে নীচে সংযোগযোগ্য পিছনে লুকানো পুরো কুইনের xxdএকটি- gzipসংক্ষেপিত সংস্করণটির একটি বিপরীতমুখী হেক্সডাম্প রয়েছে :

কোড স্নিপেট দেখান

(হ্যাঁ, এটি এত পুনরাবৃত্ত যে আপনি সংকুচিত হওয়ার পরেও পুনরাবৃত্তিগুলি দেখতে পাবেন )।

প্রশ্নটি বলছে "আমি টিআইওতে আপনার প্রোগ্রামটি পরিচালনা না করার জন্য অত্যন্ত পরামর্শ দিচ্ছি। ডেস্কটপ ইন্টারপ্রেটারের চেয়ে টিআইও কেবল ধীর নয়, এটি প্রায় এক মিনিটের মধ্যেও শেষ হয়ে যাবে someone যদি কেউ রান করার জন্য যথেষ্ট পরিমাণে স্কোর করতে সক্ষম হয় তবে এটি অত্যন্ত চিত্তাকর্ষক হবে It টিআইওর সময় শেষ হওয়ার আগেই তাদের প্রোগ্রাম। আমি এটা করতে পারি! রুবি ইন্টারপ্রেটার ব্যবহার করে টিআইওতে চালাতে প্রায় 20 সেকেন্ড সময় লাগে: অনলাইনে চেষ্টা করে দেখুন!

প্রোগ্রাম (পাঠযোগ্য)

এখন আমি প্রোগ্রামটির একটি সংস্করণ দিয়েছি যা কম্পিউটারগুলি পড়তে পারে, আসুন এমন একটি সংস্করণ চেষ্টা করুন যা মানুষ পড়তে পারে। কোয়েনকেজ 437 (যদি তাদের উচ্চ বিট সেট থাকে) বা ইউনিকোড নিয়ন্ত্রণের ছবিগুলি (তারা যদি এএসসিআইআই নিয়ন্ত্রণ কোড হয়) এ যুক্ত বাইটকে আমি রূপান্তর করেছি, যোগ করা হোয়াইটস্পেস (যে কোনও প্রাক-বিদ্যমান হোয়াইটস্পেস ছবি নিয়ন্ত্রণ করতে রূপান্তরিত হয়েছিল) ), সিনট্যাক্স ব্যবহার করে রান-লেংথ-এনকোডযুক্ত «string×length»এবং কিছু ডেটা-ভারী বিট একত্রে রেখেছেন:

␠
(((()()()()){}))
{{}
    (({})[(()()()())])
    (({})(
        {{}{}((()[()]))}{}
        (((((((({})){}){}{})){}{}){}){}())
        {
            ({}(
                (␀␀!S␠su! … many more comment characters … oq␝qoqoq)
                («()×35» («()×44» («()×44» («()×44» («()×44» («()×45»
                … much more data encoded the same way …
                («()×117»(«()×115»(«()×117»
                «000010101011┬â┬ … many more comment characters … ┬â0┬â┬à00␈␈
                )[({})(
                    ([({})]({}{}))
                    {
                        ((()[()]))
                    }{}
                    {
                        {
                            ({}(((({}())[()])))[{}()])
                        }{}
                        (({}))
                        ((()[()]))
                    }{}
                )]{}
                %Wwy$%Y%ywywy$wy$%%%WwyY%$$wy%$$%$%$%$%%wy%ywywy'×almost 241»
                ,444454545455┬ç┬ … many more comment characters … -a--┬ü␡┬ü-a␡┬ü
            )[{}()])
        }{}
        {}({}())
    )[{}])
    (({})(()()()()){})
}{}{}␊

("প্রায় 241" কারণ 241 তম অনুলিপিটি অনুপস্থিত অনুপস্থিত ', তবে অন্য 240 এর মতোই অন্যরকম))

ব্যাখ্যা

মন্তব্য সম্পর্কে

প্রথমটি ব্যাখ্যা করার জন্য হ'ল, অপ্রিন্টযোগ্য অক্ষর এবং অন্যান্য জাঙ্কগুলি কী হবে যা মিনি-ফ্লাক কমান্ড নয়? আপনি ভাবতে পারেন যে কুইনে মন্তব্য যুক্ত করা বিষয়গুলিকে আরও শক্ত করে তোলে তবে এটি একটি গতি প্রতিযোগিতা (আকারের প্রতিযোগিতা নয়), যার অর্থ মন্তব্যগুলি প্রোগ্রামের গতিতে আঘাত না দেয়। এদিকে, ব্রেন-ফ্লাক এবং এইভাবে মিনি-ফ্ল্যাক কেবল স্ট্যাকের সামগ্রীগুলি স্ট্যান্ডার্ড আউটপুটে ফেলে দেয়; আপনি তা নিশ্চিত করার জন্য স্ট্যাক অন্তর্ভুক্ত ছিল যদি শুধুমাত্রআপনার প্রোগ্রামের কমান্ডগুলি তৈরি করে এমন চরিত্রগুলি, আপনাকে স্ট্যাক পরিষ্কার করার জন্য চক্র ব্যয় করতে হবে। যেমনটি রয়েছে, ব্রেন-ফ্ল্যাক বেশিরভাগ চরিত্রকে উপেক্ষা করে, তাই যতক্ষণ না আমরা নিশ্চিত করি যে জাঙ্ক স্ট্যাক উপাদানগুলি ব্রেন-ফ্লাক কমান্ডগুলি বৈধ নয় (এটি একটি মস্তিষ্ক-ফ্লাক / মিনি-ফ্ল্যাক বহুভ্রংশ তৈরি করছে), এবং নেতিবাচক বা বাইরে নয় ইউনিকোড পরিসর, আমরা কেবল তাদের স্ট্যাকের উপর রেখে দিতে পারি, তাদের আউটপুট হওয়ার অনুমতি দিতে পারি এবং আমাদের প্রোগ্রামে একই চরিত্রটি একই স্থানে রেখে দিতে পারি কুইন সম্পত্তিটি ধরে রাখতে।

আমরা এর সদ্ব্যবহার করতে পারি এমন একটি বিশেষ উপায় আছে। কুইন একটি দীর্ঘ ডেটা স্ট্রিং ব্যবহার করে কাজ করে এবং মূলত কুইন থেকে সমস্ত আউটপুট ডেটা স্ট্রিংকে বিভিন্ন উপায়ে বিন্যাস করে উত্পাদিত হয়। প্রোগ্রামটির একাধিক টুকরো রয়েছে তা সত্ত্বেও কেবলমাত্র একটি ডাটা স্ট্রিং রয়েছে; সুতরাং প্রোগ্রামের বিভিন্ন অংশ মুদ্রণের জন্য আমাদের একই ডেটা স্ট্রিংটি ব্যবহার করতে সক্ষম হওয়া দরকার। "জাঙ্ক ডেটা কিছু যায় আসে না" কৌশল আমাদের খুব সাধারণ উপায়ে এটি করতে দেয়; আমরা সেই অক্ষরগুলিকে সংরক্ষণ করি যা তাদের এএসসিআইআই কোডে বা এর থেকে কোনও মান যোগ করে বা বিয়োগ করে ডেটা স্ট্রিংয়ে প্রোগ্রাম তৈরি করে। বিশেষত, প্রোগ্রামটি শুরু করার জন্য অক্ষরগুলি তাদের ASCII কোড + 4 হিসাবে সংরক্ষণ করা হয়, যে বিভাগগুলি তৈরি করে যা প্রায় 241 বার তাদের ASCII কোড হিসাবে পুনরাবৃত্তি হয় - 4,অফসেট সহ ডেটা স্ট্রিংয়ের প্রতিটি চরিত্র; যদি উদাহরণস্বরূপ, আমরা প্রতিটি অক্ষর কোডে 4 যুক্ত করে মুদ্রণ করি, তার আগে এবং পরে কিছু মন্তব্য সহ আমরা বারবার বিভাগটির একটি পুনরাবৃত্তি পাই। (এই মন্তব্যগুলি কেবল প্রোগ্রামের অন্যান্য বিভাগগুলির সাথে সাথে চরিত্রের কোডগুলি স্থানান্তরিত করা হয়েছে যাতে তারা কোনও বৈধ ব্রেইন-ফ্লাক কমান্ড তৈরি না করে কারণ ভুল অফসেট যুক্ত করা হয়েছিল Mini আমাদের কেবল মিনি- নয়, ব্রেইন-ফ্লাক কমান্ডগুলি ডজ করতে হবে We প্রশ্নের সীমাবদ্ধ-উত্স অংশটি লঙ্ঘন এড়াতে ফ্লাক কমান্ডগুলি ; অফসেটগুলির পছন্দ এটি নিশ্চিত করার জন্য ডিজাইন করা হয়েছিল))

এই মন্তব্য কৌশলটির কারণে, আমাদের কেবলমাত্র দুটি ভিন্ন উপায়ে ফর্ম্যাট করা ডেটা স্ট্রিংটি আউটপুট করতে সক্ষম হওয়া প্রয়োজন: ক) উত্সের মতো একইভাবে এনকোড করা হয়েছে, খ) প্রতিটি কোডে একটি নির্দিষ্ট অফসেটযুক্ত অক্ষর কোড হিসাবে। এটি একটি বিশাল সরলীকরণ যা যুক্ত দৈর্ঘ্যটিকে পুরোপুরি মূল্যবান করে তোলে।

প্রোগ্রাম কাঠামো

এই প্রোগ্রামটির চারটি অংশ রয়েছে: পরিচিতি, ডেটা স্ট্রিং, ডেটা স্ট্রিং ফর্ম্যাটার এবং আউটরো। ইন্ট্রো এবং আউট্রো মূলত ডেটা স্ট্রিং এবং এর ফর্ম্যাটরটি একটি লুপে চালানোর জন্য উপযুক্ত, প্রতিটি সময় উপযুক্ত বিন্যাস নির্দিষ্ট করে (যেমন এনকোড বা অফসেট কিনা এবং কী অফসেট ব্যবহার করতে হবে)। ডেটা স্ট্রিংটি কেবলমাত্র ডেটা এবং এটি কেবলমাত্র কুইনের একমাত্র অংশ যার জন্য এটি তৈরি করা অক্ষরগুলি ডেটা স্ট্রিংয়ে আক্ষরিকভাবে নির্দিষ্ট করা হয়নি (এটি করা স্পষ্টতই অসম্ভব, কারণ এটি নিজের চেয়ে দীর্ঘ হতে হবে); এটি এইভাবে এমনভাবে লেখা হয়েছে যা নিজের থেকে নতুন করে তৈরি করা বিশেষত সহজ। ডেটা স্ট্রিং ফর্ম্যাটারটি প্রায় 241 অভিন্ন অংশের তৈরি, যার প্রত্যেকটিতে ডেটা স্ট্রিংয়ের 241 টির মধ্যে একটি নির্দিষ্ট ডেটাম ফর্ম্যাট করে।

প্রোগ্রামটির প্রতিটি অংশটি নিম্নলিখিতভাবে ডেটা স্ট্রিং এবং এর ফর্ম্যাটারের মাধ্যমে উত্পাদিত হতে পারে:

  • আউটরো উত্পাদন করতে, অফসেট +8 দিয়ে ডেটা স্ট্রিংটি ফর্ম্যাট করুন
  • ডেটা স্ট্রিং বিন্যাস উত্পাদন করতে, ডেটা স্ট্রিংকে অফসেট +4, 241 বারের সাথে ফর্ম্যাট করুন
  • ডেটা স্ট্রিং উত্পাদন করতে, উত্স বিন্যাসে এনকোডিংয়ের মাধ্যমে ডেটা স্ট্রিংটি ফর্ম্যাট করুন
  • পরিচিতি উত্পাদন করতে, অফসেট -4 দিয়ে ডেটা স্ট্রিংটি ফর্ম্যাট করুন

সুতরাং আমাদের যা করতে হবে তা হল প্রোগ্রামের এই অংশগুলি কীভাবে কাজ করে তা দেখুন।

ডাটা স্ট্রিং

(«()×35» («()×44» («()×44» («()×44» («()×44» («()×45» …

আমাদের ডাটা স্ট্রিংয়ের জন্য একটি সাধারণ এনকোডিং দরকার কারণ আমাদের মিনি-ফ্ল্যাক কোডে এনকোডিংটি বিপরীত করতে সক্ষম হতে হবে। আপনি এর চেয়ে সহজ কিছু পেতে পারেন না!

এই কুইনের পেছনের মূল ধারণাটি (মন্তব্য কৌশলটি বাদে) লক্ষ্য করা যায় যে মূলত কেবলমাত্র এক জায়গা যেখানে আমরা প্রচুর পরিমাণে ডেটা সংরক্ষণ করতে পারি: প্রোগ্রাম উত্সের বিভিন্ন নেস্টিং স্তরের মধ্যে "কমান্ড রিটার্ন মানগুলির সংখ্যার পরিমাণ"। (এটি সাধারণত তৃতীয় স্ট্যাক হিসাবে পরিচিতযদিও মিনি-ফ্ল্যাকের দ্বিতীয় স্ট্যাকটি নেই, সুতরাং মিনি-ফ্ল্যাক প্রসঙ্গে "ওয়ার্কিং স্ট্যাক" সম্ভবত আরও ভাল নাম)) ডেটা সংরক্ষণের জন্য অন্যান্য সম্ভাবনাগুলি মূল / প্রথম স্ট্যাক (যা কাজ করে না) হবে কারণ আমাদের আউটপুটটি সেখানে যেতে হবে, এবং আমরা আউটপুটটি স্টোরের কাছ থেকে দূরবর্তীভাবে কার্যকরভাবে সরাতে পারি না) এবং একটি স্ট্যাকের উপাদানটিতে একটি বিগনামে এনকোড করে রেখেছি (যা এই সমস্যার জন্য উপযুক্ত নয় কারণ এটি ক্ষতিকারক সময় নেয় বলে মনে হয়) এটি থেকে ডেটা আহরণ); আপনি যখন এগুলি অপসারণ করেন, তখন কার্যকারী স্ট্যাকটি কেবলমাত্র অবশিষ্ট অবস্থান।

এই স্ট্যাকের উপর ডেটা "সঞ্চয়" করার জন্য, আমরা ভারসাম্যহীন কমান্ডগুলি ব্যবহার করি (এই ক্ষেত্রে, একটি (…)কমান্ডের প্রথম অর্ধেক ), যা পরবর্তী সময়ে ডেটা স্ট্রিং বিন্যাসের মধ্যে ভারসাম্যপূর্ণ হবে। প্রতিবার যখন আমরা এই কমান্ডগুলির মধ্যে একটি ফর্ম্যাটারের মধ্যে বন্ধ করি, তখন এটি ডাটা স্ট্রিং থেকে নেওয়া একটি ডেটামের যোগফল এবং ফর্ম্যাটারের মধ্যে নেস্টিং স্তরে সমস্ত কমান্ডের রিটার্ন মানগুলিকে চাপ দেবে; আমরা নিশ্চিত করতে পারি যে উত্তরোত্তরটি শূন্যে যুক্ত হয়, তাই ফর্ম্যাটরটি কেবল ডেটা স্ট্রিং থেকে নেওয়া একক মান দেখে।

ফর্ম্যাটটি খুব সহজ: এর (পরে এন কপি রয়েছে (), যেখানে n হ'ল আমরা সংরক্ষণ করতে চাই। (দ্রষ্টব্য যে এর অর্থ আমরা কেবল অ-নেতিবাচক সংখ্যাগুলি সঞ্চয় করতে পারি এবং ডেটা স্ট্রিংয়ের শেষ উপাদানটি ইতিবাচক হওয়া দরকার))

ডেটা স্ট্রিং সম্পর্কে একটি সামান্য অপ্রচলিত বিন্দু হ'ল এটি যে অর্ডারটিতে রয়েছে the ডাটা স্ট্রিংয়ের "শুরু" হ'ল প্রোগ্রামের সূচনা, অর্থাৎ বাহ্যিকতম নীড় স্তরের স্তর কাছাকাছি; এই অংশটি সর্বশেষ বিন্যাসিত হয় (যেহেতু বিন্যাসটি অভ্যন্তরীণ থেকে নীড়ের নীড়ের স্তর পর্যন্ত চলে)। তবে সর্বশেষ আকারে ফর্ম্যাট করা সত্ত্বেও এটি প্রথমে মুদ্রিত হয় , কারণ প্রথমে স্ট্যাকের উপরে চাপানো মানগুলি মিনি-ফ্ল্যাক ইন্টারপ্রেটার দ্বারা সর্বশেষে মুদ্রণ করা হয়। একই নীতিটি পুরোপুরি প্রোগ্রামে প্রযোজ্য; আমাদের প্রথমে আউটরো ফর্ম্যাট করতে হবে, তারপরে ডাটা স্ট্রিং ফরম্যাটার, তারপরে ডেটা স্ট্রিং, তারপরে ইন্ট্রো, অর্থাৎ তারা প্রোগ্রামে যে অর্ডার রেখেছিল তার বিপরীত হবে।

ডেটা স্ট্রিং বিন্যাসক

)[({})(
    ([({})]({}{}))
    {
        ((()[()]))
    }{}
    {
        {
            ({}(((({}())[()])))[{}()])
        }{}
        (({}))
        ((()[()]))
    }{}
)]{}

241 বিভাগের মধ্যে ডেটা স্ট্রিং ফর্ম্যাটারটি তৈরি করা হয় যার প্রত্যেকটির অভিন্ন কোড রয়েছে (একটি বিভাগে একটি প্রান্তিকভাবে আলাদা মন্তব্য রয়েছে), যার প্রতিটি ডেটা স্ট্রিংয়ের একটি নির্দিষ্ট অক্ষরকে বিন্যাস করে। (আমরা এখানে একটি লুপ ব্যবহার করতে পারি না: আমাদের ভারসাম্যহীন ভারসাম্য মেশার )মাধ্যমে ডেটা স্ট্রিং পড়তে ভারসাম্যহীন প্রয়োজন (, এবং আমরা একটি {…}লুপের মধ্যে থাকা একটিরও রাখতে পারি না , এটি লুপের একমাত্র রূপ যা বিদ্যমান exists সুতরাং পরিবর্তে, আমরা " ফর্ম্যাটরটি আনরোল করুন, এবং ফর্ম্যাটারের অফসেট দিয়ে 241 বার অফসেটের সাহায্যে ডেটা স্ট্রিং আউটপুট পেতে কেবল ইনট্রো / আউট্রো পান)

)[({})( … )]{}

ফর্ম্যাটর উপাদানটির বাইরের অংশটি ডাটা স্ট্রিংয়ের একটি উপাদান পড়ে; ডেটা স্ট্রিংয়ের এনকোডিংয়ের সরলতা এটি পড়ার ক্ষেত্রে কিছুটা জটিলতার দিকে নিয়ে যায়। আমরা (…)ডেটা স্ট্রিংয়ের সাথে তুলনামূলকভাবে বন্ধ করে শুরু করি , তারপরে ( […]) দুটি মান অগ্রাহ্য করব : ডেটাুম আমরা কেবল ডেটা স্ট্রিং ( ({})) থেকে পড়ি এবং বাকি প্রোগ্রামটির রিটার্ন মান। আমরা বাকি ফরম্যাটার উপাদানটির রিটার্ন মানটি (…)দিয়ে অনুলিপি করি এবং সাথে অনুলিপি করা সংস্করণে অনুলিপিটি যুক্ত করি {}। শেষ ফলাফলটি হ'ল ডেটা স্ট্রিং উপাদান এবং ফর্ম্যাটর উপাদানগুলির একসাথে রিটার্ন মান হ'ল ডেটা মাইনাস ডেটাম বিয়োগ বিয়োগ ফেরতের মান, বা 0; পরবর্তী ডাটা স্ট্রিং উপাদানটি সঠিক মান তৈরি করতে এটি প্রয়োজনীয়।

([({})]({}{}))

ফর্ম্যাটরটি শীর্ষ স্ট্যাক উপাদানটি ব্যবহার করে এটি কোন মোডে রয়েছে তা জানতে (ডাটা স্ট্রিং বিন্যাসে 0 = ফর্ম্যাট, অন্য কোনও মান = আউটপুট থেকে অফসেট)। যাইহোক, কেবল ডেটা স্ট্রিং পড়ে, ড্যাটাম স্ট্যাকের বিন্যাসের শীর্ষে রয়েছে এবং আমরা তাদের অন্যভাবে চাই। এই কোড ব্রেন-বিমানবিধ্বংসী কামান ও swap 'র কোডের একটি খাটো বৈকল্পিক, গ্রহণ করা হয় একটি উপরে খ থেকে খ উপরে একটি  + +  খ ; না শুধুমাত্র এটা খাটো, এটি আরো উপযোগী (এই নির্দিষ্ট ক্ষেত্রে) ও কারণ যোগ করার পার্শ্ব প্রতিক্রিয়া খ করার একটি যখন সমস্যাযুক্ত নয় খ 0, এবং যখন খ 0 নয়, এটা আমাদের জন্য অফসেট গণনা করে।

{
    ((()[()]))
}{}
{
    …
    ((()[()]))
}{}

মস্তিষ্ক-ফ্ল্যাকের কেবল একটি নিয়ন্ত্রণ প্রবাহ কাঠামো রয়েছে, সুতরাং আমরা যদি whileলুপ ব্যতীত অন্য কিছু চাই , তবে এটি কিছুটা কাজ নেবে। এটি একটি "অবহেলা" কাঠামো; যদি স্ট্যাকের শীর্ষে 0 থাকে তবে এটি সরিয়ে দেয়, অন্যথায় এটি স্ট্যাকের শীর্ষে 0 রাখে। (এটি বেশ সহজভাবে কাজ করে: যতক্ষণ না স্ট্যাকের শীর্ষে 0 নেই, 1 - 1 টি স্ট্যাকের দিকে দু'বার চাপ দিন; যখন আপনি শেষ করেন, শীর্ষ স্ট্যাক উপাদানটি পপ করুন))

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

"তারপরে" ধারাটিতে, যা ফর্ম্যাটটি নানজারো হলে চলে, আমাদের আসলে কিছুই করার নেই; আমরা যা চাই তা হ'ল ডেটা + অফসেটটিকে মূল স্ট্যাকের দিকে ঠেলে দেওয়া (যাতে এটি প্রোগ্রামের শেষে আউটপুট হতে পারে), তবে এটি ইতিমধ্যে রয়েছে। সুতরাং আমরা কেবল উত্স আকারে ডেটা স্ট্রিং উপাদান এনকোডিংয়ের ক্ষেত্রে মোকাবেলা করতে হবে।

{
    ({}(((({}())[()])))[{}()])
}{}
(({}))

আমরা কীভাবে এটি করি তা এখানে। {({}( … )[{}()])}{}গঠন যা কাজ স্ট্যাকে লুপ কাউন্টার চলন্ত এবং এটি সেখানে অধিষ্ঠিত করে কাজ করে পুনরাবৃত্তিও একটি নির্দিষ্ট নম্বর (সঙ্গে একটি লুপ নামে পরিচিত হওয়া উচিত; কারণ কাজ স্ট্যাকের এক্সেস আবদ্ধ থাকে তা অন্য কোন কোড থেকে নিরাপদে থাকবে প্রোগ্রামের নেস্টিং লেভেল)। লুপের মূল অংশটি ((({}())[()]))এটি শীর্ষ স্ট্যাক উপাদানটির তিনটি অনুলিপি তৈরি করে এবং সর্বনিম্ন 1 টিতে যোগ করে। অন্য কথায়, এটি স্ট্যাকের শীর্ষে একটি 40কে 41 এর উপরে 40 এর 40 এ রূপান্তর করে বা এএসসিআইআই হিসাবে দেখা (হয় ((); এই বারবার চলমান করা হবে (মধ্যে (()মধ্যে (()()মধ্যে (()()()এবং তাই, এবং এইভাবে আমাদের তথ্য স্ট্রিং জেনারেট করতে একটি সহজ উপায় আছে (অভিমানী একটা যে (স্ট্যাকের উপর ইতিমধ্যে)।

লুপটি শেষ হয়ে গেলে, (({}))স্ট্যাকের শীর্ষটিকে নকল করে (যাতে এটি এখন ((()…পরিবর্তে শুরু হয় (()…The শীর্ষস্থানীয় (পরবর্তী অক্ষরটি ফর্ম্যাট করতে ডেটা স্ট্রিং ফর্ম্যাটারের পরবর্তী অনুলিপি দ্বারা ব্যবহৃত হবে (এটি এতে প্রসারিত হবে (()(()…তারপরে (()()(()…, এবং আরও, সুতরাং (এটি ডেটা স্ট্রিংয়ের মধ্যে পৃথকীকরণ উত্পন্ন করে )।

%Wwy$%Y%ywywy$wy$%%%WwyY%$$wy%$$%$%$%$%%wy%ywywy'

ডেটা স্ট্রিং ফর্ম্যাটারে আগ্রহের একটি শেষ বিট আছে। ঠিক আছে, সুতরাং বেশিরভাগই কেবল এই মাত্রাটি 4 কোডপয়েন্টগুলি নীচের দিকে স্থানান্তরিত হয়; যাইহোক, শেষের দিকে apost প্রেরণাদণ্ডটি জায়গা থেকে সন্ধান করতে পারে। '(কোডপয়েন্ট 39) +(কোডপয়েন্ট ৪৩) এ স্থানান্তরিত হবে যা ব্রেন-ফ্লাক কমান্ড নয়, তাই আপনি অনুমান করতে পারেন যে এটি অন্য কোনও উদ্দেশ্যে রয়েছে।

এটি এখানে থাকার কারণটি হ'ল ডেটা স্ট্রিং ফর্ম্যাটারটি (ইতিমধ্যে স্ট্যাকটিতে একটি উপস্থিত হওয়ার প্রত্যাশা করে (এতে কোনও আক্ষরিক 40 টি কোথাও নেই)। দ্য'আসলে সেই ব্লকের শুরুতে যা ডাটা স্ট্রিং ফর্ম্যাটরটি তৈরি করতে পুনরায় পুনরায় পুনরুক্ত হয়, তাই শেষ হয় না, সুতরাং ডেটা স্ট্রিং বিন্যাসের অক্ষরগুলি স্ট্যাকের দিকে ঠেলে দেওয়া হয় (এবং কোডটি তথ্য স্ট্রিং প্রিন্টিংয়ের দিকে এগিয়ে চলেছে) নিজেই), আউট্রোটি স্ট্যাকের শীর্ষে 39টিকে 40 এর মধ্যে সামঞ্জস্য করে, এটি ব্যবহারের জন্য ফর্ম্যাটারের জন্য প্রস্তুত (চলমান চলমান ফরম্যাটার নিজেই, উত্সে এটির উপস্থাপনা নয়)। এজন্য আমাদের কাছে ফর্ম্যাটারটির "প্রায় 241" কপি রয়েছে; প্রথম অনুলিপিতে এটির প্রথম অক্ষরটি অনুপস্থিত। এবং সেই চরিত্রটি, অ্যাস্টোস্ট্রোফ, ডাটা স্ট্রিংয়ের মাত্র তিনটি অক্ষরের একটি যা প্রোগ্রামের কোথাও মিনি-ফ্ল্যাক কোডের সাথে মিলে না; এটি ধ্রুবক সরবরাহের পদ্ধতি হিসাবে বিশুদ্ধরূপে

ইন্ট্রো এবং আউটরো

(((()()()()){}))
{{}
    (({})[(()()()())])
    (({})(
        {{}{}((()[()]))}{}
        (((((((({})){}){}{})){}{}){}){}())
        {
            ({}(
                (␀␀!S␠su! … many more comment characters … oq␝qoqoq)
                …
            )[{}()])
        }{}
        {}({}())
    )[{}])
    (({})(()()()()){})
}{}{}␊

ভূমিকা এবং আউট্রো ধারণাগতভাবে প্রোগ্রামের একই অংশ; আমরা একটি পার্থক্য আঁকার একমাত্র কারণটি হ'ল ডেটা স্ট্রিং এবং এর ফর্ম্যাটরটি হওয়ার আগেই আউট্রোর আউটপুট হওয়া দরকার (যাতে এটি পরে প্রিন্ট করা হয়), যেখানে পরিচয়টি তাদের পরে আউটপুট হওয়া প্রয়োজন (তাদের আগে মুদ্রণ করা)।

(((()()()()){}))

আমরা স্ট্যাকের উপর 8 টি অনুলিপি রেখে শুরু করি। এটি প্রথম পুনরাবৃত্তির জন্য অফসেট। দ্বিতীয় অনুলিপিটি হ'ল কারণ প্রধান লুপটি অফসেটের উপরে স্ট্যাকের উপরে একটি আবর্জনা উপাদান থাকবে বলে মনে করে, পরীক্ষা থেকে পিছনে ছেড়ে যায় যা মূল লুপের অস্তিত্ব আছে কিনা তা স্থির করে এবং তাই আমাদের সেখানে একটি জাঙ্ক উপাদান রাখা দরকার যাতে আমরা আসলে যে উপাদানটি চাই তা তা ফেলে দেয় না; অনুলিপিটি হ'ল এটি করার উপায় output

8 নম্বরের অন্যান্য উপস্থাপনা রয়েছে যা এইগুলির চেয়ে বেশি নয়। তবে, দ্রুততম কোডের জন্য যাওয়ার সময় এটি অবশ্যই সেরা বিকল্প definitely একটি জিনিসের জন্য ()()()(), বলার চেয়েও দ্রুত ব্যবহার করা হয় (()()){}, কারণ উভয়ই 8 টি অক্ষর দীর্ঘ হওয়া সত্ত্বেও পূর্ববর্তীটি একটি চক্র দ্রুততর, কারণ (…)এটি 2 চক্র হিসাবে গণ্য হয়, তবে ()কেবল একটি হিসাবে। এক চক্র সংরক্ষণ করা হচ্ছে একটি জন্য অনেক বড় বিবেচনার তুলনায় তুচ্ছ হয় quine যদিও: (এবং )তুলনায় অনেক কম codepoints আছে {এবং }, তাই তাদের জন্য তথ্য টুকরা উৎপাদিত অনেক দ্রুত হতে হবে (এবং ডেটা টুকরা কোডে কম জায়গা নিয়ে করবে খুব)।

{{} … }{}{}

মূল লুপ। এটি পুনরাবৃত্তিকে গণনা করে না (এটি একটি whileলুপ, একটি forলুপ নয় এবং ব্রেক আউট করার জন্য একটি পরীক্ষা ব্যবহার করে)। এটি বের হয়ে গেলে, আমরা শীর্ষ দুটি স্ট্যাক উপাদানগুলি বাতিল করে দিই; উপরের উপাদানটি নিরীহ 0, তবে নীচের উপাদানটি হবে "পরবর্তী পুনরাবৃত্তির জন্য ব্যবহারের জন্য ফর্ম্যাট", যা (নেতিবাচক অফসেট হওয়া) একটি negativeণাত্মক সংখ্যা এবং মিনি যখন স্ট্যাকের উপর কোনও নেতিবাচক সংখ্যা থাকে -ফ্লাক প্রোগ্রামটি প্রস্থান করে, দোভাষী তাদের আউটপুট দেওয়ার চেষ্টা করে ক্র্যাশ করে।

যেহেতু এই লুপটি বিচ্ছিন্ন হয়ে যাওয়ার জন্য একটি সুস্পষ্ট পরীক্ষা ব্যবহার করে, সেই পরীক্ষার ফলাফল স্ট্যাকের উপর ছেড়ে যাবে, তাই আমরা এটিকে প্রথম জিনিস হিসাবে বাতিল করি (এর মান কার্যকর নয়)।

(({})[(()()()())])

এই কোডটি  স্ট্যাক উপাদান চ এর উপরে 4 এবং f - 4 ধাক্কা দেয় wh সেই উপাদানটি জায়গায় রেখে দেয়। আমরা পরবর্তী পুনরাবৃত্তির জন্য ফর্ম্যাটটি আগাম গণনা করছি (যখন আমাদের ধ্রুবক 4 হাতে রয়েছে), এবং একই সাথে প্রোগ্রামটির পরবর্তী কয়েকটি অংশের জন্য সঠিক ক্রমে স্ট্যাকটি পাওয়া যাচ্ছে: আমরা ফর্ম্যাট হিসাবে এফ ব্যবহার করব এই পুনরাবৃত্তি, এবং 4 এর আগে প্রয়োজন।

(({})( … )[{}])

এটি  ওয়ার্কিং স্ট্যাকের f - 4 এর একটি অনুলিপি সংরক্ষণ করে , যাতে আমরা এটি পরবর্তী পুনরাবৃত্তির জন্য ব্যবহার করতে পারি। ( চ এর মান এখনও সেই সময়ে উপস্থিত থাকবে তবে এটি স্ট্যাকের একটি বিশ্রী জায়গায় থাকবে এবং আমরা যদি এটি সঠিক জায়গায় চালাতে পারি, তবে এটি থেকে 4 বিয়োগ করে চক্র ব্যয় করতে হবে, এবং সেই বিয়োগটি করতে কোডটি মুদ্রণের চক্র now এখন এটি সঞ্চয় করা সহজ)

{{}{}((()[()]))}{}

অফসেটটি 4 (যেমন চ  - 4 হয় 0) তা দেখার জন্য একটি পরীক্ষা । যদি এটি হয়, আমরা ডেটা স্ট্রিং ফর্ম্যাটারটি মুদ্রণ করছি, সুতরাং আমাদের এই অফসেটে একবারের চেয়ে 241 বার ডেটা স্ট্রিং এবং এর ফর্ম্যাটর চালানো দরকার। কোডটি মোটামুটি সহজ: যদি চ  - 4 ননজারো হয় তবে এফ  - 4 এবং 4 টি নিজেই একজোড়া জিরো দিয়ে প্রতিস্থাপন করুন ; তারপরে যে কোনও ক্ষেত্রে শীর্ষ স্তরের উপাদানটি পপ করুন। আমরা এখন উপরে একটি নম্বর আছে চ , স্ট্যাক পারেন 4 বা 0 (যদি আমরা শুধুমাত্র একবারই এটি মুদ্রণ করতে চান) (আমরা এই পুনরাবৃত্তির 241 বার মুদ্রণ করতে চান করে থাকেন)।

(
    ((((((({})){}){}{})){}{}){}){}
    ()
)

এটি ব্রেন-ফ্লাক / মিনি-ফ্ল্যাক ধ্রুবকটির একটি আকর্ষণীয় ধরণের; দীর্ঘ লাইনটি এখানে 60০ সংখ্যাটি উপস্থাপন করে You আপনি অভাবের কারণে বিভ্রান্ত হতে পারেন ()যা সাধারণত ব্রেন-ফ্লাক ধ্রুবকগুলিতে পুরো জায়গা জুড়ে থাকে; এটি কোনও নিয়মিত সংখ্যা নয়, একটি চার্চ সংখ্যা, যা সংখ্যাকে ডুপ্লিকেশন অপারেশন হিসাবে ব্যাখ্যা করে। উদাহরণস্বরূপ, চার্চের অঙ্কগুলি এখানে seen০-র জন্য, এখানে দেখা যায়, এর ইনপুটটির 60০ টি অনুলিপি তৈরি করে এবং সেগুলি একক মানকে একত্রিত করে; মস্তিষ্ক-ফ্ল্যাকে কেবলমাত্র আমরা সংযুক্ত করতে পারি নিয়মিত সংখ্যাগুলি, সংযোজন দ্বারা, তাই আমরা স্ট্যাকের শীর্ষের 60 টি অনুলিপি যুক্ত করি এবং এভাবে স্ট্যাকের শীর্ষটি 60 দ্বারা গুণিত করি।

পার্শ্ব নোট হিসাবে, আপনি আন্ডারলোড সংখ্যার সন্ধানকারী ব্যবহার করতে পারেন , যা আন্ডারলোড সিনট্যাক্সে চার্চ সংখ্যা তৈরি করে, মিনি-ফ্ল্যাশেও উপযুক্ত নম্বর খুঁজে পেতে। আন্ডারলোড অঙ্কগুলি (শূন্য ব্যতীত) অপারেশনগুলি "ডুপ্লিকেট শীর্ষের স্ট্যাক উপাদান" :এবং "শীর্ষ দুটি স্ট্যাকের উপাদানগুলি একত্রিত করুন" ব্যবহার করে *; উভয় ঐ অপারেশন ব্রেন-বিমানবিধ্বংসী কামান মধ্যে উপস্থিত যাতে আপনি শুধু অনুবাদ :করার ), *করতে {}, শুরুতে যোগ একটি {}, এবং যথেষ্ট যোগ (ব্যালেন্সে শুরুতে (এই প্রধান স্ট্যাকের এবং কাজ স্ট্যাকের একটি অদ্ভুত মিশ্রণ ব্যবহার করছে, কিন্তু এটা কাজ করে)।

এই নির্দিষ্ট কোড খণ্ডটি গির্জার সংখ্যা 60 ব্যবহার করে (কার্যকরভাবে "60 দ্বারা গুণিত" স্নিপেট), বর্ধিতকরণের সাথে, 60 x  + 1 এক্সপ্রেশনটি তৈরি করে, সুতরাং আমাদের যদি পূর্ববর্তী পদক্ষেপ থেকে 4 থাকে, এটি আমাদের একটি মান দেয় 241 এর, বা যদি আমাদের 0 থাকে তবে আমরা কেবল 1 এর মান পাই, এটি আমাদের প্রয়োজনীয় পুনরাবৃত্তির সংখ্যাটি সঠিকভাবে গণনা করে।

241 এর পছন্দটি কাকতালীয় নয়; এটি একটি মান হিসাবে বেছে নেওয়া হয়েছিল) প্রোগ্রামটি যে দৈর্ঘ্যে যেভাবেই শেষ হবে এবং খ) 1 গোলাকার সংখ্যার চেয়ে 4 বারের বেশি। এই ক্ষেত্রে গোলাকার সংখ্যা, 60, চার্চের সংখ্যার হিসাবে সংক্ষিপ্ত উপস্থাপনা রাখে কারণ আপনার অনুলিপি করার ক্ষেত্রে আরও নমনীয়তা রয়েছে। দৈর্ঘ্যটি ঠিক 241 পর্যন্ত আনতে প্রোগ্রামটিতে প্যাডিং রয়েছে।

{
    ({}(
        …
    )[{}()])
}{}

এটি আগের মতো দেখা লুপের জন্য এটি, যা মূল স্ট্যাকের শীর্ষের সমান বেশ কয়েকটি বারের ভিতরে কোডটি চালায় (এটি খায়; লুপের কাউন্টারটি নিজেই কার্যকারী স্ট্যাকের মধ্যে সঞ্চিত থাকে, তবে এর দৃশ্যমানতা যা প্রোগ্রামটির নেস্টিং স্তরের সাথে জড়িত এবং এভাবে লুপ নিজেই এটির সাথে ইন্টারঅ্যাক্ট করার পক্ষে কিছুই অসম্ভব। এটি আসলে ডেটা স্ট্রিং এবং এর ফর্ম্যাটরটি 1 বা 241 বার চালায় এবং আমরা এখন মূল স্ট্যাক থেকে আমাদের নিয়ন্ত্রণ প্রবাহ গণনার জন্য যে সমস্ত মান ব্যবহার করছিলাম তা পপ করেছি, এর উপরে প্রস্তুত বিন্যাসটি আমাদের জন্য প্রস্তুত রয়েছে ব্যবহার করার জন্য ফরম্যাটার।

(␀␀!S␠su! … many more comment characters … oq␝qoqoq)

এখানে মন্তব্য সম্পূর্ণ আগ্রহ ছাড়াই নয়। একটি জিনিসের জন্য, ব্রেন-ফ্ল্যাক কমান্ডের কয়েকটি রয়েছে; )শেষে স্বাভাবিকভাবেই উপায় প্রোগ্রাম কাজ বিভিন্ন অংশ মধ্যে রূপান্তরের জন্য, তাই একটি পার্শ্ব প্রতিক্রিয়া হিসেবে উৎপন্ন হয় (শুরুতে নিজে সামঞ্জস্য বজায় রাখা (এবং মন্তব্য ভিতরে দৈর্ঘ্য সত্ত্বেও যোগ করা হয়েছিল, একটি মন্তব্য ভিতরে নির্বাণ একটি ()কমান্ড এখনও একটি ()কমান্ড, সুতরাং এটি যা করে তা হ'ল ডেটা স্ট্রিং এবং এর ফর্ম্যাটারের রিটার্ন মানটিতে 1 যুক্ত করা যা লুপের জন্য পুরোপুরি উপেক্ষা করে)।

আরও উল্লেখযোগ্যভাবে, মন্তব্যটির শুরুতে এই NUL অক্ষরগুলি স্পষ্টতই কোনও কিছু থেকে অফসেট নয় (এমনকি +8 এবং -4 এর মধ্যে পার্থক্য (একটি NUL তে পরিণত করার পক্ষে যথেষ্ট নয় )। এগুলি 241 উপাদানগুলিতে 239-উপাদান ডেটা স্ট্রিং আনার জন্য খাঁটি প্যাডিং (যা সহজেই নিজের জন্য অর্থ প্রদান করে: প্রয়োজনীয় পুনরাবৃত্তির সংখ্যার গণনা করার সময় 1 বনাম 241 এর চেয়ে 1 বনাম 239 জেনারেট করতে দুটি বাইটের বেশি লাগবে) )। NUL প্যাডিং চরিত্র হিসাবে ব্যবহৃত হয়েছিল কারণ এতে সর্বনিম্ন সম্ভাব্য কোডপয়েন্ট রয়েছে (ডাটা স্ট্রিংয়ের উত্স কোডটি সংক্ষিপ্ত করে আউটপুটকে আরও দ্রুত করা হয়)।

{}({}())

শীর্ষ স্ট্যাক উপাদানটি (আমরা যে ফর্ম্যাটটি ব্যবহার করছি) ফেলে দিন, পরবর্তীটিতে 1 যুক্ত করুন (আউটপুট হওয়ার জন্য শেষ অক্ষর, অর্থাত্ প্রথম সীমাবদ্ধ হওয়া মুদ্রণযোগ্য, আমরা কেবলমাত্র যে অংশটি ফর্ম্যাট করেছি তার অংশ)। আমাদের আর পুরানো ফর্ম্যাট দরকার নেই (নতুন ফর্ম্যাটটি ওয়ার্কিং স্ট্যাকের উপরে লুকিয়ে রয়েছে); এবং বর্ধিতকরণ বেশিরভাগ ক্ষেত্রেই ক্ষতিকারক নয় এবং 'ডেটা স্ট্রিং (বিন্যাসের উত্স উপস্থাপনার এক প্রান্তে একটিতে পরিবর্তিত হয় (যা পরবর্তী সময়ে আমরা ফরম্যাটারটি চালানোর জন্য স্ট্যাকের উপরে প্রয়োজনীয়, ডেটা স্ট্রিংটি নিজেই বিন্যাস করতে)। আউটরো বা ভূমিকা হিসাবে আমাদের মতো রূপান্তর প্রয়োজন, কারণ প্রতিটি ডেটা স্ট্রিং ফর্ম্যাটর উপাদানকে শুরু (করতে বাধ্য করা এটি আরও জটিল করে তুলবে (যেহেতু আমাদের এটি বন্ধ করে দেওয়া উচিত (এবং পরে এর প্রভাবটি পূর্বাবস্থায় ফেরাতে হবে), এবংআমাদের কোনওভাবে কোনও অতিরিক্ত উপার্জনের প্রয়োজন হবে (কারণ আমাদের কাছে কেবল 241 ফর্ম্যাটরটির প্রায় 241 কপি রয়েছে, সমস্ত 241 নয় (সুতরাং এটি নির্দোষ যে চরিত্রটি 'অনুপস্থিত তা হ'ল এটি সর্বোত্তম)।

(({})(()()()()){})

অবশেষে লুপের প্রস্থান পরীক্ষা। মূল স্ট্যাকের বর্তমান শীর্ষটি হল পরবর্তী পুনরাবৃত্তির জন্য আমাদের প্রয়োজনীয় ফর্ম্যাট (যা কেবলমাত্র কার্যক্ষম স্ট্যাকটি ফিরে এসেছিল)। এটি এটি অনুলিপি করে এবং অনুলিপিটিতে 8 যোগ করে; ফলাফলটি পরবর্তী সময় লুপের চারপাশে ফেলে দেওয়া হবে। তবে, আমরা যদি কেবল প্রবর্তনাটি প্রিন্ট করি, অফসেটটি -4 ছিল তাই "পরবর্তী পুনরাবৃত্তি" এর অফসেটটি -8 হবে; -8 + 8 0, সুতরাং লুপটি পরে পুনরাবৃত্তির দিকে চালিয়ে যাওয়ার চেয়ে প্রস্থান করবে।

— ais523 এর অস্থায়ী অ্যাকাউন্ট
সূত্র
16

128,673,515 চক্র

এটি অনলাইনে চেষ্টা করুন

ব্যাখ্যা

মিনিফ্লাক কুইনগুলি ধীর হয়ে যাওয়ার কারণ হ'ল মিনিফ্লাকের এলোমেলো অ্যাক্সেসের অভাব। এটি পেতে আমি কোডের একটি ব্লক তৈরি করি যা একটি সংখ্যায় লাগে এবং একটি ডেটাম ফেরত দেয়। প্রতিটি ডাটাম পূর্বের মতো একক অক্ষরকে উপস্থাপন করে এবং মূল কোডটি একবারে প্রত্যেকের জন্য কেবল এই ব্লকটি অনুসন্ধান করে। এটি মূলত এলোমেলো অ্যাক্সেস মেমরির একটি ব্লক হিসাবে কাজ করে।

কোডের এই ব্লকের দুটি প্রয়োজনীয়তা রয়েছে।

  • এটি অবশ্যই একটি সংখ্যা নেবে এবং সেই অক্ষরের জন্য কেবলমাত্র অক্ষর কোডটি আউটপুট করতে হবে

  • মস্তিষ্ক-ফ্লাকের মধ্যে টুকরো টুকরো টুকরো টুকরো পুনরুত্পাদন করা অবশ্যই সহজ

এই ব্লকটি তৈরির জন্য আমি আমার প্রমাণ থেকে একটি পদ্ধতি পুনরায় ব্যবহার করেছি যে মিনিফ্লাক টুরিং সম্পূর্ণ। প্রতিটি ডাটামের জন্য এখানে কোডের একটি ব্লক রয়েছে যা দেখতে এটির মতো দেখায়:

(({}[()])[(())]()){(([({}{})]{}))}{}{(([({}{}(%s))]{}))}{}

এটি স্ট্যাকের শীর্ষে থাকা নম্বর থেকে একটিকে বিয়োগ করে এবং যদি শূন্য %sএটির নীচে ডেটামকে ধাক্কা দেয় । যেহেতু প্রতিটি টুকরো আকার একের সাথে হ্রাস করে যদি আপনি স্ট্যাকের সাথে এন দিয়ে শুরু করেন তবে আপনি নবম ডেটুম ফিরে পাবেন।

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

এর পরে আমাদের এমন মেশিন সেট আপ করতে হবে যা এই মেমোরিটিকে উত্সতে অনুবাদ করে। এটিতে 3 টি অংশ রয়েছে:

(([()]())())
{({}[(
  -Look up table-
 )]{})
 1. (({}[()])[(())]()){(([({}{})]{}))}{}{([({}{}(([{}]))(()()()()()))]{})}{}

 2. (({}[()])[(())]()){(([({}{})]{}))}{}{([({}{}
      (({}[(
      ({}[()(((((()()()()()){}){}){}))]{}){({}[()(({}()))]{}){({}[()(({}((((()()()){}){}){}()){}))]{}){({}[()(({}()()))]{}){({}[()(({}(((()()()()())){}{}){}))]{}){([(({}{}()))]{})}}}}}{}
      (({}({}))[({}[{}])])
     )]{}({})[()]))
      ({[()]([({}({}[({})]))]{})}{}()()()()()[(({}({})))]{})
    )]{})}{}

 3. (({}[()])[(())]()){(([({}{})]{}))}{}{([({}{}
     (({}(({}({}))[({}[{}])][(
     ({}[()(
      ([()](((()()[(((((((()()()){})())){}{}){}){})]((((()()()()())){}{}){})([{}]([()()](({})(([{}](()()([()()](((((({}){}){}())){}){}{}))))))))))))
     )]{})
     {({}[()(((({})())[()]))]{})}{}
     (([(((((()()()()){}){}()))){}{}([({})]((({})){}{}))]()()([()()]({}(({})([()]([({}())](({})([({}[()])]()(({})(([()](([({}()())]()({}([()](([((((((()()()())()){}){}){}()){})]({}()(([(((((({})){}){}())){}{})]({}([((((({}())){}){}){}()){}()](([()()])(()()({}(((((({}())())){}{}){}){}([((((({}))){}()){}){}]([((({}[()])){}{}){}]([()()](((((({}())){}{}){}){})(([{}](()()([()()](()()(((((()()()()()){}){}){}()){}()(([((((((()()()())){}){}())){}{})]({}([((((({})()){}){}){}()){}()](([()()])(()()({}(((((({}){}){}())){}){}{}(({})))))))))))))))))))))))))))))))))))))))))))))))
     )]{})[()]))({()()()([({})]{})}{}())
    )]{})}{}

   ({}[()])
}{}{}{}
(([(((((()()()()){}){}())){}{})]((({}))([()]([({}())]({}()([()]((()([()]((()([({})((((()()()()){}){}()){})]()())([({})]({}([()()]({}({}((((()()()()()){}){}){}))))))))))))))))))

মেশিনটিতে চারটি অংশ রয়েছে যা প্রথমে 1 দিয়ে শুরু হয় এবং 3 দিয়ে শেষ হয় আমি উপরের কোডটিতে সেগুলি লেবেল করেছি। প্রতিটি বিভাগ এনকোডিংয়ের জন্য আমি একই ধরণের লুক টেবিল বিন্যাস ব্যবহার করি। এটি হ'ল পুরো প্রোগ্রামটি একটি লুপের মধ্যে রয়েছে এবং আমরা প্রতিবার লুপটি চালানোর সময় প্রতিটি বিভাগ চালাতে চাই না তাই আমরা একই আরএ কাঠামোতে রেখেছি এবং প্রতিটি বারের অংশটি যা ইচ্ছা আমরা অনুসন্ধান করি।

1

বিভাগ 1 একটি সহজ সেট আপ বিভাগ।

প্রোগ্রামটি প্রথম কোয়েরি বিভাগ 1 এবং ডাটাম 0 কে বলেছে ডেটাম 0 এর অস্তিত্ব নেই সুতরাং সেই মানটি ফেরত দেওয়ার পরিবর্তে প্রতিটি ডেটুমের জন্য একবারে অনুসন্ধানটি হ্রাস করে। এটি দরকারী কারণ ডেটা সংখ্যা নির্ধারণের জন্য আমরা ফলাফলটি ব্যবহার করতে পারি, যা ভবিষ্যতে বিভাগগুলিতে গুরুত্বপূর্ণ হয়ে উঠবে। বিভাগ 1 ফলাফলটি নেতিবাচক করে ডেটা সংখ্যা রেকর্ড করে এবং বিভাগ 2 এবং শেষ ডাটামকে জিজ্ঞাসা করে। একমাত্র সমস্যা হ'ল আমরা বিভাগ 2 সরাসরি জিজ্ঞাসা করতে পারি না। যেহেতু আর একটি হ্রাস বাকী রয়েছে তাই আমাদের অ-অস্তিত্বহীন বিভাগটি জিজ্ঞাসা করা দরকার In বাস্তবে আমরা যখনই অন্য বিভাগের মধ্যে একটি বিভাগ অনুসন্ধান করব তখনই এটি ঘটবে। আমি আমার ব্যাখ্যাটিতে এটিকে অগ্রাহ্য করব তবে আপনি যদি কোডটি সন্ধান করছেন তবে মনে রাখবেন 5 টি মানে একটি বিভাগ ফিরে যান এবং 4 মানে আবার একই বিভাগটি চালান।

2

বিভাগ 2 ডেটাগুলি অক্ষরগুলিতে ডিকোড করে যা ডেটা ব্লকের পরে কোড তৈরি করে। প্রতিবার এটি স্ট্যাকটি যেমন প্রদর্শিত হবে আশা করে:

Previous query
Result of query
Number of data
Junk we shouldn't touch...

এটি প্রতিটি সম্ভাব্য ফলাফলকে (1 থেকে 6 পর্যন্ত একটি সংখ্যা) ছয়টি বৈধ মিনিফ্লাক অক্ষরের একটিতে মানচিত্র দেয় (){}[]এবং "জাঙ্ক যা আমরা স্পর্শ করি না" এর সাথে ডেটা সংখ্যার নীচে রাখে। এটি আমাদের মতো স্ট্যাক পায়:

Previous query
Number of data
Junk we shouldn't touch...

এখান থেকে আমাদের পরবর্তী ডেটুমটি জিজ্ঞাসা করা দরকার বা যদি আমরা তাদের সবগুলি বিভাগে নিয়ে যেতে জিজ্ঞাসা করে থাকি তবে পূর্ববর্তী ক্যোয়ারীটি আসলে সঠিক কোয়েরি প্রেরণ করা হয়নি বরং ব্লকের ডেটা সংখ্যার চেয়ে কোয়েরি বিয়োগ করে। এটি কারণ প্রতিটি ড্যাটাম একের সাথে ক্যোয়ারী হ্রাস করে তাই কোয়েরিটি বেশ ম্যাংলেড হয়ে আসে। পরবর্তী ক্যোয়ারী তৈরি করতে আমরা তথ্য সংখ্যার একটি অনুলিপি যুক্ত করি এবং একটিকে বিয়োগ করি। এখন আমাদের স্ট্যাকটি দেখতে দেখতে:

Next query
Number of data
Junk we shouldn't touch...

আমাদের পরবর্তী কোয়েরিটি যদি শূন্য হয় তবে আমরা বিভাগ 3 তে প্রয়োজনীয় সমস্ত মেমরি পড়েছি তাই আমরা আবারো ক্যোয়ারীতে ডেটা সংখ্যা যুক্ত করব এবং বিভাগ 3 এ সরিয়ে স্ট্যাকের শীর্ষে একটি 4 টি চড় মারলাম যদি পরবর্তী কোয়েরিটি শূন্য না হয় আমরা আবার বিভাগ 2 চালানোর জন্য স্ট্যাকের উপর একটি 5 রাখুন।

3

বিভাগ 3 আমাদের র‌্যামের সন্ধান করে ঠিক তেমনি বিভাগ 3 এর মাধ্যমে ডেটা ব্লক করে।

বংশবৃদ্ধির স্বার্থে আমি ধারা 3 কীভাবে কাজ করে তার বেশিরভাগ বিবরণ বাদ দেব। এটি প্রতিটি ডিটামকে একটি অক্ষরে অনুবাদ না করে এটি বিভাগ 2 এর প্রায় সমান, এটি প্রতিটিটিকে র‌্যামে প্রবেশের প্রতিনিধিত্ব করে একটি দীর্ঘ কোডের মধ্যে অনুবাদ করে। বিভাগ 3 করা হয়ে গেলে এটি প্রোগ্রামটিকে লুপ থেকে বেরিয়ে আসতে বলে।

লুপটি চালু হওয়ার পরে কেবল কুইনের প্রথম বিটটি ধাক্কা দেওয়া দরকার ([()]())(()()()()){({}[(। আমি নীচের কোডটি স্ট্যান্ডার্ড কোলমোগোরভ-জটিলতা কৌশলগুলি প্রয়োগ করে এটি করি।

(([(((((()()()()){}){}())){}{})]((({}))([()]([({}())]({}()([()]((()([()]((()([({})((((()()()()){}){}()){})]()())([({})]({}([()()]({}({}((((()()()()()){}){}){}))))))))))))))))))

আমি আশা করি এটি পরিষ্কার ছিল। আপনি কিছু সম্পর্কে বিভ্রান্ত হলে মন্তব্য করুন।

— গম উইজার্ড
সূত্র
এটি চালাতে কতক্ষণ সময় নেয়? এটি বার বার টিআইও-তে আসে।
— পাভেল
@ পাভেল আমি এটি টিআইওতে চালাচ্ছি না কারণ এটি অবিশ্বাস্যরূপে ধীর হয়ে যাবে, আমি টিআইও যে একই ইন্টারপ্রিটার ব্যবহার করে ( রুবি ) ব্যবহার করি। আমার অ্যাক্সেস রয়েছে এমন একটি পুরানো র্যাক সার্ভারটি চালাতে প্রায় 20 মিনিট সময় লাগে। এটি ক্রেইন-ফ্ল্যাটে প্রায় 15 মিনিট সময় নেয়, তবে ক্রেন-ফ্ল্যাকের ডিবাগ পতাকা নেই তাই রুবি ইন্টারপ্রেটারে না চালিয়ে আমি এটি স্কোর করতে পারি না।
— গম উইজার্ড
@ পাভেল আমি এটিকে আবার চালিয়েছি এবং সময়টি ঠিক করেছি। এটি 30m45.284sরুবি ইন্টারপ্রিটার ব্যবহার করে বরং নিম্ন প্রান্তের সার্ভারে (প্রায় একটি আধুনিক আধুনিক ডেস্কটপের সমতুল্য) সমাপ্ত হতে পারে।
— গম উইজার্ড
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.