在 Haskell 中整理列表理解答案

【问题标题】：Tidying up a list comprehension in Haskell在 Haskell 中整理列表理解
【发布时间】：2018-06-07 13:59:32
【问题描述】：

所以我试图在 Haskell 中生成出租车号码列表。出租车号码是可以用两种不同方式写成两个不同立方体的总和的数字 - 最小的是 1729 = 1^3 + 12^3 = 9^3 + 10^3.

现在，我只想生成“组成”出租车号码的四个数字，例如（1,12,9,10），并被告知使用列表理解（我不太熟悉）。此函数将生成最大数最多为 n 的所有 4 元组：

taxi n = [(a,b,c,d) | a <- [1..n], b <- [1..n], c <- [1..n], d <- [1..n], a^3 + b^3 == c^3 + d^3, a < b, a < c, c < d]

但是，由于以下几个原因，它很麻烦：

a、b、c、d 的域都是相同的，但我不知道如何简化此代码，所以 [1..n] 只写一次。
我想要一个无限列表，没有上限，所以我可以让程序尽可能长时间地运行，并在我喜欢的时候终止它。显然，如果我只设置 a <- [1..] 等，那么程序将永远不会评估任何内容。
程序非常慢：仅taxi 50 需要 19 秒。

任何速度优化也很好，但如果不是我使用的幼稚方法就足够了。

【问题讨论】：

谁让你使用列表理解的？您如何对此进行基准测试？请说ghc -O2 -fforce-recomp -fllvm。搜索应该按什么顺序？深度优先？如果a 是从一个无限列表中抽取的，为什么什么都不会被评估？
使用列表理解是问题的要求。我不知道您的“ghc ...”代码是什么意思；我在 Haskell 中使用了命令:set +s，但速度不是我主要关心的问题。任何合理的顺序对我都有好处 - 问题是我不知道如何让 Haskell 以特定顺序进行评估，尽管我可以构造一个双射 ℕ^4 -> ℕ 循环遍历整数。我知道无限列表是必要的；我的意思是用a <- [1..] 替换a <- [1..n] 而不做进一步更改将导致程序永远不会输出任何东西。
仅供参考 :set +s 不是在“Haskell”中完成的，而是在名为 GHCi 的 GHC 解释器中完成的。除了这个解释器之外，还有一个名为 ghc 的编译器，它可以生成运行得更快的机器代码。列表推导的使用将您锁定在对第一个列表的值进行广度优先探索的过程中，在考虑第一个列表的下一个值之前，先考虑后面列出的变量的所有可能值。使用诸如[ (a,b,c) | a <- [1..3], b <- [1,2], c <- [1,2] ] 之类的语句可以轻松且具有教育意义。
不应该是b
@Soldalma 一点也不。考虑 (1,12,9,10)。不等式条件只是为了避免获得该元组的其他 23 个排列，例如(9,10,1,12) 或 (12,1,9,10)。在每一对中，我们希望数字较小的在前，在这些对中，我们希望数字最小的在前（当然，这只是一种可能的解决方案）。

标签： haskell list-comprehension infinite

【解决方案1】：

a、b、c、d 的域都是相同的，但我不知道如何简化此代码，所以 [1..n] 只写一次。

使用[a,b,c,d] <- replicateM 4 [1..n]。

程序很慢：出租车 50 只需要 19 秒。

一个廉价的改进是将您的a<b、a<c 和c<d 条件烘焙到理解中。

taxi n = [(a,b,c,d) | a <- [1..n], b <- [a+1..n], c <- [a+1..n], d <- [c+1..n], a^3 + b^3 == c^3 + d^3]

这使我的机器上的事情变得更快。

或者，为了更好地与答案的下一个（和上一个）部分组合，将b、c 和d 视为偏移量。

taxi n =
    [ (a,b,c,d)
    | a <- [1..n]
    , b_ <- [1..n], let b = a+b_, b<=n
    , c_ <- [1..n], let c = a+c_, c<=n
    , d_ <- [1..n], let d = c+d_, d<=n
    , a^3 + b^3 == c^3 + d^3
    ]

我想要一个无限列表，没有上限。

请参阅我对Cartesian product of 2 lists in Haskell 的回答以获取提示。 tl;博士使用choices。

【讨论】：

为什么 [a+1..n] 两次而没有 [b+1..n]？
@Soldalma 因为原始问题指定了两次a< 而没有指定b<。

【解决方案2】：

您的约束意味着a < c < d < b。所以让b跑到最外面，让其他人跑在适当的较低范围内：

taxi n = [ (a,b,c,d) | b <- [1..n],
                       d <- [1..b-1],
                       c <- [1..d-1],
                       a <- [1..c-1],
                       a^3 + b^3 == c^3 + d^3 ]

要无限，只需使用b <- [1..]。

进一步的重大改进是计算从其他三个变量中的一个：

taxi = [ (a,b,c,d) | b <- [1..],
                     c <- [1..b-1],
                     a <- [1..c-1],
                     let d3 = a^3 + b^3 - c^3,
                     let d = round(fromIntegral(d3)**(1/3)),
                     c < d,
                     d^3 == d3 ]

像您一样在 GHCi 中使用 :set +s 对 taxi 50 进行基准测试：

Yours:          (16.49 secs, 17,672,510,704 bytes)
My first:        (0.65 secs,    658,537,184 bytes)
My second:       (0.09 secs,     66,229,376 bytes)  (modified to use b <- [1..n] again)
Daniel's first:  (1.94 secs,  2,016,810,312 bytes)
Daniel's second: (2.87 secs,  2,434,309,440 bytes)

【讨论】：

啊哈，就是这么简单！谢谢你。一个问题：您是如何获得列表的这些范围的？我推断出b <- [1..n], a <- [1..b-3], c <- [a+1..b-2], d <- [c+1..b-1]，因为这四个整数都是不同的。
@A.Morris 是的，你可以这样做。不过，并没有真正的帮助。你只是避免了一些无关紧要的小死胡同，代价是不得不思考并增加犯错的机会。
喜欢这个解决方案，比我的干净得多。您可能还喜欢exactCubeRoot。（当然，在您愿意等待的时间内，这可能并不重要。）
@DanielWagner 谢谢，我以后可能会尝试。我刚开始学习 Haskell，还不知道如何使用它。
@A.Morris 我刚刚更改了变量的顺序，完全从最大到最小。现在范围都从 1 开始，看起来好多了。我什至考虑改为从 4、3、2 和 1 开始，因为它现在非常有序。但我还是更喜欢一切从 1 开始的简单。

【解决方案3】：

拿起 Stefan 他的出色回答。给定a^3 + b^3 == c^3 + d^3，我们只需要查看拥有0 < a < c < b 的整数。现在介绍这个（无限的）迭代结构

-- generates all integers x, y and z for which holds 0 < x < y < z
triplets = [(x, y, z) | z <- [3 .. ], y <- [2 .. z - 1], x <- [1 .. y - 1]]

这将使我们可以从列表理解中轻松访问三元组，我们将在后面介绍。对于有 Python 背景的人来说，这应该相当于 Python 的yield。

接下来我们需要一些东西来（快速）找到最大的立方体并测试整数是否为立方体，也称为整数立方根。有这个包Math.NumberTheory.Powers.Cubes 具有这些任务的功能。或者只是使用这些

-- given integer x >= 0 find the largest integer r such that r^3 <= x
largestCube :: Integral a => a -> a
largestCube x = 
    let powers_of_two = iterate ((*) 2) 1
        upper         = head [j | j <- powers_of_two, x < j ^ 3]
    in  largestCubeSub 0 upper x


largestCubeSub :: Integral a => a -> a -> a -> a
largestCubeSub lower upper x
    | lower + 1 == upper   = lower
    | b ^ 3 <= x           = largestCubeSub b upper x
    | otherwise            = largestCubeSub lower b x
    where
    b = div (lower + upper) 2


-- test if an integer x >= 0 is a cube
isCube :: Integral a => a -> Bool
isCube x = (largestCube x) ^ 3 == x

现在你对前 50 个出租车号码的紧凑列表理解看起来像

*Main> condition = \a b c -> and [isCube (a^3 + b^3 - c^3), a^3 + b^3 - c^3 > c^3]
*Main> taxi = [(a, b, c, largestCube (a^3 + b^3 - c^3)) | (a, c, b) <- triplets, condition a b c]
*Main> first50 = take 50 taxi

使用打印它们

*Main> single_line = \(x, y, z, u) -> unwords [show i | i <- [x, y, z, u]]
*Main> putStrLn $ unlines $ map single_line first50

会给

1 12 9 10
2 16 9 15
2 24 18 20
10 27 19 24
4 32 18 30
2 34 15 33
9 34 16 33
3 36 27 30
17 39 26 36
12 40 31 33
6 48 27 45
4 48 36 40
12 51 38 43
8 53 29 50
20 54 38 48
17 55 24 54
9 58 22 57
3 60 22 59
5 60 45 50
8 64 36 60
30 67 51 58
4 68 30 66
18 68 32 66
42 69 56 61
6 72 54 60
17 76 38 73
5 76 48 69
34 78 52 72
10 80 45 75
15 80 54 71
24 80 62 66
30 81 57 72
51 82 64 75
7 84 63 70
2 89 41 86
11 93 30 92
23 94 63 84
12 96 54 90
50 96 59 93
8 96 72 80
20 97 33 96
47 97 66 90
35 98 59 92
24 98 63 89
29 99 60 92
6 102 45 99
27 102 48 99
23 102 60 95
24 102 76 86
1 103 64 94

它会在几秒钟内返回前 50 个出租车号码。

【讨论】：