Hollow Rectangle Pattern - Problem

Given the width and height of a rectangle, print a hollow rectangle pattern using asterisks (*) for the borders and spaces for the interior.

A hollow rectangle has asterisks only on the top row, bottom row, leftmost column, and rightmost column. All interior positions contain spaces.

Output Format: Print each row on a separate line. Each row should have exactly width characters (asterisks and spaces).

Input & Output

Example 1 — Basic Rectangle

$ Input: width = 5, height = 3

› Output: ***** * * *****

💡 Note: Top row: all 5 asterisks. Middle row: asterisk + 3 spaces + asterisk. Bottom row: all 5 asterisks.

Example 2 — Single Column

$ Input: width = 1, height = 4

› Output: * * * *

💡 Note: When width is 1, every position is a border position, so all rows contain a single asterisk.

Example 3 — Single Row

$ Input: width = 6, height = 1

› Output: ******

💡 Note: When height is 1, there are no middle rows, so we have one complete border row.

Constraints

1 ≤ width ≤ 100
1 ≤ height ≤ 100

Visualization

Tap to expand

Asked in

M Microsoft 8 a Amazon 5

The key insight is recognizing that a hollow rectangle has only 3 row patterns: top border (all *), middle rows (* + spaces + *), and bottom border (all *). The optimal approach pre-builds these patterns and applies them based on row position. Time: O(width × height), Space: O(width)

Common Approaches

✓ Pattern-Based Construction

⏱️ Time: O(width × height) Space: O(width)

Instead of checking each position, identify the 3 patterns: top border (all stars), middle rows (star + spaces + star), and bottom border (all stars). Build each pattern efficiently.

Position-by-Position Check

⏱️ Time: O(width × height) Space: O(1)

For each position (i, j) in the rectangle, check if it's on the top row, bottom row, left column, or right column. If yes, print asterisk; otherwise print space.

Pattern-Based Construction — Algorithm Steps

Step 1: Create top border pattern (all asterisks)
Step 2: Create middle row pattern (asterisk + spaces + asterisk)
Step 3: Apply top pattern to first row
Step 4: Apply middle pattern to rows 1 to height-2
Step 5: Apply top pattern to last row (if height > 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Patterns

Build border pattern (*****) and middle pattern (* *)

Apply Rules

First/last rows use border, middle rows use middle pattern

Output Result

Construct rectangle using the patterns

Code -

solution.c — C

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

void solution(int width, int height) {
    // Create border row pattern
    char* borderRow = (char*)malloc((width + 1) * sizeof(char));
    for (int i = 0; i < width; i++) {
        borderRow[i] = '*';
    }
    borderRow[width] = '\0';
    
    // Create middle row pattern
    char* middleRow = (char*)malloc((width + 1) * sizeof(char));
    if (width == 1) {
        middleRow[0] = '*';
        middleRow[1] = '\0';
    } else {
        middleRow[0] = '*';
        for (int i = 1; i < width - 1; i++) {
            middleRow[i] = ' ';
        }
        middleRow[width - 1] = '*';
        middleRow[width] = '\0';
    }
    
    for (int i = 0; i < height; i++) {
        if (i == 0 || i == height - 1) {
            printf("%s\n", borderRow);
        } else {
            printf("%s\n", middleRow);
        }
    }
    
    free(borderRow);
    free(middleRow);
}

int main() {
    int width, height;
    scanf("%d", &width);
    scanf("%d", &height);
    solution(width, height);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(width × height)

Still need to build all characters, but with fewer conditional checks

✓ Linear Growth

Space Complexity

O(width)

Store pattern strings for reuse, size proportional to width

✓ Linear Space

12.5K Views

Medium Frequency

~8 min Avg. Time

340 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

Hollow Rectangle Pattern - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Pattern-Based Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler