Haskell 将一个单词拆分为所有可能的“单词”；子词-不带进口的所有可能组合

我试图通过以下方式获得单词的所有可能组合，而不使用任何导入：

例如

    Input: Bang

    Output: [['B','ang'], ['Ba','ng'], ['Ban','g'], ['B','a','ng'], ['B','an','g'], ['Ba','n','g'], ['B','a','n','g']]

这个问题困扰了我一段时间，我似乎无法想出一个算法来解决这个问题

下面的代码就是我所做的，但它给出了字符串的所有可能组合，但不是以我需要的方式

我试图用haskell实现这段python代码，但没能实现。这基本上是相同的问题，但是haskell中没有循环

下面代码的输出是

[“太阳”、“苏”、“s”、“联合国”、“u”、“n”]

而不是

[s”，“un”]，[s”，“u”，“n”]，[su”，“n”]

---

递归在这里是有帮助的。假设我们有一个非空列表

x:xs

。我们想知道

子字符串（x:xs）

。我们将我们的解决方案递归地应用于

xs

，因此

子字符串xs

是

xs

的所有解决方案的列表。但是我们仍然有一个

x

。在

x:xs

的解决方案中，有两种方法可以返回

x

，该解决方案涵盖了

子字符串（x:xs）

的整个解决方案集：

---

• 将

  x

  带回，而不将其附加到其邻居。如果我们有

  x:xs=“Bang”

  ，那么

  x

  将是

  'B'

  ，

  xs

  将是

  “ang”

  ，

  子字符串“ang”

  将是

  [“ang”]，[“an”，“g”]，[“a”，“ng”，[“a”，“n”，“g”]

  。这是由

  [[x]：u | u完成的。请注意，您尝试的类型签名是错误的。您需要子字拆分的所有组合，这是字符串列表，但您的类型只是字符串列表
  
  这将有助于：
  
  onHead :: (a -> a) -> [a] -> [a]
  onHead _ [] = []
  onHead f (x:xs) = f x:xs
  
  combos :: [a] -> [[[a]]]
  combos [] = [[]]
  combos [x] = [[[x]]]
  combos (x:xs) = [([x]:), onHead (x:)] <*> combos xs
  
  它使用了与上面相同的技术，只是使用了更干净的实现。
  注意
  subString''
  将导致您的整个程序崩溃，出现一个非穷举模式错误。@Joseph可能是正确的，但如果他愿意，很容易修复。谢谢您的快速回答！@Elmex80s您能进一步详细说明代码的工作原理吗？我在理解它时遇到问题，因为我是haskell的新手。我假设它与Joseph给出的以下答案类似但是我很难理解它的逻辑。提前再次感谢！这是给你的汉克斯！它很有魅力，但我接受第一个答案只是为了成为第一个。真的非常感谢！@rempakos如果你认为值得，你可以给答案+1，即使你不接受它作为答案。@elmex80你需要15次重复upvote，rempakos还没有。我尝试过upvoting，但它不允许我，因为我没有代表，但如果我达到这个数字，我会回来投票！再次感谢！
  subString :: String -> [[String]]
  subString   [x]    = [[[x]]]
  subString (x : xs) = [(x : u) : us | (u : us) <- subString xs] ++ [[x] : u | u <- subString xs]
  
  *Main> subString "Bang"
  [["Bang"],["Ban","g"],["Ba","ng"],["Ba","n","g"],["B","ang"],["B","an","g"],["B","a","ng"],["B","a","n","g"]]
  
  onHead :: (a -> a) -> [a] -> [a]
  onHead _ [] = []
  onHead f (x:xs) = f x:xs
  
  combos :: [a] -> [[[a]]]
  combos [] = [[]]
  combos [x] = [[[x]]]
  combos (x:xs) = [([x]:), onHead (x:)] <*> combos xs
  
  combos :: Foldable t => t a -> [[[a]]]
  combos = foldr (concatMap . go) [[]]
    where go x l = ([x]:l):case l of
            [] -> []
            h:t -> [(x:h):t]