Leftmost Column with at Least a One - Practice Coding Problems

Leftmost Column with at Least a One - Problem

Interactive Matrix Problem: You're given a row-sorted binary matrix where each row contains only 0s and 1s arranged in non-decreasing order (all 0s come before all 1s in each row). Your task is to find the leftmost column that contains at least one 1.

🔒 The Challenge: You cannot access the matrix directly! Instead, you must use a special BinaryMatrix interface with two methods:
• get(row, col) - returns the element at position (row, col)
• dimensions() - returns [rows, cols] as the matrix dimensions

⚠️ Constraint: You can make at most 1000 calls to get() method. If no column contains a 1, return -1.

Example: In a 4×4 matrix where column 1 is the leftmost column containing a 1, you should return 1.

Input & Output

example_1.py — Standard Case

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

› Output: 1

💡 Note: The leftmost column with at least one 1 is column index 1. Row 2 has a 1 at column 1, which is the earliest position where any 1 appears in the matrix.

example_2.py — No Ones Matrix

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

› Output: -1

💡 Note: There are no 1s in the entire matrix, so we return -1 as specified when no column contains a 1.

example_3.py — First Column Has One

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

› Output: 0

💡 Note: The very first column (index 0) contains a 1 in the first row, making it the leftmost column with at least one 1.

Time & Space Complexity

Time Complexity

⏱️

O(rows × cols)

In worst case, we check every cell in the matrix

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

rows == binaryMatrix.dimensions()[0]
cols == binaryMatrix.dimensions()[1]
1 ≤ rows, cols ≤ 100
binaryMatrix[i][j] is either 0 or 1
Each row of the matrix is sorted in non-decreasing order
You cannot access the matrix directly - only through the BinaryMatrix interface
You can make at most 1000 calls to BinaryMatrix.get

Asked in

The optimal solution uses a two-pointer approach starting from the top-right corner. When we encounter a 1, we move left to find potentially earlier columns; when we encounter a 0, we move down since all cells to the left are guaranteed to be 0 due to the sorted property. This achieves O(rows + cols) time complexity with minimal API calls.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Column by Column)	O(rows × cols)	O(1)	Check each column from left to right, scanning entire column for any 1
Binary Search on Each Row	O(rows × log cols)	O(1)	Use binary search to find the first 1 in each row, track the minimum column
Start from Top-Right Corner (Optimal)	O(rows + cols)	O(1)	Start from top-right corner, move left if 1 found, move down if 0 found

Brute Force (Column by Column) — Algorithm Steps

Get matrix dimensions
For each column from 0 to cols-1:
Check all rows in current column
If any cell contains 1, return current column
If no column contains 1, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with leftmost column

Begin checking column 0 from top to bottom

Scan entire column

Check each row in current column for any 1

Move to next column

If no 1 found, move to next column and repeat

Return first column with 1

As soon as we find a 1, return the column index

Code -

solution.c — C

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

// BinaryMatrix interface simulation
typedef struct {
    int** matrix;
    int rows;
    int cols;
    int calls;
} BinaryMatrix;

BinaryMatrix* createBinaryMatrix(int** matrix, int rows, int cols) {
    BinaryMatrix* bm = (BinaryMatrix*)malloc(sizeof(BinaryMatrix));
    bm->matrix = matrix;
    bm->rows = rows;
    bm->cols = cols;
    bm->calls = 0;
    return bm;
}

int get(BinaryMatrix* bm, int row, int col) {
    bm->calls++;
    return bm->matrix[row][col];
}

void dimensions(BinaryMatrix* bm, int* dims) {
    dims[0] = bm->rows;
    dims[1] = bm->cols;
}

int leftMostColumnWithOne(BinaryMatrix* binaryMatrix) {
    int dims[2];
    dimensions(binaryMatrix, dims);
    int rows = dims[0], cols = dims[1];
    
    // Check each column from left to right
    for (int col = 0; col < cols; col++) {
        // Check if current column has any 1
        for (int row = 0; row < rows; row++) {
            if (get(binaryMatrix, row, col) == 1) {
                return col;
            }
        }
    }
    
    return -1;
}

// Test
int main() {
    int rows = 4, cols = 4;
    int** matrix = (int**)malloc(rows * sizeof(int*));
    int data[4][4] = {{0,0,0,1},{0,0,1,1},{0,1,1,1},{0,0,0,1}};
    
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = data[i][j];
        }
    }
    
    BinaryMatrix* bm = createBinaryMatrix(matrix, rows, cols);
    int result = leftMostColumnWithOne(bm);
    printf("Result: %d, Calls made: %d\n", result, bm->calls);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(rows × cols)

In worst case, we check every cell in the matrix

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

rows == binaryMatrix.dimensions()[0]
cols == binaryMatrix.dimensions()[1]
1 ≤ rows, cols ≤ 100
binaryMatrix[i][j] is either 0 or 1
Each row of the matrix is sorted in non-decreasing order
You cannot access the matrix directly - only through the BinaryMatrix interface
You can make at most 1000 calls to BinaryMatrix.get

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Column by Column) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler