मुझे क्लोजर में शतरंज बिटबोर्ड का प्रतिनिधित्व कैसे करना चाहिए?

Question

क्लोजर (/ जावा) में शतरंज बिटबोर्ड का प्रतिनिधित्व करने के कुछ संभावित तरीके क्या हैं?

http://pages.cs.wisc.edu/~psilord/blog/data/chess-pages/rep.html

मैं अलग-अलग बिट्स तक पहुँचने के लिए है और यह भी बिटवाइज़ कार्रवाई करने में सक्षम होना चाहिए।

मैंने java.lang.Long का उपयोग करने के बारे में सोचा लेकिन यह संकेत के कारण 1x10^63 के साथ समस्याएं पैदा करता है। मुझे यह भी यकीन नहीं है कि मैं एक विशिष्ट अनुक्रमणिका में बिट्स का उपयोग कैसे करूं?

मैंने बिटसेट पर भी देखा, लेकिन मुझे आदर्श लंबाई की आवश्यकता है।

Answer 1

कोई कारण नहीं है कि आप सीधे लंबे समय तक उपयोग नहीं कर सकते। समस्या, जैसा कि आपने नोट किया है, यह है कि जावा (और इसलिए क्लोजर) लंबे समय तक हस्ताक्षरित है, सकारात्मक संख्याओं के लिए केवल 63 बिट्स को

जावा, डिफ़ॉल्ट रूप से, त्रुटि के बिना अंकगणित अतिप्रवाह की अनुमति देता है। क्लोजर, डिफ़ॉल्ट रूप से, त्रुटि के बिना अंकगणित ओवरफ़्लो की अनुमति नहीं देता है (*unchecked-math* ध्वज देखें)। यह अंकगणितीय परिचालनों और कास्ट के आसपास अतिरिक्त जांच जोड़ता है, उदाहरण के लिए, (byte 128) अपवाद का कारण बनता है। clojure v1.3.0 के बाद से वहाँ (unchecked-byte) जो जावा कार्यक्षमता के बराबर है जैसे कार्यों ....

(unchecked-byte 128) 
;=> -128 ; 2s-complement of 10000000 
(unchecked-byte 2r10000001) 
;=> -127 ; 2s-complement of 10000001 

unchecked-* उपलब्ध परिचालन (see clojuredocs) की एक पूरी बेड़ा रहे हैं कर रहे हैं।

यदि आप सीधे लंबे और unchecked-* संचालन का उपयोग करते हैं तो आप अधिकतर वहां होते हैं, और फिर आप बिट्स/चेक बिट्स के लिए bit-* संचालन का उपयोग कर सकते हैं।

अंत में एक परमाणु में अपनी बिसात भंडारण समझ में आता है, और आप तो (swap! chessboard fn args)

(थोड़ा अधिक मुहावरेदार स्वैप के साथ अद्यतन 15/02/13! कॉल) के साथ अपडेट

उदा

(inc Long/MAX_VALUE) ; java.lang.ArithmeticException 

(unchecked-inc Long/MAX_VALUE) ; wraps. 
-9223372036854775808 

(def chessboard (atom 0)) 
@chessboard 
;=> 0 
(bit-test @chessboard 1) 
;=> false 
(swap! chessboard bit-flip 1) 
;=> 2 
(bit-test @chessboard 1) 
;=> true 
@chessboard 
;=> 2 
(reset! chessboard 0) 
;=> 0 
(swap! chessboard bit-flip 63) 
;=> -9223372036854775808 
(bit-test @chessboard 63) 
;=> true 

Answer 2

=> (def chessboard (byte-array 8)) 
#'user/chessboard 

=> (vec chessboard) 
[0 0 0 0 0 0 0 0] 

=> (for [row (range 8)] (aset-byte chessboard row (rand-int 8))) 
(3 0 6 6 2 3 6 7) 

=> (bigint chessboard) 
216179404987106823N 

=> (defn bigint-to-array 
[bi] 
(.toByteArray (biginteger bi))) 

=> (vec (bigint-to-array 216179404987106823N)) 
[3 0 6 6 2 3 6 7] 

क्लोजर आपको इस तरह की अधिकांश कार्यों का समर्थन करता है। सभी क्लोजर संख्याओं की तरह, clojure.lang.BigInt द्विआधारी संचालन (बिट-और आदि) का समर्थन करता है। बाइट-सरणी पर आप java.util.Arrays (खोज, भरें, क्रमबद्ध) से सभी विधियों का उपयोग कर सकते हैं।

ध्यान रखें कि bigint fn clojure.lang.BigInt को coerces, और biginteger fn corces java.math.BigInteger को coerces। यदि आप java.math.BigInteger के तरीकों का उपयोग करना चाहते हैं, तो आपको Biginteger के माध्यम से अपने बिगिन या बाइट-सर को कॉरर्स करना होगा।