Haskell 检查列表其余部分中的元素（lx）

我最近学习了Haskell，我在输入代码时遇到了问题，无法查看元素是否在列表的其余部分

（x:lx）

，在本例中是

lx

。 我的代码：

现在的方式是检查第一个元素

（x==y）

，但我不知道如何检查元素

y

是否存在于

lx

中。我实际上要做的事情是找出在初始化器列表中，数字

y

是否包含0或1次，并返回

True

，否则返回

False

，您可以使用以下函数执行此操作：

atmostonce:: [Int] -> Int -> Bool
atmostonce [] y = True
atmostonce (x:lx) y | x /= y = atmostonce lx y
                    | otherwise = not $ elem y lx

elem :: Eq a => a -> [a] -> Bool

atmostonce [] y = True
atmostonce (x:ls) y
    | (x == y) && (y `elem` ls) = False
    | otherwise = True

最好先检查元素

x

是否不等于

y

。如果是这种情况，只需调用递归部分

atmostonce lx y

：就可以在列表中进一步搜索

在

x==y

的情况下（在

的情况下，否则

的情况下），您需要检查

lx

（列表的其余部分）中是否有另一个元素，该元素等于

x

。如果是这种情况，则需要返回

False

，因为在这种情况下，列表中有多个实例。否则返回

True

此外，您还可以进一步概括您的函数：

atmostonce:: (Eq a) => [a] -> a -> Bool
atmostonce [] y = True
atmostonce (x:lx) y | x /= y = atmostonce lx y
                    | otherwise = not $ elem y lx

是一个类型类，它意味着在

a

上定义了函数

=

和

/=

。因此，您可以调用它们，而不管

a

（

Int

，

String

，等等）的实际类型是什么

最后，在第一种情况下，您可以使用下划线（

\uu

），这意味着您不关心该值（尽管在本例中这并不重要）。您可能可以更改大小写的顺序，因为它们是不相交的，这使得函数在语法上是完整的：

您可以使用以下功能执行此操作：

atmostonce:: [Int] -> Int -> Bool
atmostonce [] y = True
atmostonce (x:lx) y | x /= y = atmostonce lx y
                    | otherwise = not $ elem y lx

elem :: Eq a => a -> [a] -> Bool

atmostonce [] y = True
atmostonce (x:ls) y
    | (x == y) && (y `elem` ls) = False
    | otherwise = True

最好先检查元素

x

是否不等于

y

。如果是这种情况，只需调用递归部分

atmostonce lx y

：就可以在列表中进一步搜索

在

x==y

的情况下（在

的情况下，否则

的情况下），您需要检查

lx

（列表的其余部分）中是否有另一个元素，该元素等于

x

。如果是这种情况，则需要返回

False

，因为在这种情况下，列表中有多个实例。否则返回

True

此外，您还可以进一步概括您的函数：

atmostonce:: (Eq a) => [a] -> a -> Bool
atmostonce [] y = True
atmostonce (x:lx) y | x /= y = atmostonce lx y
                    | otherwise = not $ elem y lx

是一个类型类，它意味着在

a

上定义了函数

=

和

/=

。因此，您可以调用它们，而不管

a

（

Int

，

String

，等等）的实际类型是什么

最后，在第一种情况下，您可以使用下划线（

\uu

），这意味着您不关心该值（尽管在本例中这并不重要）。您可能可以更改大小写的顺序，因为它们是不相交的，这使得函数在语法上是完整的：

---

您可以使用几种实现，我看到的一种可以避免将

length

应用于潜在无限列表的实现是

atmostonce xs y
    = (<= 1)
    $ length
    $ take 2
    $ filter (== y) xs

---

n您可以使用几种实现，我看到的一种可以避免将
length
应用于潜在无限列表的实现是

atmostonce xs y
    = (<= 1)
    $ length
    $ take 2
    $ filter (== y) xs

n现有答案很好，但您可以使用
dropWhile
完成当前通过手动递归完成的部分：

atMostOnce xs y =
    let afterFirstY = drop 1 $ dropWhile (/= y) xs
    in y `notElem` afterFirstY

现有答案不错，但您可以使用
dropWhile
来完成当前通过手动递归完成的部分：

atMostOnce xs y =
    let afterFirstY = drop 1 $ dropWhile (/= y) xs
    in y `notElem` afterFirstY

当你的帖子看起来不像你想要的样子时，不要评论，编辑它。如chi所示，您可以通过在左侧缩进四个空格来获得代码块标记。好的，对不起，我也是stackoverflow的新手。如果您的文章看起来不符合您的要求，请不要发表评论，请编辑它。如chi所示，您可以通过在左侧缩进四个空格来获得代码块标记。好的，对不起，我也是stackoverflow的新手。谢谢您的帮助。我很感激，这是完全正确的。谢谢你的帮助。我很感激，这是完全正确的。我也很好，但我想我现在会坚持使用更基本的变体，因为我才刚刚开始学习Haskell@SebastianRedl：事实上，答案或多或少是在实现
dropWhile（/=y）
with的基本情况下（在我们找到一个元素之后），
elem
hardcoded.filter也是一个很好的过滤器
let atMostOnce xs x=（@CharlesDurham，但这需要遍历整个列表，因为即使是Haskell也没有懒到只计算比较失败所需的
长度。另一方面，dropWhile/notElem版本在找到第二个y后会提前中止。@SebastianRedl很好！尽管我仍然喜欢过滤器：）
让atMostOnce xs x=null。去掉1$filter（=x）xs，我也很好，但我想我现在会坚持使用更基本的变体，因为我刚刚开始学习Haskell@SebastianRedl：事实上，答案或多或少是在基本情况下的
dropWhile（/=y）
with的实现中（在我们找到一个元素之后），则
elem
hardcoded.filter也是一个很好的过滤器
let atMostOnce xs x=（@CharlesDurham，但这需要遍历整个列表，因为即使是Haskell也没有懒到只计算比较失败所需的
长度。另一方面，dropWhile/notElem版本在找到第二个y后会提前中止。@SebastianRedl很好！尽管我仍然喜欢过滤器：）
让atMostOnce xs x=null。删除1$filter（=x）xs