 GFG App
Open App Browser
Continue

# Check whether an Array is Subarray of another Array

Given two arrays A[] and B[] consisting of and integers. The task is to check whether the array B[] is a subarray of the array A[] or not.

Examples

Input : A[] = {2, 3, 0, 5, 1, 1, 2}, B[] = {3, 0, 5, 1}
Output : Yes

Input : A[] = {1, 2, 3, 4, 5}, B[] = {2, 5, 6}
Output : No

Source: Visa Interview Experience

Approach:

• Iterate through the array A[] using a loop that runs from 0 to n-m, where n and m are the sizes of arrays A[] and B[] respectively. This loop represents the starting index of the subarray of A[] that we are comparing with B[].
• For each starting index in the loop, iterate through the array B[] using another loop that runs from 0 to m-1. This loop represents the index of the elements in the subarray that we are comparing with the corresponding elements in B[].
• If the elements at the corresponding indices in the subarray of A[] and B[] are not equal, break out of the inner loop and move to the next starting index in the outer loop.
• If all the elements in the subarray of A[] match the elements in B[], return true.
• If none of the starting indices in the outer loop result in a matching subarray, return false.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `// Function to check if an array is` `// subarray of another array` `bool` `isSubArray(``int` `A[], ``int` `B[], ``int` `n, ``int` `m) {` `    ``for` `(``int` `i = 0; i <= n-m; i++) {  ``// Loop through possible starting indices of subarray` `        ``int` `j;` `        ``for` `(j = 0; j < m; j++) {  ``// Loop through elements of subarray and compare with B[]` `            ``if` `(A[i+j] != B[j]) {` `                ``break``;` `            ``}` `        ``}` `        ``if` `(j == m) {  ``// All elements of B[] match subarray starting at index i` `            ``return` `true``;` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Driver Code` `int` `main() {` `    ``int` `A[] = { 2, 3, 0, 5, 1, 1, 2 };` `    ``int` `n = ``sizeof``(A) / ``sizeof``(``int``);` `    ``int` `B[] = { 3, 0, 5, 1 };` `    ``int` `m = ``sizeof``(B) / ``sizeof``(``int``);`   `    ``if` `(isSubArray(A, B, n, m))` `        ``cout << ``"YES\n"``;` `    ``else` `        ``cout << ``"NO\n"``;`   `    ``return` `0;` `}`

Output

```YES
```

Time Complexity: O(n*m), where n and m are the sizes of the arrays A[] and B[], respectively.
Space Complexity: O(1) as we are not using any additional space to store the arrays or any other variables.

Efficient Approach : An efficient approach is to use two pointers to traverse both the array simultaneously. Keep the pointer of array B[] still and if any element of A[] matches with the first element of B[] then increase the pointer of both the array else set the pointer of A to the next element of the previous starting point and reset the pointer of B to 0. If all the elements of B are matched then print YES otherwise print NO.

Below is the implementation of the above approach:

## C++

 `// C++ program to check if an array is` `// subarray of another array`   `#include ` `using` `namespace` `std;`   `// Function to check if an array is` `// subarray of another array` `bool` `isSubArray(``int` `A[], ``int` `B[], ``int` `n, ``int` `m)` `{` `    ``// Two pointers to traverse the arrays` `    ``int` `i = 0, j = 0;`   `    ``// Traverse both arrays simultaneously` `    ``while` `(i < n && j < m) {`   `        ``// If element matches` `        ``// increment both pointers` `        ``if` `(A[i] == B[j]) {`   `            ``i++;` `            ``j++;`   `            ``// If array B is completely` `            ``// traversed` `            ``if` `(j == m)` `                ``return` `true``;` `        ``}` `        ``// If not,` `        ``// increment i and reset j` `        ``else` `{` `            ``i = i - j + 1;` `            ``j = 0;` `        ``}` `    ``}`   `    ``return` `false``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A[] = { 2, 3, 0, 5, 1, 1, 2 };` `    ``int` `n = ``sizeof``(A) / ``sizeof``(``int``);` `    ``int` `B[] = { 3, 0, 5, 1 };` `    ``int` `m = ``sizeof``(B) / ``sizeof``(``int``);`   `    ``if` `(isSubArray(A, B, n, m))` `        ``cout << ``"YES\n"``;` `    ``else` `        ``cout << ``"NO\n"``;`   `    ``return` `0;` `}`

## Java

 `// Java program to check if an array is` `// subarray of another array` `class` `gfg ` `{` `    `  `    ``// Function to check if an array is` `    ``// subarray of another array` `    ``static` `boolean` `isSubArray(``int` `A[], ``int` `B[], ` `                                   ``int` `n, ``int` `m)` `    ``{` `        ``// Two pointers to traverse the arrays` `        ``int` `i = ``0``, j = ``0``;` `    `  `        ``// Traverse both arrays simultaneously` `        ``while` `(i < n && j < m)` `        ``{` `    `  `            ``// If element matches` `            ``// increment both pointers` `            ``if` `(A[i] == B[j])` `            ``{` `    `  `                ``i++;` `                ``j++;` `    `  `                ``// If array B is completely` `                ``// traversed` `                ``if` `(j == m)` `                    ``return` `true``;` `            ``}` `            `  `            ``// If not,` `            ``// increment i and reset j` `            ``else` `            ``{` `                ``i = i - j + ``1``;` `                ``j = ``0``;` `            ``}` `        ``}` `        ``return` `false``;` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `main(String arr[])` `    ``{` `        ``int` `A[] = { ``2``, ``3``, ``0``, ``5``, ``1``, ``1``, ``2` `};` `        ``int` `n = A.length;` `        ``int` `B[] = { ``3``, ``0``, ``5``, ``1` `};` `        ``int` `m = B.length;` `    `  `        ``if` `(isSubArray(A, B, n, m))` `            ``System.out.println(``"YES"``);` `        ``else` `            ``System.out.println(``"NO"``);` `    ``}` `}`   `// This code is contributed by gp6`

## Python3

 `# Python3 program to check if an array is ` `# subarray of another array `   `# Function to check if an array is` `# subarray of another array` `def` `isSubArray(A, B, n, m):` `    `  `    ``# Two pointers to traverse the arrays` `    ``i ``=` `0``; j ``=` `0``;`   `    ``# Traverse both arrays simultaneously` `    ``while` `(i < n ``and` `j < m):`   `        ``# If element matches` `        ``# increment both pointers` `        ``if` `(A[i] ``=``=` `B[j]):`   `            ``i ``+``=` `1``;` `            ``j ``+``=` `1``;`   `            ``# If array B is completely` `            ``# traversed` `            ``if` `(j ``=``=` `m):` `                ``return` `True``;` `        `  `        ``# If not,` `        ``# increment i and reset j` `        ``else``:` `            ``i ``=` `i ``-` `j ``+` `1``;` `            ``j ``=` `0``;` `        `  `    ``return` `False``;`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``A ``=` `[ ``2``, ``3``, ``0``, ``5``, ``1``, ``1``, ``2` `];` `    ``n ``=` `len``(A);` `    ``B ``=` `[ ``3``, ``0``, ``5``, ``1` `];` `    ``m ``=` `len``(B);`   `    ``if` `(isSubArray(A, B, n, m)):` `        ``print``(``"YES"``);` `    ``else``:` `        ``print``(``"NO"``);`   `# This code is contributed by Rajput-Ji`

## C#

 `// C# program to check if an array is` `// subarray of another array` `using` `System;`   `public` `class` `GFG ` `{` `     `  `    ``// Function to check if an array is` `    ``// subarray of another array` `    ``static` `bool` `isSubArray(``int` `[]A, ``int` `[]B, ` `                                   ``int` `n, ``int` `m)` `    ``{` `        ``// Two pointers to traverse the arrays` `        ``int` `i = 0, j = 0;` `     `  `        ``// Traverse both arrays simultaneously` `        ``while` `(i < n && j < m)` `        ``{` `     `  `            ``// If element matches` `            ``// increment both pointers` `            ``if` `(A[i] == B[j])` `            ``{` `     `  `                ``i++;` `                ``j++;` `     `  `                ``// If array B is completely` `                ``// traversed` `                ``if` `(j == m)` `                    ``return` `true``;` `            ``}` `             `  `            ``// If not,` `            ``// increment i and reset j` `            ``else` `            ``{` `                ``i = i - j + 1;` `                ``j = 0;` `            ``}` `        ``}` `        ``return` `false``;` `    ``}` `     `  `    ``// Driver Code` `    ``public` `static` `void` `Main(String []arr)` `    ``{` `        ``int` `[]A = { 2, 3, 0, 5, 1, 1, 2 };` `        ``int` `n = A.Length;` `        ``int` `[]B = { 3, 0, 5, 1 };` `        ``int` `m = B.Length;` `     `  `        ``if` `(isSubArray(A, B, n, m))` `            ``Console.WriteLine(``"YES"``);` `        ``else` `            ``Console.WriteLine(``"NO"``);` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

`YES`

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

Related Topic: Subarrays, Subsequences, and Subsets in Array

My Personal Notes arrow_drop_up