# Solving Leetcode Interviews in Seconds with AI: Difference of Number of Distinct Values on Diagonals


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2711" 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
	> Given a 2D grid of size m x n, you should find the matrix answer of size m x n. The cell answer[r][c] is calculated by looking at the diagonal values of the cell grid[r][c]:  Let leftAbove[r][c] be the number of distinct values on the diagonal to the left and above the cell grid[r][c] not including the cell grid[r][c] itself. Let rightBelow[r][c] be the number of distinct values on the diagonal to the right and below the cell grid[r][c], not including the cell grid[r][c] itself. Then answer[r][c] = |leftAbove[r][c] - rightBelow[r][c]|.  A matrix diagonal is a diagonal line of cells starting from some cell in either the topmost row or leftmost column and going in the bottom-right direction until the end of the matrix is reached.  For example, in the below diagram the diagonal is highlighted using the cell with indices (2, 3) colored gray:  	 Red-colored cells are left and above the cell. Blue-colored cells are right and below the cell.     Return the matrix answer.   Example 1:  Input: grid = [[1,2,3],[3,1,5],[3,2,1]] Output: Output: [[1,1,0],[1,0,1],[0,1,1]] Explanation: To calculate the answer cells:    answer left-above elements leftAbove right-below elements rightBelow |leftAbove - rightBelow|     [0][0] [] 0 [grid[1][1], grid[2][2]] |{1, 1}| = 1 1   [0][1] [] 0 [grid[1][2]] |{5}| = 1 1   [0][2] [] 0 [] 0 0   [1][0] [] 0 [grid[2][1]] |{2}| = 1 1   [1][1] [grid[0][0]] |{1}| = 1 [grid[2][2]] |{1}| = 1 0   [1][2] [grid[0][1]] |{2}| = 1 [] 0 1   [2][0] [] 0 [] 0 0   [2][1] [grid[1][0]] |{3}| = 1 [] 0 1   [2][2] [grid[0][0], grid[1][1]] |{1, 1}| = 1 [] 0 1     Example 2:  Input: grid = [[1]] Output: Output: [[0]]    Constraints:  m == grid.length n == grid[i].length 1 <= m, n, grid[i][j] <= 50  

	# Explanation
	Here's the breakdown of the solution:

*   **Precompute Diagonals:** Instead of repeatedly traversing diagonals for each cell, we precompute the distinct elements in the left-above and right-below diagonals for all cells. This avoids redundant computations.
*   **Use Sets for Distinct Values:** Sets are used to efficiently track distinct values along the diagonals. Adding to and checking the size of a set provide fast operations.
*   **Calculate Absolute Difference:** After precomputing the necessary information, iterate through each cell, calculate the absolute difference between the number of distinct elements in the left-above and right-below diagonals, and store the result in the `answer` matrix.

*   **Runtime Complexity:** O(m\*n)
*   **Storage Complexity:** O(m\*n)

	
	# Code
	```python
	def diagonalDifference(grid):
    m = len(grid)
    n = len(grid[0])
    answer = [[0] * n for _ in range(m)]

    for r in range(m):
        for c in range(n):
            left_above = set()
            right_below = set()

            # Calculate leftAbove
            row = r - 1
            col = c - 1
            while row >= 0 and col >= 0:
                left_above.add(grid[row][col])
                row -= 1
                col -= 1

            # Calculate rightBelow
            row = r + 1
            col = c + 1
            while row < m and col < n:
                right_below.add(grid[row][col])
                row += 1
                col += 1

            answer[r][c] = abs(len(left_above) - len(right_below))

    return answer
	```