├── HackerRank The Grid Search problem solution(python).py
├── HackerRank The Grid Search problem solution(c++).cpp
├── HackerRank The Grid Search problem solution(java).java
├── HackerRank The Grid Search problem solution(c).c
└── Algorithm.txt


/HackerRank The Grid Search problem solution(python).py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/HackerRank The Grid Search problem solution(c++).cpp:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | char arr[1001][1001]; 
 8 | char find2[1001][1001]; 
 9 | int main() {
10 |     int a; cin >> a;
11 |     for (int g=0;g<a; g++)
12 |     {
13 |         int b,c;cin>>b>>c;
14 |         for (int g=0;g<b; g++)
15 |             {
16 |             for (int y=0;y<c; y++)
17 |                 {
18 |                 cin >> arr[g][y]; 
19 |             }
20 |         }
21 |         int d,e;cin>>d>>e;
22 |         for (int g=0;g<d; g++)
23 |             {
24 |             for (int y=0;y<e; y++)
25 |                 {
26 |                 cin >> find2[g][y]; 
27 |             }
28 |         }
29 |         if (d>b || e>c)
30 |             {
31 |             cout << "NO" << '\n'; continue; 
32 |         }int realcheck=0; 
33 |         for (int z=0;z<=b-d; z++)
34 |             {
35 |             for (int zz=0; zz<=c-e; zz++)
36 |                 {int checker=0; 
37 |                 for (int l=z; l<z+d; l++)
38 |                     {
39 |                     for (int ll=zz; ll<zz+e; ll++)
40 |                         {
41 |                         if (find2[l-z][ll-zz]!=arr[l][ll])
42 |                          {
43 |                             checker=1; break;    
44 |                         }
45 |                     }if (checker==1)break; 
46 |                 }
47 |                  if (checker==0) {realcheck=1; break;}
48 |             }if (realcheck==1) break; 
49 |         }
50 |         if (realcheck) cout << "YES" << '\n'; 
51 |         else cout << "NO" << '\n';
52 |     }
53 |     return 0;
54 | }


--------------------------------------------------------------------------------
/HackerRank The Grid Search problem solution(java).java:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class Solution {
 5 |     
 6 |     public static boolean isMatch(String[] grid, int r, int c, String[] pattern) {
 7 |         for(int i = r; i < r + pattern.length; i++) {
 8 |             if(!grid[i].substring(c, c + pattern[0].length()).equals(pattern[i - r]))
 9 |                 return false;
10 |         }
11 |         return true;
12 |     }
13 | 
14 |     public static void main(String[] args) {
15 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your clas should be named Solution. */
16 |         Scanner sc = new Scanner(System.in);
17 |         int T = sc.nextInt();
18 |         for(int k = 0; k < T; k++){
19 |             int R = sc.nextInt();
20 |         int C = sc.nextInt();
21 |         String[] grid = new String[R];
22 |         for(int i = 0; i < R; i++){
23 |             grid[i] = sc.next();
24 |         }
25 |         int r = sc.nextInt();
26 |         int c = sc.nextInt();
27 |         String[] pattern = new String[r];
28 |         for(int i = 0; i < r; i++) {
29 |             pattern[i] = sc.next();
30 |         }
31 |         boolean ret = false;
32 |         for(int i = 0; i <= R - r; i++){
33 |             for(int j = 0; j <= C - c; j++){
34 |                 if(grid[i].charAt(j) == pattern[0].charAt(0)){
35 |                     ret = isMatch(grid, i, j, pattern);
36 |                     if(ret)
37 |                         break;
38 |                 }
39 |             }
40 |             if(ret)
41 |                 break;
42 |         }
43 |         if(ret){
44 |             System.out.println("YES");
45 |         }
46 |         else{
47 |             System.out.println("NO");
48 |         }
49 |         }
50 |     }
51 | }


