# Solving Leetcode Interviews in Seconds with AI: Largest Local Values in a Matrix


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2373" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an n x n integer matrix grid. Generate an integer matrix maxLocal of size (n - 2) x (n - 2) such that:  maxLocal[i][j] is equal to the largest value of the 3 x 3 matrix in grid centered around row i + 1 and column j + 1.  In other words, we want to find the largest value in every contiguous 3 x 3 matrix in grid. Return the generated matrix.   Example 1:   Input: grid = [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]] Output: [[9,9],[8,6]] Explanation: The diagram above shows the original matrix and the generated matrix. Notice that each value in the generated matrix corresponds to the largest value of a contiguous 3 x 3 matrix in grid. Example 2:   Input: grid = [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]] Output: [[2,2,2],[2,2,2],[2,2,2]] Explanation: Notice that the 2 is contained within every contiguous 3 x 3 matrix in grid.    Constraints:  n == grid.length == grid[i].length 3 <= n <= 100 1 <= grid[i][j] <= 100  

	# Explanation
	Here's a solution to the problem, along with explanations:

*   **High-Level Approach:**
    *   Iterate through the `grid` matrix, focusing on the cells that can be the center of a 3x3 submatrix.  This means the row and column indices will range from 1 to `n - 2`.
    *   For each such center cell `(i, j)`, find the maximum value within the 3x3 submatrix centered at `(i, j)`.
    *   Store this maximum value in the corresponding position `(i - 1, j - 1)` of the `maxLocal` matrix.

*   **Complexity Analysis:**
    *   Runtime: O(n<sup>2</sup>), where n is the dimension of the grid.  We iterate through a (n-2)x(n-2) subgrid and then iterate through a 3x3 grid, both being constant factor of n<sup>2</sup>.
    *   Storage: O(n<sup>2</sup>) because the `maxLocal` matrix has a size of (n-2) x (n-2), which is proportional to n<sup>2</sup>.

	
	# Code
	```python
	def largestLocal(grid: list[list[int]]) -> list[list[int]]:
    n = len(grid)
    max_local = [[0] * (n - 2) for _ in range(n - 2)]

    for i in range(1, n - 1):
        for j in range(1, n - 1):
            max_val = 0
            for x in range(i - 1, i + 2):
                for y in range(j - 1, j + 2):
                    max_val = max(max_val, grid[x][y])
            max_local[i - 1][j - 1] = max_val

    return max_local
	```