बुद्धिशीलता: एक अलग कोण से कार्यों को कैसे देखें

ट्रांसप्लांटेशन के साथ विचार मंथन

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


मैं जिन कोशिकाओं के साथ काम कर रहा हूं, वे स्तंभों और पंक्तियों में व्यवस्थित हैं। आइए एक सरल खेल से एक उदाहरण लेते हैं:


लाइनें चरित्र वर्ग हैं: योद्धा, दाना, चोर।

कॉलम क्रिया के प्रकार हैं: हमला, रक्षा, विशेष कार्रवाई।

मैट्रिक्स में प्रत्येक प्रकार के चरित्र के लिए प्रत्येक प्रकार के कार्यों को संसाधित करने के लिए सभी कोड होते हैं।

कोड कैसा दिखता है? आमतौर पर, इस तरह के ढांचे को ऐसे मॉड्यूल में व्यवस्थित किया जाता है:

1. Fighter तलवार के हमलों से निपटने के लिए एक कोड होगा, कवच के साथ क्षति को कम करने और एक विशेष शक्तिशाली झटका होगा।
2. Mage में फायरबॉल हैंडलिंग कोड, क्षति प्रतिबिंब और एक विशेष फ्रीज हमला होगा।
3. Thief डैगर हमलों को संभालने के लिए कोड होगा, चकमा नुकसान से बचने के लिए, और एक विशेष निरस्त्रीकरण हमला होगा।

मैट्रिक्स को स्थानांतरित करने के लिए यह कभी-कभी उपयोगी होता है। हम इसे दूसरे अक्ष पर व्यवस्थित कर सकते हैं :

1. Attack झूलों, आग के गोले और खंजर के हमलों से निपटने के लिए एक कोड होगा।
2. Defend नुकसान को कम करने, नुकसान को दर्शाने और नुकसान से बचने के लिए एक कोड होगा।
3. Special में एक शक्तिशाली स्ट्राइक, फ्रीज़ और डिसर्मर हैंडलिंग कोड होगा।

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

आइए एक और उदाहरण देखें।

प्रोग्रामिंग भाषाओं की व्याख्याओं में आदिम के अनुरूप विभिन्न प्रकार के नोड होते हैं: स्थिरांक, ऑपरेटर, लूप, ब्रांचिंग, फ़ंक्शंस, प्रकार, आदि। हमें उन सभी के लिए कोड तैयार करने की आवश्यकता है।


बहुत बढ़िया! आप प्रत्येक प्रकार के नोड के लिए एक वर्ग बना सकते हैं, और वे सभी आधार वर्ग Node से विरासत में प्राप्त कर सकते हैं। लेकिन हम इस धारणा पर भरोसा करते हैं कि हम पंक्तियों और कम अक्सर कॉलम जोड़ देंगे। ऑप्टिमाइज़िंग कंपाइलर में क्या होता है? हम नए अनुकूलन पास जोड़ रहे हैं। और उनमें से प्रत्येक एक नया कॉलम है।


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

यदि आप ट्रांसपोज़्ड मैट्रिक्स को देखते हैं, तो हम एक और दृष्टिकोण खोलेंगे:


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

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

और यह न केवल कोड पर लागू होता है। इस विचार को उत्पादों पर लागू करने का एक उदाहरण है। मान लीजिए कि अलग-अलग रुचियों वाले लोग हैं:


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

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

विघटन मंथन

मैं अपघटन नामक एक अन्य तकनीक का उपयोग करता हूं।

बीजगणित में, अपघटन ऑपरेशन 5xbra + 8x - 21 का एक बहुपद बदलता है (x + 3) · (5x - 7)। समीकरण को हल करने के लिए 5x the + 8x - 21 = 0, हम इसे पहले (x + 3) में कारक कर सकते हैं · (5x - 7) = 0. तब हम कह सकते हैं कि x + 3 = 0 या 5x - 7 = 0. विस्तार मुश्किल काम को कुछ आसान कामों में बदल देता है।


आइए एक उदाहरण देखें: मेरे पास छह वर्ग हैं: File , EncryptedFile , GzipFile , EncryptedGzipFile , BzipFile , EncryptedBzipFile । मैं उन्हें एक मैट्रिक्स में विघटित कर सकता हूं:


"डेकोरेटर" पैटर्न (या अशुद्धियों) का उपयोग करते हुए, मैंने छह अलग-अलग प्रकार की फ़ाइलों को चार घटकों में बदल दिया: सादा, गज़िप, बीज़िप, एन्क्रिप्ट। यह ज्यादा बचत नहीं करता है, लेकिन अगर मैं अधिक बदलाव करता हूं, तो बचत बढ़ जाएगी। अपघटन O (M * N) घटकों को O (M + N) घटकों में बदल देता है।

एक और उदाहरण: कभी-कभी लोग मुझसे सवाल पूछते हैं कि "सी # में रैखिक प्रक्षेप कैसे लिखें?" । मैं कई संभावित ट्यूटोरियल लिख सकता हूं:


यदि एम विषय और एन भाषाएं हैं, तो मैं एम * एन ट्यूटोरियल लिख सकता हूं। हालांकि, यह बहुत काम है। इसके बजाय, मैं प्रक्षेप पर एक ट्यूटोरियल लिखूंगा, कोई और C # के बारे में एक ट्यूटोरियल लिखेगा, और फिर पाठक C # के ज्ञान को प्रक्षेप के ज्ञान के साथ जोड़ देगा, और C # में उनके प्रक्षेप का संस्करण लिख देगा।

ट्रांसपोज़िशन की तरह, अपघटन हमेशा मदद नहीं करता है, लेकिन यदि लागू हो, तो यह काफी उपयोगी हो सकता है।

पिछड़ों का मंथन

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


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

यही प्रेरणा थी जिसने मुझे बीजगणित का अध्ययन कराया। यदि हमारे पास 5x² + 8x - 21 = 0 फॉर्म का समीकरण है, तो x क्या होगा? जब मुझे बीजगणित का पता नहीं था, तो मैं इस समीकरण को हल करूंगा, x के विभिन्न मूल्यों को स्थान देने की कोशिश करूंगा, पहले उन्हें यादृच्छिक रूप से चुनूंगा, और तब उन्हें समायोजित करूंगा जब मुझे लगेगा कि मैं समाधान के करीब पहुंच गया हूं। बीजगणित हमें एक अलग दिशा में जाने के लिए एक उपकरण देता है। जवाबों का अनुमान लगाने के बजाय, वह मुझे एक उपकरण (अपघटन, या द्विघात समीकरण, या जड़ों के लिए पुनरावृत्ति खोज का न्यूटनियन तरीका) देती है, जिसे मैं एक्स वैल्यू (-3 या 7/5) की खोज के लिए अधिक सचेत रूप से उपयोग कर सकता हूं।

मुझे ऐसा लगता है कि मैं अक्सर इस तरह की प्रोग्रामिंग स्थिति में आ जाता हूं। प्रक्रियात्मक मानचित्रों की पीढ़ी पर काम करते समय, कुछ समय के लिए मापदंडों के साथ प्रयोग करने के बाद, मैंने एक परियोजना के खेल की दुनिया में क्या होना चाहिए, इसकी सूची तैयार की और संकलित किया:

1. खिलाड़ियों को तट से दूर खेल शुरू करना चाहिए।
2. समतल करते समय, खिलाड़ियों को चढ़ाई पर चढ़ना चाहिए।
3. खिलाड़ियों को नक्शे के किनारे तक पहुंचने में सक्षम नहीं होना चाहिए।
4. जैसे-जैसे स्तर बढ़ता है, खिलाड़ियों को समूहों में शामिल होना चाहिए।
5. बहुत अधिक भिन्नता के बिना तटों पर सरल राक्षस होना चाहिए।
6. मैदानों पर मध्यम कठिनाई के राक्षसों की एक विस्तृत विविधता होनी चाहिए।
7. पहाड़ी क्षेत्रों में जटिल बॉस राक्षस होने चाहिए।
8. कुछ प्रकार के लैंडमार्क होने चाहिए जो खिलाड़ियों को कठिनाई के समान स्तर पर बने रहने दें, और एक अन्य लैंडमार्क जो आपको कठिनाई के स्तर में वृद्धि या गिरावट की अनुमति देता है।

इस सूची के संकलन से निम्नलिखित प्रतिबंधों का निर्माण हुआ:

1. खेल की दुनिया में कई तटों और केंद्र में एक छोटी चोटी के साथ द्वीप होना चाहिए।
2. फिटकरी को राक्षसों की जटिलता के अनुरूप होना चाहिए।
3. कम और उच्च ऊंचाई पर, मध्यम ऊंचाई पर बायोम की कम परिवर्तनशीलता होनी चाहिए।
4. सड़कों को कठिनाई के समान स्तर पर रहना चाहिए।
5. नदियों को बड़ी से छोटी ऊँचाई तक प्रवाहित करना चाहिए, और खिलाड़ियों को ऊपर / नीचे जाने की क्षमता प्रदान करनी चाहिए।

इन सीमाओं ने मुझे एक मानचित्र जनरेटर डिजाइन करने के लिए प्रेरित किया। और वह उन कार्डों के बेहतर सेट की पीढ़ी का नेतृत्व करता था जो मुझे मापदंडों को समायोजित करके प्राप्त हुए थे, जैसा कि मैं आमतौर पर करता हूं। और परिणामस्वरूप लेख ने वोरोनोई आरेखों के आधार पर मानचित्र बनाने में कई लोगों की दिलचस्पी दिखाई।

यूनिट परीक्षण एक और उदाहरण है। यह सुझाव दिया जाता है कि मुझे परीक्षण करने के लिए उदाहरणों की सूची के साथ आना चाहिए। उदाहरण के लिए, हेक्सागोन्स के ग्रिड के लिए, मैं सोच सकता हूं कि मुझे हालत add(Hex(1, 2), Hex(3, 4)) == Hex(4, 6) । फिर मुझे याद है कि आपको शून्य की जांच करने की आवश्यकता है: add(Hex(0, 1), Hex(7, 9)) == Hex(7, 10) । तब मुझे याद आ सकता है कि आपको नकारात्मक मूल्यों की जांच करने की आवश्यकता है: add(Hex(-3, 4) + Hex(7, -8)) == Hex(4, -4) । ठीक है, महान, मेरे पास कुछ यूनिट परीक्षण हैं।

लेकिन अगर आप थोड़ा आगे सोचते हैं, तो मैं वास्तव में add(Hex(A, B), Hex(C, D)) == Hex(A+C, B+D) जांच करता हूं। मैं इस सामान्य नियम के आधार पर ऊपर दिखाए गए तीन उदाहरणों के साथ आया हूं। मैं इकाई परीक्षणों में आने के लिए इस नियम से विपरीत दिशा में जा रहा हूं। अगर मैं सीधे इस नियम को एक परीक्षण प्रणाली में शामिल कर सकता हूं, तो सिस्टम स्वयं परीक्षण के लिए उदाहरण बनाने के लिए रिवर्स ऑर्डर में काम कर सकेगा। इसे संपत्ति-आधारित परीक्षण कहा जाता है। (यह भी देखें: कायापलट परीक्षण )

एक अन्य उदाहरण: बाधाओं का हल। ऐसी प्रणालियों में, उपयोगकर्ता वर्णन करता है कि वह आउटपुट में क्या देखना चाहता है, और सिस्टम इन बाधाओं को संतुष्ट करने का एक तरीका ढूंढता है। प्रक्रियात्मक सामग्री पीढ़ी पुस्तक से उद्धरण, अध्याय 8 :

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

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

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

WFC वापस जाने के बिना एक लालची खोज विधि को लागू करता है। यह लेख WFC को बाधा-आधारित निर्णय विधियों के उदाहरण के रूप में बताता है।

मैंने पहले ही बाधा सॉल्वरों की मदद से बहुत कुछ हासिल किया है। बीजगणित के साथ के रूप में, इससे पहले कि मैं उन्हें प्रभावी ढंग से उपयोग करने का तरीका सीखूं, मुझे बहुत कुछ सीखने की जरूरत है।

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


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


सिस्टम ने काम किया, लेकिन सही नहीं। बाद में मुझे एहसास हुआ कि यह एक और उदाहरण है जहां विपरीत दिशा में समाधान मदद कर सकता है। यह पता चला कि अंतरिक्ष यान की गति को प्रतिबंधों की एक रैखिक प्रणाली द्वारा वर्णित किया जा सकता है। अगर मुझे यह समझ में आया, तो मैं एक तैयार पुस्तकालय का उपयोग कर सकता हूं जो बाधाओं को ठीक करता है, न कि मेरी परीक्षण और त्रुटि विधि, जो एक सन्निकटन लौटाता है।

और एक अन्य उदाहरण: G9.js परियोजना, जिसमें आप स्क्रीन पर एक निश्चित फ़ंक्शन के आउटपुट को खींच सकते हैं, और यह निर्धारित करता है कि वांछित आउटपुट डेटा से मिलान करने के लिए इनपुट डेटा को कैसे बदला जाए। G9.js डेमो बहुत अच्छे लगते हैं! रिंग्स डेमो में "निम्न पंक्ति को अनलिंक करें" लाइन को अनलिंक करना सुनिश्चित करें।

किसी कार्य को उल्टे क्रम में सोचना कभी-कभी उपयोगी होता है। यह अक्सर पता चलता है कि यह मुझे सीधे तर्क के साथ बेहतर समाधान देता है।