क्लोजर: पहले सदिश को खोजने के लिए वेक्टरों के वेक्टर पर इटरेटिंग

Question

क्लोजर सीखने के लिए मैं थोड़ा टिक टैक पैर गेम पर काम कर रहा हूं। सापेक्ष आसानी से खेल के पहले भाग को पूरा करने के बाद, मैंने एक बुद्धिमान कंप्यूटर प्लेयर बनाने की कोशिश कर संघर्ष किया है।

परीक्षण मैं इस सहायता के लिए लिख रहा हूँ के लिए, मुझे लगता है कि कंप्यूटर मौके 9 उठाता है अगर यह कंप्यूटर की बारी है जाँच करना चाहते हैं और इस बोर्ड है:

एक्स | ओ | 3
4 | एक्स | ओ
7 | 8 | 9

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

(def board {1 "1" 2 "2" 3 "3" 4 "4" 5 "5" 6 "6" 7 "7" 8 "8" 9 "9"}) 

मैं कुछ विचार किया था इस समस्या को हल करने के बारे में।

(def winning-sets 
    [[(board 1) (board 2) (board 3)], 
    [(board 4) (board 5) (board 6)], 
    [(board 7) (board 8) (board 9)], 
    [(board 1) (board 4) (board 7)], 
    [(board 2) (board 5) (board 8)], 
    [(board 3) (board 6) (board 9)], 
    [(board 1) (board 5) (board 9)], 
    [(board 3) (board 5) (board 7)]]) 

प्रत्येक सेट से अधिक दोहराएं:: एक इस तरह जीतने सेट को परिभाषित करने के लिए था

(for [set winning-sets] 
    (filter #(= symbol %) set)) 

लेकिन वह नहीं सही प्रतीत होता है ... मैं नहीं जानता कि जहां मैं वहाँ से जाना होगा । समस्या मैं हल करने के लिए कोशिश कर रहा हूँ इस तरह वर्णित किया जा सकता:

कंप्यूटर को बताएँ 8 जीतने सेट पर देखने के लिए और एक सेट है कि अपने प्रतीकों और एक खुली जगह के दो खोजने के लिए।

मैं क्लोजर के लिए बिल्कुल नया हूं, इसलिए मुझे यकीन नहीं है कि मैं इस समस्या से संपर्क करने का सबसे अच्छा तरीका समझता हूं। मैं ClojureDocs देख रहा हूं (for और loop और case) पुनरावृत्त कार्यों की जांच कर रहा हूं, लेकिन यह काम करने में सक्षम नहीं हैं।

वर्तमान में वेक्टर फॉर्म में उन जीतने वाले सेटों को फिर से शुरू करने का सबसे अच्छा तरीका क्या होगा, और उस सेट को ढूंढें जिसमें दो विशिष्ट प्रतीक हैं और एक खुलता है? या जीतने वाले सेट को एक अलग डेटा संरचना में स्टोर करना सबसे अच्छा होगा?

नोट: मैंने this question पर प्रतिक्रियाएं पढ़ी हैं, लेकिन उन्हें मेरे लिए लागू करने में सक्षम नहीं हैं।

Answer 1

सबसे पहले, मैं बोर्ड की स्थिति के लिए इस संरचना का उपयोग करने की सलाह:

(def board [[1 1 0] 
      [0 0 0] 
      [1 0 1]]) 

कहाँ एक्स 1 है, हे -1 है और खाली कक्ष 0 है। मेरे उदाहरण में बोर्ड में केवल एक्स प्रतीक हैं (सरलीकृत करने के लिए)। अगला,

(def winning-sets 
    '([[0 0] [0 1] [0 2]] 
    [[1 0] [1 1] [1 2]] 
    [[2 0] [2 1] [2 2]] 
    [[0 0] [1 0] [2 0]] 
    [[0 1] [1 1] [2 1]] 
    [[0 2] [1 2] [2 2]] 
    [[0 0] [1 1] [2 2]] 
    [[0 2] [1 1] [2 0]])) 

यह निर्देशांक के "जीतने" सेट है। यदि आवश्यक हो तो आप इसकी गणना कर सकते हैं, लेकिन 3x3 के लिए यह सूची वास्तव में इतना बड़ी नहीं है।इस संदर्भ में, आप सवाल के लिए जवाब है

(defn check 
    [target combo] 
    (= (map #(count (filter (partial = %) combo)) [target 0]) '(2 1))) 

(defn extract 
    [coords] 
    (apply vector (map (fn [[f s]] ((board f) s)) coords))) 

(filter #(check 1 (extract %)) winning-sets) 

आप आरईपीएल में इस कोड को निष्पादित हैं, तो आप

user=> (filter #(check 1 (extract %)) winning-sets) 
([[0 0] [0 1] [0 2]] 
[[2 0] [2 1] [2 2]] 
[[0 0] [1 0] [2 0]] 
[[0 0] [1 1] [2 2]]) 

जो सही जवाब की तरह लग रहा (2 क्षैतिज लाइनों, 1 ऊर्ध्वाधर और 1 विकर्ण देखेंगे)। कोड मोटा है और इसे और अधिक सुंदर और पुन: प्रयोज्य बनाने के कुछ तरीके हैं। क्या मुझे समझाया जाना चाहिए कि क्या हो रहा है या कोड पर्याप्त स्पष्ट है?