🏻 🚷 📐 स्रोत कोड में स्टार वार्स 🧔🏾 🐏 ❔

मेरे पास लंबे समय से एक विचार है जो क्वेंस से संबंधित कुछ दिलचस्प को लागू करने का है। और आखिरकार इस मामले को सामने लाया गया। एक बार मैंने सोर्स कोड में लाइफ गेम के कार्यान्वयन को देखा: सेल्फ प्रिंटिंग गेम ऑफ लाइफ और मैं कुछ ऐसा ही करना चाहता था। कुछ प्रतिबिंब के बाद, मुझे याद आया कि एक ASCII ग्राफिक है । लेकिन ASCII ग्राफिक्स में एनीमेशन बनाना और भी अधिक रोचक और कठिन होगा। हमें लंबे समय तक एक उदाहरण के लिए नहीं देखना पड़ा , लगभग तुरंत स्टार वार्स का एक एनीमेशन मिल गया, या नई आशा के 4 एपिसोड को असिमिशन कहा जाता है। जापानी प्रोग्रामर युसुके एंडोह "क्ले रिले" के काम ने भी मुझे इस विचार को लागू करने के लिए प्रेरित किया। इस तरह की "फिल्म" को लागू करने की प्रक्रिया में, मुझे कई अन्य समस्याओं का समाधान करना पड़ा, जो कि अफसोस नहीं करना था।

परिणामी स्रोत है: जिस्ट । "देखने" की सुविधा के लिए एक स्क्रिप्ट भी शामिल है जो पूरे एनीमेशन को घुमाएगी। अपनी पीढ़ी, इंटरफ़ेस और अन्य उपयोगिताओं के लिए पूरे प्रोजेक्ट के स्रोत कोड गिथब पर रखे गए हैं: फ्रीकी-सोर्स (क्विन पलिंड्रोम्स जिनके बारे में मैंने पहले ही लिखा था, वे वहां शामिल हैं)। यह स्पष्ट है कि ऐसी चीज का कोई व्यावहारिक लाभ नहीं है, यह सिर्फ मनोरंजन के लिए है।

परिचय

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

पूर्वोक्त "गेम ऑफ लाइफ" एक फील्ड स्ट्रिंग्स के रूप में उपयोग किया जाता है जो प्रोग्राम के स्रोत कोड की शुरुआत में प्रारंभ और प्रदर्शित होते हैं। यह दृष्टिकोण स्वीकार्य है यदि कोड की मात्रा छोटी है, और संकलन के दौरान यह हमेशा दिखाई देगा। हालांकि, मेरे मामले में, कोड का आकार कई सौ किलोबाइट है, जिसका अर्थ है कि फ़्रेम को अंत में प्रदर्शित किया जाना चाहिए ताकि उन्हें देखा जा सके। यह फ़्रेम का उत्पादन वास्तविक लाइनों के रूप में नहीं करने का निर्णय लिया गया था, लेकिन एकल-लाइन टिप्पणियों (मल्टी-लाइन का भी उपयोग किया जा सकता है) के रूप में, जिसने उन्हें अतिरिक्त पूंछ पात्रों (अंतिम घुंघराले ब्रैकेट) और उद्धरण चिह्नों के बिना प्रदर्शित करने की अनुमति दी।

चूंकि ~~मेरे पास कम आईक्यू है,~~ मेरे पास विशेष क्षमताएं नहीं हैं और मेरे सिर में बड़ी संख्या में मापदंडों के साथ काम नहीं किया जा सकता है, मैंने अधिकतम करने के लिए रानी लिखने की प्रक्रिया को स्वचालित करने का फैसला किया। इसके अलावा, इससे संबंधित क्षेत्रों में क्वीन की संरचना को बेहतर ढंग से समझना और अनुभव प्राप्त करना संभव हो गया (NRefactory का उपयोग करके C # स्रोत कोड को पार्स करना और संसाधित करना)।

नौ पीढ़ी के चरण

इस प्रकार, मैंने किसी भी क्वीन को लिखने की प्रक्रिया को निम्न चरणों में तोड़ने का निर्णय लिया:

कोड पीढ़ी।
डेटा जनरेशन।
कोड मिनिफिकेशन।
कोड स्वरूपण।
काफी पीढ़ी।

ये सभी चरण विशेष रूप से डिज़ाइन किए गए टेम्पलेट के लिए किए गए हैं। स्टार वार्स पर लागू "कोड" के अनुसार, एक ऐसा कोड होता है जो डेटा को संकुचित करता है। और डेटा एनीमेशन फ्रेम का एक पैक सरणी है। ~~कोड~~ के पाठ आकार को कम करने के ~~लिए कोड को अपठनीय बनाने के~~ लिए न्यूनतम आवश्यकता होती है।

सच है, शुरुआत में एक संस्करण संपीड़ित डेटा को अनपैक करने के लिए सामान्य .NET वर्ग GZipStream के साथ लिखा गया था। लेकिन मुझे लगा कि यह खेल नहीं है, इसके अलावा यह केवल इस मंच के लिए मौजूद है। इस प्रकार, मैंने अपने संग्रह के साथ एक अधिक जटिल संस्करण लिखा।

इन चरणों में नेविगेट करना आसान बनाने के लिए, मैंने WinForms पर एक इंटरफ़ेस लिखा।

ऊपर बाईं ओर एक टेक्स्ट बॉक्स है जिसमें सभी मार्करों के साथ एक क्वीन टेम्पलेट दर्ज किया गया है। उनके उद्देश्य पर नीचे चर्चा की गई है। इस क्षेत्र में पहले चार चरण किए जाते हैं।
नीचे के चरणों में उपरोक्त चरणों के प्रदर्शन के लिए विभिन्न पैरामीटर और बटन हैं। साथ ही, संकलन का उपयोग करते हुए त्रुटियों के लिए टेम्प्लेट के कोड या परिणामी क्वीन को तुरंत जांचा जा सकता है।
शीर्ष दाईं ओर, वह क्षेत्र जो अंतिम चरण में उत्पन्न क्वीन कोड से भरा होता है।
फ़ील्ड के शीर्ष दाईं ओर जिसमें संकलन के बाद क्वीन का अगला पुनरावृत्ति आउटपुट है। इसके अलावा, बटन "कंसोल आउटपुट -> आउटपुट" के साथ पुनरावृत्ति की प्रक्रिया को पूरा करने के लिए पुनरावृत्तियों की संख्या की आवश्यकता होती है और फ्रेम-बाय-फ्रेम एनीमेशन (या कुछ और) देखें।

C # सिंटैक्स को हाइलाइट करने के लिए, BigObfuscator FastColoredTextBox घटक का उपयोग किया गया था । दुर्भाग्य से, यह धीरे-धीरे काम करता है, इसलिए परिणामी "मूवी" को एक नियमित कंसोल के माध्यम से देखना अधिक सुविधाजनक है (हालांकि, दुर्भाग्य से, यह या तो इसमें बहुत तेज़ नहीं है)।

काफी अच्छा पैटर्न

टेम्प्लेट ऐसे जटिल क्वीन का प्रारंभिक बिंदु है, और यह इस तरह दिख सकता है:

काफी अच्छा पैटर्न

using System; using System.Text; using System.Collections.Generic; namespace Asciimation_1_3 { class Program { /*#Asciimation_1_3*/ /*Asciimation_1_3#*/ /*#DecodeBase64*/ /*DecodeBase64#*/ /*#HuffmanTree*/ /*HuffmanTree#*/ /*#HuffmanRleDecode2*/ /*HuffmanRleDecode2#*/ /*#Enums*/ /*Enums#*/ /*#Utils*/ /*Utils#*/ static string Data = /*%Data_1_3*/""/*Data_1_3%*/; static int CurrentFrame = /*$CurrentFrame*/0/*CurrentFrame$*/; static void Main() { var output = Decompress_v_1_3(Data, CurrentFrame++); if (CurrentFrame == 3591) CurrentFrame = 3590; /*$@$*/ } } } /*$Output_1_3$*/

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

/*#..*/..//.....#*/ - कोड। इन मार्करों के बीच कोड के टुकड़े निर्दिष्ट निर्देशिका से फ़ाइलों के लिए खोजे जाते हैं।
/*%..*/..//.....%*/ - डेटा। इन मार्करों के बीच, कुछ विधियों का उपयोग करके उत्पन्न डेटा डाला जाता है, जिसे स्ट्रिंग रूप में प्रस्तुत किया जाना चाहिए (अच्छी तरह से, यानी एक साधारण स्ट्रिंग, स्ट्रिंग का एक सरणी, बाइट्स की एक सरणी, पूर्णांक, आदि)। सामान्यतया, आप डेटा मार्करों से एक विधि के बारे में जानकारी निकाल सकते हैं, इसे संकलित विधानसभा में खोज सकते हैं, और प्रतिबिंब का उपयोग करके इसे लागू कर सकते हैं। लेकिन अभी के लिए, मैंने खुद को आवश्यक तरीकों से कॉल करने के लिए खुद को सीमित करने का फैसला किया, क्योंकि यह एक अधिक सार्वभौमिक दृष्टिकोण है (इस तरह से अन्य भाषाओं में पोर्ट करना आसान है)।
/* ++...*/..//.....$*/ - पैरामीटर। ये मार्कर एक कोड को दर्शाते हैं जो क्वीन के प्रदर्शन के प्रत्येक बाद के पुनरावृत्ति के साथ बदलता है। उन्हें एक विशेष तालिका में इंगित किया जाता है जिसमें प्रतिस्थापन के लिए कोड इंगित किया गया है। इस मामले में, पैरामीटर वर्तमान फ्रेम की संख्या है (यह हर बार बढ़ाया जाता है) और नीचे के फ्रेम का आउटपुट फ़ील्ड, एकल-लाइन टिप्पणियों का उपयोग करके कार्यान्वित किया जाता है। कुछ पैरामीटर इंट्रॉन हैं , अर्थात लाइनें जो अगले पुनरावृत्ति में कोड को प्रभावित नहीं करती हैं। इस मामले में, इंट्रॉन आउटपुट फ़ील्ड है।
/ * @ * / - प्रिंट। यह एक विशेष मार्कर है जिसमें कोड पूरी तरह से प्रदर्शित करने के लिए डाला जाता है। यह केवल एक प्रति में मौजूद है। पिछले चरणों में कोड और डेटा उत्पन्न करने के बाद, प्रतिस्थापन बहुत अंत में होता है। यह ध्यान रखना महत्वपूर्ण है कि डेटा अनुभाग के दोहराव को रोकने के लिए (ताकि रानी में और इस पंक्ति में इसे मुद्रित न करें), इस स्तर पर, डेटा को डेटा के साथ नहीं, बल्कि मापदंडों के साथ प्रतिस्थापित किया जाता है (जो कि, "asdf" आउटपुट में निहित है) '' '+ आउटपुट +' '' आउटपुट है)।

इस प्रकार, चरणों और मार्करों के बारे में जानकारी का संयोजन, आप निम्नलिखित ग्राफिक आरेख का निर्माण कर सकते हैं:

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

सभी चरणों के बारे में अधिक जानकारी नीचे वर्णित है।

कोड जनरेशन

कोड उत्पन्न करते समय, निर्दिष्ट फ़ोल्डर से सभी स्रोत कोड फ़ाइलों का विश्लेषण किया जाता है। और मार्करों के बीच कोड /*#...*/../../*...#*/ मूल टेम्पलेट में उपयुक्त स्थानों पर कॉपी किया जाता है। उदाहरण के लिए, निम्नलिखित उदाहरण में, संपूर्ण HuffmanRle2 वर्ग को / * # HuffmanRleD timecode2 * // * HuffmanRleDecode2 # * / के बीच के अनुभाग में कॉपी किया जाता है। इन मार्करों के अंदर कोड के कुछ अंशों को अनदेखा करने के लिए (उदाहरण के लिए, .ToString () विधियों को क्वीन में आवश्यक नहीं है, उन्हें डीबगिंग के लिए आवश्यक है) और इस टुकड़े को दो में विभाजित नहीं किया गया है, मार्कर / * इग्नोर * // * इग्नोर # पेश किए गए थे * / , जो आपको उनके अंदर सभी कोड को अनदेखा करने की अनुमति देता है।

स्रोत कोड में नमूना मार्कर

 /*#HuffmanRleDecode2*/ public class HuffmanRle2 { public static byte[] Decode(HuffmanTree tree, byte[] bytes, ref int curBit, int bytesCount, int bitsCountPerRepLength = 8, int bitsCountPerNotRepLength = 8) { int minLength = Math.Min(bitsCountPerRepLength, bitsCountPerNotRepLength); var maxCount = 1 << (minLength - 1); var root = tree.Root; var result = new List<byte>(bytes.Length * 2); int curBytesCount = 0; int i = 0; while (curBytesCount < bytesCount) { var length = Utils.GetInt(bytes, ref curBit, minLength); if ((length & maxCount) == 0) { curBit -= minLength; length = Utils.GetInt(bytes, ref curBit, bitsCountPerRepLength); var repeatCount = length + 2; byte value = Utils.GetValue(root, bytes, ref curBit); for (int j = 0; j < repeatCount; j++) { result.Add(value); curBytesCount++; } } else { curBit -= minLength; length = Utils.GetInt(bytes, ref curBit, bitsCountPerNotRepLength); var notRepeatCount = (((1 << (bitsCountPerNotRepLength - 1)) - 1) & length) + 1; for (int j = 0; j < notRepeatCount; j++) { byte value = Utils.GetValue(root, bytes, ref curBit); result.Add(value); curBytesCount++; } } i++; } return result.ToArray(); } } /*HuffmanRleDecode2#*/

इस तथ्य के बावजूद कि विभिन्न फाइलों से एकत्र किया गया कोड न्यूनतम लंबाई मानदंड के दृष्टिकोण से इष्टतम नहीं हो सकता है, क्योंकि फिर भी, यह एक मानक शैली में लिखा गया था, इस दृष्टिकोण ने हमें अपनी पीढ़ी के तुरंत पहले, क्वीन डेटा को संपीड़ित करने और निकालने के लिए परीक्षण (एनयूएनआईटी) लिखने और चलाने की अनुमति दी, जो विकास प्रक्रिया को सरल करता है और इसे कम थकाऊ बनाता है। यद्यपि कोड का मिनिमाइज़ेशन, जो बाद में वर्णित है, हमें इस दृष्टिकोण के नुकसान को व्यावहारिक रूप से कम करने की अनुमति देता है।

डेटा जनरेशन

डेटा को संपीड़ित करने के लिए सरलतम दोषरहित संपीड़न एल्गोरिदम, जैसे कि RLE और हफ़मैन कोडिंग का उपयोग किया गया था। हालांकि, यह एनीमेशन, किसी भी फिल्म की तरह, मुख्य और मध्यवर्ती फ्रेम में विभाजित किया जा सकता है। मध्यवर्ती फ़्रेम में ऐसी जानकारी होती है जो अंतिम फ़्रेम के बाद से बदल गई है, और मुख्य फ़्रेम में फ़्रेम के बारे में सभी जानकारी होती है। इस प्रकार, मध्यवर्ती फ्रेम के सभी पात्रों को प्राप्त करने के लिए, पिछले सभी फ़्रेमों को मुख्य एक को डीकोड करना आवश्यक है, और उसके बाद प्राप्त परिवर्तनों को ध्यान में रखते हुए सभी फ़्रेमों को वर्तमान में प्रस्तुत करना। यह एक प्रकार का छद्म-एमपीईजी निकला। मुख्य और मध्यवर्ती फ्रेम की संरचना नीचे प्रस्तुत की गई है। सामान्य और मध्यवर्ती फ़्रेमों के अलावा, मैंने बाएं, दाएं, ऊपर और नीचे स्थानांतरित करके प्राप्त मध्यवर्ती फ़्रेमों को शामिल करने का निर्णय लिया, क्योंकि वे इतने दुर्लभ नहीं हैं।

फ़्रेम:
0..3 - प्रकार:

000 - आधार:
3..13 - वर्ण गणना
13 ... - हफ़मैन री कोड
001 - बायाँ:
010 - शीर्ष:
011 - सही:
100 - नीचे:
101 - परिवर्तित:
3..10 - परिवर्तन गिनती
10 ... - परिवर्तन

परिवर्तित करें:
0..2 - प्रकार:

00 - एक चार:
2..12 - स्थिति
12 ... - हफ़मैन कोड
01 - लाइन क्षैतिज:
2..12 - स्थिति
12.19 - वर्ण गणना
19 ... - हफ़मैन कोड
10 - खड़ी रेखा:
2..12 - स्थिति
12..16 - वर्ण गणना
16 ... - हफ़मैन कोड

दुर्भाग्य से, अंतिम संपीड़न उतना बड़ा नहीं था जितना हम चाहते हैं, लेकिन काफी स्वीकार्य है। मैं 7-ज़िप में lzma स्तर पर, अर्थात् 100 केबी से कम। सबसे अधिक संभावना है, अधिक उन्नत तरीकों (अंतराल कोडिंग, शब्दकोश विधियों) की मदद से, सम्पीडन के एक भी बड़े स्तर को प्राप्त करना संभव होगा।

कोड मिनिफिकेशन

