Haskell-我如何走向并比较阵列/列表

Question

I am New to Haskell, but Veteran in some other languages. (This question was taken from an Assembly language exercise, but I would like to solve it in Haskell.It is not part of homework or a test question)

Given: An array (list) which has the values inside the list follow this pattern:

The first item is smaller than the second item, the second item is greater than the third item, the third item is smaller than the fourth item and so on, (a "wave").

Questions:

1 How do I solve it in Haskell? (I know how to solve it in other languages where I can handle the array indices, but I do not know how to how solve it with a functional language.

2. Can the answer be generalized so it can solve other patterns?

Answer 1

This can be quite easily expressed in Haskell

wave :: (Ord a) => [a] -> Bool
wave xs = and $ zipWith3 ($) (cycle [(<),(>)]) xs (tail xs)

We could also trivially parametrise it on the patterns

waveLike :: [(a -> a -> Bool)] -> [a] -> Bool
waveLike patterns xs = and $ zipWith3 ($) (cycle patterns) xs (tail xs)

twoUpTwoDown :: (Ord a) => [a] -> Bool
twoUpTwoDown = waveLike [(<),(<),(>),(>)]

coprimeThenNotCoprime :: (Integral a) => [a] -> Bool
coprimeThenNotCoprime = waveLike [coprime, notCoprime]
  where coprime m n = gcd m n == 1
        notCoprime m n = not (coprime m n)

Answer 2

Probie's is a very elegant solution, but perhaps a basic recursion can be more understandable for a beginner.

wave :: (Ord a) => [a] -> Bool
wave []            = True
wave [_]           = True
wave [x1,x2]       = x1 < x2
wave (x1:x2:x3:xs) = x1 < x2 && x2 > x3 && wave (x3:xs)

The four lines of code read as follows:

A list with 0 elements is wavy.

A list with 1 element is wavy.

A list with 2 elements is wavy iff it is increasing.

A list with at least 3 elements starting with x1,x2,x3 is wavy iff

1. we go "up" between x1 and x2 ,
2. we go "down" between x2 and x3 ,
3. the list from x3 onward (including x3 ) is wavy.