Find the Width of Columns of a Grid - Practice Coding Problems

Find the Width of Columns of a Grid - Problem

Array Matrix Easy

Imagine you're designing a data visualization tool that needs to calculate the display width of columns in a spreadsheet-like grid. Each column contains integers of varying lengths, and you need to determine how much horizontal space each column requires.

Given a m × n integer matrix grid, your task is to find the width of each column, where the width is defined as the maximum character length needed to display any number in that column.

Important: Negative numbers require an extra character for the minus sign!

Example: If a column contains [-10, 3, 12], the widths are:

-10 → 3 characters (including minus sign)
3 → 1 character
12 → 2 characters

So this column has width 3.

Return an integer array where ans[i] represents the width of the i-th column.

Input & Output

example_1.py — Basic Example

$ Input: grid = [[1,2,3],[11,12,13]]

› Output: [2, 2, 2]

💡 Note: Column 0: max(len('1'), len('11')) = max(1, 2) = 2. Column 1: max(len('2'), len('12')) = max(1, 2) = 2. Column 2: max(len('3'), len('13')) = max(1, 2) = 2.

example_2.py — Negative Numbers

$ Input: grid = [[-15,1,3],[15,-7,12]]

› Output: [3, 2, 2]

💡 Note: Column 0: max(len('-15'), len('15')) = max(3, 2) = 3 (negative sign counts). Column 1: max(len('1'), len('-7')) = max(1, 2) = 2. Column 2: max(len('3'), len('12')) = max(1, 2) = 2.

example_3.py — Single Column

$ Input: grid = [[-10],[3],[12]]

› Output: [3]

💡 Note: Only one column with values -10 (3 chars), 3 (1 char), 12 (2 chars). Maximum width is 3.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
-10⁹ ≤ grid[i][j] ≤ 10⁹
The length of integer x with len digits is len if x ≥ 0, and len + 1 if x < 0

Visualization

Tap to expand

Understanding the Visualization

Scan Column

Go through each number in the column

Calculate Width

Count digits, add 1 for negative sign

Track Maximum

Keep the largest width found

Store Result

Save the column width to result array

Key Takeaway

🎯 Key Insight: We only need one pass through each column to find the maximum character width, making this an efficient O(m×n) solution for matrix traversal.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal approach scans each column once to find the maximum character width needed. For each number, calculate its display length by counting digits and adding 1 for negative numbers. Time complexity is O(m × n × log(max_value)) where the log factor comes from calculating digit length.

Common Approaches

Approach	Time	Space	Notes
✓ Column-by-Column Scanning	O(m × n × log(max_value))	O(n)	Iterate through each column and find the maximum digit length

Column-by-Column Scanning — Algorithm Steps

Initialize result array with size equal to number of columns
For each column index from 0 to n-1:
Iterate through all rows in current column
Calculate length of each number (digits + 1 if negative)
Track maximum length for this column
Store maximum length in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first column

Begin scanning the first column from top to bottom

Calculate each number's length

For each number, count digits and add 1 for negative numbers

Track maximum

Keep the largest length found in this column

Move to next column

Repeat process for remaining columns

Code -

solution.c — C

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

int getLength(int num) {
    if (num == 0) return 1;
    
    int length = 0;
    if (num < 0) {
        length = 1; // for minus sign
        num = -num;
    }
    
    while (num > 0) {
        length++;
        num /= 10;
    }
    
    return length;
}

int* findColumnWidth(int** grid, int m, int n) {
    int* result = (int*)calloc(n, sizeof(int));
    
    // Check each column
    for (int col = 0; col < n; col++) {
        int maxWidth = 0;
        for (int row = 0; row < m; row++) {
            int length = getLength(grid[row][col]);
            if (length > maxWidth) {
                maxWidth = length;
            }
        }
        result[col] = maxWidth;
    }
    
    return result;
}

int main() {
    // Example usage
    int m = 2, n = 3;
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    grid[0][0] = 1; grid[0][1] = 2; grid[0][2] = 3;
    grid[1][0] = 11; grid[1][1] = 12; grid[1][2] = 13;
    
    int* result = findColumnWidth(grid, m, n);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × log(max_value))

We visit each of m×n cells, and calculating digit length takes O(log(value)) time

⚡ Linearithmic

Space Complexity

O(n)

Only need space for the result array of size n (number of columns)

⚡ Linearithmic Space

28.5K 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

Column-by-Column Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler