Question

嗯，这就是事情：

我有以下Haskell代码，这一个：

[ (a, b, c) | c <- [1..10], b <- [1..10], a <- [1..10], a ^ 2 + b ^ 2 == c ^ 2 ]

将返回

[(4,3,5),(3,4,5),(8,6,10),(6,8,10)]

对于那些不熟悉这一点的人，我会解释：

它返回tuple（a，b，c），其中每个“定义”（a，b，c）都会收到一个列表（1到10），并且他的成员通过{进行比较{1}}表达式（每个成员）。

我如何在Python / Ruby中做同样的事情（如果可能的话，一行）？

P.S。：它们按字典顺序进行比较。

Answer 1

在Python中有一条长行并且没有导入。 Python的列表推导可以与多个变量一起使用：

>>> [ (a, b, c) for c in range(1, 11) for b in range(1, 11) for a in range(1, 11) if a*a + b*b == c*c ]
[(4, 3, 5), (3, 4, 5), (8, 6, 10), (6, 8, 10)]

Answer 2

Ruby解决方案：

(1..10).to_a.repeated_permutation(3).select { |a, b, c| a*a + b*b == c*c }
# => [[3, 4, 5], [4, 3, 5], [6, 8, 10], [8, 6, 10]]

Answer 3

Python解决方案，使用itertools.product，相当于生成器表达式中的嵌套for循环：

[(a,b,c) for c,b,a in product(range(1,11), repeat=3) if a*a + b*b == c*c]

Answer 4

Ruby替代方案，不强制使用相同的范围：

>> (1..10).to_a.product((1..10).to_a, (1..10).to_a).select { |a, b, c| a*a + b*b == c*c }
#=> [[3, 4, 5], [4, 3, 5], [6, 8, 10], [8, 6, 10]]

你可以说这不会返回预期的结果，那是因为你使用c-> b-> a来迭代但返回（a，b，c）。所以我害怕在Ruby中，没有列表推导，我们需要做这样的事情（map_select = map + compact）：

>> (1..10).to_a.product((1..10).to_a, (1..10).to_a).map { |c, b, a| [a, b, c] if a*a + b*b == c*c }.compact
 #=> [[4, 3, 5], [3, 4, 5], [8, 6, 10], [6, 8, 10]]

不是vanilla Ruby，但使用酷库lazylist可以写：

>> list { [a, b, c] }.where(:c => (1..10), :b => (1..10), :a => (1..10)) { a*a + b*b == c*c }.to_a
#=> [[4, 3, 5], [3, 4, 5], [8, 6, 10], [6, 8, 10]]

Answer 5

(for [a (range 1 11)
  b (range 1 11)
  c (range 1 11) :when (=
                        (+ (* a a) (* b b))
                        (* c c))]
  [a b c])

同样的clojure例子。

如何创建一个元组，其中每个成员都通过表达式进行比较？

5 个答案: