Magic Squares In Grid

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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force (Check All Subgrids)

⏱️ Time: O(m×n) Space: O(1)

For each possible 3×3 subgrid position, extract the 9 numbers and verify: (1) all numbers are between 1-9 and distinct, (2) all rows sum to 15, (3) all columns sum to 15, (4) both diagonals sum to 15.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int* solution(char* s, int queries[][2], int queryCount, int* returnSize) {
    int n = strlen(s);
    int* result = (int*)malloc(queryCount * sizeof(int));
    *returnSize = queryCount;
    
    // Precompute prefix sums for faster range sum queries
    int* prefixOnes = (int*)calloc(n + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        prefixOnes[i + 1] = prefixOnes[i] + (s[i] == '1' ? 1 : 0);
    }
    
    for (int q = 0; q < queryCount; q++) {
        int l = queries[q][0], r = queries[q][1];
        int substrLen = r - l + 1;
        char* substr = (char*)malloc((substrLen + 1) * sizeof(char));
        strncpy(substr, s + l, substrLen);
        substr[substrLen] = '\0';
        
        char* augmented = (char*)malloc((substrLen + 3) * sizeof(char));
        sprintf(augmented, "1%s1", substr);
        
        int originalOnes = prefixOnes[r + 1] - prefixOnes[l];
        int maxOnes = originalOnes;
        int augLen = strlen(augmented);
        
        // Find all '1' blocks and try trading with '0' blocks
        for (int i = 1; i < augLen - 1; ) {
            if (augmented[i] == '1') {
                int oneStart = i;
                while (i < augLen - 1 && augmented[i] == '1') i++;
                int oneEnd = i - 1;
                
                // Try trading this '1' block with each '0' block
                for (int j = 1; j < augLen - 1; ) {
                    if (augmented[j] == '0') {
                        int zeroStart = j;
                        while (j < augLen - 1 && augmented[j] == '0') j++;
                        int zeroEnd = j - 1;
                        
                        int onesLost = oneEnd - oneStart + 1;
                        int onesGained = zeroEnd - zeroStart + 1;
                        int newCount = originalOnes - onesLost + onesGained;
                        maxOnes = max(maxOnes, newCount);
                    } else {
                        j++;
                    }
                }
            } else {
                i++;
            }
        }
        
        result[q] = maxOnes;
        free(substr);
        free(augmented);
    }
    
    free(prefixOnes);
    return result;
}

int main() {
    char s[100001];
    if (fgets(s, sizeof(s), stdin) == NULL) return 1;
    s[strcspn(s, "\n")] = 0;
    
    char queryLine[100001];
    if (fgets(queryLine, sizeof(queryLine), stdin) == NULL) return 1;
    queryLine[strcspn(queryLine, "\n")] = 0;
    
    int queries[1000][2];
    int queryCount = 0;
    
    if (strcmp(queryLine, "[]") != 0) {
        char* ptr = queryLine + 1; // Skip opening bracket
        char* end = queryLine + strlen(queryLine) - 1; // Skip closing bracket
        *end = '\0';
        
        char* token = strtok(ptr, "[]");
        while (token != NULL && queryCount < 1000) {
            if (strlen(token) > 0 && token[0] != ',') {
                char* comma = strchr(token, ',');
                if (comma != NULL) {
                    *comma = '\0';
                    queries[queryCount][0] = atoi(token);
                    queries[queryCount][1] = atoi(comma + 1);
                    queryCount++;
                }
            }
            token = strtok(NULL, "[]");
        }
    }
    
    int returnSize;
    int* result = solution(s, queries, queryCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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