Match Alphanumerical Pattern in Matrix I - Practice Coding Problems

Match Alphanumerical Pattern in Matrix I - Problem

Imagine you're a cryptographer trying to decode a secret pattern hidden within a grid of numbers! 🕵️‍♂️

You are given a 2D integer matrix board containing digits (0-9) and a 2D character matrix pattern that serves as your decoder key. The pattern contains both digits and lowercase letters.

Your mission is to find a submatrix within the board that matches the pattern according to these rules:

Digit matching: If pattern[r][c] is a digit, then the corresponding cell in the board submatrix must be exactly the same digit
Letter constraints: If pattern[r][c] is a letter 'x':
- All cells in the pattern marked with 'x' must map to the same digit in the board
- This digit must be different from any digit used by other letters
- Each letter represents a unique digit (0-9)

Return the coordinates [row, col] of the upper-left corner of the first matching submatrix (prioritizing smaller row, then smaller column). If no match exists, return [-1, -1].

Input & Output

example_1.py — Basic Pattern Match

$ Input: board = [[3,1,4],[2,1,3],[0,1,1]], pattern = [['a','1'],['2','a']]

› Output: [0,0]

💡 Note: The submatrix starting at [0,0] is [[3,1],[2,1]]. Pattern 'a' maps to digit 3, '1' stays 1, '2' stays 2. All constraints satisfied!

example_2.py — No Match Found

$ Input: board = [[1,2],[3,4]], pattern = [['a','a'],['b','b']]

› Output: [-1,-1]

💡 Note: No 2x2 submatrix exists where two different letters can map to distinct digits consistently.

example_3.py — Multiple Letters

$ Input: board = [[1,1,2],[1,2,2],[3,3,3]], pattern = [['a','b']]

› Output: [0,1]

💡 Note: At position [0,1], submatrix is [[1,2]]. Letter 'a' maps to 1, letter 'b' maps to 2. Perfect match!

Constraints

1 ≤ board.length, board[i].length ≤ 50
1 ≤ pattern.length, pattern[i].length ≤ 50
0 ≤ board[r][c] ≤ 9
pattern[r][c] is either a digit or a lowercase English letter
The pattern dimensions must not exceed board dimensions

Visualization

Tap to expand

Understanding the Visualization

Position Template

Place the pattern template at each possible board position

Validate Digits

Check that fixed digit pieces match exactly

Map Letters

Assign flexible letter pieces to board digits consistently

Check Uniqueness

Ensure each letter maps to a unique digit

Key Takeaway

🎯 Key Insight: Success depends on maintaining bidirectional mappings - pattern→board for consistency and board→pattern for uniqueness validation.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This problem requires pattern matching with variable substitution. The optimal approach uses brute force with hash map validation - try every possible position and maintain bidirectional mappings to ensure letter-to-digit consistency and uniqueness. Time complexity is O(m*n*p*q) where the board is m×n and pattern is p×q.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Pattern Matching	O(mnp*q)	O(1)	Try every possible position and validate pattern matching with hash maps

Brute Force Pattern Matching — Algorithm Steps

Iterate through all possible starting positions (r, c) in the board
For each position, extract a submatrix of the same size as the pattern
Create mappings: pattern_to_board and board_to_pattern
Validate each cell according to pattern rules
Return the first valid match found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position

Place pattern template at current board position

Check Digits

Verify that all digit constraints are satisfied

Map Letters

Create consistent letter-to-digit mappings

Validate

Ensure no conflicts in the mappings

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h>

int* findPattern(int** board, int boardSize, int* boardColSize, char** pattern, int patternSize, int* patternColSize, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    if (boardSize == 0 || patternSize == 0) {
        result[0] = -1; result[1] = -1;
        return result;
    }
    
    int m = boardSize, n = boardColSize[0];
    int p = patternSize, q = patternColSize[0];
    
    if (p > m || q > n) {
        result[0] = -1; result[1] = -1;
        return result;
    }
    
    for (int r = 0; r <= m - p; r++) {
        for (int c = 0; c <= n - q; c++) {
            // Simple validation for each position
            bool valid = true;
            int letterMap[26]; // a-z mapping
            bool letterUsed[26] = {false};
            bool digitUsed[10] = {false};
            
            for (int i = 0; i < 26; i++) letterMap[i] = -1;
            
            for (int i = 0; i < p && valid; i++) {
                for (int j = 0; j < q && valid; j++) {
                    char patternChar = pattern[i][j];
                    int boardVal = board[r + i][c + j];
                    
                    if (isdigit(patternChar)) {
                        if (patternChar - '0' != boardVal) valid = false;
                    } else {
                        int idx = patternChar - 'a';
                        if (letterUsed[idx]) {
                            if (letterMap[idx] != boardVal) valid = false;
                        } else {
                            if (digitUsed[boardVal]) valid = false;
                            letterMap[idx] = boardVal;
                            letterUsed[idx] = true;
                            digitUsed[boardVal] = true;
                        }
                    }
                }
            }
            
            if (valid) {
                result[0] = r; result[1] = c;
                return result;
            }
        }
    }
    
    result[0] = -1; result[1] = -1;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*p*q)

m*n positions to try, p*q cells to validate for each position

✓ Linear Growth

Space Complexity

O(1)

Only using hash maps of constant size (at most 26 letters + 10 digits)

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Pattern Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler