Jtdylktuy

I have two lists, A & B, and I would like to test whether A is contained in B. By "contained" I mean that the elements of A appear in the exact same order within B with no other elements between them. What I'm looking for is very similar to the behavior of A in B if they were strings.

Some elements of A will be repeated. We can assume A will be shorter than B.

There are many answers to similar questions on SO, but most answer a different question:

• Is A an element of B? (Not my question: B is a flat list, not a list of lists.)


• Are all the elements of A contained in B? (Not my question: I'm concerned about order as well.)


• Is A a sublist of B? (Not my question: I don't want to know whether the elements of A appear in the same order in B, I want to know if they appear exactly as they are somewhere in B.)

If the operation were implemented as the keyword containedin, it would behave like this.

>>> [2, 3, 4] containedin [1, 2, 3, 4, 5]

True

>>> [2, 3, 4] containedin [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]

False

>>> [2, 3, 4] containedin [5, 4, 3, 2, 1]

False

>>> [2, 2, 2] containedin [1, 2, 3, 4, 5]

False

>>> [2, 2, 2] containedin [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]

False

>>> [2, 2, 2] containedin [1, 1, 1, 2, 2, 2, 3, 3, 3]

True

Is there a concise way to perform this operation in Python? Am I missing some important terminology that would have led me to the answer more quickly?

Use any with list slicing:

def contained_in(lst, sub):

    n = len(sub)

    return any(sub == lst[i:i+n] for i in range(len(lst)-n+1))

Or, use join to join both lists to strings and use in operator:

def contained_in(lst, sub):

    return ','.join(map(str, sub)) in ','.join(map(str, lst))

Usage:

>>> contained_in([1, 2, 3, 4, 5], [2, 3, 4])

True

>>> contained_in([1, 2, 2, 4, 5], [2, 3, 4])

False

many people have posted their answers. but I want to post my efforts anyway ;)
this is my code:

def containedin(a,b):

    for j in range(len(b)-len(a)+1):

        if a==b[j:j+len(a)]:

            return True

    return False



print(containedin([2, 3, 4],[1, 2, 3, 4, 5]))

print(containedin([2, 3, 4],[1, 1, 2, 2, 3, 3, 4, 4, 5, 5]))

print(containedin([2, 3, 4],[5, 4, 3, 2, 1]))

print(containedin([2, 2, 2],[1, 2, 3, 4, 5]))

print(containedin([2, 2, 2],[1, 1, 1, 2, 2, 2, 3, 3, 3]))

this is the output:
True
False
False
False
True

Assuming a always shorter than b what you can do is as follows.

 any(a == b[i:i+len(a)] for i in range(len(b)-len(a)+1))

Considering you need to preserve order:

def contains(sub_array, array):

    for i in range(len(array)-len(sub_array)+1):

        for j in range(len(sub_array)):

            if array[i+j] != sub_array[j]:

                break

        else:

            return i, i+len(sub_array)

    return False

Use this function

I tried to not make it complex

def contains(list1,list2):



    str1=""

    for i in list1:

        str1+=str(i)



    str2=""

    for j in list2:

        str2+=str(j)



    if str1 in str2:

        return True



    else:

        return False

Hope it works :)

Something like this?

class myList(list):

    def in_other(self, other_list):

        for i in range(0, len(other_list)-len(self)):

            if other_list[i:i+len(self)] == self:

                return True

            else:

                continue



if __name__ == "__main__":



    x = myList([1, 2, 3])

    b = [0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]



    print(x.in_other(b))