पाठ प्रारूप में कोड के आकार को कम करने के लिए न्यूनतम करने की आवश्यकता होती है। C # कोड को प्रोसेस करने के लिए NRefactory लाइब्रेरी का इस्तेमाल किया गया था। रोजलिन पर इसका लाभ यह है कि पार्स ट्री को प्रक्रिया में बदला जा सकता है, जिसकी आवश्यकता न्यूनतम कार्य में होती है।

शॉर्टिंग क्लास के नाम, तरीके, क्षेत्र, स्थानीय चर

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

एक तरफ और दूसरी ओर, कम से कम पहचानकर्ताओं का उपयोग करने के लिए, ताकि वे ओवरलैप न करें और संकलन त्रुटियों को जन्म न दें, छोटा एल्गोरिथ्म निम्नलिखित चरणों में विभाजित किया गया था:

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

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

यह ध्यान देने योग्य है कि पुस्तकालय उपेक्षित पहचानकर्ताओं का समर्थन करता है, अर्थात्। जिन्हें किसी कारण से छोटा नहीं किया जाना चाहिए, जो इस परियोजना में उपयोग किया जाता है।

उपयोग किए गए पहचानकर्ताओं के सभी लिंक की एक सूची प्राप्त करने के लिए (विज़ुअल स्टूडियो में सभी संदर्भों का पता लगाएं), NRefactory संकल्प तंत्र का उपयोग किया जाता है। ऐसा करने के लिए, आपको पहले पेड़ को संकलित करना होगा (प्रत्येक चरण में: स्थानीय चर, प्रकार सदस्य, प्रकार):

 var unresolvedFile = SyntaxTree.ToTypeSystem(); var projectContent = projectContent.AddOrUpdateFiles(_unresolvedFile); var compilation = projectContent.CreateCompilation(); var resolver = new CSharpAstResolver(_compilation, SyntaxTree, _unresolvedFile);

फिर आप निम्न प्रकार से लिंक खोज सकते हैं:

 var resolveResult = resolver.Resolve(node); var findReferences = new FindReferences(); ... findReferences.FindLocalReferences(); ... findReferences.FindReferencesInFile();

अन्य minifications

निम्नलिखित छोटे मंत्रालय भी लागू किए गए थे:

निजी कीवर्ड निकाल रहा है
नामस्थानों को हटाना
चर आरंभीकरण अभिव्यक्ति की अभिव्यक्ति:
- ```
 List<byte> a = new List<byte>() -> var a = new List<byte>() 
```
- ```
 var a = new b() -> ba = new b() 
```
नोट: यह प्रतिस्थापन लेख में वर्णित टेम्पलेट खोज का उपयोग करके भी किया जा सकता है:
Csharp कोड के विश्लेषण के लिए NRefactory का उपयोग करना
घुंघराले ब्रेसिज़ को हटाना जिसके भीतर एक ही अभिव्यक्ति है: if (a) { b; } => if (a) b; if (a) { b; } => if (a) b;
एक बूलियन प्रकार के साथ तुलना रिकॉर्ड को कम करना: if (a == true) => if (a); if (a == false) => if (!a) if (a == true) => if (a); if (a == false) => if (!a)
क्षेत्रों और टिप्पणियों को हटाना।

व्हाट्सएप और लाइन ब्रेक को हटाने

सभी प्रकार के मिन्नतें किए जाने के बाद, यह कोड से केवल अनावश्यक व्हाट्सएप और अनुवाद को हटाने के लिए रहता है, ताकि लाइनों की लंबाई एक निश्चित मूल्य (सौंदर्य के लिए) से अधिक न हो।

मिनीफ़ायर को एक अलग परियोजना द्वारा कार्यान्वित किया जाता है और यहाँ डाउनलोड किया जा सकता है: CSharp-Minifier । यह मुख्य रूप से क्वाइन में कोड को कम करने के उद्देश्य से विकसित किया गया था, इसलिए इस तथ्य में आश्चर्य की बात नहीं है कि इसकी थोड़ी अजीब कार्यक्षमता है। हालांकि, मुझे आपकी टिप्पणियों और / या पुल-क्वैस्ट को स्वीकार करने में खुशी होगी।

कोड स्वरूपण

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

काफी बड़ी पीढ़ी

निम्नलिखित का उपयोग एक मार्कर के रूप में किया गया था जहां क्वीन की अंतिम पंक्ति को मुद्रित करने के लिए: / * @ * * /
चरणों में, सब कुछ इस प्रकार दिखता है। सभी कोड पूरी तरह से मनमाने ढंग से हो सकते हैं, लेकिन उदाहरण के लिए बेहतर पठनीयता के लिए ब्रेक को जोड़ा जाता है।

टेम्प्लेट आरंभीकरण:
टेम्पलेट =

 class P { static void Main() { var a = 6; /*@*/ int b = 10; } }

एक क्वीन प्रिंट करने के लिए उपयोग किए जाने वाले स्ट्रिंग टेम्पलेट उत्पन्न करें। कोटेशन के निशान, बैकस्लैश और लाइन ब्रेक से बच जाना चाहिए, ताकि एक स्वरूपित स्ट्रिंग प्रदर्शित करते समय उन्हें अलग-अलग मापदंडों द्वारा दर्शाया जाए।
कर्नेल = "var s = {1}{0}{1}; System.Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1});"
पिछले चरण से छपाई के लिए उपयोग की जाने वाली लाइन के साथ मार्कर को प्रतिस्थापित करना। क्योंकि सी # में, मापदंडों को आउटपुट करते समय घुंघराले ब्रैकेट का उपयोग किया जाता है, उन्हें भी बच जाना चाहिए। यह उन्हें डुप्लिकेट करके किया जाता है।
str = template.Replace("{", "{{").Replace("}", "}}").Replace("/*@*/", kernel)
str =
```
 class P {{ static void Main() {{ var a = 6; var s = {1}{0}{1}; System.Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1}); int b = 10; }} }} 
```
क्वीन को प्रिंट करने के लिए उपयोग किए जाने वाले परिणाम स्ट्रिंग का निर्माण
InsertToResult = "var s=\"" + str + "\""
सम्मिलित करें
```
 var s=" class P {{ static void Main() {{ int a=6; var s={1}{0}{1}; Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1}); int b=10; }} }}"; Console.Write(s,s,'"', '\\', "\r\n"); 
```

स्रोत टेम्पलेट में मार्कर को परिणामस्वरूप स्ट्रिंग के साथ बदलना:
परिणाम = template.Replace("/*@*/", insertToResult)
परिणाम =

 using System; class c { static void Main() { int a=6; var s="using System;class c{{static void Main(){{int a=6;var s={1}{0}{1};Console.Write(s,s,'{1}','{2}{2}',{1}{2}r{2}n{1});int b=10;}}}}"; Console.Write(s,s,'"', '\\', "\r\n"); int b=10; } }

संपन्न: एक प्रोग्राम प्राप्त होता है जो स्वयं प्रिंट कर सकता है।
वर्णित दृष्टिकोण को पालिंडम क्वाइल की पीढ़ी के लिए सामान्यीकृत किया जा सकता है, लेकिन मैंने अभी तक इसे लागू नहीं किया है।

लांच

क्वीन उत्पन्न होने के बाद, यह, उदाहरण के लिए, Asciimation.cs फ़ाइल में सहेजा जा सकता है और निम्नलिखित रूपरेखा के साथ एक फ्रेम आउटपुट कर सकता है:

"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" Asciimation.cs && (Asciimation > Asciimation.cs) && Asciimation

और पूरी तरह से उत्पन्न "फिल्म" देखने के लिए, आपको निम्नलिखित स्क्रिप्ट का उपयोग करने की आवश्यकता है:

 echo off SET /ai=0 :LOOP IF %i%==3591 GOTO END "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe" Asciimation.cs && (Asciimation > Asciimation.cs) && Asciimation SET /ai=%i%+1 GOTO LOOP :END pause

निष्कर्ष

लेख में वर्णित सिद्धांत अन्य प्रोग्रामिंग भाषाओं में विभिन्न quines के कार्यान्वयन के लिए लागू होते हैं। दुर्भाग्य से, ऑनलाइन सेवाओं ( ideone.com , compileonline ) का उपयोग करके विकसित कोड का परीक्षण करना असंभव है, क्योंकि यह संपीड़न के बावजूद अभी भी अधिकतम आकार से अधिक है।

जेनरेट की गई फाइलें और बैच फाइलें यहां डाउनलोड की जा सकती हैं: AsciimationQoodle_1_3.7z । भविष्य में, आप चेन क्वेंस करने की कोशिश कर सकते हैं और, शायद, युसुके एंडोह के करतब को न केवल मैन्युअल रूप से, बल्कि स्वचालित पीढ़ी के साथ दोहरा सकते हैं।

खासकर उन लोगों के लिए जो संकलन करने की क्षमता नहीं रखते हैं, लेकिन इस प्रक्रिया को देखना चाहते हैं:

स्रोत कोड में स्टार वार्स