Học Haskell: Câu hỏi thao tác chuỗi

Question

Làm cách nào để viết một hàm trong Haskell, có chuỗi đầu vào theo định dạng a1a2a3 và mở rộng thành a1a2a2a3a3a3. Ví dụ: chuỗi đầu vào "mã" sẽ được mở rộng thành "coodddeeee"

Answer 1

lẽ rất không hiệu quả :)

f :: Int -> [Char] -> [Char] 
f _ [] = [] 
f n (c:s) = (replicate n c) ++ (f (n+1) s) 

g :: [Char] -> [Char] 
g s = f 1 s 

.

*Main> g "code" 
"coodddeeee" 

Answer 2

Vì vậy, bạn muốn nhân vật nth được lặp lại n lần.

f :: String -> String 
f x = concatMap g (zip x [1..]) 
    where 
     g (x,y) = replicate y x 

Tôi chắc chắn có cách dễ dàng hơn để thực hiện việc này.

Giải thích: Trước tiên, chúng tôi lấy chuỗi và ghép nối với vị trí của nó trong danh sách (bắt đầu từ 1). Đây là những gì zip hiện:

Prelude> zip "code" [1..] 
[('c',1),('o',2),('d',3),('e',4)] 

Sử dụng chức năng sao chép sao chép bất cứ điều gì bạn muốn y lần. Vì vậy, chúng tôi nhân rộng x, y lần.

Prelude> g ('z',4) 
"zzzz" 

Nếu chúng ta bản đồ chức năng này qua danh sách sản xuất bạn sẽ có được kết quả:

Prelude> map g $ zip "code" [1..] 
["c","oo","ddd","eeee"] 

Nếu bạn có một danh sách các chuỗi, bạn có thể nối chúng lại với nhau bằng concat. concatMap áp dụng hàm g cho mỗi cặp chữ cái và số và sau đó nối chuỗi vào kết quả cuối cùng.

Prelude> concat $ map g $ zip "code" [1..] 
"coodddeeee" 

Về cơ bản: concat $ map g ->concatMap g

EDIT: bây giờ nó hoạt động, nó cũng có thể được thực hiện trong một dòng thusly:

f x = concatMap (\(a,b)->replicate b a) $ zip x [1..] 

Output:

Prelude> f "lambda" 
"laammmbbbbdddddaaaaaa" 

Answer 3

import Control.Monad 
f = zip [1..] >=> uncurry replicate 

mang

Main> f "code" 
"coodddeeee" 

Answer 4

Prelude> let l = "code" in concat $ [take y $ repeat (last $ take y l) | y <- [1..length l]] 
"coodddeeee" 

Answer 5

Tại sao người ta ghét comprehensions danh sách?

Prelude> let f s = concat [ replicate x y | (x,y) <- zip [1..] s] 
Prelude> f "code" 
"coodddeeee" 

hoặc nếu bạn muốn phát điên với phần mở rộng

Prelude> :set -XParallelListComp 
Prelude> let f s = concat [ replicate x y | x <- [1..] | y <- s] 
Prelude> f "code" 
"coodddeeee"