实现一个程序，其中字符串的字符在 haskell 中重复了某些时间

Question

这是我家庭作业中的一个问题，因此提示将不胜感激。

我这学期正在学习Haskell，我的第一个作业要求我编写一个函数，输入2个字符串(string1和string2(并返回一个字符串，该字符串由第一个字符串string1的(重复(字符组成，直到创建了与string2长度相同的字符串。

我只被允许使用前奏功能length。

例如：取string1 "Key"和我的名字"Ahmed"作为string2函数应该返回"KeyKe" 。

这是我到目前为止得到的：

    makeString :: Int -> [a] -> [a]
    makeString val (x:xs)
        | val > 0 = x : makeString (val-1) xs
        | otherwise = x:xs

我没有直接给它两个字符串，而是给它一个整数值(因为我以后可以用它代替长度(，但这给了我一个运行时错误：

*Main> makeString 8 "ahmed"
"ahmed*** Exception: FirstScript.hs: (21,1)-(23,21) : Non-exhaustive patterns in function makeString

我认为它可能与我的列表用完并成为空列表(？

一点帮助将不胜感激。

Answer 1

我认为这段代码足以解决您的问题：

extend :: String -> String -> String
extend src dst = extend' src src (length dst)
    where
        extend' :: String -> String -> Int -> String
        extend' _ _ 0 = []
        extend' [] src size = extend' src src size
        extend' (x:xs) src size  = x : extend' xs src (size - 1)

extend'函数将循环第一个字符串，直到被使用，然后再次开始使用它。

您还可以使用类似take和cycle的函数来制作它：

repeatString :: String -> String
repeatString x = x ++ repeatString x
firstN :: Int -> String -> String
firstN 0 _ = []
firstN n (x:xs) = x : firstN ( n - 1 ) xs
extend :: String -> String -> String
extend src dst = firstN (length dst) (repeatString src)

或更通用的版本

repeatString :: [a] -> [a]
repeatString x = x ++ repeatString x
firstN :: (Num n, Eq n ) => n -> [a] -> [a]
firstN 0 _ = []
firstN n (x:xs) = x : firstN ( n - 1 ) xs
extend :: [a] -> [b] -> [a]
extend _ [] = error "Empty target"
extend [] _ = error "Empty source"
extend src dst = firstN (length dst) (repeatString src)

它能够接受任何类型的列表：

>extend [1,2,3,4] "foo bar"
[1,2,3,4,1,2,3]

Answer 2

就像卡斯滕说的，你应该

• 处理列表为空的情况
删除列表时，将
• 第一个元素推到列表末尾。
• 当 n 为 0 或更低时返回空列表

例如：

makeString :: Int -> [a] -> [a]
makeString _ [] = []    -- makeString 10 "" should return ""
makeString n (x:xs)
    | n > 0 = x:makeString (n-1) (xs++[x])
    | otherwise = []    -- makeString 0 "key" should return ""

在GHCI中尝试此操作：

>makeString (length "Ahmed") "Key"
"KeyKe"

Answer 3

^{注意：这个答案是用识字的哈斯克尔写的。将其另存为Filename.lhs并在GHCi中试用。}

我认为在这种情况下，length是红鲱鱼。你可以只通过递归和模式匹配来解决这个问题，这甚至可以在很长的列表上工作。但首先要做的是。

我们的函数应该具有什么类型？我们采用两根字符串，我们将一遍又一遍地重复第一根字符串，这听起来像String -> String -> String .然而，这种"一遍又一遍"的事情并不是字符串独有的：你可以对每种列表做到这一点，所以我们选择以下类型：

> repeatFirst :: [a] -> [b] -> [a]
> repeatFirst as bs = go as bs

好吧，到目前为止，没有什么花哨的事情发生，对吧？我们用go来定义repeatFirst，这仍然缺失。在go中，我们想将bs项与相应的as项交换，因此我们已经知道一个基本情况，即如果bs为空会发生什么：

>    where go  _     []     = []

如果bs不是空的怎么办？在这种情况下，我们想使用正确的项目 as .因此，我们应该同时遍历两者：

>          go (x:xs) (_:ys) = x : go xs ys

我们目前正在处理以下情况：空的第二个参数列表和非空列表。我们仍然需要处理空的第一个参数列表：

>          go []     ys     = 

在这种情况下应该怎么做？好吧，我们需要从as重新开始.事实上，这有效：

>                              go as ys

这里再次在一个地方提供了所有内容：

repeatFirst :: [a] -> [b] -> [a]
repeatFirst as bs = go as bs
   where go  _     []     = []
         go (x:xs) (_:ys) = x : go xs ys
         go []     ys     =     go as ys

请注意，如果没有约束，则可以改用cycle、zipWith和const：

repeatFirst :: [a] -> [b] -> [a]
repeatFirst = zipWith const . cycle

但这可能是另一个问题。