public static String gridSearch(List<String> G, List<String> P) {
    for (int i = 0; i <= G.size() - P.size(); i++) {
      int index = G.get(i).indexOf(P.get(0));
      while (index != -1) {
        boolean match = true;
        for (int j = 1; j < P.size(); j++) {
          if (!G.get(i + j).substring(index, index + P.get(0).length()).equals(P.get(j))) {
            match = false;
            break;
          }
        }
        if (match) return "YES";
        index = G.get(i).indexOf(P.get(0), index + 1);
      }
    }
    return "NO";
  }

function gridSearch(G, P) {
    // Write your code here
    const n = G.length;
    const m = P.length;
    for (let i = 0; i <= n - m; i++) {
        // loop row
        for (let j = 0; j <= G[i].length - P[0].length; j++) {
            // loop P
            let check = true;

            for (let k = 0; k < m; k++) {
                if (G[i + k].substring(j, P[0].length + j) !== P[k]) {
                    check = false;
                    break;
                }
            }
            if (check) {
                return "YES";
            }
        }
    }
    return "NO";
}

static boolean solve(int n2, int m2, char matrizX[][], char matrizY[][], int filaX) {
        ArrayList<String> valores = new ArrayList<>();
        for (int i = 0; i < n2; i++)valores.add(pasarCadena(matrizY[i]));
        for (int i = 0; i <= filaX - n2; i++) {
            for (int j = 0; j <= matrizX[i].length - m2; j++) {
                boolean encontrado = true;
                for (int k = 0; k < n2; k++) {
                    String subcadenaX = pasarCadena(Arrays.copyOfRange(matrizX[i + k], j, j + m2));
                    if (!subcadenaX.equals(valores.get(k))) {
                        encontrado = false;
                        break;
                    }
                }
                if (encontrado)return true;
            }
        }
        return false;
    }

def gridSearch(G, P):
    pattern_len = len(P)
    single_pattern_len = len(P[0])
    
    patter_index = None
    for c, row in enumerate(G):
        
        row_temp = row
        pattern_row_index, pattern_col_index = c, 0
        while P[0] in row_temp:
            patter_index = row_temp.index(P[0])
            pattern_col_index += patter_index

            is_match = True
            for i in range(1, pattern_len):
                if G[pattern_row_index+i][pattern_col_index:][:single_pattern_len] != P[i]:
                    is_match = False
                    break
            pattern_col_index += 1
            row_temp = row_temp[patter_index+1:]
            if is_match: return "YES"
    return "NO"

def gridSearch(G, P):
    string = "".join(G)
    separation = C-c
    if separation < 0:
        return "NO"
    pattern = fr'.{{{separation}}}'.join(P)
    for match in re.finditer(pattern, string):
        rows = (match.end()-1)//C - match.start()//C + 1
        if rows == r:
            return "YES"
    return "NO"