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 :2
Input : 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:
- To count all occurrences, we follow simple brute force approach.
- Traverse through each character of the matrix and taking each character as a start of the string to be found.
- Try to search in all the possible directions.
- Whenever, a word is found, increase the count.
- 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
#include <bits/stdc++.h>
using namespace std;
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))
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
{
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;
}
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;
}
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;
}
|
C
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))
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 {
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;
}
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;
}
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
import java.util.*;
class GFG{
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
{
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;
}
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;
}
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()));
}
}
|
Python3
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:
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
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
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])))
|
C#
using System;
public class GFG
{
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
{
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;
}
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;
}
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());
}
}
|
Javascript
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
{
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 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;
}
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));
|
Time Complexity: O(n*m)^2, where n is the row size and m is the column size.
Auxiliary Space: O(n*m)