--------------------------------------------------------------------------------
/HackerRank The Grid Search problem solution(c).c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <math.h>
 4 | #include <stdlib.h>
 5 | int is_match(char** a,int r, int c,char **pat,int pr,int pc,int starty,int startx){
 6 |     int i,j;
 7 |     if(pr+starty>r||pc+startx>c)
 8 |         return 0;
 9 |     for(i=0;i<pr;i++){
10 |         for(j=0;j<pc;j++){
11 |             if(a[starty+i][startx+j]!=pat[i][j]){
12 |                 return 0;
13 |             }
14 |         }
15 |     }
16 |     return 1;
17 | }
18 | int main() {
19 |     int ntest;
20 |     scanf("%i",&ntest);
21 |     int s;
22 |     int found=0;
23 |     for(s=0;s<ntest;s++){
24 |         int r,c;
25 |         scanf("%i %i",&r,&c);
26 |         char** test;
27 |         test=malloc(sizeof(char*)*r);
28 |         int i;
29 |         for(i=0;i<r;i++){
30 |             test[i]=calloc(sizeof(char),1+c);
31 |             scanf("%s",test[i]);
32 |         }
33 |         int R,C;
34 |         scanf("%i %i",&R,&C);
35 |         
36 |         char **pattern;
37 |         pattern=malloc(sizeof(char*)*R);
38 |         for(i=0;i<R;i++){
39 |             pattern[i]=calloc(sizeof(char),1+C);
40 |             scanf("%s",pattern[i]);
41 |         }
42 |   
43 |         for(i=0;i<r;i++){
44 |             int j;
45 |             for(j=0;j<c;j++){
46 |                 if(is_match(test,r,c,pattern,R,C,i,j))
47 |                    {
48 |                        found=1;
49 |                        goto quit;
50 |                    }
51 |             }
52 |         }
53 |             quit:
54 |         if(found)
55 |             printf("YES\n");
56 |         else
57 |             printf("NO\n");
58 |         found=0;
59 |         for(i=0;i<R||i<r;i++){
60 |             if(i<R)
61 |             free(pattern[i]);
62 |             free(test[i]);
63 |          
64 |         }
65 |         
66 |     }
67 | 
68 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
69 |     return 0;
70 | }


--------------------------------------------------------------------------------
/Algorithm.txt:
--------------------------------------------------------------------------------
 1 | Let's go through the code step by step:
 2 | 
 3 | 1. The code includes several standard C++ libraries:
 4 |    - `<cmath>`: Provides mathematical functions like `sqrt`, `sin`, etc.
 5 |    - `<cstdio>`: Provides input/output functions like `printf` and `scanf`.
 6 |    - `<vector>`: Provides dynamic array implementation.
 7 |    - `<iostream>`: Provides input/output stream objects (e.g., `cin` and `cout`).
 8 |    - `<algorithm>`: Provides various algorithms like sorting, searching, etc.
 9 | 
10 | 2. The code defines a two-dimensional character array `arr` with a size of 1001x1001 and another array `find2` of the same size.
11 | 
12 | 3. The `main()` function begins.
13 | 
14 | 4. It reads an integer `a` from the input. This represents the number of test cases to follow.
15 | 
16 | 5. It starts a loop that runs `a` times. This loop is used to process multiple test cases.
17 | 
18 | 6. Inside the loop, it reads two integers `b` and `c` from the input. These represent the dimensions of the array `arr`.
19 | 
20 | 7. It then uses nested loops to read characters into the `arr` array.
21 | 
22 | 8. Next, it reads two integers `d` and `e` from the input. These represent the dimensions of the array `find2`.
23 | 
24 | 9. Again, nested loops are used to read characters into the `find2` array.
25 | 
26 | 10. The code checks if `d` is greater than `b` or `e` is greater than `c`. If either condition is true, it means that the dimensions of `find2` are greater than `arr`, and it prints "NO" and continues to the next test case.
27 | 
28 | 11. If the dimensions are valid, the code proceeds to compare `find2` with different subarrays of `arr` using nested loops. The purpose is to find if `find2` exists within `arr` as a subarray.
29 | 
30 | 12. It uses two variables `z` and `zz` to iterate over the possible starting indices of the subarray within `arr`.
31 | 
32 | 13. Inside the nested loops, it uses additional loops to compare each element of `find2` with the corresponding element of the subarray in `arr`.
33 | 
34 | 14. If any character of `find2` doesn't match the corresponding character in `arr`, it sets the `checker` variable to 1 and breaks out of the innermost loop.
35 | 
36 | 15. If the `checker` variable remains 0, it means all characters of `find2` match the subarray in `arr`. In this case, it sets `realcheck` to 1 and breaks out of the outermost loop.
37 | 
38 | 16. After the loop finishes, it checks the value of `realcheck`. If it's 1, it means `find2` was found within `arr`, and it prints "YES". Otherwise, it prints "NO".
39 | 
40 | 17. The loop continues for the next test case.
41 | 
42 | 18. Finally, the `main()` function ends, and the program returns 0 to indicate successful execution.
43 | 
44 | In summary, this code takes a series of test cases as input. For each test case, it compares whether a given 2D array `find2` exists as a subarray within another 2D array `arr`. It outputs "YES" if `find2` is found and "NO" otherwise.


--------------------------------------------------------------------------------