# Find starting index for every occurence of given array B in array A using Z-Algorithm

Given two array A and B, the task is to find the starting index for every occurence of array B in array A using Z-Algorithm.

Examples:

Input: A = {1, 2, 3, 2, 3}, B = {2, 3}
Output: 1 3
Explanation:
In array A, array B occurs at index 1 and index 3. Thus the answer is {1, 3}.

Input: A = {1, 1, 1, 1, 1}, B = {1}
Output: 0 1 2 3 4
In array A, array B occur at index {0, 1, 2, 3, 4}.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

In Z-Algorithm, we construct a Z-Array.

What is Z-Array?

For a arr[0..n-1], Z array is an array, of same length as the string array arr, where each element Z[i] of Z array stores length of the longest substring starting from arr[i] which is also a prefix of arr[0..n-1]. The first entry of Z array is meaning less as complete array is always prefix of itself.

For example: For a given array arr[] = { 1, 2, 3, 0, 1, 2, 3, 5} Approach:

• Merge array B and array A with a separator in between into a new array C. Here separator can be any special character.
• Create Z-array using array C.
• Iterate over the Z-array and print all those indices whose value is greater than or equal to the length of the array B.

Below is the implementation of the above approach.

## Java

 `// Java implementation for pattern ` `// searching in an array using Z-Algorithm ` ` `  `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GfG { ` ` `  `    ``// Function to calculate Z-Array ` `    ``private` `static` `int``[] zArray(``int` `arr[]) ` `    ``{ ` `        ``int` `z[]; ` `        ``int` `n = arr.length; ` `        ``z = ``new` `int``[n]; ` `        ``int` `r = ``0``, l = ``0``; ` ` `  `        ``// Loop to calculate Z-Array ` `        ``for` `(``int` `k = ``1``; k < n; k++) { ` ` `  `            ``// Outside the Z-box ` `            ``if` `(k > r) { ` `                ``r = l = k; ` `                ``while` `(r < n ` `                       ``&& arr[r] == arr[r - l]) ` `                    ``r++; ` `                ``z[k] = r - l; ` `                ``r--; ` `            ``} ` ` `  `            ``// Inside Z-box ` `            ``else` `{ ` `                ``int` `k1 = k - l; ` ` `  `                ``if` `(z[k1] < r - k + ``1``) ` `                    ``z[k] = z[k1]; ` ` `  `                ``else` `{ ` `                    ``l = k; ` `                    ``while` `(r < n ` `                           ``&& arr[r] == arr[r - l]) ` `                        ``r++; ` `                    ``z[k] = r - l; ` `                    ``r--; ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `z; ` `    ``} ` ` `  `    ``// Helper function to merge two ` `    ``// arrays and create a single array ` `    ``private` `static` `int``[] mergeArray(``int` `A[], ` `                                    ``int` `B[]) ` `    ``{ ` `        ``int` `n = A.length; ` `        ``int` `m = B.length; ` `        ``int` `z[]; ` ` `  `        ``// Array to store merged array ` `        ``int` `c[] = ``new` `int``[n + m + ``1``]; ` ` `  `        ``// Copying array B ` `        ``for` `(``int` `i = ``0``; i < m; i++) ` `            ``c[i] = B[i]; ` ` `  `        ``// Adding a seperator ` `        ``c[m] = Integer.MAX_VALUE; ` ` `  `        ``// Copying array A ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``c[m + i + ``1``] = A[i]; ` ` `  `        ``// Calling Z-function ` `        ``z = zArray(c); ` `        ``return` `z; ` `    ``} ` ` `  `    ``// Function to help compute the Z array ` `    ``private` `static` `void` `findZArray(``int` `A[], ``int` `B[], ``int` `n) ` `    ``{ ` `        ``int` `flag = ``0``; ` `        ``int` `z[]; ` `        ``z = mergeArray(A, B); ` ` `  `        ``// Printing indexes where array B occur ` `        ``for` `(``int` `i = ``0``; i < z.length; i++) { ` `            ``if` `(z[i] == n) { ` ` `  `                ``System.out.print((i - n - ``1``) ` `                                 ``+ ``" "``); ` `                ``flag = ``1``; ` `            ``} ` `        ``} ` `        ``if` `(flag == ``0``) { ` `            ``System.out.println(``"Not Found"``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `A[] = { ``1``, ``2``, ``3``, ``2``, ``3``, ``2` `}; ` `        ``int` `B[] = { ``2``, ``3` `}; ` `        ``int` `n = B.length; ` ` `  `        ``findZArray(A, B, n); ` `    ``} ` `} `

## Python3

 `# Python3 implementation for pattern  ` `# searching in an array using Z-Algorithm  ` `import` `sys; ` ` `  `# Function to calculate Z-Array  ` `def` `zArray(arr) : ` `    ``n ``=` `len``(arr);  ` `    ``z ``=` `[``0``]``*``n; ` `    ``r ``=` `0``;  ` `    ``l ``=` `0``; ` `     `  `    ``# Loop to calculate Z-Array ` `    ``for` `k ``in` `range``(``1``, n) : ` `         `  `        ``# Outside the Z-box ` `        ``if` `(k > r) : ` `            ``r ``=` `l ``=` `k; ` `            ``while` `(r < n ``and` `arr[r] ``=``=` `arr[r ``-` `l]) : ` `                ``r ``+``=` `1``; ` `            ``z[k] ``=` `r ``-` `l; ` `            ``r ``-``=` `1``; ` `                 `  `        ``# Inside Z-box ` `        ``else` `: ` `            ``k1 ``=` `k ``-` `l; ` `             `  `            ``if` `(z[k1] < r ``-` `k ``+` `1``) : ` `                ``z[k] ``=` `z[k1]; ` `                 `  `            ``else` `: ` `                ``l ``=` `k; ` `                ``while` `(r < n ``and` `arr[r] ``=``=` `arr[r ``-` `l]) : ` `                    ``r ``+``=` `1` `; ` `                ``z[k] ``=` `r ``-` `l; ` `                ``r ``-``=` `1``; ` `                     `  `    ``return` `z;  ` ` `  `# Helper function to merge two  ` `# arrays and create a single array  ` `def` `mergeArray(A,B) :  ` ` `  `    ``n ``=` `len``(A);  ` `    ``m ``=` `len``(B);  ` ` `  `    ``# Array to store merged array  ` `    ``c ``=` `[``0``]``*``(n ``+` `m ``+` `1``);  ` ` `  `    ``# Copying array B  ` `    ``for` `i ``in` `range``(m) : ` `        ``c[i] ``=` `B[i];  ` ` `  `    ``# Adding a seperator  ` `    ``c[m] ``=` `sys.maxsize;  ` ` `  `    ``# Copying array A  ` `    ``for` `i ``in` `range``(n) :  ` `        ``c[m ``+` `i ``+` `1``] ``=` `A[i];  ` ` `  `    ``# Calling Z-function  ` `    ``z ``=` `zArray(c);  ` `    ``return` `z;  ` ` `  `# Function to help compute the Z array  ` `def` `findZArray( A,B, n) : ` `    ``flag ``=` `0``; ` `    ``z ``=` `mergeArray(A, B); ` `     `  `    ``# Printing indexes where array B occur ` `    ``for` `i ``in` `range``(``len``(z)) : ` `        ``if` `(z[i] ``=``=` `n) : ` `            ``print``(i ``-` `n ``-` `1``, end``=` `" "``); ` `            ``flag ``=` `1``; ` `             `  `    ``if` `(flag ``=``=` `0``) : ` `        ``print``(``"Not Found"``);  ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `"__main__"` `: ` `     `  `    ``A ``=` `[ ``1``, ``2``, ``3``, ``2``, ``3``, ``2``]; ` `    ``B ``=` `[ ``2``, ``3` `]; ` `    ``n ``=` `len``(B); ` `    ``findZArray(A, B, n);  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation for pattern  ` `// searching in an array using Z-Algorithm  ` `using` `System; ` ` `  `class` `GfG  ` `{  ` ` `  `    ``// Function to calculate Z-Array  ` `    ``private` `static` `int``[] zArray(``int` `[]arr)  ` `    ``{  ` `        ``int` `[]z;  ` `        ``int` `n = arr.Length;  ` `        ``z = ``new` `int``[n];  ` `        ``int` `r = 0, l = 0;  ` ` `  `        ``// Loop to calculate Z-Array  ` `        ``for` `(``int` `k = 1; k < n; k++)  ` `        ``{  ` ` `  `            ``// Outside the Z-box  ` `            ``if` `(k > r) ` `            ``{  ` `                ``r = l = k;  ` `                ``while` `(r < n  ` `                    ``&& arr[r] == arr[r - l])  ` `                    ``r++;  ` `                ``z[k] = r - l;  ` `                ``r--;  ` `            ``}  ` ` `  `            ``// Inside Z-box  ` `            ``else` `            ``{  ` `                ``int` `k1 = k - l;  ` ` `  `                ``if` `(z[k1] < r - k + 1)  ` `                    ``z[k] = z[k1];  ` ` `  `                ``else` `                ``{  ` `                    ``l = k;  ` `                    ``while` `(r < n  ` `                        ``&& arr[r] == arr[r - l])  ` `                        ``r++;  ` `                    ``z[k] = r - l;  ` `                    ``r--;  ` `                ``}  ` `            ``}  ` `        ``}  ` `        ``return` `z;  ` `    ``}  ` ` `  `    ``// Helper function to merge two  ` `    ``// arrays and create a single array  ` `    ``private` `static` `int``[] mergeArray(``int` `[]A,  ` `                                    ``int` `[]B)  ` `    ``{  ` `        ``int` `n = A.Length;  ` `        ``int` `m = B.Length;  ` `        ``int` `[]z;  ` ` `  `        ``// Array to store merged array  ` `        ``int` `[]c = ``new` `int``[n + m + 1];  ` ` `  `        ``// Copying array B  ` `        ``for` `(``int` `i = 0; i < m; i++)  ` `            ``c[i] = B[i];  ` ` `  `        ``// Adding a seperator  ` `        ``c[m] = ``int``.MaxValue;  ` ` `  `        ``// Copying array A  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `            ``c[m + i + 1] = A[i];  ` ` `  `        ``// Calling Z-function  ` `        ``z = zArray(c);  ` `        ``return` `z;  ` `    ``}  ` ` `  `    ``// Function to help compute the Z array  ` `    ``private` `static` `void` `findZArray(``int` `[]A, ``int` `[]B, ``int` `n)  ` `    ``{  ` `        ``int` `flag = 0;  ` `        ``int` `[]z;  ` `        ``z = mergeArray(A, B);  ` ` `  `        ``// Printing indexes where array B occur  ` `        ``for` `(``int` `i = 0; i < z.Length; i++)  ` `        ``{  ` `            ``if` `(z[i] == n) ` `            ``{  ` ` `  `                ``Console.Write((i - n - 1)  ` `                                ``+ ``" "``);  ` `                ``flag = 1;  ` `            ``}  ` `        ``}  ` `        ``if` `(flag == 0)  ` `        ``{  ` `            ``Console.WriteLine(``"Not Found"``);  ` `        ``}  ` `    ``}  ` ` `  `    ``// Driver Code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `        ``int` `[]A = { 1, 2, 3, 2, 3, 2 };  ` `        ``int` `[]B = { 2, 3 };  ` `        ``int` `n = B.Length;  ` ` `  `        ``findZArray(A, B, n);  ` `    ``}  ` `}  ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```1 3
```

Time Complexity: O(N + M).

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : AnkitRai01

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.