clojure中的除数函数

Question

我是clojure的新手，我想创建一个函数，它返回某个数的所有除数的向量。

例如：
[1 2 3] 6作为输入

(defn div [x seq] 
    (let [r (range 1 (+ (/ x 2) 1)) ] 
    (dotimes [i (count (range 1 (+ (/ x 2) 1)))]  
    (cond 
     (= (mod x (nth r i)) 0)(print (conj seq (nth r i))) 
    )))) 

该函数返回以下列格式的输出：
[1] [2] [4] [5] [ 10] [20] [25] [50]为100，但我想要在一个向量中获得输出。看起来，seq变量不断被每个循环覆盖。任何人都可以解释这种行为并为我提供解决方法吗？

提前感谢和问候

Answer 1

我觉得你的做法是不正确的，你可以去看看：

• 的loop功能来解决这类问题（我指的情况下，你需要遍历和屈服值），
• iterate功能
• 递归功能（即调用自身的函数）

而这种代码（使用“for”功能），可以轻松解决您的规格

(let [n 100] 
    (for [x (range 1 n) 
     :when (zero? (rem n x))] 
    x)) 
=>(1 2 4 5 10 20 25 50) 

Answer 2

你能避免使用一个较为惯用的解决方案循环：

(defn divisors 
    [n] 
    (filter (comp zero? (partial rem n)) (range 1 n))) 

Answer 3

你的根本问题是，你是试图采取一种必要的方法，但Clojure集合是不可改变的。此外，我认为dotimes将始终返回nil，print返回nil后打印其参数。

有一个更好的办法，但让我们先来看看我们如何能够利用atoms获得必要的解决方案：

(defn div [x seq] 
    (let [r (range 1 (+ (/ x 2) 1)) ] 
    (dotimes [i (count (range 1 (+ (/ x 2) 1)))]  
     (cond 
     ;; "Append" the ith element of r to seq 
     ;; (Technically, we are replacing the value stored in seq 
     ;; with a new list -- the result of conj-ing (nth r i) 
     ;; to the current value stored in seq) 
     (= (mod x (nth r i)) 0) (swap! seq conj (nth r i))))) ;; <= don't print 
    seq) ;; <== seq is what we're interested in, so we return it here. 
     ;;  Otherwise, we would return the result of dotimes, 
     ;;  which is nil 

请注意，我们已经消除了print并期望seq是一个原子（我们更新使用swap!）。现在，我们可以称之为div如下：

user> (deref (div 6 (atom []))) 
[1 2 3] 

我们可以通过从参数列表移动seq到let里面的函数，然后取消引用它，当我们回到改善这个。但首先避免突变会更好。作为tangrammer表示他的回答，这是使用for很容易实现：

(defn div [x] 
    (let [r (range 1 (+ (/ x 2) 1))] 
    ;; Loop over r, taking only elements that are divisors of x 
    (for [i r 
      :when (= (mod x i) 0)] 
     i))) ;; <= for accumulates the result of this expression (here simply i) into a sequence 

user> (div 6) 
(1 2 3) 

在生产代码中，你可能会内嵌在这种情况下r，但我想保留原始结构，尽可能地。我们也可以在:when条款中使用zero?。但是我们在for循环中所做的只是一个简单的过滤器，所以我们可以使用Guillermo's approach并使用filter来代替。

Answer 4

div取整数x和作为参数的序列seq：

• 它首先声明r范围1..(x/2);

• 它然后遍历用于i从0到(count r)，即从0到(x/2) - 1：

  • 每个i，它打印的(conj seq (nth r i))的结果，即(conj seq (+ i 1))结果。

    Clojure使用不可变的数据结构，这意味着(conj seq d)返回一个新的序列，包含所有seq的元素加上d;特别是，如果seq是空向量[]，则返回[d]。

最终结果：(div n [])打印[d]如果d划分x，对于每个d从1到(x/2)。

您的代码失败，因为您尝试以命令的方式编写Clojure代码;它不是标准的（也不推荐），但可以通过使用可变引用来实现。 atoms（见@NathanDavis 's answer）或transient（可变）的数据结构：

(defn div [n] 
    (let [coll (transient [])] 
    (dotimes [i (quot n 2)] 
     (let [d (inc i)] 
     (when (zero? (rem n d)) 
      (conj! coll d)))) 
    (persistent! coll))) 

一种惯用的解决方案将使用for（如@tangrammer suggested）;它不是一个环结构（如Java中），但它返回一个懒惰的序列宏：

(defn div [n] 
    (for [:let [from 1     ;; :let bindings are great for 
       upto (inc (quot n 2)) ;; readability 
       divides? #(zero? 
         (rem % %2))] 

     d (range from upto)   ;; This binding form translates to 
             ;; "each d from 1 to x/2". 
             ;; You can have several binding forms 
             ;; in a single for, to iterate over 
             ;; several variables. 

     :when (divides? n d)]   ;; Selects d only if it divides n. 
             ;; You can also define termination 
             ;; conditions with :while. 

    d))        ;; Each valid d is appended to a growing 
             ;; lazy sequence i.e. a sequence that is 
             ;; constructed the first time it is 
             ;; traversed. 

一个for形式没有身体说话的感觉有点虐待（尽管顺眼，恕我直言）;另一种方法是在@GuillermoWinkler 's answer中显示过滤器：

(defn divisors 
    [n] 
    (->> (range 1 (inc (quot n 2)))  ;; the threading macros ->, ->> and .. are 
     (filter #(zero? (rem n %))))) ;; great to write sequence-manipulation 
             ;; code as a sequence of step, though 
             ;; maybe overkill in the present case