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的情况。出于您的目的，您可以将其视为迭代，但它确实在进行list comprehension。

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

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

Clojure：列表中的复杂迭代？

2 个答案: