प्रोजेक्ट यूलर # 14 और क्लोजर

Question

एक ज्ञापन क्लोजुरियन के रूप में ज्ञापन, यह recommended to me था कि मैं Project Euler समस्याओं को भाषा सीखने के तरीके के रूप में देखता हूं। यह आपके कौशल को बेहतर बनाने और आत्मविश्वास हासिल करने का एक शानदार तरीका है। मैंने अभी अपना जवाब problem #14 पर पूरा कर लिया है। यह ठीक काम करता है, लेकिन इसे कुशलतापूर्वक चलाने के लिए मुझे कुछ ज्ञापन लागू करना पड़ा। मैं अपने कोड को संरचित करने के तरीके के कारण प्रीपेक्स्ड memoize फ़ंक्शन का उपयोग नहीं कर सका, और मुझे लगता है कि यह मेरे स्वयं के किसी भी तरह से रोल करने का अच्छा अनुभव था। मेरा सवाल यह है कि अगर मेरे कैश को फ़ंक्शन के भीतर ही एन्सेप्लेट करने का कोई अच्छा तरीका है, या यदि मुझे बाहरी कैश को परिभाषित करना है जैसे मैंने किया है। इसके अलावा, मेरे कोड को अधिक बेवकूफ बनाने के लिए कोई सुझाव की सराहना की जाएगी।

(use 'clojure.test) 

(def mem (atom {})) 

(with-test 
    (defn chain-length  
    ([x] (chain-length x x 0))  
    ([start-val x c] 
     (if-let [e (last(find @mem x))] 
     (let [ret (+ c e)] 
      (swap! mem assoc start-val ret) 
      ret) 
     (if (<= x 1)    
      (let [ret (+ c 1)] 
      (swap! mem assoc start-val ret) 
      ret)     
      (if (even? x)    
      (recur start-val (/ x 2) (+ c 1)) 
      (recur start-val (+ 1 (* x 3)) (+ c 1))))))) 
    (is (= 10 (chain-length 13)))) 

(with-test 
    (defn longest-chain 
    ([] (longest-chain 2 0 0)) 
    ([c max start-num] 
     (if (>= c 1000000) 
     start-num 
     (let [l (chain-length c)] 
      (if (> l max) 
      (recur (+ 1 c) l c) 
      (recur (+ 1 c) max start-num)))))) 
    (is (= 837799 (longest-chain)))) 

Answer 1

के बाद से आप चाहते हैं कैश chain-length के सभी आमंत्रण के बीच साझा करने के लिए, आप chain-length(let [mem (atom {})] (defn chain-length ...)) के रूप में लिखते थे, ताकि इसमें केवल chain-length को दिखाई जाएगी।

इस मामले में, के बाद से सबसे लंबी चेन पर्याप्त छोटा है, तो आप अनुभवहीन पुनरावर्ती पद्धति का उपयोग करके chain-length को परिभाषित करने और उस पर Clojure के builtin memoize समारोह इस्तेमाल कर सकते हैं।

Answer 2

आप एक clojure में आसपास के वातावरण पर कब्जा कर सकते हैं:

(defn my-memoize [f] 
    (let [cache (atom {})] 
    (fn [x] 
     (let [cy (get @cache x)] 
     (if (nil? cy) 
      (let [fx (f x)] 
      (reset! cache (assoc @cache x fx)) fx) cy))))) 


(defn mul2 [x] (do (print "Hello") (* 2 x))) 
(def mmul2 (my-memoize mul2)) 
user=> (mmul2 2) 
Hello4 
user=> (mmul2 2) 
4 

तुम देखो mul2 funciton केवल एक बार कहा जाता है।

तो 'कैश' क्लोजर द्वारा कब्जा कर लिया गया है और मूल्यों को स्टोर करने के लिए उपयोग किया जा सकता है।

Answer 3

सादे पुराने memoize का उपयोग करके एक बेवकूफ (?) संस्करण है।

(def chain-length 
    (memoize 
     (fn [n] 
     (cond 
     (== n 1) 1 
     (even? n) (inc (chain-length (/ n 2))) 
     :else  (inc (chain-length (inc (* 3 n)))))))) 

(defn longest-chain [start end] 
    (reduce (fn [x y] 
      (if (> (second x) (second y)) x y)) 
      (for [n (range start (inc end))] 
      [n (chain-length n)]))) 

आप recur उपयोग करने के लिए आग्रह करता हूं है, पर विचार map या reduce पहले। वे अक्सर जो चाहते हैं वह करते हैं, और कभी-कभी इसे बेहतर/तेज़ करते हैं, क्योंकि वे चंकित सीक का लाभ उठाते हैं।

(inc x)(+ 1 x) जैसा है, लेकिन inc लगभग दोगुना तेज़ है।