blocks|key|3144755|text|Sry，距离我做haskell已经有一段时间了，所以我将用文字来描述它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144756|正如我在评论中指出的那样。在无限列表中找不到最小的任何东西是不可能的，因为总会有更小的。|3144757|你可以做的是，有一个基于流的方法，它获取列表并返回一个只有“有效”元素的列表，即满足条件的地方。让我们调用此函数triangle|offset|length|style|CODE|3144758|然后，您可以使用take+n+(triangle+...)在某种程度上计算三角形列表，并且可以从这个n元素中找到最小值。|3144759|entityMap^0|0|0|1K|8|0|8|L|1E|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$F|T|G|U|H|I]|$F|V|G|W|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|M|$]]

Sry, it's quite a while since I did haskell, so I'm going to describe it with words.

As I pointed out in my comment. It is not possible to find the smallest anything in an infinite list, since there could always be a smaller one.

What you can do is, have a stream based approach that takes the lists and returns a list with only 'valid' elements, i. e. where the condition is met. Lets call this function <code>triangle</code>

You can then compute the triangle list to some extent with <code>take n (triangle ...)</code> and from this <code>n</code> elements you can find the minium.

blocks|key|828734|text|对于这个答案，我将使用“最小”来表示元组中数字的总和。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828735|要按顺序列出所有可能的对，可以先列出和为2的所有对，然后列出和为3的所有对，依此类推。在代码中|828736|pairsWithSum+n+=+[(i,+n-i)+%7C+i+<-+[1..n-1]]
xs+=+concatMap+pairsWithSum+[2..]|code-block|syntax|javascript|828737|Haskell没有在不使用模板Haskell的情况下处理n-tuple的工具，因此为了推广这一点，您必须切换到列表。|828738|ntuplesWithSum+1+s+=+[[s]]
ntuplesWithSum+n+s+=+concatMap+(\i+->+map+(i:)+(ntuplesWithSum+(n-1)+(s-i)))+[1..s-n%2B1]
nums+n+=+concatMap+(ntuplesWithSum+n)+[n..]|828739|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

For this answer I will take "smallest" to refer to the sum of the numbers in the tuple.

To list all possible pairs in order, you can first list all of the pairs with a sum of 2, then all pairs with a sum of 3 and so on. In code

<pre><code>pairsWithSum n = [(i, n-i) | i &lt;- [1..n-1]]
xs = concatMap pairsWithSum [2..]
</code></pre>

Haskell doesn't have facilities for dealing with n-tuples without using Template Haskell, so to generalize this you will have to switch to lists.

<pre><code>ntuplesWithSum 1 s = [[s]]
ntuplesWithSum n s = concatMap (\i -&gt; map (i:) (ntuplesWithSum (n-1) (s-i))) [1..s-n+1]
nums n = concatMap (ntuplesWithSum n) [n..]
</code></pre>

blocks|key|4611978|text|{-这取决于什么是“最小”。但是这里有一个“最小”概念的解决方案，如果首先比较元组的最大值。数字，然后是它们的总和。(当我在注释中写入文本时，您可以将我的整个答案复制并粘贴到文件中。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4611979|我们稍后将需要nub。-}|offset|length|style|CODE|4611980|import+Data.List+(nub)|code-block|syntax|javascript|4611981|{-仅供说明:具有2元组的简单情况。-}|4611982|--+all+the+two-tuples+where+'snd'+is+'n'
tuples+n+=+[(i,+n)+%7C+i+<-+[1..n]]
--+all+the+two-tuples+where+'snd'+is+in+'1..n'
tuplesUpTo+n+=+concat+[tuples+i+%7C+i+<-+[1..n]]|4611983|{-要获得所有结果，您需要将每个元组的翻转插入到流中。但让我们稍后再做，并首先进行推广。|4611984|构建任意长度的元组有些困难，所以我们将使用列表。如果它们的长度是'k‘，我称它们为’kList‘。-}|4611985|--+just+copied+from+the+tuples+case,+only+we+need+a+base+case+for+k=1+and+
--+we+can+combine+all+results+utilizing+the+list+monad.
kLists+1+n+=+[[n]]
kLists+k+n+=+do+
+++++++rest+<-+kLists+(k-1)+n
+++++++add+<-+[1..head+rest]
+++++++return+(add:rest)

--+same+as+above.+all+the+klists+with+length+k+and+max+number+of+n
kListsUpTo+k+n+=+concat+[kLists+k+i+%7C+i+<-+[1..n]]

--+we+can+do+that+unbounded+as+well,+creating+an+infinite+list.
kListsInf+k+=+concat+[kLists+k+i+%7C+i+<-+[1..]]|4611986|{-下一步是循环这些列表，因为到目前为止，最大的数字总是在最后。所以我们只看所有的旋转来得到所有的结果。无可否认，在这里使用nub很笨拙，您可以改进这一点。但是如果没有它，所有元素都相同的列表就会重复k次。-}|4611987|rotate+n+l+=+let+(init,+end)+=+splitAt+n+l+
+++++++++++++in+end+%2B%2B+init
rotations+k+l+=+nub+[rotate+i+l+%7C+i+<-+[0..k-1]]

rotatedKListsInf+k+=+concatMap+(rotations+k)+$+kListsInf+k|4611988|{-剩下的就是将这些列表转换成元组。这有点尴尬，因为每个n元组都是一个单独的类型。当然，这很简单。-}|4611989|kListToTuple2+[x,y]+++++++++=+(x,y)
kListToTuple3+[x,y,z]+++++++=+(x,y,z)
kListToTuple4+[x,y,z,t]+++++=+(x,y,z,t)
kListToTuple5+[x,y,z,t,u]+++=+(x,y,z,t,u)
kListToTuple6+[x,y,z,t,u,v]+=+(x,y,z,t,u,v)|4611990|{-一些测试：|4611991|*Main>+take+30+.+map+kListToTuple2+$+rotatedKListsInf+2
[(1,1),(1,2),(2,1),(2,2),(1,3),(3,1),(2,3),(3,2),(3,3),(1,4),(4,1),(2,4),(4,2),(3,4),
(4,3),(4,4),(1,5),(5,1),(2,5),(5,2),(3,5),(5,3),(4,5),(5,4),(5,5),(1,6),(6,1),
(2,6),+(6,2),+(3,6)]
*Main>+take+30+.+map+kListToTuple3+$+rotatedKListsInf+3
[(1,1,1),(1,1,2),(1,2,1),(2,1,1),(1,2,2),(2,2,1),(2,1,2),(2,2,2),(1,1,3),(1,3,1),
(3,1,1),(1,2,3),(2,3,1),(3,1,2),(2,2,3),(2,3,2),(3,2,2),(1,3,3),(3,3,1),(3,1,3),
(2,3,3),(3,3,2),(3,2,3),(3,3,3),(1,1,4),(1,4,1),(4,1,1),(1,2,4),(2,4,1),(4,1,2)]|4611992|编辑：我意识到有一个bug:当然，仅仅旋转有序列表是不够的。解决方案必须是这样的：|BOLD|4611993|rest+<-+concat+.+map+(rotations+(k-1))+$+kLists+(k-1)+n|4611994|在kLists中，但随后会出现一些重复输出的问题。我想你可以弄明白这一点。;-)+-}|4611995|entityMap^0|0|7|3|0|0|0|0|0|0|0|1Q|3|2S|1|0|0|0|0|0|0|0|3|0|0|1|6|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1I|8|@$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1L|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1M|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1N|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1O|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1P|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|1Q|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|J|7|1W|8|@]|9|@]|A|$K|L]]|$1|10|3|11|5|6|7|1X|8|@]|9|@]|A|$]]|$1|12|3|13|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|14|3|15|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|16|3|17|5|J|7|20|8|@]|9|@]|A|$K|L]]|$1|18|3|19|5|6|7|21|8|@$D|22|E|23|F|1A]]|9|@]|A|$]]|$1|1B|3|1C|5|J|7|24|8|@]|9|@]|A|$K|L]]|$1|1D|3|1E|5|6|7|25|8|@$D|26|E|27|F|G]]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|1G|$]]

{- It depends on what is "smallest". But here is a solution for a concept of "smallest" if tuples were compared first by their max. number and then by their total sum. (You can just copy and paste my whole answer into a file as I write the text in comments.)

We will need <code>nub</code> later. -}

<pre><code>import Data.List (nub)
</code></pre>

{- Just for illustration: the easy case with 2-tuples. -}

<pre><code>-- all the two-tuples where 'snd' is 'n'
tuples n = [(i, n) | i &lt;- [1..n]]
-- all the two-tuples where 'snd' is in '1..n'
tuplesUpTo n = concat [tuples i | i &lt;- [1..n]]
</code></pre>

{- 
To get all results, you will need to insert the flip of each tuple into the stream. But let's do that later and generalize first. 

Building tuples of arbitrary length is somewhat difficult, so we will work on lists. I call them 'kList's, if they have a length 'k'.
-}

<pre><code>-- just copied from the tuples case, only we need a base case for k=1 and 
-- we can combine all results utilizing the list monad.
kLists 1 n = [[n]]
kLists k n = do 
 rest &lt;- kLists (k-1) n
 add &lt;- [1..head rest]
 return (add:rest)

-- same as above. all the klists with length k and max number of n
kListsUpTo k n = concat [kLists k i | i &lt;- [1..n]]

-- we can do that unbounded as well, creating an infinite list.
kListsInf k = concat [kLists k i | i &lt;- [1..]]
</code></pre>

{-
The next step is rotating these lists around, because until now the largest number is always in the last place. So we just look at all rotations to get all the results. Using <code>nub</code> here is admittedly awkward, you can improve that. But without it, lists where all elements are the same are repeated <code>k</code> times.
-}

<pre><code>rotate n l = let (init, end) = splitAt n l 
 in end ++ init
rotations k l = nub [rotate i l | i &lt;- [0..k-1]]

rotatedKListsInf k = concatMap (rotations k) $ kListsInf k
</code></pre>

{- What remains is to convert these lists into tuples. This is a bit awkward, because every n-tuple is a separate type. But it's straightforward, of course. -}

<pre><code>kListToTuple2 [x,y] = (x,y)
kListToTuple3 [x,y,z] = (x,y,z)
kListToTuple4 [x,y,z,t] = (x,y,z,t)
kListToTuple5 [x,y,z,t,u] = (x,y,z,t,u)
kListToTuple6 [x,y,z,t,u,v] = (x,y,z,t,u,v)
</code></pre>

{- Some tests:

<pre><code>*Main&gt; take 30 . map kListToTuple2 $ rotatedKListsInf 2
[(1,1),(1,2),(2,1),(2,2),(1,3),(3,1),(2,3),(3,2),(3,3),(1,4),(4,1),(2,4),(4,2),(3,4),
(4,3),(4,4),(1,5),(5,1),(2,5),(5,2),(3,5),(5,3),(4,5),(5,4),(5,5),(1,6),(6,1),
(2,6), (6,2), (3,6)]
*Main&gt; take 30 . map kListToTuple3 $ rotatedKListsInf 3
[(1,1,1),(1,1,2),(1,2,1),(2,1,1),(1,2,2),(2,2,1),(2,1,2),(2,2,2),(1,1,3),(1,3,1),
(3,1,1),(1,2,3),(2,3,1),(3,1,2),(2,2,3),(2,3,2),(3,2,2),(1,3,3),(3,3,1),(3,1,3),
(2,3,3),(3,3,2),(3,2,3),(3,3,3),(1,1,4),(1,4,1),(4,1,1),(1,2,4),(2,4,1),(4,1,2)]
</code></pre>

Edit:
I realized there is a bug: Just rotating the ordered lists isn't enough of course. The solution must be somewhere along the lines of having 

<pre><code>rest &lt;- concat . map (rotations (k-1)) $ kLists (k-1) n
</code></pre>

in <code>kLists</code>, but then some issues with repeated outputs arise. You can figure that out, I guess. ;-)
 -}

blocks|key|828784|text|这是另一个解决方案，可能还有另一个略有不同的“最小”概念。我的顺序是“所有具有最大元素N的元组排在所有具有最大元素N%2B1的元组之前”。我写了成对和三元组的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828785|gen2_step+::+Int+->+[(Int,+Int)]
gen2_step+s+=+[(x,+y)+%7C+x+<-+[1..s],+y+<-+[1..s],+(x+==+s+%7C%7C+y+==+s)]

gen2+::+Int+->+[(Int,+Int)]
gen2+n+=+concatMap+gen2_step+[1..n]

gen2inf+::+[(Int,+Int)]
gen2inf+=+concatMap+gen2_step+[1..]

gen3_step+::+Int+->+[(Int,+Int,+Int)]
gen3_step+s+=+[(x,+y,+z)+%7C+x+<-+[1..s],+y+<-+[1..s],+z+<-+[1..s],+(x+==+s+%7C%7C+y+==+s+%7C%7C+z+==+s)]

gen3+::+Int+->+[(Int,+Int,+Int)]
gen3+n+=+concatMap+gen3_step+[1..n]

gen3inf+::+[(Int,+Int,+Int)]
gen3inf+=+concatMap+gen3_step+[1..]|code-block|syntax|javascript|828786|你不能真的将它推广到N元组，尽管只要你保持同构，如果你使用数组，你也许能够推广它。但我不想把我的大脑绑在那个结里。|828787|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's another solution, with probably another slightly different idea of "smallest". My order is just "all tuples with max element N come before all tuples with max element N+1". I wrote the versions for pairs and triples:

<pre><code>gen2_step :: Int -&gt; [(Int, Int)]
gen2_step s = [(x, y) | x &lt;- [1..s], y &lt;- [1..s], (x == s || y == s)]

gen2 :: Int -&gt; [(Int, Int)]
gen2 n = concatMap gen2_step [1..n]

gen2inf :: [(Int, Int)]
gen2inf = concatMap gen2_step [1..]

gen3_step :: Int -&gt; [(Int, Int, Int)]
gen3_step s = [(x, y, z) | x &lt;- [1..s], y &lt;- [1..s], z &lt;- [1..s], (x == s || y == s || z == s)]

gen3 :: Int -&gt; [(Int, Int, Int)]
gen3 n = concatMap gen3_step [1..n]

gen3inf :: [(Int, Int, Int)]
gen3inf = concatMap gen3_step [1..]
</code></pre>

You can't really generalize it to N-tuples, though as long as you stay homogeneous, you may be able to generalize it if you use arrays. But I don't want to tie my brain into that knot.

blocks|key|4612078|text|列表理解是解决这类问题的很好(而且简明)的方法。首先，你知道你想要所有可能满足a%5E2+%2B+b%5E2+=+c%5E2的(a,b,c)组合-一个有用的观察是(只考虑正数)+a+<=+c+&&+b+<=+c总是这样的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4612079|因此，为了生成我们的候选列表，我们可以说c的范围从1到无穷大，而a和b的范围从1到c。|4612080|[(a,b,c)+%7C+c+<-+[1..],+a+<-+[1..c],+b+<-+[1..c]]|code-block|syntax|javascript|4612081|为了得到解决方案，我们只需要添加您想要的方程式作为保护：|4612082|[(a,b,c)+%7C+c+<-+[1..],+a+<-+[1..c],+b+<-+[1..c],+a*a%2Bb*b+==+c*c]|4612083|这很低效，但输出是正确的：|4612084|[(3,4,5),(4,3,5),(6,8,10),(8,6,10),(5,12,13),(12,5,13),(9,12,15)...|4612085|有比盲测试更有原则的方法可以解决这个问题。|4612086|entityMap^0|13|F|1J|7|29|G|0|K|1|P|1|W|1|Y|1|15|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1L|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|X|$]]

List comprehensions are great (and concise) ways to solve such problems. First, you know you want all combinations of <code>(a,b,c)</code> that might satisfy <code>a^2 + b^2 = c^2</code> - a helpful observation is that (considering only positive numbers) it will always be the case that <code>a &lt;= c &amp;&amp; b &lt;= c</code>.

To generate our list of candidates we can thus say <code>c</code> ranges from <code>1</code> to infinity while <code>a</code> and <code>b</code> range from one to <code>c</code>.

<pre><code>[(a,b,c) | c &lt;- [1..], a &lt;- [1..c], b &lt;- [1..c]]
</code></pre>

To get to the solution we just need to add your desired equation as a guard:

<pre><code>[(a,b,c) | c &lt;- [1..], a &lt;- [1..c], b &lt;- [1..c], a*a+b*b == c*c]
</code></pre>

This is inefficient, but the output is correct:

<pre><code>[(3,4,5),(4,3,5),(6,8,10),(8,6,10),(5,12,13),(12,5,13),(9,12,15)...
</code></pre>

There are more principled methods than blind testing that can solve this problem.

blocks|key|3144886|text|有一个monad可以做到这一点Omega|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3144887|Prelude>+let+as+=+each+[1..]
Prelude>+let+x+=+liftA3+(,,)+as+as+as
Prelude>+let+x'+=+mfilter+(\(a,b,c)+->+a*a+%2B+b*b+==+c*c)+x
Prelude>+take+10+$+runOmega+x'
[(3,4,5),(4,3,5),(6,8,10),(8,6,10),(5,12,13),(12,5,13),(9,12,15),(12,9,15),(8,15,17),(15,8,17)]|code-block|syntax|javascript|3144888|使用它的应用特性，您可以将其泛化为任意元组：|3144889|quadrupels+=+(,,,)+<$>+as+<*>+as+<*>+as+<*>+as+++--+or+call+it+liftA4|3144890|但：当然，这本身并不能消除重复。它只会给你适当的对角化。也许您可以将monad+comprehensions与类似Thomas的方法一起使用，或者只是使用另一个mfilter通道(在本例中，仅限于b+/=+c+)。|style|BOLD|CODE|3144891|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/packages/archive/control-monad-omega/0.3/doc/html/Control-Monad-Omega.html|1|http://www.haskell.org/ghc/docs/7.2.1/html/users_guide/syntax-extns.html#monad-comprehensions^0|F|5|0|0|0|0|0|0|1|28|7|2Q|6|Y|K|1|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|18|8|@$A|19|B|1A|O|P]|$A|1B|B|1C|O|Q]|$A|1D|B|1E|O|Q]]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|R|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]|Z|$5|U|V|W|C|$X|10]]]]

There's a monad for that, <a href="http://hackage.haskell.org/packages/archive/control-monad-omega/0.3/doc/html/Control-Monad-Omega.html">Omega</a>.

<pre><code>Prelude&gt; let as = each [1..]
Prelude&gt; let x = liftA3 (,,) as as as
Prelude&gt; let x' = mfilter (\(a,b,c) -&gt; a*a + b*b == c*c) x
Prelude&gt; take 10 $ runOmega x'
[(3,4,5),(4,3,5),(6,8,10),(8,6,10),(5,12,13),(12,5,13),(9,12,15),(12,9,15),(8,15,17),(15,8,17)]
</code></pre>

Using it's applicative features, you can generalize to arbitrary tuples:

<pre><code>quadrupels = (,,,) &lt;$&gt; as &lt;*&gt; as &lt;*&gt; as &lt;*&gt; as -- or call it liftA4
</code></pre>

But: this alone does not eliminate duplication, of course. It only gives you proper diagonalization. Maybe you could use <a href="http://www.haskell.org/ghc/docs/7.2.1/html/users_guide/syntax-extns.html#monad-comprehensions">monad comprehensions</a> together with an approach like Thomas's, or just another <code>mfilter</code> pass (restricting to <code>b /= c</code>, in this case).

blocks|key|1010040|text|此答案适用于未知谓词的更一般问题。如果谓词是已知的，则可能有更有效的解决方案，就像其他人列出的基于知识的解决方案一样，您不需要迭代给定c的所有Int。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1010041|在处理无限列表时，需要执行广度优先搜索。列表理解只提供深度优先搜索，这就是为什么在原始代码中永远得不到解决方案的原因。|1010042|counters+0+xs+=+[[]]
counters+n+xs+=+concat+$+foldr+f+[]+gens+where
++gens+=+[[x:t+%7C+t+<-+counters+(n-1)+xs]+%7C+x+<-+xs]
++f+ys+n+=+cat+ys+([]:n)
++cat+(y:ys)+(x:xs)+=+(y:x):+cat+ys+xs
++cat+[]+xs+=+xs
++cat+xs+[]+=+[xs]

main+=+print+$+take+10+$+filter+p+$+counters+3+[1..]+where
++p+[a,b,c]+=+a*a+%2B+b*b+==+c*c|code-block|syntax|javascript|1010043|counters为指定数字范围内的值生成所有可能的计数器，包括无限范围。|offset|length|style|CODE|1010044|首先，我们获得计数器有效组合的生成器列表-对于每个允许的数字，将其与较小大小的计数器的所有允许组合组合。这可能导致生成器产生无限数量的组合。因此，我们需要均匀地从每个生成器中借用。|1010045|所以gens是一个生成器列表。可以把它看作一个以一个数字开头的所有计数器的列表：gens+!!+0是以1开头的所有计数器的列表，gens+!!+1是以2开头的所有计数器的列表，依此类推。|1010046|为了均匀地借用每个生成器，我们可以转置生成器列表-这样我们将获得生成器的第一个元素的列表，然后是生成器的第二个元素的列表，依此类推。|1010047|由于生成器列表可能是无限的，因此我们无法转置生成器列表，因为我们可能永远无法查看任何生成器的第二个元素(对于无限数量的数字，我们将拥有无限数量的生成器)。因此，我们“对角”地枚举生成器中的元素-从第一个生成器中获取第一个元素；然后从第一个生成器中获取第二个元素，从第二个生成器中获取第一个元素；然后从第一个生成器中获取第三个元素，从第二个生成器中获取第二个元素，并从第三个生成器中获取第一个元素，依此类推。这可以通过使用函数f折叠生成器列表来完成，该函数将两个列表压缩在一起-一个列表是生成器，另一个是已经压缩的生成器-，其中一个列表的开头通过在头部添加[]:来偏移一步。这几乎是zipWith+(:)+ys+([]:n)+-不同的是，如果n或ys比另一个短，我们不会丢弃另一个列表的其余部分。请注意，使用zipWith+(:)+ys+n折叠将是一种转置。|1010048|entityMap^0|0|0|0|0|8|0|0|2|4|14|9|1F|1|1S|9|23|1|0|0|5W|1|7P|3|82|L|9T|G|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@$K|12|L|13|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@$K|16|L|17|M|N]|$K|18|L|19|M|N]|$K|1A|L|1B|M|N]|$K|1C|L|1D|M|N]|$K|1E|L|1F|M|N]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@$K|1I|L|1J|M|N]|$K|1K|L|1L|M|N]|$K|1M|L|1N|M|N]|$K|1O|L|1P|M|N]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|X|$]]

This answer is for a more general problem for a unknown predicate. If the predicate is known, more efficient solutions are possible, like others have listed solutions based on knowledge that you don't need to iterate for all Ints for a given c.

When dealing with infinite lists, you need to perform breadth-first search for solution. The list comprehension only affords depth-first search, that is why you never arrive at a solution in your original code.

<pre><code>counters 0 xs = [[]]
counters n xs = concat $ foldr f [] gens where
 gens = [[x:t | t &lt;- counters (n-1) xs] | x &lt;- xs]
 f ys n = cat ys ([]:n)
 cat (y:ys) (x:xs) = (y:x): cat ys xs
 cat [] xs = xs
 cat xs [] = [xs]

main = print $ take 10 $ filter p $ counters 3 [1..] where
 p [a,b,c] = a*a + b*b == c*c
</code></pre>

<code>counters</code> generates all possible counters for values from the specified range of digits, including a infinite range.

First, we obtain a list of generators of valid combinations of counters - for each permitted digit, combine it with all permitted combinations for counters of smaller size. This may result in a generator that produces a infinite number of combinations. So, we need to borrow from each generator evenly.

So <code>gens</code> is a list of generators. Think of this as a list of all counters starting with one digit: <code>gens !! 0</code> is a list of all counters starting with <code>1</code>, <code>gens !! 1</code> is a list of all counters starting with <code>2</code>, etc.

In order to borrow from each generator evenly, we could transpose the list of generators - that way we would get a list of first elements of the generators, followed by a list of second elements of the generators, etc.

