न्यूनतम: 0 बिट्स
मैक्स: 1734 243 बिट्स (4.335 4.401 बिट्स / बोर्ड परिशोधन)
अपेक्षित होना: 351 177 बिट्स (4.376 4.430 बिट्स / बोर्ड परिशोधन)
चूंकि मैं इनपुट और आउटपुट निर्धारित कर सकता हूं, लेकिन मैं चाहता हूं कि मैंने इस बिंदु तक गेम के इतिहास को एन्कोडिंग के साथ जाने का फैसला किया। एक फायदा यह है कि यह किसकी बारी की अतिरिक्त जानकारी है, एन-पासेंट, और जिसके पास महल की क्षमता है, जहां व्युत्पन्न किया जा सकता है और एन्कोड नहीं किया जा सकता है।
प्रयास 1:
Naively मैंने सोचा कि मैं प्रत्येक कदम को 12 बिट्स, फ़ॉर्म के 4 ट्रिपल (प्रारंभ x, प्रारंभ y, अंत x, अंत y) में शामिल कर सकता हूं, जहां प्रत्येक 3 बिट्स है।
हम शुरुआती स्थिति को मान लेंगे और पहले सफेद होने के साथ टुकड़ों को वहां से स्थानांतरित करेंगे। बोर्ड को इस तरह से व्यवस्थित किया गया है कि (0, 0) सफेद रंग के निचले बाएं कोने में है।
उदाहरण के लिए खेल:
e4 e5
Nf3 f6
Nxe5 fxe5
... ...
इनकोड किया जाएगा:
100001 100010 100110 100100
110000 101010 101110 101101
101010 100100 101101 100100
...
यह 12 मीटर बिट्स की एन्कोडिंग की ओर जाता है जहां मीटर की गई चालों की संख्या होती है
एक ओर यह वास्तव में बड़ी मिल सकता है, दूसरे हाथ पर आप इसे खुद खेल है इसलिए प्रत्येक एन्कोडिंग वास्तव में encodes होने के लिए प्रत्येक चाल पर विचार कर सकते m "शतरंज बोर्ड"। यदि आप इसे परिशोधित करते हैं तो आपको लगता है कि प्रत्येक "शतरंज बोर्ड" 12 बिट्स है। लेकिन मुझे लगता है कि यह थोड़ा धोखा है ...
प्रयास 2:
मैंने महसूस किया कि पिछले प्रयास में प्रत्येक कदम कई अवैध चालों को कूटबद्ध करता है। इसलिए मैंने केवल कानूनी कदमों को एनकोड करने का फैसला किया। हम इस प्रकार के संभावित कदमों की गणना करते हैं, प्रत्येक वर्ग की संख्या (0, 0) → 0, (1, 0) → 1, (x, y) → x + 8 y। टाइल्स के माध्यम से इरेट करें और जांचें कि क्या कोई टुकड़ा है और अगर वह चल सकता है। यदि ऐसा है तो पदों को जोड़ें यह एक सूची में जा सकता है। सूची सूचकांक चुनें जो वह कदम है जिसे आप बनाना चाहते हैं। उस संख्या को मूव्स के रनिंग टोटल में 1 प्लस की संभावित चालों की संख्या से जोड़ें।
ऊपर के रूप में उदाहरण: प्रारंभिक स्थिति से जो पहला टुकड़ा चल सकता है वह वर्ग 1 पर शूरवीर है, यह वर्ग 16 या 18 में स्थानांतरित हो सकता है, इसलिए उन लोगों को सूची में जोड़ें [(1,16),(1,18)]
। अगला वर्ग 6 पर शूरवीर है, इसे जोड़ें। कुल मिलाकर हमें मिलता है:
[(1,16),(1,18),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(11,19),(11,27),(12,20),(12,28),(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]
चूंकि हम चाल (12, 28) चाहते हैं, इसलिए हम इसे बेस 20 में 13 मानते हैं क्योंकि 20 संभावित चालें हैं।
तो अब हम गेम नंबर जी 0
= 13 प्राप्त करते हैं
आगे हम काले रंग के लिए भी ऐसा ही करते हैं, इसके अलावा हम चालों की सूची प्राप्त करने के लिए (उल्टे इसे आसान बनाने के लिए, आवश्यक नहीं) टाइल्स को नंबर देते हैं:
[(1,16),(1,18),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(11,19),(11,27),(12,20),(12,28),(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]
चूंकि हम चाल (11, 27) चाहते हैं, इसलिए हम इसे बेस 20 में 11 मानते हैं क्योंकि 20 संभावित चालें हैं।
तो अब हम गेम नंबर जी 1
= (11 + 20) + 13 = 233 प्राप्त करते हैं
आगे हमें सफ़ेद के लिए निम्नलिखित चालों की सूची मिलती है:
[(1,16),(1,18),(3,12),(3,21),(3,30),(3,39),(4,12),(5,12),(5,19),(5,26),(5,33),(5,40),(6,12),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(11,19),(11,27)(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]
चूँकि हम चाल (6, 21) चाहते हैं, हम इसे आधार 29 में 13 मानते हैं क्योंकि 29 संभावित चालें हैं।
तो अब हम गेम नंबर जी 2
= ((13 + 20) + 11) 20 + 13 = 5433 प्राप्त करते हैं
आगे हमें काले रंग के लिए निम्न चालों की सूची मिलती है:
[(1,11),(1,16),(1,18),(2,11),(2,20),(2,29),(2,38),(2,47),(3,11),(4,11),(4,18),(4,25),(4,32),(6,21),(6,23),(8,16),(8,24),(9,17),(9,25),(10,18),(10,26),(12,20),(12,28),(13,21),(13,29),(14,22),(14,30),(15,23),(15,31)]
चूंकि हम $ (10, 18) $ (10, 18) कदम चाहते हैं
तो अब हम खेल संख्या जी 3
= (((19 13 29 + 13) 20) + 11) 20 + 13 = 225833 प्राप्त करते हैं।
और सभी शेष चालों के लिए इस प्रक्रिया को जारी रखें। आप g को फंक्शन g (x, y, z) = x y + z के रूप में सोच सकते हैं । इस प्रकार जी 0
= जी (1, 1, 13), जी 1
= जी (जी (1, 1, 11), 20, 13), जी 2
= जी (जी (जी (1, 1, 13), 20) 11), 20, 13), जी 3
= जी (जी (जी (जी (1, 1, 19), 29, 13), 20, 11), 20, 13)
गेम नंबर जी 0 को डीकोड करने के लिए , हम प्रारंभिक स्थिति में शुरू करते हैं और सभी संभावित चालों को गणना करते हैं। फिर हम g 1 = g 0 // l , m 0 = g 0 % l की गणना करते हैं , जहाँ l संभव चालों की संख्या है, '//' पूर्णांक विभाजन ऑपरेटर है और '%' मापांक ऑपरेटर है। यह उस g 0 = g 1 + m 0 को पकड़ना चाहिए । अगला हम मूव एम 0 बनाते हैं और दोहराते हैं।
उपरोक्त उदाहरण से यदि g 0 = 225833 तब g 1 = 225833 // 20 = 11291 और m 0 = 225833% 20 = 13. अगला g 2 = 11291 // 20 = 564 और m 1 = 11291% 20 = 11. तब g 3 = 11291 // 20 = 564 और m 2 = 11291% 20 = 11. इसलिए g 4 = 564 // 29 = 19 और_m_ 3 = 564% 29 = 13. अंत में g 5 = 19 // 29 = 0 और m 4 = 19% 29 = 19।
तो इस तरह से गेम को एनकोड करने के लिए कितने बिट्स का उपयोग किया जाता है?
सादगी के लिए, मान लें कि प्रत्येक मोड़ पर हमेशा 20 चालें होती हैं और सबसे खराब स्थिति के लिए हम हमेशा सबसे बड़ा एक चुनते हैं, 19. हमें जो संख्या मिलेगी वह 19 ⋅ 20 मीटर होगी
+ 19 m 20 m-1
+ 19-20 m-2
+ 19 + 19 + 20 + 19 = 20 m + 1
- 1 जहाँ _m चाल की संख्या है। 20 m + 1
- 1 को एनकोड करने के लिए हमें log 2
(20 m + 1
) बिट्स की आवश्यकता होती है जो लगभग (m + 1)) log 2
(20) = 4.3219 + (m + 1) है।
औसतन m = 80 (प्रति खिलाड़ी 40 चाल) तो इससे 351 बिट्स को एनकोड करना होगा। यदि हम कई गेम रिकॉर्ड कर रहे थे तो हमें एक सार्वभौमिक एन्कोडिंग की आवश्यकता होगी क्योंकि हमें नहीं पता है कि प्रत्येक नंबर को कितने बिट्स की आवश्यकता होगी
सबसे खराब स्थिति जब m = 400 (प्रति खिलाड़ी 200 चाल) तो इससे 1734 बिट्स को एनकोड करना होगा।
ध्यान दें कि जिस स्थिति को हम एनकोड करना चाहते हैं, उसे नियमों का पालन करते हुए वहां तक पहुंचने के लिए सबसे छोटे रास्ते से जाना चाहिए। उदाहरण के लिए गेम को यहाँ पर वर्गीकृत करने के लिए m = 11741 की आवश्यकता नहीं है जो कि अंतिम स्थिति को एनकोड करता है। इसके बजाय हम उस स्थिति के लिए सबसे छोटा रास्ता खोजने के लिए एक ब्रेड-फ़र्स्ट सर्च चलाते हैं और इसके बजाय उसे एनकोड करते हैं। मुझे नहीं पता कि सभी शतरंज पदों पर जाने के लिए हमें कितनी गहराई तक जाने की आवश्यकता होगी, लेकिन मुझे संदेह है कि 400 एक overestimate है।
त्वरित गणना:
12 अद्वितीय टुकड़े हैं या चौकोर खाली हो सकता है ताकि उन्हें शतरंज की चौकी पर रखने के लिए 13 64 हो । यह एक विशाल overestimate है क्योंकि इसमें कई अमान्य पद शामिल हैं। जब हम गेम में एम मूव करते हैं तो हमने लगभग 20 मीटर पोजीशन बनाई है । तो हम देख रहे हैं कि कब 20 मीटर = 13 64 । M = 64 * लॉग 20 (13) = 54.797 प्राप्त करने के लिए दोनों पक्षों को लॉग इन करें । इससे पता चलता है कि हमें 55 चालों में किसी भी स्थिति में पहुंचने में सक्षम होना चाहिए।
अब जब मैंने सबसे खराब स्थिति की गणना m = 55 नहीं m = 400 की है तो मैं अपने परिणाम संपादित करूंगा। ऐसी स्थिति को सांकेतिक शब्दों में बदलना जहां एम = 55 243 बिट्स लेता है। मैं यह भी कहने जा रहा हूं कि औसत मामला लगभग m = 40 है जो एन्कोड करने के लिए 177 बिट्स लेता है।
यदि हम पहले से परिशोधन तर्क का उपयोग करते हैं तो हम 1734 बिट्स में 400 "शतरंज बोर्ड" को एन्कोडिंग कर रहे हैं ताकि हम प्राप्त करें कि प्रत्येक "शतरंज बोर्ड" सबसे खराब स्थिति में 4.335 बिट्स लेता है।
ध्यान दें कि जी = 0 एक वैध खेल को दर्शाता है, वह स्थान जहां सबसे कम वर्ग का टुकड़ा सबसे कम वर्ग तक जाता है।
अतिरिक्त नोट्स:
यदि आप खेल में एक विशिष्ट स्थिति को संदर्भित करना चाहते हैं तो आपको सूचकांक को एनकोड करना पड़ सकता है। यह या तो मैन्युअल रूप से जोड़ा जा सकता है जैसे कि खेल के लिए सूचकांक को संक्षिप्त करें, या प्रत्येक मोड़ पर अंतिम संभव कदम के रूप में एक अतिरिक्त "अंत" चाल जोड़ें। यह अब खिलाडियों के लिए, या एक पंक्ति में 2 खिलाड़ियों को आकर्षित करने के लिए सहमत करने के लिए जिम्मेदार हो सकता है। यह केवल तभी आवश्यक है जब खेल स्थिति के आधार पर एक चेकमेट या गतिरोध में समाप्त नहीं हुआ था, इस मामले में यह निहित है। इस मामले में यह औसतन 356 और सबसे खराब स्थिति 1762 में आवश्यक बिट्स की संख्या लाता है।