从字符串中消除连续重复

Question

我想消除像f "aaabbbcccdeefgggg" = "abcdefg"这样的字符串中的连续重复项

这是我的代码

f :: String -> String
f "" = ""
f "_" = "_"
f (x : xs : xss)
    | x == xs   = f (xs : xss)
    | otherwise = x : f (xs : xss)

我得到了错误的非详尽模式，我认为它来自第二行，当它只剩下 1 个字符时，程序不知道如何处理。我该如何解决？

Answer 1

"_" 模式不匹配带有任何字符的字符串，它匹配包含下划线的字符串。

您可以使用[_] 作为单例字符串的模式，所以：

f :: String -> String
f "" = ""
f s@[_] = s
f (x : xs : xss)
    | x == xs   = f (xs : xss)
    | otherwise = x : f (xs : xss)

这里我们使用s@来捕获一个字符为s的字符串。

或者我们可以简化为：

f :: String -> String
f (x : xs : xss)
    | x == xs   = f (xs : xss)
    | otherwise = x : f (xs : xss)
f s = s

Answer 2

我想消除像f "aaabbbcccdeefgggg" = "abcdefg"这样的字符串中的连续重复项

您可以将相等的字母分组（通过Data.List.group），然后取每个组中的第一个（通过map head，它将head 应用于列表的每个元素并返回列表结果）：

import Data.List (group) -- so we write group instead of Data.List.group
map head $ group "aaabbbcccdeefgggg"

这可以看作是map head的应用group对输入String的应用。 因此，您的f 可以定义为这两个函数的组合：

f :: String -> String
f = map head . group

---

为了完整起见，由于您似乎是 Haskell 的新手，这里有一些细节：

• Data.List.group "aaabbbcccdeefgggg" 返回["aaa","bbb","ccc","d","ee","f","gggg"]；
• f $ a b c 与f (a b c) 相同；
• . 是合成运算符，它是这样的 (f . g) x == f (g x)。

Answer 3

或者，如果您不处理可以不处理的事情，您可以让它变得更简单：

f :: String -> String
f (x:y:xs) | x == y = f (y:xs)
f (x:xs) = x:f xs
f _ = ""

Answer 4

为避免不必要地向前看，您不应尝试匹配前两个元素。相反，请跟踪 最近的元素。

f :: Eq a => [a] -> [a]
f = start
  where
    start [] = []
    start (x : xs) = x : go x xs

    go _old [] = []
    go old (x : xs)
      | x == old
      = go old xs
      | otherwise
      = x : go x xs

如果你愿意，你也可以把它写成一个折叠，在这里你可以用Maybe跟踪你是否见过一个元素：

f :: Eq a => [a] -> [a]
f xs = foldr go stop xs Nothing
  where
    stop _ = []
    go x r (Just old)
      | x == old = r (Just old)
    go x r _ = x : r (Just x)

如果重新排列一下，有些人可能会发现折叠更容易阅读。

f :: Eq a => [a] -> [a]
f xs = (foldr go stop xs) Nothing
  where
    stop :: Maybe a -> [a]
    stop = \_ -> []

    go :: a -> (Maybe a -> [a]) -> (Maybe a -> [a])
    go x r = \acc -> case acc of
      Just old
        | x == old -> r (Just old)
      _ -> x : r (Just x)

Answer 5

您也可以使用foldl。逻辑是：将累加器的最后一个元素与当前元素进行比较。

f :: Eq a => [a] -> [a]
f xs = foldl (\x y -> if last x == y then x else x++[y] )  [head xs] xs

在这里，我们使用[head x] 启动我们的累加器。

根据@dfeuer 的提示，我改变了我的解决方案：

-- with foldl
f :: Eq a => [a] -> [a]
f xs = snd $ foldl  opr (Nothing, []) xs
  where
    opr (Just old, acc) n
      | old == n = (Just old, acc)
      | otherwise = (Just n, acc ++ [n])
    opr (Nothing, acc) n = (Just n, acc ++ [n])

-- with foldr
f2 :: Eq a =>[a] -> [a]
f2 xs = snd $ foldr opr (Nothing, []) xs
  where
    opr n (Just old, acc)
      | old == n = (Just old, acc)
      | otherwise = (Just n, n:acc)
    opr n (Nothing, acc) = (Just n, n:acc)

感谢@dfeuer，我学到了很多新东西。这是基于cmets的第三个版本：

-- with foldl
f :: Eq a => [a] -> [a]
f xs = snd $ foldl opr (Nothing, []) xs
  where
    opr (old, acc) n =
      ( Just n,
        case old of
          Just o
            | o == n -> acc
            | otherwise -> acc ++ [n]
          Nothing -> acc ++ [n]
      )

-- with foldr
f :: Eq a => [a] -> [a]
f xs = snd $ foldr opr (Nothing, []) xs
  where
    opr n (old, acc) =
      ( Just n,
        case old of
          Just o
            | o == n -> acc
            | otherwise -> n : acc
          Nothing -> n : acc
      )