 GeeksforGeeks App
Open App Browser
Continue

# Python | Check if a list is contained in another list

Given two lists A and B, write a Python program to Check if list A is contained in list B without breaking A’s order.

Examples:

```Input : A = [1, 2], B = [1, 2, 3, 1, 1, 2, 2]
Output : True```
```Input : A = ['x', 'y', 'z'], B = ['x', 'a', 'y', 'x', 'b', 'z']
Output : False```

Approach #1: Naive Approach

A simple naive approach is to use two for loops and check if the whole list A is contained within list B or not. If such a position is met in list A, then break the loop and return true, otherwise false.

## Python3

 `# Python3 program to Check if a list is``# contained in another list without breaking order` `# Function``def` `removeElements(A, B):``    ` `    ``for` `i ``in` `range``(``len``(B)``-``len``(A)``+``1``):``        ``for` `j ``in` `range``(``len``(A)):``            ``if` `B[i ``+` `j] !``=` `A[j]:``                ``break``        ``else``:``            ``return` `True``    ` `    ``return` `False` `# Initializing lists  ``A ``=` `[``1``, ``2``]``B ``=` `[``1``, ``2``, ``3``, ``1``, ``1``, ``2``, ``2``]` `# Printing result``print``(removeElements(A, B))`

Output:

`True`

Time Complexity: O(n*n)
Auxiliary Space: O(1)

Approach #2: Using list comprehension

A more efficient approach is to use List comprehension. We first initialize ‘n’ with the length of A. Now use a for loop till len(B)-n and check in each iteration if A == B[i:i+n] or not.

## Python3

 `# Python3 program to Remove elements of``# list that repeated less than k times``def` `removeElements(A, B):``    ``n ``=` `len``(A)``    ``return` `any``(A ``=``=` `B[i:i ``+` `n] ``for` `i ``in` `range``(``len``(B)``-``n ``+` `1``))` `# Initializing lists``A ``=` `[``1``, ``2``]``B ``=` `[``1``, ``2``, ``3``, ``1``, ``1``, ``2``, ``2``]` `print``(removeElements(A, B))`

Output:

`True`

Time complexity: O(n^2). where A and B are both of length n,
Auxiliary space: O(n), where n is the length of B.

Approach #3: Using join and map module

Here we use join to join both lists to strings and then use in operator to check if list A is contained in B or not.

## Python3

 `# Python3 program to Remove elements of``# list that repeated less than k times``def` `removeElements(A, B):``    ``return` `', '``.join(``map``(``str``, A)) ``in` `', '``.join(``map``(``str``, B))`  `# Initializing lists``A ``=` `[``'x'``, ``'y'``, ``'z'``]``B ``=` `[``'x'``, ``'a'``, ``'y'``, ``'x'``, ``'b'``, ``'z'``]` `print``(removeElements(A, B))`

Output:

`False`

Time complexity: O(m*n) , where m is the length of A and n is the length of B.
Auxiliary space: O(1),where m is length of A and n is the length of B.

Approach #4: Using regular expressions

To check if a list is contained in another list using the Python re (regular expression) module, you can use the re.findall() function to find all instances of list A within list B as a string. If the number of instances found is greater than 0, it means that list A is contained within list B.

Here is an example of how this can be done:

## Python3

 `import` `re`  `def` `check_list_contained(A, B):``  ``# convert list A to string``    ``A_str ``=` `' '``.join(``map``(``str``, A))``    ``# convert list B to string``    ``B_str ``=` `' '``.join(``map``(``str``, B))``    ``# find all instances of A within B``    ``instances ``=` `re.findall(A_str, B_str)` `    ``# return True if any instances were found, False otherwise``    ``return` `len``(instances) > ``0`  `# Initializing lists``A ``=` `[``'x'``, ``'y'``, ``'z'``]``B ``=` `[``'x'``, ``'a'``, ``'y'``, ``'x'``, ``'b'``, ``'z'``]` `print``(check_list_contained(A, B))` `# This code is contributed by Edula Vinay Kumar Reddy`

Output

`False`

Time complexity: O(m*n) , where m is length of A and n is length of B.
Auxiliary space: O(1), where m is length of A and n is length of B.

Approach #5: Using Recursive method

Steps:

1. If list A is empty, return True, as an empty list is always a sublist of any list.
2. If list B is empty, return False, as an empty list cannot contain any sublist.
3. If A matches B, recursively check the rest of the elements of A and B by calling the is_sublist method with A[1:] and B[1:].
4. If A does not match B, recursively check if A is a sublist of the remaining elements of B by calling the is_sublist method with A and B[1:]
5. Return True if the previous recursive call returned True, indicating that A is a sublist of B, or False otherwise.

## Python3

 `def` `is_sublist(A, B):``    ``if` `not` `A:``        ``return` `True``    ``if` `not` `B:``        ``return` `False``    ``if` `A[``0``] ``=``=` `B[``0``]:``        ``return` `is_sublist(A[``1``:], B[``1``:])``    ``return` `is_sublist(A, B[``1``:])`  `# Initializing lists``A ``=` `[``1``, ``2``]``B ``=` `[``1``, ``2``, ``3``, ``1``, ``1``, ``2``, ``2``]` `res ``=` `is_sublist(A, B)` `# Printing the result``print``(res)` `# This code contributed by tvsk`

Output

`True`

Time complexity: O(n * m), where n is the length of list A and m is the length of list B. This is because the function needs to traverse both lists in the worst-case scenario, and the length of list B may need to be traversed multiple times depending on the position of the matching element of A.

Auxiliary space: O(max(n, m)), where n is the length of list A and m is the length of list B. This is because the function makes recursive calls, and each call adds a new stack frame to the call stack, potentially using up additional memory. However, the maximum depth of the call stack is bounded by the maximum length of A or B, so the space used is proportional to the maximum of the two lengths.

Approach #6: Using Numpy

Note: install numpy module using command “pip install numpy”

Steps:

1. Import numpy module and define a function named “check_list_contained” that takes two parameters, “A” and “B”.
2. Convert “A” and “B” to numpy arrays “A_arr” and “B_arr” respectively.
3. Loop through “B_arr” using a for loop and range function for index “i” in range of length of “B_arr”.
4. Check if the subarray of “B_arr” starting from index “i” and of length equal to the length of “A_arr” is equal to “A_arr” using the numpy array_equal() function.
5. If the above condition is true, then return True, as the list “A” is contained in the list “B”.
6. If the loop finishes execution without returning True, return False, as the list “A” is not contained in the list “B”.
7. Test the function by passing two list parameters “A” and “B”.
8. Print the result of the function call.

## Python3

 `import` `numpy as np`  `def` `check_list_contained(A, B):` `  ``# convert list A to numpy array``    ``A_arr ``=` `np.array(A)``    ``# convert list B to numpy array``    ``B_arr ``=` `np.array(B)` `    ``for` `i ``in` `range``(``len``(B_arr)):``        ``if` `np.array_equal(A_arr, B_arr[i:i``+``len``(A_arr)]):``            ``return` `True``    ``return` `False`  `# Initializing lists``A ``=` `[``1``, ``2``]``B ``=` `[``1``, ``2``, ``3``, ``1``, ``1``, ``2``, ``2``]` `print``(check_list_contained(A, B))` `A ``=` `[``'x'``, ``'y'``, ``'z'``]``B ``=` `[``'x'``, ``'a'``, ``'y'``, ``'x'``, ``'b'``, ``'z'``]` `print``(check_list_contained(A, B))`

Output:

```True
False```

Time complexity: O(n^2), where n is the length of B.
Auxiliary space: O(n), where n is the length of B.

My Personal Notes arrow_drop_up