अपडेट: मुझे यह विषय इतना पसंद आया कि मैंने प्रोग्रामिंग पज़ल्स, शतरंज पोज़िशन और हफ़मैन कोडिंग लिखा । यदि आप इसके माध्यम से पढ़ते हैं, तो मैंने निर्धारित किया है कि एक पूर्ण गेम स्टेट को स्टोर करने का एकमात्र तरीका चालों की एक पूरी सूची को संग्रहीत करना है। पर क्यों पढ़ें। तो मैं टुकड़े लेआउट के लिए समस्या का थोड़ा सरलीकृत संस्करण का उपयोग करता हूं।
समस्या
यह छवि आरंभिक शतरंज स्थिति को दर्शाती है। शतरंज 8x8 के बोर्ड पर होता है, जिसमें प्रत्येक खिलाड़ी 8 टुकड़ों, समानों, 2 शूरवीरों, 2 शूरवीरों, 2 बिशपों, 1 रानी और 1 राजा के समान सेट से शुरू होता है।
पदों को आम तौर पर स्तंभ के लिए एक पत्र के रूप में दर्ज किया जाता है, जिसके बाद पंक्ति के लिए संख्या होती है इसलिए व्हाइट की रानी d1 पर है। मूव्स को अक्सर बीजीय संकेतन में संग्रहित किया जाता है , जो अस्पष्ट है और आम तौर पर केवल आवश्यक न्यूनतम जानकारी को निर्दिष्ट करता है। इस उद्घाटन पर विचार करें:
- e4 e5
- एनएफ 3 एनसी 6
- ...
जिसका अनुवाद है:
- व्हाइट ई 2 से ई 4 तक किंग्स प्यादा चलता है (यह एकमात्र ऐसा टुकड़ा है जो ई 4 को प्राप्त कर सकता है इसलिए "ई 4");
- ब्लैक ई 7 से ई 5 तक राजा के मोहरे को स्थानांतरित करता है;
- व्हाइट नाइट के लिए नाइट (N) ले जाता है;
- ब्लैक नाइट को c6 में ले जाता है।
- ...
बोर्ड इस तरह दिखता है:
किसी भी प्रोग्रामर के लिए एक महत्वपूर्ण क्षमता सही ढंग से और स्पष्ट रूप से समस्या को निर्दिष्ट करने में सक्षम होना है ।
तो क्या याद आ रही है या अस्पष्ट है? बहुत कुछ बदल जाता है।
बोर्ड राज्य बनाम खेल राज्य
पहली बात यह निर्धारित करने की आवश्यकता है कि क्या आप किसी खेल की स्थिति या बोर्ड पर टुकड़ों की स्थिति का भंडारण कर रहे हैं। बस टुकड़ों की स्थिति को एन्कोड करना एक बात है लेकिन समस्या "सभी बाद की कानूनी चाल" कहती है। समस्या यह भी है कि इस बिंदु पर जाने के बारे में कुछ भी नहीं कहा जाता है। यह वास्तव में एक समस्या है जैसा कि मैं समझाता हूँ।
कैसलिंग
खेल इस प्रकार आगे बढ़ा है:
- e4 e5
- एनएफ 3 एनसी 6
- Bb5 a6
- Ba4 Bc5
बोर्ड इस प्रकार है:
व्हाइट में कास्टिंग का विकल्प होता है । इसके लिए आवश्यकताओं का एक हिस्सा यह है कि राजा और संबंधित बदमाश कभी भी स्थानांतरित नहीं हो सकते हैं, इसलिए क्या राजा या प्रत्येक पक्ष के बदमाश स्थानांतरित हो गए हैं, उन्हें संग्रहीत करने की आवश्यकता होगी। जाहिर है कि यदि वे अपने शुरुआती पदों पर नहीं हैं, तो वे स्थानांतरित हो गए हैं अन्यथा इसे निर्दिष्ट करने की आवश्यकता है।
ऐसी कई रणनीतियाँ हैं जिनका उपयोग इस समस्या से निपटने के लिए किया जा सकता है।
सबसे पहले, हम उस टुकड़े को स्थानांतरित करने के लिए सूचना के अतिरिक्त 6 बिट्स (प्रत्येक बदमाश और राजा के लिए 1) को स्टोर कर सकते हैं। हम इन छह वर्गों में से एक के लिए थोड़ा सा भंडारण करके इसे सुव्यवस्थित कर सकते हैं यदि सही टुकड़ा इसमें होता है। वैकल्पिक रूप से हम प्रत्येक बेपर्दा के टुकड़े को दूसरे टुकड़े के रूप में मान सकते हैं, इसलिए प्रत्येक पक्ष पर 6 टुकड़े प्रकारों के बजाय (मोहरा, भोंकना, शूरवीर, बिशप, रानी और राजा) 8 होते हैं (बेपनाह किश्ती और बेपनाह बादशाह जोड़ना)।
एन पास
शतरंज में एक और अजीबोगरीब और अक्सर उपेक्षित शासन एन पासेंट है ।
खेल में प्रगति हुई है।
- e4 e5
- एनएफ 3 एनसी 6
- Bb5 a6
- Ba4 Bc5
- OO b5
- Bb3 b4
- सी 4
B4 पर ब्लैक का प्यादा अब c4 पर व्हाइट प्यादा ले कर b4 से c3 पर अपने प्यादा को स्थानांतरित करने का विकल्प रखता है। यह केवल पहले अवसर पर होता है यदि विकल्प पर ब्लैक पास करता है तो वह इसे अगले कदम पर नहीं ले जा सकता है। इसलिए हमें इसे स्टोर करने की आवश्यकता है।
यदि हम पिछली चाल को जानते हैं तो हम निश्चित रूप से उत्तर दे सकते हैं कि क्या En Passant संभव है। वैकल्पिक रूप से हम स्टोर कर सकते हैं कि क्या इसकी 4 वीं रैंक पर प्रत्येक मोहरा सिर्फ एक दोहरे कदम के साथ वहां चला गया है। या हम बोर्ड पर प्रत्येक संभावित एन पासेंट स्थिति को देख सकते हैं और यह इंगित करने के लिए एक झंडा है कि क्या यह संभव है या नहीं।
पदोन्नति
यह व्हाइट की चाल है। अगर व्हाइट h7 से h8 पर अपने मोहरे को आगे बढ़ाता है तो इसे किसी अन्य टुकड़े (लेकिन राजा नहीं) को बढ़ावा दिया जा सकता है। 99% यह एक रानी को पदोन्नत किया जाता है, लेकिन कभी-कभी ऐसा नहीं होता है, आमतौर पर क्योंकि यह तब गतिरोध पैदा कर सकता है जब आप जीतेंगे। यह इस प्रकार लिखा गया है:
- H8 = Q
यह हमारी समस्या में महत्वपूर्ण है क्योंकि इसका मतलब है कि हम प्रत्येक पक्ष पर निश्चित संख्या में टुकड़ों की गणना नहीं कर सकते हैं। एक तरफ से 9 रानियों, 10 बदमाशों, 10 बिशपों या 10 शूरवीरों के साथ पूरी तरह से संभव (लेकिन अविश्वसनीय रूप से संभावना नहीं है) यदि सभी 8 प्यादों को बढ़ावा मिलता है।
गतिरोध
जब आप जिस स्थिति से अपनी सर्वश्रेष्ठ रणनीति नहीं जीत सकते हैं वह गतिरोध के लिए प्रयास करना है । सबसे अधिक संभावना वाला संस्करण वह जगह है जहां आप एक कानूनी कदम नहीं उठा सकते हैं (आमतौर पर क्योंकि कोई भी कदम जब आपके राजा को जांच में रखा जाता है)। इस मामले में आप ड्रॉ का दावा कर सकते हैं। यह एक के लिए पूरा करने के लिए आसान है।
दूसरा संस्करण तीन गुना पुनरावृत्ति द्वारा है । यदि एक ही बोर्ड की स्थिति खेल में तीन बार होती है (या अगली चाल पर तीसरी बार घटित होगी), तो ड्रा का दावा किया जा सकता है। पदों को किसी विशेष क्रम में होने की आवश्यकता नहीं है (जिसका अर्थ है कि तीन बार दोहराए गए चालों का समान अनुक्रम नहीं है)। यह एक समस्या को बहुत जटिल करता है क्योंकि आपको हर पिछले बोर्ड की स्थिति को याद रखना होगा। यदि यह समस्या की आवश्यकता है तो समस्या का एकमात्र समाधान हर पिछले कदम को संग्रहीत करना है।
अंत में, पचास चाल नियम है । एक खिलाड़ी ड्रॉ का दावा कर सकता है अगर कोई मोहरा नहीं चला गया है और पिछले पचास लगातार चालों में कोई टुकड़ा नहीं लिया गया है, तो हमें यह संग्रहीत करने की आवश्यकता होगी कि एक मोहरा ले जाने के बाद से कितने चाल चले गए या एक टुकड़ा लिया गया (दो के नवीनतम)। 6 बिट्स (0-63)।
यह किसकी बारी है?
निश्चित रूप से हमें यह भी जानना होगा कि यह किसकी बारी है और यह जानकारी का एक सा है।
दो समस्याएं
गतिरोध के मामले के कारण, खेल की स्थिति को संग्रहीत करने का एकमात्र संभव या समझदार तरीका उन सभी चालों को संग्रहीत करना है जो इस स्थिति का नेतृत्व करते थे। मैं उस एक समस्या से निपटूंगा। बोर्ड की राज्य की समस्या को सरल बनाया जाएगा: बोर्ड पर सभी टुकड़ों की वर्तमान स्थिति को ध्यान में रखें, जिसमें किसलिंग, एन पासेंट, गतिरोध की स्थिति की अनदेखी करना और यह किसकी बारी है ।
टुकड़ा लेआउट को मोटे तौर पर दो तरीकों में से एक में संभाला जा सकता है: प्रत्येक वर्ग की सामग्री को स्टोर करके या प्रत्येक टुकड़े की स्थिति को स्टोर करके।
सरल सामग्री
छह टुकड़े प्रकार (प्यादा, किश्ती, शूरवीर, बिशप, रानी और राजा) हैं। प्रत्येक टुकड़ा सफेद या काला हो सकता है इसलिए एक वर्ग में 12 संभावित टुकड़ों में से एक हो सकता है या यह खाली हो सकता है इसलिए 13 संभावनाएं हैं। 13 को 4 बिट्स (0-15) में संग्रहित किया जा सकता है, इसलिए सबसे सरल उपाय है कि प्रत्येक वर्ग के लिए 4 बिट्स को 64 वर्ग या 256 बिट्स की जानकारी के लिए स्टोर किया जाए।
इस पद्धति का लाभ यह है कि हेरफेर अविश्वसनीय रूप से आसान और तेज है। भंडारण आवश्यकताओं को बढ़ाए बिना 3 और संभावनाओं को जोड़कर इसे बढ़ाया जा सकता है: एक मोहरा जो अंतिम मोड़ पर 2 रिक्त स्थान ले गया है, एक राजा जो स्थानांतरित नहीं हुआ है और एक बदमाश जो स्थानांतरित नहीं हुआ है, जो बहुत कुछ पूरा करेगा पहले बताए गए मुद्दों पर।
लेकिन हम बेहतर कर सकते हैं।
बेस 13 एनकोडिंग
बोर्ड की स्थिति को बहुत बड़ी संख्या के रूप में सोचना अक्सर सहायक होता है। यह अक्सर कंप्यूटर विज्ञान में किया जाता है। उदाहरण के लिए, हॉल्टिंग समस्या एक कंप्यूटर प्रोग्राम (सही तरीके से) को एक बड़ी संख्या के रूप में मानती है।
पहला समाधान स्थिति को 64 अंकों के आधार 16 नंबर के रूप में मानता है लेकिन जैसा कि प्रदर्शित किया गया है कि इस जानकारी में अतिरेक है (प्रति अंक 3 अप्रयुक्त संभावनाएं हैं) इसलिए हम संख्या स्थान को 64 आधार 13 अंकों तक कम कर सकते हैं। बेशक, यह कुशलतापूर्वक आधार 16 के रूप में नहीं किया जा सकता है, लेकिन यह भंडारण आवश्यकताओं (और भंडारण स्थान को कम करना हमारा लक्ष्य है) पर बचाएगा।
आधार 10 में संख्या 234 2 x 10 2 + 3 x 10 1 + 4 x 10 0 के बराबर है ।
आधार 16 में संख्या 0xA50 10 x 16 2 + 5 x 16 1 + 0 x 16 0 = 2640 (दशमलव) के बराबर है ।
इसलिए हम अपनी स्थिति को p 0 x 13 63 + p 1 x 13 62 + ... + p 63 के रूप में एन्कोड कर सकते हैं x 13 0 जहां पी मैं वर्ग की सामग्री का प्रतिनिधित्व करता है मैं ।
2 256 लगभग 1.16e77 के बराबर है। 13 64 लगभग 1.96e71 के बराबर है, जिसमें 237 बिट्स स्टोरेज स्पेस की आवश्यकता होती है। महज 7.5% की बचत से हेरफेर की लागत काफी बढ़ जाती है।
परिवर्तनीय आधार एनकोडिंग
कानूनी बोर्डों में कुछ निश्चित वर्गों में कुछ टुकड़े दिखाई नहीं दे सकते हैं। उदाहरण के लिए, प्यादे पहली या आठवीं रैंक पर नहीं हो सकते हैं, उन चौकों के लिए संभावनाओं को कम करके 11. 11 कि संभावित बोर्ड को कम कर देता है 11 16 x 13 48 = 1.35e70 (लगभग), भंडारण स्थान के 233 बिट्स की आवश्यकता होती है।
वास्तव में और दशमलव (या बाइनरी) से ऐसे मूल्यों को एन्कोडिंग और डिकोड करना थोड़ा अधिक दृढ़ है, लेकिन यह मज़बूती से किया जा सकता है और पाठक को एक अभ्यास के रूप में छोड़ दिया जाता है।
चर चौड़ाई अक्षर
पिछले दो तरीकों को निश्चित-चौड़ाई वाले अल्फाबेटिक एन्कोडिंग के रूप में वर्णित किया जा सकता है । वर्णमाला के 11, 13 या 16 सदस्यों में से प्रत्येक को दूसरे मूल्य के लिए प्रतिस्थापित किया जाता है। प्रत्येक "वर्ण" समान चौड़ाई है, लेकिन दक्षता में सुधार किया जा सकता है जब आप समझते हैं कि प्रत्येक वर्ण समान रूप से संभव नहीं है।
मोर्स कोड पर विचार करें (ऊपर चित्रित) । किसी संदेश में वर्ण डैश और डॉट्स के अनुक्रम के रूप में एन्कोड किए गए हैं। उन डैश और डॉट्स को रेडियो (आम तौर पर) पर स्थानांतरित कर दिया जाता है और उनके बीच एक विराम होता है।
ध्यान दें कि पत्र ई ( अंग्रेजी में सबसे आम पत्र) कैसे है ) एक एकल बिंदु, सबसे छोटा संभव अनुक्रम है, जबकि जेड (कम से कम लगातार) दो डैश और दो बीप हैं।
इस तरह की स्कीम का आकार काफी कम कर सकता है अपेक्षित संदेश लेकिन एक यादृच्छिक चरित्र अनुक्रम के आकार को बढ़ाने की लागत पर आती है।
यह ध्यान दिया जाना चाहिए कि मोर्स कोड में एक और इनबिल्ट सुविधा है: डैश तीन डॉट्स के रूप में लंबे होते हैं, इसलिए उपरोक्त कोड को डैश के उपयोग को कम करने के लिए ध्यान में रखते हुए बनाया गया है। 1s और 0s (हमारे बिल्डिंग ब्लॉक) के बाद से यह समस्या नहीं है, यह एक ऐसी विशेषता नहीं है जिसे हमें दोहराने की आवश्यकता है।
अंत में, मोर्स कोड में दो प्रकार के आराम होते हैं। एक छोटे आराम (डॉट की लंबाई) का उपयोग डॉट्स और डैश के बीच अंतर करने के लिए किया जाता है। वर्णों को परिसीमित करने के लिए एक लंबे अंतराल (डैश की लंबाई) का उपयोग किया जाता है।
तो यह हमारी समस्या पर कैसे लागू होता है?
हफमैन कोडिंग
हफमैन कोडिंग नामक चर लंबाई कोड से निपटने के लिए एक एल्गोरिथ्म है । हफ़मैन कोडिंग एक चर लंबाई कोड प्रतिस्थापन बनाता है, आमतौर पर प्रतीकों की अपेक्षित आवृत्ति का उपयोग करता है ताकि अधिक सामान्य प्रतीकों को छोटे मान निर्दिष्ट किए जा सकें।
उपरोक्त पेड़ में, E को 000 के रूप में एन्कोड किया गया है (या बाएं-बाएं-बाएं) और S 1011 है। यह स्पष्ट होना चाहिए कि यह एन्कोडिंग योजना अस्पष्ट है ।
यह मोर्स कोड से एक महत्वपूर्ण अंतर है। मोर्स कोड में वर्ण विभाजक होता है, इसलिए यह अन्यथा अस्पष्ट प्रतिस्थापन कर सकता है (जैसे 4 डॉट्स H या 2 Is हो सकते हैं) लेकिन हमारे पास केवल 1s और 0s हैं, इसलिए हम इसके बजाय एक अस्पष्ट प्रतिस्थापन का चयन करते हैं।
नीचे एक सरल कार्यान्वयन है:
private static class Node {
private final Node left;
private final Node right;
private final String label;
private final int weight;
private Node(String label, int weight) {
this.left = null;
this.right = null;
this.label = label;
this.weight = weight;
}
public Node(Node left, Node right) {
this.left = left;
this.right = right;
label = "";
weight = left.weight + right.weight;
}
public boolean isLeaf() { return left == null && right == null; }
public Node getLeft() { return left; }
public Node getRight() { return right; }
public String getLabel() { return label; }
public int getWeight() { return weight; }
}
स्थैतिक डेटा के साथ:
private final static List<string> COLOURS;
private final static Map<string, integer> WEIGHTS;
static {
List<string> list = new ArrayList<string>();
list.add("White");
list.add("Black");
COLOURS = Collections.unmodifiableList(list);
Map<string, integer> map = new HashMap<string, integer>();
for (String colour : COLOURS) {
map.put(colour + " " + "King", 1);
map.put(colour + " " + "Queen";, 1);
map.put(colour + " " + "Rook", 2);
map.put(colour + " " + "Knight", 2);
map.put(colour + " " + "Bishop";, 2);
map.put(colour + " " + "Pawn", 8);
}
map.put("Empty", 32);
WEIGHTS = Collections.unmodifiableMap(map);
}
तथा:
private static class WeightComparator implements Comparator<node> {
@Override
public int compare(Node o1, Node o2) {
if (o1.getWeight() == o2.getWeight()) {
return 0;
} else {
return o1.getWeight() < o2.getWeight() ? -1 : 1;
}
}
}
private static class PathComparator implements Comparator<string> {
@Override
public int compare(String o1, String o2) {
if (o1 == null) {
return o2 == null ? 0 : -1;
} else if (o2 == null) {
return 1;
} else {
int length1 = o1.length();
int length2 = o2.length();
if (length1 == length2) {
return o1.compareTo(o2);
} else {
return length1 < length2 ? -1 : 1;
}
}
}
}
public static void main(String args[]) {
PriorityQueue<node> queue = new PriorityQueue<node>(WEIGHTS.size(),
new WeightComparator());
for (Map.Entry<string, integer> entry : WEIGHTS.entrySet()) {
queue.add(new Node(entry.getKey(), entry.getValue()));
}
while (queue.size() > 1) {
Node first = queue.poll();
Node second = queue.poll();
queue.add(new Node(first, second));
}
Map<string, node> nodes = new TreeMap<string, node>(new PathComparator());
addLeaves(nodes, queue.peek(), "");
for (Map.Entry<string, node> entry : nodes.entrySet()) {
System.out.printf("%s %s%n", entry.getKey(), entry.getValue().getLabel());
}
}
public static void addLeaves(Map<string, node> nodes, Node node, String prefix) {
if (node != null) {
addLeaves(nodes, node.getLeft(), prefix + "0");
addLeaves(nodes, node.getRight(), prefix + "1");
if (node.isLeaf()) {
nodes.put(prefix, node);
}
}
}
एक संभावित उत्पादन है:
White Black
Empty 0
Pawn 110 100
Rook 11111 11110
Knight 10110 10101
Bishop 10100 11100
Queen 111010 111011
King 101110 101111
एक प्रारंभिक स्थिति के लिए यह 32 x 1 + 16 x 3 + 12 x 5 + 4 x 6 = 164 बिट्स के बराबर है।
राज्य का अंतर
एक और संभावित दृष्टिकोण है हफमैन कोडिंग के साथ बहुत पहले दृष्टिकोण को संयोजित करना। यह इस धारणा पर आधारित है कि अधिकांश अपेक्षित शतरंज बोर्ड (बेतरतीब ढंग से उत्पन्न होने के बजाय) कम से कम भाग में, शुरुआती स्थिति से मिलते-जुलते हैं।
तो आप क्या करते हैं XOR 256 बिट करंट बोर्ड पोजीशन के साथ 256 बिट स्टार्टिंग पोजिशन और फिर उसको इनकोड करते हैं (हफमैन कोडिंग या, कहते हैं, रन लेंथ एन्कोडिंग की कुछ विधि )। जाहिर है कि यह (64 0 एस शायद 64 बिट्स के अनुरूप) के साथ शुरू करने के लिए बहुत कुशल होगा, लेकिन खेल में प्रगति के रूप में आवश्यक भंडारण में वृद्धि।
टुकड़ा स्थिति
जैसा कि उल्लेख किया गया है, इस समस्या पर हमला करने का एक और तरीका यह है कि प्रत्येक खिलाड़ी की स्थिति को संग्रहीत करना है। यह विशेष रूप से एंडगेम पदों के साथ अच्छी तरह से काम करता है जहां अधिकांश वर्ग खाली होंगे (लेकिन हफ़मैन कोडिंग दृष्टिकोण में खाली वर्ग केवल 1 बिट का उपयोग करते हैं)।
प्रत्येक पक्ष में एक राजा और 0-15 अन्य टुकड़े होंगे। पदोन्नति के कारण उन टुकड़ों का सटीक मेक-अप पर्याप्त हो सकता है कि आप मान नहीं सकते कि शुरुआती स्थिति के आधार पर संख्याएँ अधिकतम हैं।
इसे विभाजित करने का तार्किक तरीका दो पक्षों (सफेद और काले) से मिलकर एक स्थिति है। प्रत्येक पक्ष में है:
- एक राजा: स्थान के लिए 6 बिट्स;
- प्यादे हैं: 1 (हां), 0 (नहीं);
- यदि हाँ, प्यादों की संख्या: 3 बिट्स (4-7 + 1 = 1-8);
- यदि हाँ, प्रत्येक प्यादा का स्थान एन्कोडेड है: 45 बिट्स (नीचे देखें);
- गैर-पंजे की संख्या: 4 बिट्स (0-15);
- प्रत्येक टुकड़े के लिए: टाइप करें (2 बिट्स फॉर क्वीन, रोक, नाइट, बिशप) और लोकेशन (6 बिट्स)
प्यादा स्थान के लिए, प्यादे केवल 48 संभावित चौकों पर (64 अन्य की तरह नहीं) हो सकते हैं। जैसे, यह बेहतर है कि अतिरिक्त 16 मानों को बर्बाद न करें जो कि 6 बिट प्रति मोहरे का उपयोग करेंगे। तो अगर आपके पास 8 प्यादे हैं तो 48 8 संभावनाएं हैं, 28,179,280,429,056 के बराबर। आपको कई मानों को एनकोड करने के लिए 45 बिट्स की आवश्यकता है।
यह 105 बिट्स प्रति साइड या 210 बिट्स है। आरंभिक स्थिति इस पद्धति के लिए सबसे खराब स्थिति है, लेकिन टुकड़ों को हटाते ही यह काफी हद तक बेहतर हो जाएगी।
यह ध्यान दिया जाना चाहिए कि 48 से कम 8 हैं संभावनाएं हैं क्योंकि प्यादे सभी एक ही वर्ग में नहीं हो सकते हैं पहली में 48 संभावनाएं हैं, दूसरा 47 और इसी तरह। 48 x 47 x… x 41 = 1.52e13 = 44 बिट्स संग्रहण।
आप अन्य टुकड़ों (दूसरे पक्ष सहित) पर कब्जे वाले वर्गों को समाप्त करके इसे और बेहतर कर सकते हैं ताकि आप पहले सफेद गैर-पंजे, फिर काले गैर-पंजे, फिर सफेद पंजे और अंत में काले पंजे रख सकें। एक प्रारंभिक स्थिति पर यह स्टोरेज आवश्यकताओं को व्हाइट के लिए 44 बिट्स और ब्लैक के लिए 42 बिट्स को कम करता है।
संयुक्त दृष्टिकोण
एक अन्य संभावित अनुकूलन यह है कि इनमें से प्रत्येक दृष्टिकोण की अपनी ताकत और कमजोरियां हैं। आप कह सकते हैं, सबसे अच्छा 4 चुनें और फिर पहले दो बिट्स में स्कीम चयनकर्ता को एनकोड करें और उसके बाद स्कीम-विशिष्ट स्टोरेज।
ओवरहेड के साथ छोटा, यह अब तक का सबसे अच्छा तरीका होगा।
खेल राज्य
मैं एक स्थिति के बजाय एक खेल के भंडारण की समस्या पर लौटता हूं । तीन गुना पुनरावृत्ति के कारण हमें इस बिंदु पर हुई चालों की सूची संग्रहीत करनी होगी।
एनोटेशन
एक बात जो आपको निर्धारित करनी है, क्या आप केवल चाल की सूची जमा कर रहे हैं या आप खेल को एनोटेट कर रहे हैं? उदाहरण के लिए शतरंज के खेल को अक्सर एनोटेट किया जाता है:
- BB5 !! Nc4?
व्हाइट के कदम को दो विस्मयादिबोधक बिंदुओं द्वारा शानदार के रूप में चिह्नित किया गया है जबकि ब्लैक को एक गलती के रूप में देखा जाता है। शतरंज का विराम चिह्न देखें ।
इसके अतिरिक्त आपको नि: शुल्क पाठ को संग्रहीत करने की भी आवश्यकता हो सकती है क्योंकि चालें वर्णित हैं।
मैं मान रहा हूं कि चालें पर्याप्त हैं, इसलिए कोई टिप्पणी नहीं होगी।
बीजगणितीय संकेतन
हम बस यहाँ ("e4", "Bxb5", आदि) के पाठ को संग्रहीत कर सकते हैं। एक टर्मिनेटिंग बाइट सहित आप प्रति चाल (सबसे खराब स्थिति) के बारे में 6 बाइट्स (48 बिट्स) देख रहे हैं। यह विशेष रूप से कुशल नहीं है।
कोशिश करने के लिए दूसरी चीज शुरुआती स्थान (6 बिट्स) और अंत स्थान (6 बिट्स) को संग्रहीत करना है ताकि प्रति कदम 12 बिट्स हो। यह काफी बेहतर है।
वैकल्पिक रूप से हम वर्तमान स्थिति से सभी वैधानिक चालों को एक अनुमान और नियतात्मक तरीके और स्थिति में निर्धारित कर सकते हैं जिसे हमने चुना है। यह फिर ऊपर वर्णित चर आधार एन्कोडिंग पर वापस जाता है। श्वेत और श्याम की प्रत्येक पहली चाल पर 20 संभव चालें हैं, दूसरे पर अधिक और इतने पर।
निष्कर्ष
इस सवाल का कोई बिल्कुल सही जवाब नहीं है। कई संभावित दृष्टिकोण हैं जिनमें से उपरोक्त कुछ ही हैं।
मुझे इस और इसी तरह की समस्याओं के बारे में क्या पसंद है कि यह किसी भी प्रोग्रामर के लिए क्षमताओं की मांग करता है जैसे उपयोग पैटर्न पर विचार करना, आवश्यकताओं को सही ढंग से निर्धारित करना और कोने के मामलों के बारे में सोचना।
शतरंज स्थिति ट्रेनर से स्क्रीनशॉट के रूप में लिया गया शतरंज का स्थान ।