Magic Squares In Grid - Practice Coding Problems

Magic Squares In Grid - Problem

Magic Squares in Grid

A 3×3 magic square is a fascinating mathematical construct where a 3×3 grid is filled with distinct numbers from 1 to 9 such that:
• Each row sums to the same value
• Each column sums to the same value
• Both diagonals sum to the same value

For example:

2 7 6
9 5 1
4 3 8

Each row, column, and diagonal sums to 15! 🎯

Given a row × col grid of integers, your task is to count how many 3×3 subgrids within this larger grid are valid magic squares. Note that while magic squares can only contain numbers 1-9, the input grid may contain numbers up to 15.

Input & Output

example_1.py — Basic Magic Square

$ Input: grid = [[4,3,8,4],[9,5,1,9],[2,7,6,2]]

› Output: 1

💡 Note: The 3×3 subgrid starting at position (0,0) contains numbers 1-9 exactly once, and all rows, columns, and diagonals sum to 15

example_2.py — No Magic Squares

$ Input: grid = [[8]]

› Output: 0

💡 Note: The grid is too small to contain any 3×3 subgrids

example_3.py — Multiple Candidates

$ Input: grid = [[5,5,5],[5,5,5],[5,5,5]]

› Output: 0

💡 Note: While all sums equal 15, the numbers are not distinct (all 5s), so this is not a valid magic square

Constraints

1 ≤ grid.length, grid[i].length ≤ 10
0 ≤ grid[i][j] ≤ 15
Magic squares must contain numbers 1-9 exactly once
All rows, columns, and diagonals must sum to 15

Visualization

Tap to expand

Understanding the Visualization

Position Scanner

Move the 3×3 scanning window to each possible position in the grid

Number Validation

Check if the current 3×3 area contains numbers 1-9 exactly once

Sum Verification

Verify all rows, columns, and diagonals sum to the magic number 15

Count Magic Squares

Increment counter for each valid magic square found

Key Takeaway

🎯 Key Insight: Magic squares have fixed properties (numbers 1-9, sum=15) that make validation efficient with just basic checking!

Asked in

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

The optimal approach is to systematically check each 3×3 subgrid by first validating that it contains numbers 1-9 exactly once, then verifying all rows, columns, and diagonals sum to 15. The key insight is that all valid magic squares have these fixed properties, making validation straightforward.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subgrids)	O(m×n)	O(1)	Check every 3×3 subgrid by validating all rows, columns, and diagonals

Brute Force (Check All Subgrids) — Algorithm Steps

Iterate through all possible top-left positions for 3×3 subgrids
For each position, extract the 3×3 subgrid
Check if all numbers are distinct and between 1-9
Verify all rows sum to 15
Verify all columns sum to 15
Verify both diagonals sum to 15
If all checks pass, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Grid

Move through each possible 3×3 position in the grid

Extract Subgrid

Extract the current 3×3 subgrid for analysis

Check Validity

Verify numbers 1-9 are distinct and all sums equal 15

Code -

solution.c — C

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

bool isMagicSquare(int** grid, int r, int c) {
    // Check if all numbers are 1-9 and distinct
    int count[10] = {0};
    for (int i = r; i < r + 3; i++) {
        for (int j = c; j < c + 3; j++) {
            if (grid[i][j] < 1 || grid[i][j] > 9) return false;
            count[grid[i][j]]++;
            if (count[grid[i][j]] > 1) return false;
        }
    }
    
    int target = 15;
    
    // Check rows
    for (int i = 0; i < 3; i++) {
        int sum = 0;
        for (int j = 0; j < 3; j++) {
            sum += grid[r + i][c + j];
        }
        if (sum != target) return false;
    }
    
    // Check columns
    for (int j = 0; j < 3; j++) {
        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += grid[r + i][c + j];
        }
        if (sum != target) return false;
    }
    
    // Check diagonals
    if (grid[r][c] + grid[r+1][c+1] + grid[r+2][c+2] != target) return false;
    if (grid[r][c+2] + grid[r+1][c+1] + grid[r+2][c] != target) return false;
    
    return true;
}

int numMagicSquaresInGrid(int** grid, int rows, int cols) {
    if (rows < 3 || cols < 3) return 0;
    
    int count = 0;
    for (int i = 0; i <= rows - 3; i++) {
        for (int j = 0; j <= cols - 3; j++) {
            if (isMagicSquare(grid, i, j)) count++;
        }
    }
    return count;
}

int main() {
    // Demo with hardcoded grid
    int rows = 3, cols = 4;
    int** grid = malloc(rows * sizeof(int*));
    int data[3][4] = {{4,3,8,4},{9,5,1,9},{2,7,6,2}};
    for (int i = 0; i < rows; i++) {
        grid[i] = malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            grid[i][j] = data[i][j];
        }
    }
    
    printf("%d\n", numMagicSquaresInGrid(grid, rows, cols));
    
    for (int i = 0; i < rows; i++) free(grid[i]);
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We check O((m-2)×(n-2)) possible 3×3 subgrids, each taking constant time O(1) to validate

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track sums and check validity

✓ Linear Space

24.0K Views

Medium Frequency

~15 min Avg. Time

890 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 (Check All Subgrids) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler