Python code to check if an array has a sequence (1,3,4)

By PEP 8, doesSeqAppear should be does_seq_appear. You used the right naming convention for your unit tests, though. Personally, I would prefer def contains_seq(arr, seq=[1, 3, 4]).

Your arr_len < 3 test is superfluous and should therefore be eliminated. Don't write a special case when the regular case works correctly and just as quickly.

Your all(isinstance(item, int) for item in int_arr) check was not specified in the problem, and is therefore harmful. The question does not say that doesSeqAppear([3.1, 1, 3, 4]) should return False, nor does it say that it should fail with an exception. In fact, by my interpretation, it does contain the magic sequence and should therefore return True. In any case, you have wasted a complete iteration of the list just to perform a check that wasn't asked for.

Checking isinstance(int_arr, list) is un-Pythonic, since duck-typing is the norm in Python. In any case, the code would likely fail naturally if it is not a list.

After cutting all that excess, you should drop the # Loop through elements comment as well.

Per the problem definition, I would expect a function thas is able to check any sequence in an array. Not necessarily (1, 3, 4) which was given as an example. In this case, the sequence should also be a parameter of the function, giving the signature:

def has_sequence(array, sequence):

Next, I would rely on Python iterations to "check" if array is a list, or at least an iterable. As there is no obvious reasons, to me, that has_sequence('once upon a time', 'e u') should fail. It seems like a valid usecase.

Following, I would use a variation of the itertools recipe pairwise to group elements of array in tuples of the same length than sequence:

import itertools


def lookup(iterable, length):
    tees = itertools.tee(iterable, length)
    for i, t in enumerate(tees):
        for _ in xrange(i):
            next(t, None)
    return itertools.izip(*tees)


def has_sequence(array, sequence):
    # Convert to tuple for easy testing later
    sequence = tuple(sequence)
    return any(group == sequence for group in lookup(array, len(sequence)))

Now, other things that could have been done better:

• # Tested with Python 2.7 can be replaced by #!/usr/bin/env python2
• if int_arr[i] == 1 and int_arr[i+1] == 3 and int_arr[i+2] == 4 : can be replaced by if int_arr[i:i+3] == [1, 3, 4]: removing the need for the ugly \
• assert in unit tests should be replaced by self.assertTrue(…) or self.assertFalse(…)
• you should be more consistent in your usage of whitespace (putting one after each comma, none before any colon…).

KIS[S]

def sequence_contains_subsequence(sequence, subsequence):
    for i in range(0, len(sequence) - len(subsequence) + 1):
        if subsequence == sequence[i:i+len(subsequence)]:
            return True
    return False

We can't know why your interviewer rejected your application, but these types of questions are often starting points for conversation--not finished product endpoints. If you write the simplest, most straightforward code you can, you and your interviewer can then talk about things like expansion, generalization, and performance.

Your interviewer knows that asking you to change your function interface is more problematic because you'll also have to change all your [unasked for] unit tests. This slows down the process and might make the interviewer worry that you'll pollute their codebase with a lot of brittle code.

I have taken the approach of a generator get_triplet:

def get_triplet(data):
    for i, d in enumerate(data):
        if i + 2 < len(data):
            yield(i, data[i:i+3])


haystack = [2, 4, 5, 1, 3, 9, 6, 8, 1, 3, 4, 5]
needle = [1, 3, 4]
for i, d in get_triplet(haystack):
    if d == needle:
        print("Found {} at index {:d}.".format(needle, i))
        break
else:
    print("Search item {} not found.".format(needle))

This optimization allows you to reduce the number of times checking an element. It also eliminates the need to make a new iterator which you had created with range

# Loop through elements
index = 0
while index < (arr_len-2):
    if int_arr[index] != 1:
        index += 1
        continue
    if int_arr[index+1] != 3:
        index += 1
        continue
    if int_arr[index+2] != 4:
        index += 1 
        continue
    return True
return False

This may not be optimal but tries to solve the problem generically with very little code:

#! /usr/bin/env python3
def main():
    print('PASS' if contains((0, 1, 3, 4, 5), (1, 3, 4)) else 'FAIL')


def contains(iterable, sequence):
    offset, length = 0, len(sequence)
    for item in iterable:
        if item == sequence[offset]:
            offset += 1
            if offset == length:
                return True
        elif offset:
            offset = 0
    return False


if __name__ == '__main__':
    main()

I think your answer is much too long. Here's mine:

def check_for_1_3_4(seq):
    return (1, 3, 4) in zip(seq, seq[1:], seq[2:])

Here are some tests:

>>> check_for_1_3_4([1, 3, 4, 5, 6, 7])
True
>>> check_for_1_3_4([5, 6, 7, 1, 3, 4])
True
>>> check_for_1_3_4([5, 6, 1, 3, 4, 7, 8])
True
>>> check_for_1_3_4([1, 3])
False
>>> check_for_1_3_4([])
False
>>> 

My code may seem terse, but it's still readable for anyone who understands slicing and zip. I expect Python experts to at least know about slicing.