Question

Given a list like:

let list = [1,2,3,4,5,6,7,8,9,10]

I am trying to come up with a way to detect if 7,8,9 exists in the list in sequential order and simply printout ‘success’ if it does and ‘fail’ otherwise.

I am trying to accomplish this using zip for the index. Can someone advise if I am on the right track or if there is a better way to accomplish this?

zip [0..] list

And then something like:

[if (snd x)== 
             7 && let index = (fst x) 
               && (snd x)==8 && (fst x)==(index+1) 
               && (snd x)==9 && (fst x)==(index+2) 
               then "success" 
               else "fail" | x <- list]

Answer 1

When trying to figure out a list algorithm it’s usually best to start by
thinking about the special case in the list head. In this case, how would you
test that the list begins with [7,8,9]?

beginsWith789 :: [Int] -> Bool
beginsWith789 (7:8:9:_) = True
beginsWith789 _         = False

I.e. we can just pattern match to the first three elements. Now to generalize
this, if we don’t find the subsequence in the list head, we recursively check
the tail of the list

contains789 :: [Int] -> Bool
contains789 (7:8:9:_) = True
contains789 (_:xs)    = contains789 xs
contains789 _         = False

Now if we want to further generalize this to find any subsequence, we can use
the isPrefixOf function from Data.List:

import Data.List (isPrefixOf)

contains :: Eq a => [a] -> [a] -> Bool
contains sub lst | sub `isPrefixOf` lst = True
contains (_:xs)  = contains sub xs
contains _       = False

We can tidy this up by using any and tails to check if any successively
shorter tail of the list begins with the given subsequence:

import Data.List (isPrefixOf, tails)

contains :: Eq a => [a] -> [a] -> Bool
contains sub = any (sub `isPrefixOf`) . tails

Or, we can simply use the standard library function isInfixOf. 😉

> import Data.List
> [7,8,9] `isInfixOf` [1,2,3,4,5,6,7,8,9]
True