Fill a Special Grid - Practice Coding Problems

Fill a Special Grid - Problem

Fill a Special Grid is a fascinating recursive pattern problem that challenges you to construct a 2ⁿ × 2ⁿ grid with a unique hierarchical structure.

Given a non-negative integer n, you must fill the grid with integers from 0 to 2²ⁿ - 1 such that the grid becomes "special". A grid is special if it satisfies these conditions:

🔹 Quadrant Ordering: Numbers must follow this strict hierarchy:
   • Top-right quadrant < Bottom-right quadrant
   • Bottom-right quadrant < Bottom-left quadrant
   • Bottom-left quadrant < Top-left quadrant

🔹 Recursive Structure: Each quadrant must itself be a special grid

🔹 Base Case: Any 1×1 grid is considered special

Example: For n=1 (2×2 grid), you might have [1,0] [3,2] where top-right={0,1}, bottom-right={2}, bottom-left={3}, top-left={} following the ordering rules.

Input & Output

example_1.py — Basic case n=1

$ Input: n = 1

› Output: [[0, 3], [1, 2]]

💡 Note: For n=1, we have a 2×2 grid with numbers 0-3. Top-right quadrant has [0,1], bottom-right has [2], bottom-left has [3], and top-left has []. The ordering 0,1 < 2 < 3 < ∅ satisfies the special grid condition.

example_2.py — Edge case n=0

$ Input: n = 0

› Output: [[0]]

💡 Note: For n=0, we have a 1×1 grid. By definition, any 1×1 grid is special, so we simply place the single number 0.

example_3.py — Complex case n=2

$ Input: n = 2

› Output: [[0, 1, 12, 13], [2, 3, 14, 15], [4, 5, 8, 9], [6, 7, 10, 11]]

💡 Note: For n=2, we have a 4×4 grid with numbers 0-15. Each 2×2 quadrant follows the special pattern recursively. Top-right (0-3), bottom-right (4-7), bottom-left (8-11), top-left (12-15) maintain the required ordering.

Constraints

0 ≤ n ≤ 10
The grid size will be 2ⁿ × 2ⁿ
Total numbers to place: 2²ⁿ
Each quadrant must be recursively special

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Recognize that we need TR < BR < BL < TL ordering in every level

Divide Range

Split available numbers into four equal parts for each quadrant

Recursive Build

Apply the same pattern recursively to each quadrant

Combine Results

Merge all quadrants into the final special grid

Key Takeaway

🎯 Key Insight: By dividing the number range according to quadrant hierarchy and applying the pattern recursively, we can construct any size special grid efficiently in O(4^n) time.

Asked in

G Google 45 ⊞ Microsoft 38 f Meta 32 a Amazon 28

The optimal solution uses divide and conquer to recursively construct the special grid. We divide the number range into four parts according to the quadrant hierarchy (TR < BR < BL < TL), then recursively build each quadrant as a smaller special grid. This approach achieves O(4^n) time complexity, which is optimal since we need to fill exactly 4^n cells.

Common Approaches

Approach	Time	Space	Notes
✓ Divide and Conquer (Optimal)	O(4^n)	O(4^n)	Recursively construct special grids by dividing number ranges across quadrants

Divide and Conquer (Optimal) — Algorithm Steps

Base case: if n=0, return [[0]]
Calculate total numbers needed: 2^(2n)
Divide numbers into 4 ranges based on quadrant ordering
Recursively construct each quadrant with its assigned range
Combine quadrants into the final 2^n × 2^n grid

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide Range

Split available numbers into 4 ranges: TR < BR < BL < TL

Recursive Construction

Build each quadrant recursively with its assigned range

Combine Results

Merge quadrants into the final 2^n × 2^n grid

Code -

solution.c — C

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

int** divideAndConquer(int n, int start, int end, int* size) {
    *size = 1 << n; // 2^n
    
    if (n == 0) {
        int** result = malloc(sizeof(int*));
        result[0] = malloc(sizeof(int));
        result[0][0] = start;
        return result;
    }
    
    int totalSize = end - start + 1;
    int quadrantSize = totalSize / 4;
    
    // Divide numbers according to quadrant hierarchy: TR < BR < BL < TL
    int trStart = start, trEnd = start + quadrantSize - 1;
    int brStart = trEnd + 1, brEnd = trEnd + quadrantSize;
    int blStart = brEnd + 1, blEnd = brEnd + quadrantSize;
    int tlStart = blEnd + 1, tlEnd = end;
    
    int halfSize;
    
    // Recursively build each quadrant
    int** topRight = divideAndConquer(n - 1, trStart, trEnd, &halfSize);
    int** bottomRight = divideAndConquer(n - 1, brStart, brEnd, &halfSize);
    int** bottomLeft = divideAndConquer(n - 1, blStart, blEnd, &halfSize);
    int** topLeft = divideAndConquer(n - 1, tlStart, tlEnd, &halfSize);
    
    // Combine quadrants into result grid
    int** result = malloc((*size) * sizeof(int*));
    for (int i = 0; i < *size; i++) {
        result[i] = malloc((*size) * sizeof(int));
    }
    
    int half = (*size) / 2;
    
    // Place quadrants in correct positions
    for (int i = 0; i < half; i++) {
        for (int j = 0; j < half; j++) {
            result[i][j] = topRight[i][j]; // Top-right
            result[i][j + half] = topLeft[i][j]; // Top-left
            result[i + half][j] = bottomRight[i][j]; // Bottom-right
            result[i + half][j + half] = bottomLeft[i][j]; // Bottom-left
        }
    }
    
    // Free temporary arrays
    for (int i = 0; i < half; i++) {
        free(topRight[i]);
        free(bottomRight[i]);
        free(bottomLeft[i]);
        free(topLeft[i]);
    }
    free(topRight);
    free(bottomRight);
    free(bottomLeft);
    free(topLeft);
    
    return result;
}

int** fillGrid(int n, int* size) {
    if (n == 0) {
        *size = 1;
        int** result = malloc(sizeof(int*));
        result[0] = malloc(sizeof(int));
        result[0][0] = 0;
        return result;
    }
    
    int totalNumbers = (1 << (2 * n)) - 1;
    return divideAndConquer(n, 0, totalNumbers, size);
}

int main() {
    int n, size;
    scanf("%d", &n);
    
    int** result = fillGrid(n, &size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("[");
        for (int j = 0; j < size; j++) {
            printf("%d", result[i][j]);
            if (j < size - 1) printf(",");
        }
        printf("]");
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < size; i++) {
        free(result[i]);
    }
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

We need to fill 2^(2n) = 4^n cells in the grid exactly once

✓ Linear Growth

Space Complexity

O(4^n)

Space for the result grid plus recursive call stack of depth n

⚡ Linearithmic Space

24.0K Views

Medium Frequency

~18 min Avg. Time

892 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

Divide and Conquer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler