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

Find the Width of Columns of a Grid - Problem

Array Matrix Easy

You are given a 0-indexed m x n integer matrix grid. The width of a column is the maximum length of its integers.

For example, if grid = [[-10], [3], [12]], the width of the only column is 3 since -10 is of length 3.

Return an integer array ans of size n where ans[i] is the width of the i^th column.

The length of an integer x with len digits is equal to len if x is non-negative, and len + 1 otherwise.

Input & Output

Example 1 — Basic Case

$ Input: grid = [[1,2,3],[-10,-20,100],[4,5,6]]

› Output: [3,3,3]

💡 Note: Column 0: max(len('1'), len('-10'), len('4')) = max(1, 3, 1) = 3. Column 1: max(len('2'), len('-20'), len('5')) = max(1, 3, 1) = 3. Column 2: max(len('3'), len('100'), len('6')) = max(1, 3, 1) = 3.

Example 2 — Single Column

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

› Output: [3]

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

Example 3 — Mixed Values

$ Input: grid = [[7],[-7]]

› Output: [2]

💡 Note: Column has 7 (length 1) and -7 (length 2 due to minus sign). Maximum width is 2.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
-10⁹ ≤ grid[i][j] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input Matrix

2D grid with integers, including negatives

Calculate Widths

For each number, count digits plus sign if negative

Find Column Max

Return maximum width per column as array

Key Takeaway

🎯 Key Insight: Negative numbers need an extra character for the minus sign, affecting the total width calculation.

Asked in

G Google 12 M Microsoft 8

The key insight is that negative numbers require an extra character for the minus sign when calculating width. The optimal approach processes the matrix in row-major order for better cache performance. Time: O(m×n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Row-by-Row Traversal	O(m×n)	O(1)	Single pass through matrix in row-major order for better cache efficiency
Brute Force - Column by Column	O(m×n)	O(1)	Iterate through each column, check all numbers to find maximum width

Row-by-Row Traversal — Algorithm Steps

Step 1: Initialize result array with zeros
Step 2: Iterate through each row
Step 3: For each cell, calculate number width
Step 4: Update column maximum if current width is larger

Visualization

Tap to expand

Step-by-Step Walkthrough

Row-Major Access

Process matrix row by row

Update Column Max

Track maximum width for each column

Final Result

Array of column widths

Code -

solution.c — C

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

int* solution(int** grid, int gridSize, int* gridColSize, int* returnSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int n = gridColSize[0];
    int* result = (int*)calloc(n, sizeof(int));
    *returnSize = n;
    
    // Process row by row for better cache locality
    for (int row = 0; row < gridSize; row++) {
        for (int col = 0; col < gridColSize[row]; col++) {
            int num = grid[row][col];
            // Calculate width: length of digits + 1 if negative
            int absNum = abs(num);
            int width = 1;
            while (absNum >= 10) {
                width++;
                absNum /= 10;
            }
            if (num < 0) width += 1;
            if (width > result[col]) {
                result[col] = width;
            }
        }
    }
    
    return result;
}

int main() {
    // Simple demo
    int grid[3][3] = {{1, 2, 3}, {-10, -20, 100}, {4, 5, 6}};
    int* gridRows[3] = {grid[0], grid[1], grid[2]};
    int gridColSize[3] = {3, 3, 3};
    int returnSize;
    
    int* result = solution(gridRows, 3, gridColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Still visit each cell once, but with better memory access pattern

✓ Linear Growth

Space Complexity

O(1)

Only using result array and temporary variables

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

456 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

Row-by-Row Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler