Difference Between Ones and Zeros in Row and Column

Difference Between Ones and Zeros in Row and Column - Problem

You are given a 0-indexed m x n binary matrix grid.

A 0-indexed m x n difference matrix diff is created with the following procedure:

Let the number of ones in the i^th row be onesRow_i.
Let the number of ones in the j^th column be onesCol_j.
Let the number of zeros in the i^th row be zerosRow_i.
Let the number of zeros in the j^th column be zerosCol_j.
diff[i][j] = onesRow_i + onesCol_j - zerosRow_i - zerosCol_j

Return the difference matrix diff.

Input & Output

Example 1 — Basic 2x2 Matrix

$ Input: grid = [[0,1,1],[1,0,1],[0,0,1]]

› Output: [[0,0,4],[0,0,4],[-2,-2,2]]

💡 Note: For cell (0,0): Row 0 has 2 ones and 1 zero, Column 0 has 1 one and 2 zeros. Formula: 2+1-1-2 = 0

Example 2 — Simple 2x2

$ Input: grid = [[1,1,1],[1,1,1]]

› Output: [[5,5,5],[5,5,5]]

💡 Note: All ones matrix: Each row has 3 ones, each column has 2 ones. Formula: 3+2-0-0 = 5 for every cell

Example 3 — All Zeros

$ Input: grid = [[0,0],[0,0]]

› Output: [[-4,-4],[-4,-4]]

💡 Note: All zeros: Each row has 0 ones and 2 zeros, each column has 0 ones and 2 zeros. Formula: 0+0-2-2 = -4

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12

The key insight is to precompute row and column statistics to avoid redundant counting. The optimal approach first counts ones in each row and column, then uses these precomputed values to calculate the difference formula for each cell. Time: O(mn), Space: O(m + n)

Common Approaches

✓ Brute Force

⏱️ Time: O(m²n + mn²) Space: O(1)

For every position (i,j) in the result matrix, iterate through row i and column j to count ones and zeros, then calculate the difference formula. This approach recalculates the same row/column statistics multiple times.

Precompute Row/Column Stats

⏱️ Time: O(mn) Space: O(m + n)

First pass through the matrix to count ones in each row and column. Store these counts in arrays. Then use the precomputed values to quickly calculate the difference formula for each cell without redundant counting.

Brute Force — Algorithm Steps

Step 1: For each cell (i,j) in result matrix
Step 2: Count ones and zeros in row i
Step 3: Count ones and zeros in column j
Step 4: Apply formula: onesRowi + onesColj - zerosRowi - zerosColj

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Cell

Pick cell (0,1) to calculate

Count Row

Count ones/zeros in row 0

Count Column

Count ones/zeros in column 1

Apply Formula

Calculate: onesRow + onesCol - zerosRow - zerosCol

Code -

solution.c — C

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

// Function to parse a 2D array from JSON-like string
int** parseGrid(char* input, int* m, int* n) {
    char* ptr = input;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return NULL;
    ptr++; // skip '['
    
    // Count rows by counting '[' at row level
    char* temp = ptr;
    *m = 0;
    int bracket_depth = 0;
    while (*temp) {
        if (*temp == '[') {
            if (bracket_depth == 0) (*m)++;
            bracket_depth++;
        } else if (*temp == ']') {
            bracket_depth--;
        }
        temp++;
    }
    
    // Find number of columns from first row
    *n = 0;
    temp = ptr;
    while (*temp && *temp != '[') temp++; // find first row
    if (*temp == '[') {
        temp++;
        while (*temp && *temp != ']') {
            if (isdigit(*temp)) {
                (*n)++;
                while (*temp && isdigit(*temp)) temp++;
            } else {
                temp++;
            }
        }
    }
    
    // Allocate grid
    int** grid = (int**)malloc(*m * sizeof(int*));
    for (int i = 0; i < *m; i++) {
        grid[i] = (int*)malloc(*n * sizeof(int));
    }
    
    // Parse the actual values
    temp = ptr;
    int row = 0, col = 0;
    int in_row = 0;
    
    while (*temp && row < *m) {
        if (*temp == '[') {
            in_row = 1;
            col = 0;
        } else if (*temp == ']') {
            if (in_row) {
                row++;
                in_row = 0;
            }
        } else if (isdigit(*temp) && in_row) {
            grid[row][col] = *temp - '0';
            col++;
        }
        temp++;
    }
    
    return grid;
}

int** solution(int** grid, int m, int n, int* returnSize, int** returnColumnSizes) {
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    int** diff = (int**)malloc(m * sizeof(int*));
    
    for (int i = 0; i < m; i++) {
        (*returnColumnSizes)[i] = n;
        diff[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Count ones and zeros in row i
            int onesRow = 0;
            for (int k = 0; k < n; k++) {
                onesRow += grid[i][k];
            }
            int zerosRow = n - onesRow;
            
            // Count ones and zeros in column j
            int onesCol = 0;
            for (int k = 0; k < m; k++) {
                onesCol += grid[k][j];
            }
            int zerosCol = m - onesCol;
            
            // Apply formula
            diff[i][j] = onesRow + onesCol - zerosRow - zerosCol;
        }
    }
    
    return diff;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int m, n;
    int** grid = parseGrid(input, &m, &n);
    
    if (!grid) {
        printf("[]");
        return 0;
    }
    
    int returnSize, *returnColumnSizes;
    int** result = solution(grid, m, n, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(grid[i]);
        free(result[i]);
    }
    free(grid);
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n + mn²)

For each of m*n cells, we scan entire row (n elements) and column (m elements)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

23.4K Views

Medium Frequency

~15 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler