我在哈斯克尔寻找第八个欧拉问题的解决方案，但我不太明白。

这里是解决方案的链接，您可以在这里找到任务。

有人能一个接一个地给我解释一下解决办法吗？

readFile读取文件"number.txt"。如果我们在一个名为number.txt的文件中输入一个16位数字

号

奔跑

结果

。

此字符串中有多余的换行符。为了删除它们，作者将字符串拆分为lines。

结果不再包含任何'
'字符，而是字符串列表。

。

为了将其转换成一个字符串，这些字符串一起使用concat。

。

连接的字符串是字符列表，而不是数字列表

每个字符由digitToInt转换成Int，然后由fromInteger转换成Integer。在32位硬件上，使用全尺寸Integer是很重要的，因为13位数字的乘积可能大于2^31-1。这个转换是针对列表中的每个项目的map。

。

结果列表中充满了Integer。

子序列

作者的下一个目标是找到这个整数列表中所有的13位数字。tails返回一个列表的所有子列表，从任何位置开始，一直运行到列表结束。

。

这将为我们的16位示例生成17个列表。(我添加了格式)

号

作者将采取一个技巧，我们重新排列这些列表，以读取13位长的子列表。如果我们看到这些列表是左对齐的而不是右对齐的，我们可以看到子序列沿着每列向下运行。

号

我们只希望这些列的长度为13位，所以我们只希望take是第一行13行。

号

foldr (zipWith (:)) (repeat [])转换列表(解释它可能属于另一个问题)。它丢弃行中比最短行长的部分。

号

我们现在像往常一样在列表中读取子序列

号问题

我们通过mapping product找到每个子序列的product。

号

这会将列表减少到一个单独的数字

号

从中我们必须找到maximum。

号

答案是

1791590400年

相关讨论

• 但重复是否有问题，因为它创建了一个无限列表？
• @用户2965601 zipWith和zip在最短的参数列表结束时停止。因此，使用无限列表可以确保无论最短列表的长度是多少，它都将得到完整的处理。由于哈斯克尔的懒散，在无限列表中的其他[]将被忽略。当然，可以计算长度(1000-13，+-1)，列表与drop齐平，但是使用这个技巧是很好的，因为它可以自动处理端点对齐，而不需要计算。注意，foldr f [a,b,c,...,n] z == f a (f b (f c ...(f n z) ... ))。
• @用户2965601…列表平均化…当然，与take有关，而不是drop有关。
• 是否可以用Data.List的transpose函数替换foldr (zipWith (:)) (repeat [])行，因为它已经被导入？
• 关于我的上述评论，似乎transpose可能会给出不同的答案，尽管这不太可能。与zipWith不同的是，它不会自动地将给定行的部分放长于最短行。例如，transpose [[1,2],[3],[4]]生成[[1,3,4],[2]]，其中，foldr方法将生成[[1,3,4]]。这意味着transpose会在组合中留下一些少于13个项目的附加列表。通常，这些列表不会有更大的产品，但是有可能，例如，如果列表中的产品主要是较低的，并且有一个90年代的岛被0年代所包围。
• 上面的一个简单例子是列表[[1]、[1]、[1,9]。使用转置方法，最大的产品是9，但folder方法会给你1。

---

如果您不熟悉所使用的函数，首先应该检查每个函数的类型。因为这是函数组合，所以从内到外应用(即，读取时从右到左、从下到上进行操作)。我们可以一行一行地穿过这条线。

从最后一行开始，我们首先检查类型。

1 2 3 4 5 6

:t str str :: String -- This is your input :t lines lines :: String -> [String] -- Turn a string into an array of strings splitting on new line :t concat concat :: [[a]] -> [a] -- Merge a list of lists into a single list (hint: type String = [Char])

由于type String = [Char](所以[String]相当于[[Char]]，所以此行将多个行号转换为一个数字字符数组。更准确地说，它首先基于完整的字符串创建一个字符串数组。也就是说，每新行一个字符串。然后，它将所有这些行(现在只包含数字字符)合并为一个字符数组(或单个String)。

下一行将这个新字符串作为输入。同样，让我们观察一下类型：

1 2 3 4 5 6 7 8 9 10

:t digitToInt digitToInt :: Char -> Int -- Convert a digit char to an int :t fromIntegral fromIntegral :: (Num b, Integral a) => a -> b -- Convert integral to num type :t map map :: (a -> b) -> [a] -> [b] -- Perform a function on each element of the array :t tails tails :: [a] -> [[a]] -- Returns all final segments of input (see: http://hackage.haskell.org/package/base-4.8.0.0/docs/Data-List.html#v:tails) :t take take :: Int -> [a] -> [a] -- Return the first n values of the list

号

如果我们将这些操作应用到我们的字符串电流输入中，首先要对字符串中的每个字符映射(fromIntegral . digitToInt)的复合函数。这样做的目的是将我们的数字串转换为数字类型列表。如下面注释所指出的那样编辑，本例中的fromIntegral是为了防止32位整数类型溢出。既然我们已经将字符串转换为实际的数字类型，那么我们首先要对这个结果运行tails。因为(根据problem语句)所有的值都必须是相邻的，并且我们知道所有的整数都是非负的(由于是一个更大的数的位置)，所以我们只取前13个元素，因为我们要确保乘法是13个连续元素的分组。不考虑下一行，很难理解这是如何工作的。

所以，让我们做一个快速的实验。在将字符串转换成数字类型之后，我们现在有了一个大列表。这实际上有点难想象我们这里到底有什么。为了理解，清单的内容并不重要。重要的是它的大小。让我们来看一个人工例子：

1 2	(map length . take 13 . tails) [1..1000] [1000,999,998,997,996,995,994,993,992,991,990,989,988]

你可以看到我们这里有一个13个元素的大列表。每个元素都是一个大小为1000(即完整数据集)的列表，按降序排列到988。所以这就是我们目前对下一行的输入，可以说，这是最难理解的——也是最重要的——行。为什么理解这一点很重要应该在我们走过下一行时变得清晰。

1 2 3 4 5 6 7 8

:t foldr foldr :: (a -> b -> b) -> b -> [a] -> b -- Combine values into a single value :t zipWith zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] -- Generalization of zip :t (:) (:) :: a -> [a] -> [a] -- Cons operator. Add element to list :t repeat repeat :: a -> [a] -- Infinite list containing specified value

。

还记得我说过我们以前有13个元素的列表吗(不同大小的列表)？这现在很重要。该行将遍历该列表并将(zipWith (:))应用于该列表。(repeat [])是这样的：每次在子序列上调用zipWith时，它都以一个空列表作为基。这允许我们构建一个包含长度为13的相邻子序列的列表列表。

最后，我们到达最后一行，这很容易。也就是说，我们仍然应该注意我们的类型

1 2 3 4

:t product product :: Num a => [a] -> a -- Multiply all elements of a list together and return result :t maximum maximum :: Ord a => [a] -> a -- Return maximum element in the list

我们要做的第一件事是在每个子序列上映射product函数。完成后，我们会得到一个数字类型列表(嘿，我们终于没有列表了！)。这些值是每个子序列的乘积。最后，我们应用maximum函数，它只返回列表中最大的元素。

相关讨论

• fromIntegral不是多余的，它可以防止Int在32位系统上溢出。我在回答之前的一个问题时添加了它。不过，我隐约记得后来有人"清理过"了。但我不确定，因为有人还打破了haskell wiki上的差异…
• 啊，谢谢你指出这一点！：)我已经更正了这篇文章。
• 顺便说一句，我刚刚意识到，"清理"版本当然是@willness从他对同一个so问题的回答中纠正的版本。

---

编辑：我后来发现了foldr表达式的作用。(见我回答后的评论)。

我认为这可以用不同的方式表达——您可以在列表的末尾添加一个守卫。

这个解决方案的详细版本是：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import Data.List import Data.Char euler_8 = do     let len  = 13     let str1 ="123456789 123456789"     -- Join lines     let str2 = concat (lines str1)     -- Transform the list of characters into a list of numbers     let lst1 = map (fromIntegral . digitToInt) str2     -- EDIT: Add a guard at the end of list     let lst2 = lst1 ++ [-1]     -- Get all tails of the list of digits     let lst3 = tails lst2     -- Get first 13 digits from each tail     let lst4 = map (take len) lst3     -- Get a list of products     let prod = map product lst4     -- Find max product     let m    = maximum prod     print m

相关讨论

• 很好的解释。根据你在回答开始时的问题，map (take 13)会导致一些列表长度小于13，而foldr (zipWith (:)) (repeat []) . take 13不会。虽然习惯上这可能会被拼写为transpose . take 13。
• 如果找到使产品最小化的连续数字，map (take 13)和foldr (zipWith (:)) (repeat []) . take 13之间的差异将非常重要。
• @Danielwagner transpose . take 13也导致一些列表长度小于13。
• @cirdec如果在输入的末尾有类似0999999999999的东西，它也可能是最大的问题。
• 我已经编辑了我的答案以使解决方案正确。
• @完全正确！transpose可以用任何一种方式来定义，但zip是zip的，所以其含义是明确的。
• @你说得对，transpose不是foldr (zipWith (:)) (repeat [])的正确回答。

---