# Find a string which matches all the patterns in the given array

Given an array of strings arr[] which contains patterns of characters and “*” denoting any set of characters including the empty string. The task is to find a string that matches all the patterns in the array.
Note: If there is no such possible pattern, print -1.
Examples:

Input: arr[] = {“pq*du*q”, “pq*abc*q”, “p*d*q”}
Output: pqduabcdq
Explanation:
Pattern “pqduabcdq” matches all the strings:
String 1:
First “*” can be replaced by a empty string.
Second “*” can be replaced by “abcdq”.
String 2:
First “*” can be replaced by “du”
Second “*” can be replaced by “d”
String 3:
First “*” can be replaced by “q”
Second “*” can be replaced by “uabcd”
Input: arr[] = {“a*c”, “*”}
Output: ac

Approach: The idea is to find the common prefix and suffix string in all the patterns and then the middle of every pattern can be replaced by the first or last “*” in every pattern. Below is the illustration of the approach:

• Create three empty strings that match with the prefix, suffix, and middle portion of every pattern.
• Iterate over every pattern in the array, For every pattern:
• Find the first and last “*” in the pattern.
• Iterate over the existing prefix and check that if it matches the current prefix of the pattern, If any character doesn’t match with the pattern, return -1.
• If there is some portion that is leftover in the prefix of the current pattern, then append it to the prefix of the common string.
• Similarly, match the suffix of the pattern.
• Finally, append all the middle characters of the string except the “*” in the middle initialized string for the common string.
• Finally, concatenate the portions of the common string that is the prefix, middle, and the suffix portion of the string.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ` `// string which matches ` `// all the patterns`   `#include` `using` `namespace` `std;`   `// Function to find a common string ` `// which matches all the pattern` `string find(vector S,``int` `N)` `{` `    ``// For storing prefix till` `    ``// first most * without conflicts` `    ``string pref;` `    `  `    ``// For storing suffix till` `    ``// last most * without conflicts` `    ``string suff;` `    `  `    ``// For storing all middle ` `    ``// characters between ` `    ``// first and last *` `    ``string mid;` `        `  `    ``// Loop to iterate over every ` `    ``// pattern of the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        `  `        ``// Index of the first "*"` `        ``int` `first = ``int``(` `            ``S[i].find_first_of(``'*'``)` `            ``);` `           `  `        ``// Index of Last "*"` `        ``int` `last = ``int``(` `            ``S[i].find_last_of(``'*'``)` `            ``);` `        `  `        ``// Iterate over the first "*"` `        ``for` `(``int` `z = 0; z < ``int``(pref.size()) && ` `                              ``z < first; z++) {` `            ``if` `(pref[z] != S[i][z]) {` `                ``return` `"*"``;` `            ``}` `        ``}` `        `  `        ``// Prefix till first most *` `        ``// without conflicts` `        ``for` `(``int` `z = ``int``(pref.size()); ` `                       ``z < first; z++) {` `            ``pref += S[i][z];` `        ``}` `        `  `        ``// Iterate till last ` `        ``// most * from last` `        ``for` `(``int` `z = 0; z < ``int``(suff.size()) &&` `               ``int``(S[i].size())-1-z > last; z++) {` `            ``if` `(suff[z] != S[i][``int``(S[i].size())-1-z]) {` `                ``return` `"*"``;` `            ``}` `        ``}` `        `  `        ``// Make suffix till last ` `        ``// most * without conflicts` `        ``for` `(``int` `z = ``int``(suff.size()); ` `         ``int``(S[i].size())-1-z > last; z++) {` `            ``suff += S[i][``int``(S[i].size())-1-z];` `        ``}` `        `  `        ``// Take all middle characters ` `        ``// in between first and last most *` `        ``for` `(``int` `z = first; z <= last; z++) {` `            ``if` `(S[i][z] != ``'*'``) mid += S[i][z];` `        ``}` `    ``}` `    `  `    ``reverse(suff.begin(), suff.end());` `    ``return` `pref + mid + suff;` `}`   `// Driver Code` `int` `main() {`   `    ``int` `N = 3; ` `    ``vector s(N);` `    `  `    ``// Take all ` `    ``// the strings` `    ``s=``"pq*du*q"``;` `    ``s=``"pq*abc*q"``;` `    ``s=``"p*d*q"``;` `    `  `    ``// Method for finding` `    ``// common string` `    ``cout<

## Python3

 `# Python3 implementation ` `# to find the string which ` `# matches all the patterns`   `# Function to find a common ` `# string which matches all ` `# the pattern` `def` `find(S, N):`   `    ``# For storing prefix ` `    ``# till first most * ` `    ``# without conflicts` `    ``pref ``=` `""`   `    ``# For storing suffix ` `    ``# till last most * ` `    ``# without conflicts` `    ``suff ``=` `""`   `    ``# For storing all middle ` `    ``# characters between ` `    ``# first and last *` `    ``mid ``=` `""`   `    ``# Loop to iterate over every ` `    ``# pattern of the array` `    ``for` `i ``in` `range``(N):`   `        ``# Index of the first "*"` `        ``first ``=` `int``(S[i].index(``"*"``))`   `        ``# Index of Last "*"` `        ``last ``=` `int``(S[i].rindex(``"*"``))`   `        ``# Iterate over the first "*"` `        ``for` `z ``in` `range``(``len``(pref)):` `            ``if``(z < first):` `                ``if``(pref[z] !``=` `S[i][z]):` `                    ``return` `"*"`   `        ``# Prefix till first most *` `        ``# without conflicts` `        ``for` `z ``in` `range``(``len``(pref),first):` `            ``pref ``+``=` `S[i][z];`   `        ``# Iterate till last ` `        ``# most * from last` `        ``for` `z ``in` `range``(``len``(suff)):` `            ``if``(``len``(S[i]) ``-` `1` `-` `z > last):` `                ``if``(suff[z] !``=` `S[i][``len``(S[i]) ``-` `1` `-` `z]):` `                    ``return` `"*"`   `        ``# Make suffix till last ` `        ``# most * without conflicts` `        ``for` `z ``in` `range``(``len``(suff), ` `                       ``len``(S[i]) ``-` `1` `-` `last):` `            ``suff ``+``=` `S[i][``len``(S[i]) ``-` `1` `-` `z]`   `        ``# Take all middle characters ` `        ``# in between first and last most *` `        ``for` `z ``in` `range``(first, last ``+` `1``):` `            ``if``(S[i][z] !``=` `'*'``):` `                ``mid ``+``=` `S[i][z]` `    `  `    ``suff``=``suff[:: ``-``1``]` `    ``return` `pref ``+` `mid ``+` `suff`   `# Driver Code` `N ``=` `3` `s ``=` `["" ``for` `i ``in` `range``(N)]`   `# Take all ` `# the strings` `s[``0``] ``=` `"pq*du*q"` `s[``1``] ``=` `"pq*abc*q"` `s[``2``] ``=` `"p*d*q"`   `# Method for finding` `# common string` `print``(find(s, N))`   `# This code is contributed by avanitrachhadiya2155`

Output:

```pqduabcdq

```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.