Question

鉴于swapIfAdjacent函数的声明，我需要执行以下操作：

swapIfAdjacent :: Eq a => a -> a -> [a] -> [a]

如果a，b或b，a是连续项目，那么对于第一次也是唯一一次，应该交换这两个项目的顺序。

到目前为止我的代码：

swapIfAdjacent _ _ [] = []
swapIfAdjacent a b (x:xs) | a `elem` xs && b `elem` xs
                          = if adjacent a b xs then swap a b (x:xs) else (x:xs) 
                          | otherwise = error "not adjacent"   
                             where
                             swap _ _ [] = []
                             swap a b (x:xs) 
                                 |    a == x = b : swap a b xs
                                 |    b == x = a : swap a b xs
                                 | otherwise = x : swap a b xs

我使用的相邻功能已经定义如下：

adjacent :: Eq a => a -> a -> [a] -> Bool
adjacent a b (x:y:etc)  |  x == a
                        =  y == b
                        |  x == b
                        =  y == a
                        |  otherwise
                        =  adjacent a b (y:etc)
adjacent _ _ _          =  False

我观察到根据我的实现，每个元素都会发生交换过程，而不仅仅是第一个元素，还有以下错误：

swapIfAdjacent 'a' 'a' "banana" --> banana

而

swapIfAdjacent 'b' 'b' "banana" --> error "not adjacent"

以上两个例子都应该产生整个列表而不是错误。我认为这个错误与＆＃39; b＆＃39;只出现在列表中一次＆＃34; banana＆＃34;虽然＆＃39; a＆＃39;多次。

Answer 1

你在这里做了很多不必要的工作。这是一个需要考虑的实现。

adjacent

您不需要swap，{{1}}或{{1}}中的任何一个。

在Haskell中交换给定列表中的相邻输入字符

1 个答案: