क्लोजर

Question

में सबसे बड़ा आम विभाजक मैंने दो सकारात्मक संख्याओं के सबसे महान आम विभाजक की गणना के लिए निम्नलिखित कोड लिखा है। क्या कोड में कुछ मामले हैं जो इष्टतम या क्लोजुरियन पर्याप्त नहीं हैं, और यदि ऐसा है तो जीसीडी करने का अधिक क्लोज़रियन तरीका क्या होगा?

(def gcd (fn [a b] (->> (map (fn [x] 
           (filter #(zero? (mod x %)) (range 1 (inc x)))) 
         [a b]) 
         (map set) 
         (apply clojure.set/intersection) 
         (apply max)))) 

(gcd 1023 858)` => 33 

Answer 1

सांख्यिक परिचालन (ट्रांसड्यूसर के बिना) के लिए अनुक्रम हेरफेर का उपयोग कर एक सा हैवीवेट है और यह बजाय recur के लिए एक महान मामला होगा:

user> (defn gcd [a b] 
     (if (zero? b) 
      a 
      (recur b (mod a b)))) 
#'user/gcd 
user> (gcd 1023 858) 
33 

यह कुछ प्रयास/समय है कि इमारत में जाना होगा की बचत होती है अनुक्रम जिन्हें तब छोड़ दिया जाता है। इस मामले में यह संख्याओं के दो अनुक्रमों की एक सिक्योरेंस बनाता है, जो कि दो सेटों के अनुक्रम में बदल जाता है, फिर उसे एक सेट में गिरा देता है जिससे सबसे बड़ा मूल्य उत्तर होता है।
इसके अलावा, सामान्य रूप से, जब कार्य युक्त वर्रों को परिभाषित करते हैं तो defn (फ़ंक्शन परिभाषित करने के लिए छोटा) का उपयोग करते हैं, यह अच्छी चीजों को स्वचालित रूप से जोड़ता है जो टूलिंग को बहुत मदद करता है, जैसे कि तर्क प्रकार और ऐसे प्रदर्शित करना।

Answer 2

यह मैं क्या किया है, यह थोड़ा छोटा है और यह प्रत्यावर्तन का उपयोग नहीं करता:

(defn gcd 
    [a b] 
    (last 
    (filter 
     #(and (zero? (mod b %)) (zero? (mod a %))) 
     (range 1 (inc (min a b))) 
    ) 
    ) 
) 

Answer 3

(loop [a (map #(Integer/parseInt %) (clojure.string/split (read-line) #" "))] 
    (cond 
     (reduce > a) (recur (list (reduce - a) (last a))) 
     (reduce < a) (recur (list (- (reduce - a)) (first a))) 
     (reduce = a) (println (first a))))