Since the list of generators may be infinite, we cannot afford to transpose the list of generators, because we may never get to look at the second element of any generator (for a infinite number of digits we'd have a infinite number of generators). So, we enumerate the elements from the generators "diagonally" - take first element from the first generator; then take the second element from the first generator and the first from the second generator; then take the third element from the first generator, the second from the second, and the first element from the third generator, etc. This can be done by folding the list of generators with a function <code>f</code>, which zips together two lists - one list is the generator, the other is the already-zipped generators -, the beginning of one of them being offset by one step by adding <code>[]:</code> to the head. This is almost <code>zipWith (:) ys ([]:n)</code> - the difference is that if n or ys is shorter than the other one, we don't drop the remainder of the other list. Note that folding with <code>zipWith (:) ys n</code> would be a transpose.

blocks|key|3144978|text|这真的取决于你所说的“最小”是什么意思，但我假设你想要找到一个关于它的最大元素的数字元组-所以(2,2)小于(1,3)+(而标准的Haskell排序是按字典排序的)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3144979|有一个data-ordlist包，它的目标就是处理有序列表。它的函数mergeAll+(和mergeAllBy)允许您将在每个方向上排序的二维矩阵组合成一个有序列表。|3144980|首先，让我们在元组上创建一个所需的比较函数：|3144981|import+Data.List+(find)
import+Data.List.Ordered

compare2+::+(Ord+a)+=>+(a,+a)+->+(a,+a)+->+Ordering
compare2+x+y+=+compare+(max2+x,+x)+(max2+y,+y)
++where
++++max2+::+Ord+a+=>+(a,+a)+->+a
++++max2+(x,+y)+=+max+x+y|code-block|syntax|javascript|3144982|然后使用mergeAll创建一个接受比较器的函数、一个组合函数(在两个参数中都必须为monotonic+)和两个排序列表。它使用函数组合两个列表中所有可能的元素，并生成一个结果排序列表：|3144983|mergeWith+::+(b+->+b+->+Ordering)+->+(a+->+a+->+b)+->+[a]+->+[a]+->+[b]
mergeWith+cmp+f+xs+ys+=+mergeAllBy+cmp+$+map+(\x+->+map+(f+x)+xs)+ys|3144984|使用此函数，可以非常简单地生成根据最大值排序的元组：|3144985|incPairs+::+[(Int,Int)]
incPairs+=+mergeWith+compare2+(,)+[1..]+[1..]|3144986|它的前10个元素是：|3144987|>+take+10+incPairs+
[(1,1),(1,2),(2,1),(2,2),(1,3),(2,3),(3,1),(3,2),(3,3),(1,4)]|3144988|当我们(例如)寻找平方和等于65的第一对时：|3144989|find+(\(x,y)+->+x%5E2%2By%5E2+==+65)+incPairs|3144990|我们得到正确的结果(4,7)+(而不是(1,8)，如果使用字典排序)。|3144991|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/packages/data-ordlist|1|http://hackage.haskell.org/packages/archive/data-ordlist/0.4.5/doc/html/Data-List-Ordered.html#v%253amergeAll|2|https://en.wikipedia.org/wiki/Monotonic_function^0|1B|5|1I|5|0|Y|8|19|A|3|C|0|Y|8|1|0|0|0|4|8|16|9|2|0|0|0|0|0|0|0|0|9|5|J|5|0^^$0|@$1|2|3|4|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@$9|1S|A|1T|1|1U]|$9|1V|A|1W|1|1X]]|E|$]]|$1|H|3|I|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@$9|23|A|24|1|25]]|E|$]]|$1|Q|3|R|5|L|7|26|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|27|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|28|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|29|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|2A|8|@]|D|@]|E|$M|N]]|$1|10|3|11|5|6|7|2B|8|@]|D|@]|E|$]]|$1|12|3|13|5|L|7|2C|8|@]|D|@]|E|$M|N]]|$1|14|3|15|5|6|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|2I|8|@]|D|@]|E|$]]]|17|$18|$5|19|1A|1B|E|$1C|1D]]|1E|$5|19|1A|1B|E|$1C|1F]]|1G|$5|19|1A|1B|E|$1C|1H]]]]

It really depends on what you mean by "smallest", but I assume you want to find a tuple of numbers with respect to its maximal element - so <code>(2,2)</code> is less than <code>(1,3)</code> (while standard Haskell ordering is lexicographic).

There is package <a href="http://hackage.haskell.org/packages/data-ordlist" rel="nofollow">data-ordlist</a>, which is aimed precisely at working with ordered lists. It's function <a href="http://hackage.haskell.org/packages/archive/data-ordlist/0.4.5/doc/html/Data-List-Ordered.html#v%3amergeAll" rel="nofollow"><code>mergeAll</code></a> (and <code>mergeAllBy</code>) allows you to combine a 2-dimensional matrix ordered in each direction into an ordered list.

First let's create a desired comparing function on tuples:

<pre><code>import Data.List (find)
import Data.List.Ordered

compare2 :: (Ord a) =&gt; (a, a) -&gt; (a, a) -&gt; Ordering
compare2 x y = compare (max2 x, x) (max2 y, y)
 where
 max2 :: Ord a =&gt; (a, a) -&gt; a
 max2 (x, y) = max x y
</code></pre>

Then using <code>mergeAll</code> we create a function that takes a comparator, a combining function (which must be <a href="https://en.wikipedia.org/wiki/Monotonic_function" rel="nofollow">monotonic</a> in both arguments) and two sorted lists. It combines all possible elements from the two lists using the function and produces a result sorted list:

<pre><code>mergeWith :: (b -&gt; b -&gt; Ordering) -&gt; (a -&gt; a -&gt; b) -&gt; [a] -&gt; [a] -&gt; [b]
mergeWith cmp f xs ys = mergeAllBy cmp $ map (\x -&gt; map (f x) xs) ys
</code></pre>

With this function, it's very simple to produce tuples ordered according to their maximum:

<pre><code>incPairs :: [(Int,Int)]
incPairs = mergeWith compare2 (,) [1..] [1..]
</code></pre>

Its first 10 elements are:

<pre><code>&gt; take 10 incPairs 
[(1,1),(1,2),(2,1),(2,2),(1,3),(2,3),(3,1),(3,2),(3,3),(1,4)]
</code></pre>

and when we (for example) look for the first pair whose sum of squares is equal to 65:

<pre><code>find (\(x,y) -&gt; x^2+y^2 == 65) incPairs
</code></pre>

we get the correct result <code>(4,7)</code> (as opposed to <code>(1,8)</code> if lexicographic ordering were used).

blocks|key|1016250|text|我认为如果“最小”被定义为x%2By%2Bz，这是最简单的解决方案，因为当你在整值勾股三角形空间中找到你的第一个解决方案后，你从无限列表中得到的下一个解决方案会更大。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1016251|take+1+[(x,y,z)+%7C+y+<-+[1..],+x+<-+[1..y],+z+<-+[1..x],+z*z+%2B+x*x+==+y*y]+->+(4,5,3)|offset|length|style|CODE|1016252|它有一个很好的特性，它只返回每个对称唯一解一次。X和z也是无穷大的，因为y是无穷大的。|1016253|这不起作用，因为x的序列永远不会结束，因此你永远不会得到y的值，更不用说z了。最右边的生成器是最里面的循环。|1016254|take+1+[(z,y,x)%7Cz+<-+[1..],y+<-+[1..],x+<-+[1..],x*x+%2B+y*y+==+z*z]|1016255|entityMap^0|0|0|21|0|0|0|0|1U|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

I think this is the simplest solution if "smallest" is defined as x+y+z because after you find your first solution in the space of Integral valued pythagorean triangles, your next solutions from the infinite list are bigger.

<code>take 1 [(x,y,z) | y &lt;- [1..], x &lt;- [1..y], z &lt;- [1..x], z*z + x*x == y*y]</code>
-> [(4,5,3)]

It has the nice property that it returns each symmetrically unique solution only once. x and z are also infinite, because y is infinite.

This does not work, because the sequence for x never finishes, and thus you never get a value for y, not to mention z. The rightmost generator is the innermost loop.

<code>take 1 [(z,y,x)|z &lt;- [1..],y &lt;- [1..],x &lt;- [1..],x*x + y*y == z*z]</code>

I want to iterate 2 (or 3) infinite lists and find the "smallest" pair that satisfies a condition, like so:

<pre><code>until pred [(a,b,c) | a&lt;-as, b&lt;-bs, c&lt;-cs]
 where pred (a,b,c) = a*a + b*b == c*c
 as = [1..]
 bs = [1..]
 cs = [1..]
</code></pre>

The above wouldn't get very far, as <code>a == b == 1</code> throughout the run of the program.
Is there a nice way to dovetail the problem, e.g. build the infinite sequence <code>[(1,1,1),(1,2,1),(2,1,1),(2,1,2),(2,2,1),(2,2,2),(2,2,3),(2,3,2),..]</code> ?

Bonus: is it possible to generalize to n-tuples?

Dovetail iteration over infinite lists in Haskell

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想迭代2个(或3个)无限列表，并找到满足条件的“最小”对，如下所示：until pred [(a,b,c) | a<-as, b<-bs, c<-cs] where pred (a,b,c) = a*a + b*b == c*c as = [1..] bs = [1..] ...

问Haskell中无限列表上的燕尾迭代
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell中无限列表上的燕尾迭代EN