Number of Laser Beams in a Bank - Practice Coding Problems

Number of Laser Beams in a Bank - Problem

Bank Security Laser System

You're working as a security consultant for a high-tech bank that uses an innovative laser beam security system. The bank's floor plan is represented as a 2D grid where each cell can either be empty ('0') or contain a security device ('1').

The laser system works with these rules:
• Laser beams form between security devices on different rows
• A beam can only exist if there are no security devices in any row between the two connected devices
• Each device on row A connects to every device on the next valid row B

Your task is to calculate the total number of laser beams in this security system.

Example: If row 1 has 3 devices and row 4 has 2 devices (with rows 2-3 empty), there will be 3 × 2 = 6 laser beams between them.

Input & Output

example_1.py — Basic Grid

$ Input: ["011001", "000000", "010100", "001000"]

› Output: 8

💡 Note: Row 0 has 3 devices, Row 2 has 2 devices, Row 3 has 1 device. Laser beams: 3×2=6 (between rows 0,2) + 2×1=2 (between rows 2,3) = 8 total.

example_2.py — No Beams Possible

$ Input: ["000", "111", "000"]

› Output: 0

💡 Note: Only row 1 has devices. Since laser beams require devices on different rows, and there's only one row with devices, no beams can be formed.

example_3.py — All Rows Have Devices

$ Input: ["11", "01", "10"]

› Output: 3

💡 Note: Row 0: 2 devices, Row 1: 1 device, Row 2: 1 device. Beams: 2×1=2 (rows 0,1) + 1×1=1 (rows 1,2) = 3 total.

Constraints

m == bank.length
n == bank[i].length
1 ≤ m, n ≤ 500
bank[i][j] is either '0' or '1'
Each row contains at least one character

Visualization

Tap to expand

Understanding the Visualization

Scan Each Level

Count how many laser projectors are on each stage level

Skip Empty Levels

Levels with no projectors don't affect beam formation

Connect Adjacent Levels

Each projector on level A connects to each projector on the next occupied level B

Calculate Total Beams

Multiply projector counts: Level A count × Level B count

Key Takeaway

🎯 Key Insight: We only need to track consecutive 'active' levels and multiply their projector counts - no need to check individual projector pairs!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses a single-pass approach with O(m×n) time complexity. Key insight: laser beams only form between consecutive rows that contain devices. We count devices in each row and multiply consecutive non-zero counts to get the number of beams between them. This elegant mathematical approach avoids checking all device pairs individually.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(m² × n²)	O(m × n)	Check every possible pair of devices across all rows and validate connection rules
One-Pass Optimal Solution	O(m × n)	O(1)	Process rows sequentially, multiply device counts between consecutive active rows

Brute Force (Check All Pairs) — Algorithm Steps

Find all device positions in the grid
For each pair of devices in different rows (r1 < r2)
Check if all rows between r1 and r2 are empty of devices
If valid, increment the laser beam count
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Devices

Locate all security devices in the grid

Check Pairs

For each pair of devices in different rows

Validate Connection

Check if rows between them are empty

Count Valid Beams

Increment counter for valid connections

Code -

solution.c — C

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

int numPointsInLaser(char** bank, int bankSize) {
    int n = strlen(bank[0]);
    int devices[1000][2]; // Assume max 1000 devices
    int deviceCount = 0;
    
    // Find all device positions
    for (int i = 0; i < bankSize; i++) {
        for (int j = 0; j < n; j++) {
            if (bank[i][j] == '1') {
                devices[deviceCount][0] = i;
                devices[deviceCount][1] = j;
                deviceCount++;
            }
        }
    }
    
    int count = 0;
    // Check all pairs of devices
    for (int i = 0; i < deviceCount; i++) {
        for (int j = i + 1; j < deviceCount; j++) {
            int r1 = devices[i][0], r2 = devices[j][0];
            
            if (r1 != r2) { // Different rows
                // Check if rows between r1 and r2 are empty
                int valid = 1;
                int start = r1 < r2 ? r1 : r2;
                int end = r1 > r2 ? r1 : r2;
                
                for (int row = start + 1; row < end; row++) {
                    if (strchr(bank[row], '1') != NULL) {
                        valid = 0;
                        break;
                    }
                }
                
                if (valid) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char* bank[] = {"011001", "000000", "010100", "001000"};
    printf("%d\n", numPointsInLaser(bank, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n²)

For each pair of devices (potentially O(m×n) devices), we check O(m) rows between them

⚠ Quadratic Growth

Space Complexity

O(m × n)

Storage for all device positions in the worst case

⚡ Linearithmic Space

28.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 (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler