Multiplication Table Grid - Problem

Generate an N×N multiplication table and display it in a neatly aligned grid format with row and column headers.

The table should show the product of each row number (1 to N) with each column number (1 to N). Format the output so that all numbers are properly aligned in columns, making it easy to read.

For example, a 4×4 multiplication table would show products from 1×1 to 4×4 arranged in a grid with headers.

Input & Output

Example 1 — Small Table

$ Input: n = 3

› Output: 1 2 3 1 1 2 3 2 2 4 6 3 3 6 9

💡 Note: A 3×3 multiplication table with row and column headers. Each cell shows the product of row number × column number, properly aligned.

Example 2 — Larger Table

$ Input: n = 4

› Output: 1 2 3 4 1 1 2 3 4 2 2 4 6 8 3 3 6 9 12 4 4 8 12 16

💡 Note: A 4×4 multiplication table. Notice how larger numbers (like 16) maintain proper column alignment throughout the grid.

Example 3 — Minimal Case

$ Input: n = 1

› Output: 1 1 1

💡 Note: The smallest possible multiplication table: just 1×1 = 1 with proper headers and formatting.

Constraints

1 ≤ n ≤ 12
Output must be properly aligned in columns
Include row and column headers

Visualization

Tap to expand

Asked in

M Microsoft 15 A Apple 12 I IBM 8

The key insight is to calculate the maximum width needed for proper column alignment, then systematically build each row with consistent formatting. The optimal approach uses efficient string building to construct the entire table in a single pass. Time: O(n²), Space: O(n²)

Common Approaches

✓ Row-by-Row Generation

⏱️ Time: O(n²) Space: O(1)

Calculate products for each position and format them with consistent spacing using string padding techniques.

Single-Pass with String Builder

⏱️ Time: O(n²) Space: O(n²)

Use a string builder to efficiently concatenate all rows and columns without multiple string operations, reducing overhead.

Row-by-Row Generation — Algorithm Steps

Step 1: Calculate maximum width needed for largest product (N×N)
Step 2: Generate header row with column numbers
Step 3: For each row, calculate products and format with padding
Step 4: Print each formatted row

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Width

Determine spacing needed for largest number

Generate Header

Create column headers with proper alignment

Process Rows

Calculate products and format each row

Code -

solution.c — C

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

char* solution(int n) {
    if (n <= 0) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    // Calculate the width needed for the largest number (n*n)
    int maxNum = n * n;
    int maxWidth = 0;
    int temp = maxNum;
    while (temp > 0) {
        maxWidth++;
        temp /= 10;
    }
    
    // Estimate result size
    int resultSize = (n + 1) * (3 + n * (maxWidth + 1) + 1) + 1;
    char* result = malloc(resultSize);
    result[0] = '\0';
    
    char line[1000];
    
    // Generate header row
    sprintf(line, "   ");
    for (int j = 1; j <= n; j++) {
        char temp[20];
        sprintf(temp, "%*d", maxWidth + 1, j);
        strcat(line, temp);
    }
    strcat(result, line);
    strcat(result, "\n");
    
    // Generate each row
    for (int i = 1; i <= n; i++) {
        sprintf(line, "%3d", i);
        for (int j = 1; j <= n; j++) {
            int product = i * j;
            char temp[20];
            sprintf(temp, "%*d", maxWidth + 1, product);
            strcat(line, temp);
        }
        strcat(result, line);
        if (i < n) strcat(result, "\n");
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char* result = solution(n);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops to generate N×N multiplication products

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing temporary strings for formatting, no extra data structures

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Multiplication Table Grid - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Row-by-Row Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler