Open In App

# Count of number of given string in 2D character array

Given a 2-Dimensional character array and a string, we need to find the given string in 2-dimensional character array, such that individual characters can be present left to right, right to left, top to down or down to top.

Examples:

`Input : a ={            {D,D,D,G,D,D},            {B,B,D,E,B,S},            {B,S,K,E,B,K},            {D,D,D,D,D,E},            {D,D,D,D,D,E},            {D,D,D,D,D,G}           }        str= "GEEKS"Output :2Input : a = {            {B,B,M,B,B,B},            {C,B,A,B,B,B},            {I,B,G,B,B,B},            {G,B,I,B,B,B},            {A,B,C,B,B,B},            {M,C,I,G,A,M}            }        str= "MAGIC"Output :4`

We have discussed simpler problem to find if a word exists or not in a matrix.
Approach:

1. To count all occurrences, we follow simple brute force approach.
2. Traverse through each character of the matrix and taking each character as a start of the string to be found.
3. Try to search in all the possible directions.
4. Whenever, a word is found, increase the count.
5.  After traversing the matrix what ever will be the value of count will be number of times string exists in character matrix.

Algorithm :

• Step 1– Traverse matrix character by character and take one character as string start
• Step 2– For each character find the string in all the four directions recursively
• Step 3– If a string found, we increase the count
• Step 4– When we are done with one character as start, we repeat the same process for the next character
• Step 5– Calculate the sum of count for each character
• Step 6– Final count will be the answer

Implementation:

## C++14

 `// C++ code for finding count``// of string in a given 2D``// character array.``#include ``using` `namespace` `std;` `#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))` `// utility function to search``// complete string from any``// given index of 2d char array``int` `internalSearch(string needle, ``int` `row,``                   ``int` `col, string hay[],``                   ``int` `row_max, ``int` `col_max, ``int` `xx)``{``    ``int` `found = 0;` `    ``if` `(row >= 0 && row <= row_max && col >= 0 &&``        ``col <= col_max && needle[xx] == hay[row][col])``    ``{``        ``char` `match = needle[xx];``        ``xx += 1;` `        ``hay[row][col] = 0;` `        ``if` `(needle[xx] == 0)``        ``{``            ``found = 1;``        ``}``        ``else``        ``{` `            ``// through Backtrack searching``            ``// in every directions``            ``found += internalSearch(needle, row,``                                    ``col + 1, hay,``                                    ``row_max, col_max,xx);``            ``found += internalSearch(needle, row, col - 1,``                                    ``hay, row_max, col_max,xx);``            ``found += internalSearch(needle, row + 1, col,``                                    ``hay, row_max, col_max,xx);``            ``found += internalSearch(needle, row - 1, col,``                                    ``hay, row_max, col_max,xx);``        ``}``        ``hay[row][col] = match;``    ``}``    ``return` `found;``}` `// Function to search the string in 2d array``int` `searchString(string needle, ``int` `row, ``int` `col,``                  ``string str[], ``int` `row_count,``                                ``int` `col_count)``{``    ``int` `found = 0;``    ``int` `r, c;` `    ``for` `(r = 0; r < row_count; ++r)``    ``{``        ``for` `(c = 0; c < col_count; ++c)``        ``{``            ``found += internalSearch(needle, r, c, str,``                                    ``row_count - 1,``                                    ``col_count - 1, 0);``        ``}``    ``}``    ``return` `found;``}` `// Driver code``int` `main()``{``    ``string needle = ``"MAGIC"``;``    ``string input[] = { ``"BBABBM"``,``                       ``"CBMBBA"``,``                       ``"IBABBG"``,``                       ``"GOZBBI"``,``                       ``"ABBBBC"``,``                       ``"MCIGAM"` `};``    ``string str[ARRAY_SIZE(input)];``    ``int` `i;``    ``for` `(i = 0; i < ARRAY_SIZE(input); ++i)``    ``{``        ``str[i] = input[i];``    ``}` `    ``cout << ``"count: "` `<< searchString(needle, 0, 0, str,``                                      ``ARRAY_SIZE(str),``                                      ``str[0].size()) << endl;``    ``return` `0;``}`  `// This code is contributed by SHUBHAMSINGH8410`

## C

 `// C code for finding count``// of string in a given 2D``// character array.``#include ``#include ``#include ` `#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))` `// utility function to search``// complete string from any``// given index of 2d char array``int` `internalSearch(``char` `*needle, ``int` `row,``                   ``int` `col, ``char` `**hay,``                   ``int` `row_max, ``int` `col_max)``{``    ``int` `found = 0;` `    ``if` `(row >= 0 && row <= row_max && col >= 0 &&``        ``col <= col_max && *needle == hay[row][col])``        ``{``            ` `        ``char` `match = *needle++;` `        ``hay[row][col] = 0;` `        ``if` `(*needle == 0) {``            ``found = 1;``        ``} ``else` `{` `            ``// through Backtrack searching``            ``// in every directions``            ``found += internalSearch(needle, row,``                                    ``col+1, hay,``                                    ``row_max, col_max);``            ``found += internalSearch(needle, row, col-1,``                                    ``hay, row_max, col_max);``            ``found += internalSearch(needle, row+1, col,``                                    ``hay, row_max, col_max);``            ``found += internalSearch(needle, row-1, col,``                                    ``hay, row_max, col_max);``        ``}` `        ``hay[row][col] = match;``    ``}` `    ``return` `found;``}` `// Function to search the string in 2d array``int` `searchString(``char` `*needle, ``int` `row, ``int` `col,``                 ``char` `**str, ``int` `row_count, ``int` `col_count)``{``    ``int` `found = 0;``    ``int` `r, c;` `    ``for` `(r = 0; r < row_count; ++r) {``        ``for` `(c = 0; c < col_count; ++c) {``            ``found += internalSearch(needle, r, c, str,``                            ``row_count - 1, col_count - 1);``        ``}``    ``}` `    ``return` `found;``}` `// Driver code``int` `main(``void``){` `    ``char` `needle[] = ``"MAGIC"``;``    ``char` `*input[] = {``        ``"BBABBM"``,``        ``"CBMBBA"``,``        ``"IBABBG"``,``        ``"GOZBBI"``,``        ``"ABBBBC"``,``        ``"MCIGAM"``    ``};``    ``char` `*str[ARRAY_SIZE(input)];``    ``int` `i;``    ``for` `(i = 0; i < ARRAY_SIZE(input); ++i) {``        ``str[i] = ``malloc``(``strlen``(input[i]));``        ``strcpy``(str[i], input[i]);``    ``}` `    ``printf``(``"count: %d\n"``, searchString(needle, 0, 0,``              ``str, ARRAY_SIZE(str), ``strlen``(str[0])));` `    ``return` `0;``}`

## Java

 `// Java code for finding count``// of string in a given 2D``// character array.``import` `java.util.*;` `class` `GFG{``    ` `// Utility function to search``// complete string from any``// given index of 2d char array``static` `int` `internalSearch(String needle, ``int` `row,``                          ``int` `col, String hay[],``                          ``int` `row_max, ``int` `col_max,``                          ``int` `xx)``{``    ``int` `found = ``0``;``    ` `    ``if` `(row >= ``0` `&& row <= row_max && col >= ``0` `&&``        ``col <= col_max && xx < needle.length() &&``        ``needle.charAt(xx) == hay[row].charAt(col))``    ``{``        ``char` `match = needle.charAt(xx);``        ``xx += ``1``;` `        ``hay[row] = hay[row].substring(``0``, col) + ``"0"` `+``                   ``hay[row].substring(col + ``1``);` `        ``if` `(xx == needle.length())``        ``{``            ``found = ``1``;``        ``}``        ``else``        ``{``            ` `            ``// Through Backtrack searching``            ``// in every directions``            ``found += internalSearch(needle, row,``                                    ``col + ``1``, hay,``                                    ``row_max, col_max,xx);``            ``found += internalSearch(needle, row, col - ``1``,``                                    ``hay, row_max, col_max,xx);``            ``found += internalSearch(needle, row + ``1``, col,``                                    ``hay, row_max, col_max,xx);``            ``found += internalSearch(needle, row - ``1``, col,``                                    ``hay, row_max, col_max,xx);``        ``}``        ` `        ``hay[row] = hay[row].substring(``0``, col) +``           ``match + hay[row].substring(col + ``1``);``    ``}``    ``return` `found;``}` `// Function to search the string in 2d array``static` `int` `searchString(String needle, ``int` `row, ``int` `col,``                        ``String str[], ``int` `row_count,``                                      ``int` `col_count)``{``    ``int` `found = ``0``;``    ``int` `r, c;` `    ``for``(r = ``0``; r < row_count; ++r)``    ``{``        ``for``(c = ``0``; c < col_count; ++c)``        ``{``            ``found += internalSearch(needle, r, c, str,``                                    ``row_count - ``1``,``                                    ``col_count - ``1``, ``0``);``        ``}``    ``}``    ``return` `found;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``String needle = ``"MAGIC"``;``    ``String input[] = { ``"BBABBM"``, ``"CBMBBA"``,``                       ``"IBABBG"``, ``"GOZBBI"``,``                       ``"ABBBBC"``, ``"MCIGAM"` `};``    ``String str[] = ``new` `String[input.length];``    ``int` `i;``    ``for``(i = ``0``; i < input.length; ++i)``    ``{``        ``str[i] = input[i];``    ``}` `    ``System.out.println(``"count: "` `+``              ``searchString(needle, ``0``, ``0``, str,``                           ``str.length,``                           ``str[``0``].length()));``}``}` `// This code is contributed by adityapande88`

## Python3

 `# Python code for finding count``# of string in a given 2D``# character array.` `# utility function to search``# complete string from any``# given index of 2d array``def` `internalSearch(ii, needle, row, col, hay,``                    ``row_max, col_max):``    ` `    ``found ``=` `0``    ``if` `(row >``=` `0` `and` `row <``=` `row_max ``and``        ``col >``=` `0` `and` `col <``=` `col_max ``and``        ``needle[ii] ``=``=` `hay[row][col]):``        ``match ``=` `needle[ii]``        ``ii ``+``=` `1``        ``hay[row][col] ``=` `0``        ``if` `(ii ``=``=` `len``(needle)):``            ``found ``=` `1``        ``else``:``            ` `            ``# through Backtrack searching``            ``# in every directions``            ``found ``+``=` `internalSearch(ii, needle, row,``                               ``col ``+` `1``, hay, row_max, col_max)``            ``found ``+``=` `internalSearch(ii, needle, row,``                               ``col ``-` `1``, hay, row_max, col_max)``            ``found ``+``=` `internalSearch(ii, needle, row ``+` `1``,``                               ``col, hay, row_max, col_max)``            ``found ``+``=` `internalSearch(ii, needle, row ``-` `1``,``                               ``col, hay, row_max, col_max)``        ``hay[row][col] ``=` `match``    ``return` `found` `# Function to search the string in 2d array``def` `searchString(needle, row, col,strr,``                ``row_count, col_count):``    ``found ``=` `0``    ``for` `r ``in` `range``(row_count):``        ``for` `c ``in` `range``(col_count):``            ``found ``+``=` `internalSearch(``0``, needle, r, c,``                        ``strr, row_count ``-` `1``, col_count ``-` `1``)``            ` `    ``return` `found` `# Driver code` `needle ``=` `"MAGIC"``inputt ``=` `[``"BBABBM"``,``"CBMBBA"``,``"IBABBG"``,``            ``"GOZBBI"``,``"ABBBBC"``,``"MCIGAM"``]` `strr ``=` `[``0``] ``*` `len``(inputt)` `for` `i ``in` `range``(``len``(inputt)):``    ``strr[i] ``=` `list``(inputt[i])``    ` `print``(``"count: "``, searchString(needle, ``0``, ``0``, strr,``                        ``len``(strr), ``len``(strr[``0``])))` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// Include namespace system``using` `System;``public` `class` `GFG``{``    ``// Utility function to search``    ``// complete string from any``    ``// given index of 2d char array``    ``public` `static` `int` `internalSearch(String needle, ``int` `row,``                                     ``int` `col, String[] hay,``                                     ``int` `row_max, ``int` `col_max, ``int` `xx)``    ``{``        ``var` `found = 0;``        ``if` `(row >= 0 && row <= row_max && col >= 0 && col <= col_max && xx < needle.Length && needle[xx] == hay[row][col])``        ``{``            ``var` `match = needle[xx];``            ``xx += 1;``            ``hay[row] = hay[row].Substring(0,col-0) + ``"0"` `+``              ``hay[row].Substring(col + 1);``            ``if` `(xx == needle.Length)``            ``{``                ``found = 1;``            ``}``            ``else``            ``{``                ``// Through Backtrack searching``                ``// in every directions``                ``found += GFG.internalSearch(needle, row,``                                            ``col + 1, hay,``                                            ``row_max, col_max, xx);``                ``found += GFG.internalSearch(needle, row, col - 1,``                                            ``hay, row_max, col_max, xx);``                ``found += GFG.internalSearch(needle, row + 1, col,``                                            ``hay, row_max, col_max, xx);``                ``found += GFG.internalSearch(needle, row - 1, col,``                                            ``hay, row_max, col_max, xx);``            ``}``            ``hay[row] = hay[row].Substring(0,col-0) + match.ToString() + hay[row].Substring(col + 1);``        ``}``        ``return` `found;``    ``}``  ` `    ``// Function to search the string in 2d array``    ``public` `static` `int` `searchString(String needle, ``int` `row, ``int` `col, String[] str, ``int` `row_count, ``int` `col_count)``    ``{``        ``var` `found = 0;``        ``int` `r;``        ``int` `c;``        ``for` `(r = 0; r < row_count; ++r)``        ``{``            ``for` `(c = 0; c < col_count; ++c)``            ``{``                ``found += GFG.internalSearch(needle, r, c, str, row_count - 1, col_count - 1, 0);``            ``}``        ``}``        ``return` `found;``    ``}``  ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``var` `needle = ``"MAGIC"``;``        ``String[] input = {``"BBABBM"``, ``"CBMBBA"``, ``"IBABBG"``, ``"GOZBBI"``, ``"ABBBBC"``, ``"MCIGAM"``};``        ``String[] str = ``new` `String[input.Length];``        ``int` `i;``        ``for` `(i = 0; i < input.Length; ++i)``        ``{``            ``str[i] = input[i];``        ``}``        ``Console.WriteLine(``"count: "` `+ GFG.searchString(needle, 0, 0, str, str.Length, str[0].Length).ToString());``    ``}``}` `// This code is contributed by mukulsomukesh`

## Javascript

 `// JavaScript code for finding count``// of string in a given 2D``// character array.`  `// Utility function to search``// complete string from any``// given index of 2d char array``function` `internalSearch(needle, row, col, hay, row_max, col_max, xx)``{``    ``var` `found = 0;``    ``if` `(row >= 0 && row <= row_max && col >= 0 && col <= col_max && xx < needle.length && needle.charAt(xx) == hay[row].charAt(col))``    ``{``        ``var` `match = needle.charAt(xx);``        ``xx += 1;``        ``hay[row] = hay[row].substring(0,col) + ``"0"` `+ hay[row].substring(col + 1);``        ``if` `(xx == needle.length)``        ``{``            ``found = 1;``        ``}``        ``else``        ``{``            ``// Through Backtrack searching``            ``// in every directions``            ``found += internalSearch(needle, row, col + 1, hay, row_max, col_max, xx);``            ``found += internalSearch(needle, row, col - 1, hay, row_max, col_max, xx);``            ``found += internalSearch(needle, row + 1, col, hay, row_max, col_max, xx);``            ``found += internalSearch(needle, row - 1, col, hay, row_max, col_max, xx);``        ``}``        ``hay[row] = hay[row].substring(0,col) + match + hay[row].substring(col + 1);``    ``}``    ``return` `found;``}``// Function to search the string in 2d array``function` `searchString(needle, row, col, str, row_count, col_count)``{``    ``var` `found = 0;``    ``var` `r = 0;``    ``var` `c = 0;``    ``for` `(r = 0; r < row_count; ++r)``    ``{``        ``for` `(c = 0; c < col_count; ++c)``        ``{``            ``found += internalSearch(needle, r, c, str, row_count - 1, col_count - 1, 0);``        ``}``    ``}``    ``return` `found;``}``    ` `// Driver code``var` `needle = ``"MAGIC"``;``var` `input = [``"BBABBM"``, ``"CBMBBA"``, ``"IBABBG"``, ``"GOZBBI"``, ``"ABBBBC"``, ``"MCIGAM"``];``var` `str = Array(input.length).fill(``null``);``var` `i = 0;``for` `(i = 0; i < input.length; ++i)``{``    ``str[i] = input[i];``}``console.log(``"count: "` `+ searchString(needle, 0, 0, str, str.length, str[0].length));` `// This code is contributed by Aarti_Rathi`

Output

```count: 3
```

Time Complexity: O(n*m)^2, where n is the row size and m is the column size.
Auxiliary Space: O(n*m)