Functional programming 如果列表中的两个字符序列是连续的，那么有没有办法找到它们？

我目前正在使用elm语法。例如：

（顺序（'a'）（'b'））（'c'）['a'，'b'，'c'，'d']。在本例中，我只测试元素“a”、“b”、“c”是否是列表的成员。如果是，那么我对它进行分区并获得（['a'，'b'，'c']，['d']）

在以下情况下，我遇到了问题：

 (Sequence ('a') ('b')) ('c') ['a', 'b', 'c', 'a']

获得结果： （['a'、'b'、'c'、'a']、[]）

---

我的问题是：我应该设置什么条件使元素“a”和“b”必须连续避免单独匹配时出现这种情况？

以下是一些代码，用于测试列表中是否出现了一系列元素：

module Main exposing (main)
 
import Html exposing (Html, text)


containsSeq : List a -> List a -> Bool
containsSeq seq list =
    let
        helper remainingSeq remainingList savedSeq savedList =
            case remainingSeq of
                [] ->
                    True

                x :: xs ->
                    case remainingList of
                        [] ->
                            False

                        y :: ys ->
                            if x == y then
                                helper xs ys (savedSeq ++ [ x ]) (savedList ++ [ y ])

                            else
                                case savedList of
                                    [] ->
                                        helper (savedSeq ++ remainingSeq) ys [] []

                                    y2 :: y2s ->
                                        helper (savedSeq ++ remainingSeq) (y2s ++ remainingList) [] []
    in
    helper seq list [] []


main =
    text <| Debug.toString <| containsSeq [ 'a', 'b', 'c' ] [ 'a', 'b', 'a', 'b', 'c', 'd' ]

---

当然，如果您只处理字符，那么最好使用

String.fromList

将列表转换为

String

，并使用

String.contains“abc”“abababcd”

作为第一个版本和

String.split“abc”“ababcd”

来实现第二个。

这个答案假设，如果您有

序列“a”“b”“c”

，并根据列表测试它

['a'、'b'、'c'、'a']

，您希望接收结果

（['a'、'b'、'c']、['a']）

（如中所述）

在伪代码中：

将列表分成两部分，

list1

和

list2

<代码>列表1的长度应与序列的长度相同。Elm为此提供了

使用辅助函数将序列转换为列表

list\u序列

测试

list 1

和

list\u序列是否相等

如果是，则返回元组

（列表1，列表2）

下面是实际的Elm代码：

---

请尝试澄清您的问题。试着用看似过分的细节来解释你想要什么。提供多个示例。试着“像律师一样思考”你的描述；有没有漏洞？这将有助于他人帮助你，甚至有助于你学习自己。你所说的“单独的元素‘a’也将被接受”是什么意思？我建议您尝试编写一个递归函数，在相应列表的前两个元素上进行模式匹配。@d当我试图用我的结果和我关心的案例编辑问题时，我希望现在在您的示例问题中可以更清楚地看到，您是否希望接收

（['a'，'b'，'c'，['a']）

，但您得到

(['a'、'b'、'c'、'a']、[]）

？或者您想获得第二个？您可以发布您当前的代码吗？例如，发送到htttps://ellie-app.comNo，问题仍然不清楚。你讲了很多关于一个例子。但是你没有解释任何地方的总体思路是什么，你只举了一个例子。有时候，如果你给出一个wi，人们可以很好地猜测你想要什么各种各样的例子，但是如果没有一个可靠的概述，从一个例子中推断，基本上是不可能的。

module Main exposing (main)

import Html exposing (Html, text)


partitionBySeq : List a -> List a -> Maybe ( List a, List a, List a )
partitionBySeq seq list =
    let
        helper remainingSeq remainingList savedSeq savedCurrentList savedOldList =
            case remainingSeq of
                [] ->
                    Just ( savedOldList, seq, remainingList )

                x :: xs ->
                    case remainingList of
                        [] ->
                            Nothing

                        y :: ys ->
                            if x == y then
                                helper xs ys (savedSeq ++ [ x ]) (savedCurrentList ++ [ y ]) savedOldList

                            else
                                case savedCurrentList of
                                    [] ->
                                        helper (savedSeq ++ remainingSeq) ys [] [] (savedOldList ++ [ y ])

                                    y2 :: y2s ->
                                        helper (savedSeq ++ remainingSeq) (y2s ++ remainingList) [] [] (savedOldList ++ [ y ])
    in
    helper seq list [] [] []


main =
    text <| Debug.toString <| partitionBySeq [ 'a', 'b', 'c' ] [ 'a', 'b', 'a', 'b', 'c', 'd' ]