使用折叠将字符串拆分为给定长度的字符串列表

Question

我想使用 fold 将字符串拆分为给定长度的字符串列表。

split :: n -> String -> [String]
split 4 "abcdefghijklmnopqrst" -> ["abcd","efgh","ijkl","mnop","qrst"]

这可以使用foldr 完成吗？您能否提供一个解释，以便我对如何使用折叠来解决此类问题有一些直觉？

编辑：我添加了递归解决方案

split :: Int -> String -> [String]
split len xs
  | len >= length xs = [xs]
  | otherwise = take len xs : split len (drop len xs)

Answer 1

要从您的递归代码转到foldr，您需要进一步内联并融合length、take 和drop 的定义，以便您的代码一次解构输入列表一个元素，例如@ 987654326@ 确实：

split :: Int -> [a] -> [[a]]
split len xs
  | len >= length xs = [xs]
  | otherwise = take len xs : split len (drop len xs)
  where
  take :: Int -> [a] -> [a]
  take 0 xs = xs
  take 0 [] = []
  take n (x:xs) = x : take (n-1) xs
  -- and for `drop` and `len >= length` as well
  -- ......

所以我们需要为此添加一个计数器。

split2 :: Int -> [a] -> [[a]]
split2 len xs = go xs 0
  where
  go [] _  = [[]]    -- [] : []
  go (x:xs) i 
    | i < len = [x] : go xs (i+1)
    | otherwise =     go xs 0

（请在此处修复一个错误，好吗）。

这当然不会产生正确的结果，但它已经遵循foldr 模式！它同时进行计数和跳过，并正确选择从0 重新开始计数的点，这与dropped 列表的递归调用相对应——已经免费完成，只需沿着input 一次列出一个元素——就像foldr 一样。我们只需要保存我们目前忘记的那些元素：

split3 :: Int -> [a] -> [[a]]
split3 len xs = go xs 0 []
  where
  go [] _ ys = [reverse ys]
  go (x:xs) i ys
    | i < len = go xs (i+1) (x:ys)
    | otherwise = reverse (x:ys) : go xs 0 []

这直接映射到foldr 递归模式，我们将LHS 上的go (x:xs) 替换为g x r，将RHS 上的go xs 替换为r：

split4 :: Int -> [a] -> [[a]]
split4 len xs = foldr g z xs 0 []
  where
  z _ ys = [reverse ys]
  g x r i ys 
    | i < len = r (i+1) (x:ys)
    | otherwise = reverse (x:ys) : r 0 []

-- > split4 4 "123456"
-- ["12345","6"]

再次，请务必修复一个错误。

不过，这并不完全是惰性的，即 (!! 0) . head . split4 3 $ "12"++undefined 会发散而不是返回字符 '1'，因为它可以说是应该的。

为了实现，我们必须立即返回结构，即使其中有洞，并在以后填补这些洞：

split5 :: Int -> [a] -> [[a]]
split5 len xs = foldr g z xs 1
  where
  z _ = [[]]
  g x r i
    | i < len = let (a:b) = r (i+1) in (x:a):b
    | otherwise = [x] : r 1

有了这个，

> split5 4 "123456"
["1234","56"]

> take 2 . head . split5 4 $ "12" ++ undefined
"12"

这里仍然存在返回值不太正确的极端情况。一定要找到它，并尝试修复它。

Answer 2

正如其他人评论的那样，使用 fold 可能不是最好的方法。然而，这是一个有趣的练习。

从foldr 的签名我们可以看出，累加器需要是[String] 类型和Char -> [String] -> [String] 类型的组合运算符。

要实现combine，请注意我们可以将一个字符一个字符地附加到累加器中。在此过程中，我们需要注意每次超过n 个字符时都从一个新字符串开始：

split :: Int -> String -> [String]
split n = foldr combine []
    where
        combine c (x:xs) | length x < n = (c:x):xs
        combine c xs = [c]:xs