左填充 Haskell 列表

Question

If I wanted to right-pad a Haskell list of integers, I could do something like the following:

rpad m xs = take m $ xs ++ repeat 0

There would be no need to get the length of the list. I think it would be quite performant.

Is there a similar way I could definte lpad , padding the list on the left, without incurring the cost of counting the length, etc. ?

Answer 1

So the first thing worth saying is, don't worry too much about the nitty-gritty of performance . This code is unlikely to be sitting in the proverbial 20% of your code which takes up 80% of the running time.

With that said, where does performance really matter, here? It matters if m is small while length xs is huge or infinite. I mean, it would also be nice to get good performance if m is large (as you have with rpad , where if you process only the first k items of the list you only do k work for some k << m ), but of course the very problem description requires that you potentially do m work to see the top result. (If you're provided an infinite list you need to peek at m items to even know whether to return 0 for the first element.)

In that case, you really want to zero-pad take m xs instead of xs . That's the entire trick:

lpad m xs = replicate (m - length ys) 0 ++ ys
    where ys = take m xs

Answer 2

Right padding only needs to examine the first constructor in the input list ( : or [] ) in order to produce the first element of the output list. It's a streaming operation (could be done with foldr ).

Left padding needs to examine the whole input list in order to produce the first element of the output list. That is, whether the first element is 0 or not depends on the tail of the list (assuming it does not start with 0 ). This can not be done in a streaming way. O(min(m,length)) is the best you can get, for the first element only.

Also, be careful since your padding function discards elements after the m -th, if your input list is longer than that. This might be unwanted -- sometimes padding is defined so that it can only add elements, and never remove.

Answer 3

Here is an (untested but compiling) set of padding/trimming functions ( Unlicence d):

padL :: a -> Int -> [a] -> [a]
padL p s l
    | length l >= s = l
    | otherwise     = replicate (s - length l) p ++ l
{-# INLINABLE padL #-}

padR :: a -> Int -> [a] -> [a]
padR p s l = take s $ l ++ repeat p
{-# INLINABLE padR #-}

trimL :: Int -> [a] -> [a]
trimL s l
    | length l <= s = l
    | otherwise     = drop (length l - s) l
{-# INLINABLE trimL #-}

trimR :: Int -> [a] -> [a]
trimR = take
{-# INLINE trimR #-}

resizeL :: a -> Int -> [a] -> [a]
resizeL p s l
    | length l == s = l
    | length l < s  = padL p s l
    | otherwise     = trimL s l
{-# INLINABLE resizeL #-}

resizeR :: a -> Int -> [a] -> [a]
resizeR p s l
    | length l == s = l
    | length l < s  = padR p s l
    | otherwise     = trimR s l
{-# INLINABLE resizeR #-}

Answer 4

Here is an Unlicence d, (untested but compiling), probably-optimal-in-terms-of-speed set of padding/trimming functions:

padL :: a -> Int -> [a] -> [a]
padL p s l
    | length l >= s = l
    | otherwise     = replicate (s - length l) p ++ l
{-# INLINABLE padL #-}

padR :: a -> Int -> [a] -> [a]
padR p s l = take s $ l ++ repeat p
{-# INLINABLE padR #-}

trimL :: Int -> [a] -> [a]
trimL s l
    | length l <= s = l
    | otherwise     = drop (length l - s) l
{-# INLINABLE trimL #-}

trimR :: Int -> [a] -> [a]
trimR = take
{-# INLINE trimR #-}

resizeL :: a -> Int -> [a] -> [a]
resizeL p s l
    | length l == s = l
    | length l < s  = replicate (s - length l) p ++ l
    | otherwise     = drop (length l - s) l
{-# INLINABLE resizeL #-}

resizeR :: a -> Int -> [a] -> [a]
resizeR p s l
    | length l == s = l
    | length l < s  = take s $ l ++ repeat p
    | otherwise     = take s l
{-# INLINABLE resizeR #-}

Answer 5

@Solomon Ucko

Why call length twice in padL (ditto for others)? How about

padL :: a -> Int -> [a] -> [a]
padL p s l
    | length' >= s = l
    | otherwise    = replicate (s - length') p ++ l
      where length' = length l