Greatest Common Divisor in Clojure

Question

Ho scritto il seguente codice per calcolare il più grande divisore comune di due numeri positivi. Ci sono alcune cose nel codice che non sono ottimali o abbastanza clojuriane, e in tal caso quale sarebbe il modo più cloujeriano di fare GCD?

(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

usando manipolazione sequenza di operazioni numeriche (senza trasduttori) è un po 'pesante e questo sarebbe un grande caso recur invece:

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

Questo risparmia certo sforzo/tempo che andrebbe in costruzione sequenze che vengono poi scartate. In questo caso crea una secuenza di due sequenze di numeri, trasforma quella sequenza in due insiemi, poi la distrugge in un unico insieme dal quale il valore più grande è la risposta.
Inoltre, in generale, quando si definiscono i vars che contengono funzioni utilizzare defn (abbreviazione di define function) aggiunge automaticamente delle cose carine che aiutano molto l'utensileria, come la visualizzazione di tipi di argomenti e così via.

Answer 2

Questo è quello che ho fatto, è un po 'più corto e non fa uso di ricorsione:

(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))))