Lonely Pixel I - Practice Coding Problems

Lonely Pixel I - Problem

Imagine you're analyzing a black and white photograph represented as a grid of pixels. Your task is to find all the "lonely black pixels" - those special black pixels that are completely isolated in their row and column.

Given an m x n picture consisting of black 'B' and white 'W' pixels, return the number of lonely black pixels.

A lonely black pixel is a black pixel 'B' that satisfies both conditions:

It's the only black pixel in its entire row
It's the only black pixel in its entire column

Example: In a 3x3 grid, if there's a black pixel at position (1,1) and it's the only black pixel in row 1 and column 1, then it's considered lonely.

Input & Output

example_1.py — Basic Case

$ Input: picture = [['W','W','B'],['W','B','W'],['B','W','W']]

› Output: 3

💡 Note: All three black pixels are lonely: (0,2) is alone in row 0 and column 2, (1,1) is alone in row 1 and column 1, (2,0) is alone in row 2 and column 0.

example_2.py — No Lonely Pixels

$ Input: picture = [['B','B','B'],['B','B','B']]

› Output: 0

💡 Note: No black pixels are lonely because every row and column contains multiple black pixels.

example_3.py — Mixed Case

$ Input: picture = [['B','W','W'],['W','W','W'],['W','W','B']]

› Output: 2

💡 Note: Both black pixels (0,0) and (2,2) are lonely as they are the only black pixels in their respective rows and columns.

Constraints

m == picture.length
n == picture[i].length
1 ≤ m, n ≤ 500
picture[i][j] is either 'W' or 'B'

Visualization

Tap to expand

Understanding the Visualization

Population Survey

Count how many people live on each island (row) and use each shipping lane (column)

Hermit Detection

For each person, check if they're the only one on their island AND the only one in their lane

True Hermit

If both conditions are met, we've found a lonely pixel hermit!

Key Takeaway

🎯 Key Insight: Pre-counting eliminates redundant scans. Instead of checking each pixel's entire row/column repeatedly, we count once and lookup in O(1) time!

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 15

The optimal solution uses a two-pass counting approach. First, count black pixels in each row and column (O(mn) time). Then, for each black pixel, check if both its row count and column count equal 1. This avoids redundant scanning and achieves O(mn) time complexity with O(m+n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Counting (Optimal)	O(m*n)	O(m+n)	Pre-count black pixels per row/column, then identify lonely pixels in second pass
Brute Force (Nested Loops)	O(m²*n²)	O(1)	For each black pixel, scan its entire row and column to check loneliness

Two-Pass Counting (Optimal) — Algorithm Steps

First pass: Count black pixels in each row and store in array
Continue first pass: Count black pixels in each column and store in array
Second pass: For each black pixel, check if its row count and column count are both 1
If both counts equal 1, increment the lonely pixel counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Phase

Count black pixels in each row and column

Identify Phase

Check each black pixel against pre-computed counts

Lonely Check

If both row and column counts are 1, pixel is lonely

Code -

solution.c — C

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

int findLonelyPixel(char** picture, int pictureSize, int* pictureColSize) {
    if (pictureSize == 0 || pictureColSize[0] == 0) return 0;
    
    int m = pictureSize, n = pictureColSize[0];
    
    // First pass: count black pixels in each row and column
    int* rowCounts = (int*)calloc(m, sizeof(int));
    int* colCounts = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (picture[i][j] == 'B') {
                rowCounts[i]++;
                colCounts[j]++;
            }
        }
    }
    
    // Second pass: find lonely pixels
    int lonelyCount = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (picture[i][j] == 'B' && 
                rowCounts[i] == 1 && 
                colCounts[j] == 1) {
                lonelyCount++;
            }
        }
    }
    
    free(rowCounts);
    free(colCounts);
    return lonelyCount;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Two passes through the matrix: first to count, second to identify lonely pixels

✓ Linear Growth

Space Complexity

O(m+n)

Arrays to store count of black pixels for each row and column

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~12 min Avg. Time

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

Two-Pass Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler