डेटा संरचना में रूबिक क्यूब का प्रतिनिधित्व कैसे करें

Question

यदि मैं एक रूबिक क्यूब का अनुकरण करने का प्रयास कर रहा हूं , तो आप क्यूब की स्थिति को मेमोरी में स्टोर करने के लिए डेटा संरचना कैसे बना सकते हैं, जिसमें प्रति पक्ष X संख्या में टाइलें हैं?

विचार करने के लिए बातें:

• क्यूब किसी भी आकार का हो सकता है
• यह रूबिक का क्यूब है, इसलिए परतों को घुमाया जा सकता है

Comments

घर का पाठ? या वास्तविक दुनिया की समस्या ...

— sdg 12

आपको रूबिक के क्यूब सॉल्वर के स्रोत कोड में रुचि हो सकती है ।

— मौविसील

मुझे पूरा यकीन है कि एक घन की संख्या 6 होनी चाहिए

— साइमन बर्गोट

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

— ली कोवलकोव्स्की

मैं एरिक इवांस उद्धृत करने के लिए, परीक्षा महसूस (उद्धरण शायद नहीं 100% सही रूप में यह स्मृति से उद्धृत किया जाता है) "मॉडल न सही कह रहे हैं, और न ही गलत वे बस और अधिक या कम उपयोगी होते हैं।"

— पीट

Answer 1

आकार के एक सादे पुराने सरणी में क्या गलत है [6X][X]? आपको आंतरिक मिनी-क्यूब्स के बारे में जानने की आवश्यकता नहीं है , क्योंकि आप उन्हें नहीं देखते हैं; वे घन की अवस्था का हिस्सा नहीं हैं। इंटरफ़ेस का उपयोग करने के लिए एक अच्छे दिखने वाले और सरल उपयोग करने के पीछे दो बदसूरत तरीकों को छिपाएं, यूनिट इसे मौत का परीक्षण करती है, और वॉइला, आप कर रहे हैं!

Comments

यहां तक ​​कि एक असली रूबिक के घन में कोई आंतरिक मिनी क्यूब्स नहीं है

— जेके।

यह काम करेगा लेकिन आपका एल्गोरिथ्म इस तरह की सरल डेटा संरचना को व्यवस्थित करने के लिए संभवतः जटिल होगा।

— मेपल_शाफ्ट

As long as you know how the six surfaces are "threaded" together जो वास्तव में एक अधिक मजबूत डेटा संरचना आपको देगा। मुझे लगता है कि हम एक ही चीज के लिए बहस कर रहे हैं। एक सरणी भुजाएं, और एक भुजा खंडों की एक सरणी होती है, हालांकि पक्षों और खंडों के बारे में बहुत सारे दिलचस्प गुण हैं जो यह पता लगाने में मदद करते हैं कि "थ्रेडिंग" वास्तव में उस शब्द को पसंद नहीं करता है क्योंकि यह बहु-थ्रेडिंग के साथ भ्रमित हो सकता है; )

— मेपल_शफ्ट

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

— dasblinkenlight 15

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

— पीटरअलेनवेब

Answer 2

यह ध्यान दिया जाना चाहिए कि मैं एक एवीड स्पीड क्यूबेर हूं, लेकिन मैंने कभी भी एल्गोरिथम या डेटा संरचना में रूबिक के क्यूब को प्रोग्राम करने का प्रयास नहीं किया है।

मैं संभवतः एक क्यूब में प्रत्येक ब्लॉक के अद्वितीय पहलुओं को पकड़ने के लिए अलग-अलग डेटा संरचनाएं बनाऊंगा।

एक घन पर 3 अलग-अलग प्रकार के ब्लॉक होते हैं:

1. कॉर्नर ब्लॉक - इसके तीन रंगीन चेहरे और तीन आसन्न टुकड़े हैं जो किसी भी समय एक पक्ष के साथ साझा करेंगे।

2. एज ब्लॉक - इसके दो रंग चेहरे हैं और इसमें 4 आसन्न टुकड़े हैं जो किसी भी समय एक पक्ष के साथ साझा करेगा। 3x3 ब्लॉकों में हमेशा 2 केंद्र टुकड़े और 2 कोने टुकड़े होते हैं।

3. केंद्र ब्लॉक - एक 3x3 क्यूब में यह टुकड़ा जंगम नहीं है, हालांकि इसे घुमाया जा सकता है। इसमें हमेशा 4 आसन्न किनारे होंगे। बड़े क्यूब्स में कई केंद्र ब्लॉक होते हैं जो दूसरे केंद्र ब्लॉक या एक किनारे के टुकड़े के साथ साझा कर सकते हैं। केंद्र ब्लॉक कभी भी कोने के ब्लॉक से सटे नहीं होते हैं।

यह जानकर, एक ब्लॉक के पास अन्य ब्लॉकों के संदर्भों की एक सूची हो सकती है जो इसे छूती है। मैं सूचियों की एक और सूची रखूंगा, जो एक घन चेहरे का प्रतिनिधित्व करने वाले ब्लॉकों की एक सूची होगी और एक सूची जो हर घन चेहरे का संदर्भ रखती है।

प्रत्येक घन चेहरे को एक अद्वितीय चेहरे के रूप में दर्शाया जाएगा।

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

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

Comments

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

— मेल

@Mel यह संभव है कि इसे किसी भी तरह से किया जाए, लेकिन dasblinkenlight के साथ बात करने के बाद मुझे वास्तव में लगता है कि उसका दृष्टिकोण कम जटिल होगा। काश कि उनके जवाब में मेरे मुकाबले ज्यादा वोट होते। मैं सभी एल्गोरिदम और सबसे कुशल एक के साथ अच्छा नहीं हूं, मैं वास्तव में रूबिक्स क्यूब्स को पसंद करता हूं और उन्हें इकट्ठा करता हूं (दुनिया भर से 40 से अधिक विभिन्न प्रकार)।

— maple_shaft

हालांकि dasblinknenlight के सबसे सरल समाधान का उत्तर , मैं आपको इनाम दे रहा हूं क्योंकि मुझे यह तथ्य पसंद है कि आपके उत्तर में कुछ तर्क शामिल हैं, जो इस तरह के डेटा संरचना के लिए आवश्यक होंगे, और विभिन्न ब्लॉक विशेषताओं

— राहेल

यह डेटा मॉडल वास्तविकता के लिए अधिक सच है, लेकिन यह कुछ सरल संचालन करता है जिन्हें आप जितना कठिन होना चाहिए, उससे अधिक करना चाहते हैं - बस क्यूब की स्थिति प्राप्त करने के लिए क्यूब्स की सूची के माध्यम से पुनरावर्ती यात्रा की आवश्यकता होगी जो बोझिल है।

— Ziv

@ ज़ीव ट्रू, हालांकि सवाल डेटा संरचना के बारे में पूछ रहा था और जरूरी नहीं कि एल्गोरिदम के बारे में।

— maple_shaft

Answer 3

जब मैं इस समस्या के बारे में सोचता हूं, तो मैं एक स्थिर क्यूब के बारे में सोचता हूं, जिसमें ज्ञात पैटर्न में रंग बढ़ते हैं। इसलिए....

क्यूब ऑब्जेक्ट में 6 साइड ऑब्जेक्ट होते हैं जो निश्चित अनुक्रमित 0-5 रहते हैं। प्रत्येक पक्ष में 9 स्थिति ऑब्जेक्ट होते हैं जो निश्चित अनुक्रमित 0-8 रहते हैं। प्रत्येक स्थिति में एक रंग होता है।

सादगी के लिए, क्वार्टर टर्न इंक्रीमेंट में हर एक्शन को हैंडल करें। क्यूब पर कुल 6 संभावित क्रियाओं के लिए 2 संभव दिशाओं में रोटेशन के 3 अक्ष होते हैं। इस जानकारी के साथ, क्यूब पर 6 संभावित क्रियाओं को मैप करना एक काफी सरल कार्य बन जाता है।

तो पक्ष 6 में रंग हरा, स्थिति 3, की गई कार्रवाई के आधार पर, पक्ष 1 स्थिति 3, या पक्ष 2 स्थिति 7 में स्थानांतरित हो सकता है। मैंने किसी भी गणितीय अनुवाद को खोजने के लिए इसे पर्याप्त रूप से नहीं खोजा है, लेकिन पैटर्न संभवतः उभर कर आएगा कि आप कोड का लाभ उठा सकते हैं।

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

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

Comments

क्लासिक "आप यहाँ से शुरू नहीं करना चाहते हैं" सलाह!

— एर्गवुन

Answer 4

मुझे एक रुबीज क्यूब को संबोधित करने का एक सरल तरीका होने के लिए एक xyz समन्वय प्रणाली मिली और रोटेशन को लागू करने का एक सरल, सामान्य तरीका matrices को घुमाता है।

मैंने एक टुकड़ा वर्ग बनाया जिसमें एक स्थिति वेक्टर है (x, y, z)। एक टुकड़ा को घुमाकर मैट्रिक्स को उसकी स्थिति (एक मैट्रिक्स-वेक्टर गुणन) पर लागू करके घुमाया जा सकता है। टुकड़ा (cx, cy, cz)प्रत्येक रंग के साथ सामना करने वाले रंगों को देते हुए, एक रंग में भी इसका रंग रखता है। तर्क की एक छोटी मात्रा सुनिश्चित करती है कि ये रंग एक रोटेशन के दौरान उचित रूप से अपडेट किए जाते हैं: XY विमान में 90 डिग्री का रोटेशन का मतलब है कि हम cxऔर के मूल्यों को स्वैप करेंगे cy।

चूँकि रोटेशन लॉजिक के सभी टुकड़े क्लास में एनकैप्सुलेटेड होते हैं, क्यूब टुकड़ों की एक अनियंत्रित सूची को संग्रहीत कर सकता है, और घुमाव एक सामान्य शैली में किया जा सकता है। बाएं चेहरे की रोटेशन करने के लिए, -1 के x-निर्देशांक के साथ सभी टुकड़ों का चयन करें और प्रत्येक टुकड़े के लिए उपयुक्त रोटेशन मैट्रिक्स लागू करें। पूरे घन का एक रोटेशन करने के लिए, प्रत्येक टुकड़े पर एक ही रोटेशन मैट्रिक्स लागू करें।

यह कार्यान्वयन सरल है और इसमें कुछ जोड़े हैं:

1. एक टुकड़ा वस्तु की स्थिति बदल जाएगी, लेकिन इसके रंग नहीं होते हैं। इसका मतलब है कि आप लाल-हरे रंग के टुकड़े के लिए पूछ सकते हैं, ऑब्जेक्ट पर लटका सकते हैं, कुछ घुमाव कर सकते हैं, और उसी वस्तु की जांच कर सकते हैं कि लाल-हरे रंग का टुकड़ा कहां समाप्त हुआ।
2. प्रत्येक प्रकार के टुकड़े (किनारे, केंद्र, कोने) में एक अद्वितीय समन्वय पैटर्न होता है। 3x3 घन के लिए, एक कोने के टुकड़े में अपनी स्थिति वेक्टर ( (-1, 1, 1)) में कोई शून्य नहीं है , एक किनारे में बिल्कुल एक शून्य ( (1, 0, -1)) है, और एक केंद्र के टुकड़े में दो शून्य ( (-1, 0, 0)) हैं।
3. एक 3x3 क्यूब के लिए काम करने वाले रोटेशन मेट्रिक्स एक NxN क्यूब के लिए काम करेंगे।

downsides:

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

Comments

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

— जोनाथन विल्सन

Answer 5

आप एक साधारण सरणी का उपयोग कर सकते हैं (प्रत्येक तत्व एक चेहरे पर एक वर्ग के लिए 1 से 1 मैपिंग) और एक निश्चित क्रमचय के साथ प्रत्येक घुमाव का अनुकरण कर सकता है

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

यह जानने का सबसे सरल तरीका है कि क्या एक घन हल करने योग्य है (इसे क्रमपरिवर्तन की एक श्रृंखला खोजें जो घन को हल करेगा), यदि आप 2 किनारों के साथ समाप्त हो गए हैं जो जगह बदली है, एक एकल फ़्लिप किए गए किनारे, एक एकल फ़्लिप किया गया कोने या 2 अदला-बदली वाले कोने आपके पास एक अकुशल क्यूब है

Comments

the most straightforward way of know whether a cube is solvable is to solve it। खैर, आपके द्वारा सुझाए गए मॉडल का उपयोग करके मुझे लगता है कि यह सच है। लेकिन अगर आप @ मेपल_शफ्ट और ट्रैक रोटेशन के करीब एक मॉडल का उपयोग करते हैं, तो आप जल्दी से परीक्षण कर सकते हैं कि क्या एक 3x3x3 क्यूब किनारे के मॉड फ़्लिप के सत्यापन से हल कर सकता है मॉड 2 0 है और कॉर्नर रोटेशन मॉड 3 है। 0. चेक द्वारा क्रमचय की समता की जांच करें गिनती बढ़त बढ़त और कोने स्वैप (हल करने के लिए वापस पाने के लिए आवश्यक), उनके योग मॉड 2 0 होना चाहिए (कुल समता भी)। घन को हल करने के लिए ये आवश्यक और पर्याप्त परीक्षण हैं।

— जिम्हार्क

Answer 6

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

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

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

Comments

बिंदु 2 के लिए, एक यादृच्छिक क्यूब के साथ शुरू करने और जाँचने के बजाय कि यह सॉल्व है। मैं एक हल क्यूब के साथ शुरू करूंगा, और क्यू पर यादृच्छिक स्थिति में इसे प्राप्त करने के लिए एन यादृच्छिक क्रियाएं करता हूं।

— मैथ्यू वाइन

हां, बिल्कुल, यह एक कॉन्फ़िगरेशन उत्पन्न करने का सबसे सरल तरीका है जिसे हल करना शारीरिक रूप से संभव है। एक मनमाना कॉन्फ़िगरेशन के साथ शुरू करना और यह निर्धारित करना कि क्या यह हल करने योग्य है, निश्चित रूप से एक अलग लेकिन संबंधित समस्या है।

— एंजेलो

आप अनुमान लगाते हैं कि एक क्यूब एक है जिसे हल किया जा सकता है, यह निर्धारित करने के लिए "फैंसी तकनीक" हो सकती है; वास्तव में हैं। यदि आप किसी क्यूब को असंतुष्ट करते हैं, लेकिन स्टिकर को चालू रखते हैं, और फिर क्यूब को फिर से इकट्ठा करते हैं, तो आपको जरूरी नहीं कि एक घन मिल जाए जो सॉल्व हो; वास्तव में, ऑड्स एक से बारह हैं जिनके खिलाफ आपके पास एक सॉल्व क्यूब है। आप यह निर्धारित कर सकते हैं कि क्या आप किनारों और कोनों के समता विश्लेषण के माध्यम से हल करने योग्य अवस्था में हैं ; आपको वास्तव में घन को हल करने का प्रयास करने की आवश्यकता नहीं है।

— एरिक लिपर्ट

यहाँ तीन प्रकार के घन युग्म गुण का संक्षिप्त विवरण दिया गया है, जिन्हें घन के लिए संरक्षित किया जाना चाहिए। ryanheise.com/cube/cube_laws.html ।

— एरिक लिपर्ट

मैंने मैच स्टैकएक्सचेंज

— मेल

Answer 7

चूँकि आपको पहले ही बहुत अच्छे उत्तर मिल चुके हैं, इसलिए मुझे केवल एक विवरण जोड़ना है।

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

moveL :: Aut (RubiksCube a)
moveL =
    cong cube $ cong leftCols cycleLeft
              . cong leftSide rotateSideCW

इस प्रकार cycleLeftसंचालित द्वारा दिए गए दृश्य पर leftCols । इसी तरह, rotateSideCWजो कि इसके एक घुमाए गए संस्करण के लिए एक सामान्य कार्य है, जो दिए गए दृश्य पर कार्य करता है leftSide। अन्य चालों को समान तरीकों से लागू किया जा सकता है।

हास्केल पुस्तकालय का लक्ष्य सुंदर चित्र बनाना है। मुझे लगता है कि यह सफल रहा:

Answer 8

आप दो अलग-अलग प्रश्न पूछ रहे हैं।

1. एक्स संख्या के साथ क्यूब का प्रतिनिधित्व कैसे करें?

यदि आप एक वास्तविक दुनिया रूबिक के क्यूब का अनुकरण करने जा रहे हैं, तो सभी रूबिक के क्यूब्स में 6 पक्ष हैं। मुझे लगता है कि आपका क्या मतलब है "प्रति पक्ष प्रति आयाम टाइल की संख्या"। मूल रूबिक के घन का प्रत्येक पक्ष 3x3 है। अन्य आकारों में 4x4 (प्रोफेसर का घन), 5x5 और 6x6 शामिल हैं।

मैं "मानक" क्यूब सुलझाने संकेतन का उपयोग करते हुए, 6 पक्षों के साथ डेटा का प्रतिनिधित्व करता हूं:

• सामने: विलायक का सामना करना पड़ रहा है
• वापस
• सही
• बाएं
• यूपी
• नीचे

प्रत्येक पक्ष X द्वारा X का 2-D सरणी है।

Comments

आप एक 17x17 क्यूब खरीद सकते हैं ! इसमें कुछ यांत्रिक समझौते होते हैं, लेकिन यह वास्तविक चीज़ के लिए आइसोमोर्फिक है।

— RBerteig

Answer 9

मुझे अलग-अलग टुकड़ों (मिनी-क्यूब्स) का प्रतिनिधित्व करने के लिए @maple_shaft का विचार पसंद है: केंद्रीय, किनारे, और कोने के टुकड़े क्रमशः 1, 2, या 3 रंग ले जाते हैं।

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

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

• एक किनारे से संबंधित टुकड़े ढूँढना तुच्छ है।
• चेहरे से संबंधित टुकड़े ढूंढना तुच्छ है।
• उन चेहरों को ढूंढना जो दिए गए चेहरे या किसी विपरीत चेहरे की दिशा में हैं, 2 या 3 अच्छी तरह से परिभाषित लिंक का पता लगा रहे हैं।
• चेहरे को घुमाने के लिए, चेहरे के केंद्रीय टुकड़े से जुड़े सभी टुकड़ों के कनेक्शन अपडेट करें।

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

Answer 10

नोड्स और पॉइंटर्स के बारे में कैसे?

यह मानते हुए कि हमेशा 6 चेहरे होते हैं, और 1 नोड 1 चेहरे पर 1 वर्ग का प्रतिनिधित्व करता है:

r , g , b
r , g , b
r , g , b
|   |   |
r , g , b - r , g , b
r , g , b - r , g , b
r , g , b - r , g , b

नोड के पास प्रत्येक नोड के बगल में एक पॉइंटर होता है। एक सर्कल रोटेशन केवल पॉइंटर (संख्याओं की संख्या / चेहरे की संख्या) -1 नोड्स पर माइग्रेट करता है, इस मामले में 2. चूंकि सभी घुमाव सर्कल घुमाव हैं, आप सिर्फ एक rotateफ़ंक्शन का निर्माण करते हैं। यह पुनरावर्ती है, प्रत्येक नोड को एक स्थान पर ले जाता है, और यह जाँचता है कि क्या यह उन्हें पर्याप्त स्थानांतरित कर दिया है, क्योंकि यह नोड्स की संख्या एकत्र करेगा, और हमेशा चार चेहरे होते हैं। यदि नहीं, तो बढ़ाए गए मान की संख्या बढ़ाएं और फिर से कॉल घुमाएं।

यह मत भूलो कि यह दोगुना जुड़ा हुआ है, इसलिए नए इंगित किए गए नोड को भी अपडेट करें। वहाँ हमेशा ऊँचाई होगी * चौड़ाई के नोड्स को स्थानांतरित किया गया, एक पॉइंटर प्रति नोड के साथ अद्यतन किया गया, इसलिए वहाँ ऊंचाई * चौड़ाई * 2 पॉइंटर्स अपडेट किए जाने चाहिए।

चूंकि सभी नोड्स एक-दूसरे की ओर इशारा करते हैं, बस सर्कल पर घूमते हुए प्रत्येक नोड को अपडेट करें जैसे ही आप इसे आते हैं।

यह किसी भी आकार के क्यूब के लिए काम करना चाहिए, बिना किनारे के मामलों या जटिल तर्क के बिना। यह सिर्फ पॉइंटर वॉक / अपडेट है।

Answer 11

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

4 बाय 4 क्यूब में 12 सेट होंगे। 6 चेहरे के लिए 6 सेट और क्यूब के चारों ओर जाने वाले छह बैंड के लिए 6 सेट। प्रत्येक के चेहरे पर 16 उप क्यूब्स हैं और प्रत्येक में 12 उप शावक हैं। कुल 56 उप घन हैं। प्रत्येक उप घन रंग और रंगों की दिशा के बारे में जानकारी रखता है। रूबिक क्यूब अपने आप में 4 से 4 एरे द्वारा 4 एलीमेंट होता है, जिसमें प्रत्येक तत्व में 3 सेट होते हैं, जो उस स्थान पर सब क्यूब को परिभाषित करते हैं।

अन्य 11 उत्तरों के विपरीत इस डेटा संरचना में घन में प्रत्येक उप खंड स्थान को परिभाषित करने के लिए सेट के प्रतिच्छेदन का उपयोग किया गया है। जब परिवर्तन किया जाता है तो यह पास के सब ब्लॉक को अपडेट करने के कार्य को बचाता है।

Comments

इससे पहले किए गए अंकों से अधिक कुछ भी नहीं दिया गया है और पहले के 11 उत्तरों में समझाया गया है

— gnat