chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-12-30-840-Magic-Squares-In-Grid/explanation.md

@@ -0,0 +1,33 @@
+# Magic Squares In Grid (Medium)
+
+**Problem ID:** 840  
+**Date:** 2025-12-30  
+**Link:** https://leetcode.com/problems/magic-squares-in-grid/
+
+## Approach
+
+To solve the problem of counting 3x3 magic square subgrids in a given grid, we can follow a structured approach:
+
+### Main Idea
+A 3x3 magic square must contain distinct integers from 1 to 9, and each row, column, and both diagonals must sum to the same value, which is 15 for a 3x3 magic square. Therefore, our goal is to identify all possible 3x3 subgrids within the given grid and check if they satisfy the conditions of a magic square.
+
+### Steps to Solve the Problem
+1. **Iterate Through Possible Subgrids**: Since the grid can have dimensions up to 10x10, we can iterate through all possible top-left corners of 3x3 subgrids. The top-left corner can range from `(0, 0)` to `(row-3, col-3)`.
+
+2. **Extract Subgrid**: For each position `(i, j)`, extract the 3x3 subgrid starting from that position. This involves collecting the elements in the range `grid[i][j]` to `grid[i+2][j+2]`.
+
+3. **Check for Distinct Numbers**: Verify that all numbers in the extracted subgrid are distinct and fall within the range of 1 to 9. This can be efficiently done using a set to track the numbers.
+
+4. **Calculate Sums**: If the numbers are valid, calculate the sums of each row, each column, and the two diagonals. All these sums should equal 15 for the subgrid to be a magic square.
+
+5. **Count Valid Magic Squares**: Maintain a count of how many valid magic squares are found during the iteration.
+
+### Data Structures
+- A set can be used to check for distinct numbers efficiently.
+- Simple integer variables can be used to store sums for rows, columns, and diagonals.
+
+### Complexity
+- **Time Complexity**: The algorithm runs in O((row-2) * (col-2) * 1) = O(row * col) for iterating through subgrids and checking conditions, which is efficient given the constraints.
+- **Space Complexity**: The space complexity is O(1) for the counting variables and O(1) for the set used to check distinct numbers (since it can only hold up to 9 elements).
+
+By following this approach, we can systematically determine the number of 3x3 magic squares in the given grid while adhering to the constraints and properties of magic squares.

Medium/2025-12-30-840-Magic-Squares-In-Grid/solution.java

@@ -0,0 +1,33 @@
+class Solution {
+    public int numMagicSquaresInside(int[][] grid) {
+        int count = 0;
+        for (int i = 0; i < grid.length - 2; i++) {
+            for (int j = 0; j < grid[0].length - 2; j++) {
+                if (isMagicSquare(grid, i, j)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    private boolean isMagicSquare(int[][] grid, int row, int col) {
+        int[] nums = new int[10];
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                nums[grid[row + i][col + j]]++;
+            }
+        }
+        for (int i = 1; i <= 9; i++) {
+            if (nums[i] != 1) return false;
+        }
+        return (grid[row][col] + grid[row][col + 1] + grid[row][col + 2] == 15) &&
+               (grid[row + 1][col] + grid[row + 1][col + 1] + grid[row + 1][col + 2] == 15) &&
+               (grid[row + 2][col] + grid[row + 2][col + 1] + grid[row + 2][col + 2] == 15) &&
+               (grid[row][col] + grid[row + 1][col] + grid[row + 2][col] == 15) &&
+               (grid[row][col + 1] + grid[row + 1][col + 1] + grid[row + 2][col + 1] == 15) &&
+               (grid[row][col + 2] + grid[row + 1][col + 2] + grid[row + 2][col + 2] == 15) &&
+               (grid[row][col] + grid[row + 1][col + 1] + grid[row + 2][col + 2] == 15) &&
+               (grid[row + 2][col] + grid[row + 1][col + 1] + grid[row][col + 2] == 15);
+    }
+}

Medium/2025-12-30-840-Magic-Squares-In-Grid/solution.js

@@ -0,0 +1,38 @@
+var numMagicSquaresInside = function(grid) {
+    const isMagicSquare = (square) => {
+        const nums = new Set();
+        let sum = 0;
+        for (let i = 0; i < 3; i++) {
+            sum += square[i][0];
+            nums.add(square[i][0]);
+            nums.add(square[i][1]);
+            nums.add(square[i][2]);
+        }
+        for (let j = 0; j < 3; j++) {
+            let colSum = square[0][j] + square[1][j] + square[2][j];
+            if (colSum !== sum) return false;
+        }
+        const diag1 = square[0][0] + square[1][1] + square[2][2];
+        const diag2 = square[0][2] + square[1][1] + square[2][0];
+        if (diag1 !== sum || diag2 !== sum) return false;
+        return nums.size === 9 && [...nums].every(num => num >= 1 && num <= 9);
+    };
+
+    let count = 0;
+    const rows = grid.length;
+    const cols = grid[0].length;
+
+    for (let i = 0; i <= rows - 3; i++) {
+        for (let j = 0; j <= cols - 3; j++) {
+            const square = [
+                [grid[i][j], grid[i][j + 1], grid[i][j + 2]],
+                [grid[i + 1][j], grid[i + 1][j + 1], grid[i + 1][j + 2]],
+                [grid[i + 2][j], grid[i + 2][j + 1], grid[i + 2][j + 2]]
+            ];
+            if (isMagicSquare(square)) {
+                count++;
+            }
+        }
+    }
+    return count;
+};

Medium/2025-12-30-840-Magic-Squares-In-Grid/solution.py

@@ -0,0 +1,22 @@
+class Solution:
+    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
+        def isMagicSquare(x, y):
+            nums = {grid[x+i][y+j] for i in range(3) for j in range(3)}
+            if nums != {1, 2, 3, 4, 5, 6, 7, 8, 9}:
+                return False
+            return (grid[x][y] + grid[x][y+1] + grid[x][y+2] == 
+                    grid[x+1][y] + grid[x+1][y+1] + grid[x+1][y+2] == 
+                    grid[x+2][y] + grid[x+2][y+1] + grid[x+2][y+2] == 
+                    grid[x][y] + grid[x+1][y] + grid[x+2][y] == 
+                    grid[x][y+1] + grid[x+1][y+1] + grid[x+2][y+1] == 
+                    grid[x][y+2] + grid[x+1][y+2] + grid[x+2][y+2] == 
+                    grid[x][y] + grid[x+1][y+1] + grid[x+2][y+2] == 
+                    grid[x+2][y] + grid[x+1][y+1] + grid[x][y+2])
+        
+        count = 0
+        rows, cols = len(grid), len(grid[0])
+        for i in range(rows - 2):
+            for j in range(cols - 2):
+                if isMagicSquare(i, j):
+                    count += 1
+        return count

README.md

@@ -320,3 +320,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-27 — [Meeting Rooms III](https://leetcode.com/problems/meeting-rooms-iii/) (Hard) → `Hard/2025-12-27-2402-Meeting-Rooms-III`
 - 2025-12-28 — [Count Negative Numbers in a Sorted Matrix](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/) (Easy) → `Easy/2025-12-28-1351-Count-Negative-Numbers-in-a-Sorted-Matrix`
 - 2025-12-29 — [Pyramid Transition Matrix](https://leetcode.com/problems/pyramid-transition-matrix/) (Medium) → `Medium/2025-12-29-756-Pyramid-Transition-Matrix`
+- 2025-12-30 — [Magic Squares In Grid](https://leetcode.com/problems/magic-squares-in-grid/) (Medium) → `Medium/2025-12-30-840-Magic-Squares-In-Grid`