Clojure：在列表中进行复杂迭代？

Question

我想拿一个数字，20，和一个列表。 '(1 2 3 4 5 6 7 8 9 10)，并返回包含原始列表中每个值的两个值的集合：原始值与将该值潜入20时的余数成对。如果原始值以某种方式键入余数，这将很好，这样我就可以轻松地检索出产生特定余数的每个数字。基本上我想要一些功能func：

user=> (func 20 '(1 2 3 4 5 6 7 8 9 10)) 
'(:0 1, :0 2, :2 3,... :20 0) 

不过，我有一个非常困难的时期刚刚搞清楚如何遍历列表。有人可以帮助我理解如何独立使用列表元素，然后如何返回20除以的元素，并返回余数？

我的想法是在计算平方根的程序中使用类似的东西。如果数字是由剩余键，然后我可以查询集合来获取与0

---

这里是我的打算有关初步的方式其余将输入所有数字。

;; My idea on the best way to find a square root is simple. 
;; If I want to find the square root of n, divide n in half 
;; Then divide our initial number (n) by all numbers in the range 0...n/2 
;; Separate out a list of results that only only return a remainder of 0. 
;; Then test the results in a comparison to see if the elements of our returned 
;; list when squared are equal with the number we want to find a square root of. 
;; First I'll develop a function that works with evens and then odds 

(defn sqroot-range-high-end [input] (/ input 2)) 
(sqroot-range-high-end 36) ; 18 

(defn make-sqrt-range [input] (range (sqroot-range-high-end (+ 1 input)))) 
(make-sqrt-range 36) ; '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18) 

(defn zero-culler [input] (lazy-seq (remove zero? (make-sqrt-range input)))) 
(zero-culler 100) ; '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18) 

(defn odd-culler [input] (lazy-seq (remove odd? (zero-culler input)))) 
(odd-culler 100) ; '(2 4 6 8 10 12 14 16 18) 

;;the following is where I got stuck 
;;I'm new to clojure and programming, 
;;and am just trying to learn in a way that I understand 

(defn remainder-culler [input] 
    (if 
    (/ input (first odd-culler (input))) 
    input) 
    (recur (lazy-seq (input))) 
) 

(remainder-culler 100) 

Answer 1

欢迎的Clojure ！

快速注意：[1 2 3 4 5 6 7 8 9 10]是一个向量，而不是一个列表。

当你说“键入到”，然后让我觉得你正在寻找的东西，它返回一个地图。

地图

这是Clojure's cheatsheet进来非常方便。你正试图从一个函数创建一个映射。地图是一种集合，所以如果您转到备忘单上的“集合”部分，并向下滚动到地图，您将看到许多类别。你想创建一个，所以看看这个列表，并探索链接到Clojure的文档。

这将导致你到非常方便group-by功能。您给它一个函数和一个集合，并且它返回一个包含该集合中所有项目的映射，并将f值应用到每个值的结果中。

> (group-by #(rem 20 %) [1 2 3 4 5 6 7 8 9 10]) 
{0 [1 2 4 5 10], 2 [3 6 9], 6 [7], 4 [8]} 

如果你想的按键的实际关键字，你就必须修改匿名函数来回馈关键字：

> (group-by #(keyword (str (rem 20 %))) [1 2 3 4 5 6 7 8 9 10]) 
{:0 [1 2 4 5 10], :2 [3 6 9], :6 [7], :4 [8]} 

注意，返回值是向量。这是因为您无法映射到单个键上的两个项目（即映射编码函数）。

迭代/列表综合

现在，这一切说，我不知道这是你在找什么。你问，“有人能帮助我理解如何独立使用列表元素，然后如何返回20被分割的元素，并返回剩余的元素？”这听起来像是我的情况for。你的目的，你可以把它作为迭代，但它真的做listcomprehension。

(for [i [1 2 3 4 5 6 7 8 9 10]] 
    (list (rem 20 i) i)) 

再次，如果你真的想使用的关键字，而不是值，那么你可以做：

(for [i [1 2 3 4 5 6 7 8 9 10]] 
    (list (keyword (str (rem 20 i))) i)) 

在这种特殊情况下，如凯尔指出，你可能只是用地图：

(map #(list (keyword (str (rem 20 %))) 
      %) 
    [1 2 3 4 5 6 7 8 9 10]) 

如果你不喜欢这些返回的嵌套结构，你可以使用它们的flatten。

过滤

但我还是不知道你想要使用此方法解决你的问题。在你的评论中，你有“分离结果列表，只返回0的余数。”这听起来像是对我来说filter，作为副作用是懒惰的情况。

> (filter #(zero? (rem 20 %)) [1 2 3 4 5 6 7 8 9 10]) 
(1 2 4 5 10) 

Ta-da。它只是吐出满足您需求的原始集合的元素。

希望这会有所帮助。它并没有让你一路走向你的目标，但我希望它能为你提供一些可以用来达到目的的简洁工具。你有选择！在你学习的同时，玩弄多种选择。如果你读到某个地方比另一个更可取的地方，看看你是否能找出原因。

Answer 2

(map #(vector (rem 20 %) %) (range 1 21)) 
;; => ([0 1] [0 2] [2 3] ... [1 19] [0 20]) 

不过，我有一个非常困难的时期刚刚搞清楚如何通过列表

要重复迭代，使用高阶函数类似clojure.core/map

返回20除以的元素，如果它返回余数

你想返回2件事情。提供给clojure.core/map的fn可以通过返回两个元素的向量来完成此操作。

为了确定其余的，使用rem

键入到其余则返回

因为可能有多个操作返回相同的部分，我们不能创建一个映射（{}）和使用剩下的作为一个关键 - 会有碰撞。

clojure.core/range用于创建分母的集合。

要不太明确，使用clojure.core/juxt，下面的完成相同：

(map (juxt (partial rem 20) identity) (range 1 21)) 

最后，参数化这件事，并返回一个懒惰的序列：

(defn rem-denominator 
    [n] 
    (map (juxt (partial rem n) identity) 
     (iterate inc 1))) 

(take 5 (rem-denominator 20)) 
;; => ([0 1] [0 2] [2 3] [0 4] [0 5]) 
(take 20 (rem-denominator 20)) 
;; => ([0 1] [0 2] [2 3] ... [1 19] [0 20])