Haskell - alternating elements from two lists

Question

I\'m trying to write a haskell function that takes in two lists of integers and generates a list with elements that have been taken alternatingly from the two lists.

I

Answer 1

Your blend function seems to be a limited version of flatZip. The flatZip function is similar but works for any number of lists of varying lengths. Using flatZip to implement blend will cause blend to also support varying lengths by default. Therefore, using a flatZip based approach may not be the way to go in situations where trimming the input lists to equal length is part of the desired behaviour.

The name flatZip refers to "a zipish way of flattening". Note the -ish part though. We can implement the function by composing concat with transpose. We can add blend on top of flatZip as syntactic sugar to verify that our implementation matches the desired behaviour.

import Data.List

flatZip = concat . transpose
flatZip([[1,2],[3],[4,5,6]]) --[1,3,4,2,5,6]

blend xs ys = flatZip [xs, ys]
blend [1,2,3] [4,5,6] --[1,4,2,5,3,6]

Answer 2

I will assume that this is homework. Provided that you can create the following list (as you said):

[(1,4),(2,5),(3,6)]

... you can solve it with 2 functions:

1. You need to convert a tuple (a, b) into a list [a, b]. Try using pattern matching! This function needs to be applied (aka. mapped) over all elements of the list you have.
2. You will have a list of lists, like [[1,4],[2,5],[3,6]], so you need a function for concatenating the sublists into one big list.

There are of course other, maybe superior, ways to solve this problem, but it might be a good idea to continue with your original approach.

Answer 3

A solution without using concat or explicit recursion:

blend l = foldr($)[] . zipWith(.) (map(:)l) . map(:)

We can make also make this point-free

blend' = (foldr($)[].) . (.map(:)) . zipWith(.) . map(:)

---

How it works: first decorate both lists with cons operators

\[1,2,3] [4,5,6] -> [1:, 2:, 3:] [4:, 5:, 6:]

then we zip this together with function composition

-> [(1:).(4:), (2:).(5:), (3:).(6:)]

and finally fold the application of all these compositions from the right to the empty list

-> (1:).(4:) $ (2:).(5:) $ (3:).(6:) $ [] = 1:4:2:5:3:6:[] = [1,4,2,5,3,6]

Answer 4

If you want to zip, generate lists instead of tuples:

concat $ zipWith (\x y -> [x,y]) [1,2,3] [4,5,6]

Some pointless fun:

concat $ zipWith ((flip(:)).(:[])) [1,2,3] [4,5,6]  

Probably the easiest way:

import Data.List
concat $ transpose [[1,2,3],[4,5,6]]

Answer 5

How about exchanging the arguments during recursion-descend?

blend (x:xs) ys = x:(blend ys xs)
blend _ _ = []

You can even generalise this approach for any number of lists (I'll leave this to you) or take the remaining elements of a list if the other is empty:

blend _ ys = ys