Right Triangles - Practice Coding Problems

Right Triangles - Problem

🔺 Count Right Triangles in a Grid

You are given a 2D boolean matrix grid where each cell contains either 0 or 1. Your task is to count how many right triangles can be formed using cells with value 1.

A right triangle is formed by three cells with value 1 that satisfy this geometric property:

One cell serves as the corner (right angle vertex)
One cell shares the same row as the corner
One cell shares the same column as the corner

Important: The three cells don't need to be adjacent to each other - they can be anywhere in their respective row/column as long as they form the right triangle pattern.

Goal: Return the total number of right triangles that can be formed.

Example visualization:

Grid:
[[1,0,1],
 [0,1,0],
 [1,0,1]]

Right triangle example:
- Corner at (1,1) with value 1
- Row partner at (1,0) or (1,2) - but these are 0, so no triangle
- Column partner at (0,1) or (2,1) - but these are 0, so no triangle

Input & Output

example_1.py — Basic Grid

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

› Output: 2

💡 Note: There are 2 right triangles: Triangle 1 uses corner at (1,2) with row partner (1,1) and column partner (0,2). Triangle 2 uses corner at (1,1) with row partner (1,2) and column partner (2,1).

example_2.py — Larger Grid

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

› Output: 0

💡 Note: No right triangles can be formed because no cell has both a row partner and column partner with value 1.

example_3.py — All Ones

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

› Output: 4

💡 Note: Each of the 4 cells can serve as a corner: (0,0) forms 1×1=1 triangle, (0,1) forms 1×1=1 triangle, (1,0) forms 1×1=1 triangle, (1,1) forms 1×1=1 triangle. Total: 4 triangles.

Constraints

1 ≤ m, n ≤ 1000 where m = grid.length and n = grid[i].length
grid[i][j] is either 0 or 1
The number of cells with value 1 is at most min(1000, m × n)

Visualization

Tap to expand

Understanding the Visualization

Identify Corner

Select a cell with value 1 as the right-angle corner of potential triangles

Find Row Partners

Count other cells with value 1 in the same row as potential horizontal vertices

Find Column Partners

Count other cells with value 1 in the same column as potential vertical vertices

Calculate Triangles

Multiply row partners by column partners to get total triangles for this corner

Key Takeaway

🎯 Key Insight: Every cell with value 1 can be a corner, and the number of right triangles it creates equals the product of other 1s in its row and column.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a one-pass algorithm with O(mn) time and O(m+n) space. Key insight: each cell with value 1 can form (row_count × col_count) triangles as a corner. We maintain running counts and calculate triangles as we traverse, achieving maximum efficiency.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Precomputation	O(mn)	O(m + n)	Precompute row and column counts, then calculate triangles for each cell
Brute Force (Triple Nested Loops)	O(m²n²)	O(1)	Check every possible combination of three cells to see if they form a right triangle
One-Pass Optimal Solution	O(mn)	O(m + n)	Count and calculate triangles in a single pass through the grid

Two-Pass Precomputation — Algorithm Steps

First pass: Count 1s in each row and store in row_counts array
First pass: Count 1s in each column and store in col_counts array
Second pass: For each cell with value 1
Calculate triangles = (row_counts[i] - 1) × (col_counts[j] - 1)
Add to total result
Return final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Rows

Scan grid and count 1s in each row

Count Columns

Scan grid and count 1s in each column

Calculate Triangles

For each 1, multiply (row_count-1) × (col_count-1)

Sum Results

Add up triangles from all corner positions

Code -

solution.c — C

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

long long rightTriangles(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int m = gridSize, n = gridColSize[0];
    
    // First pass: count 1s 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 (grid[i][j] == 1) {
                rowCounts[i]++;
                colCounts[j]++;
            }
        }
    }
    
    // Second pass: calculate triangles for each cell
    long long result = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                long long triangles = (long long)(rowCounts[i] - 1) * (colCounts[j] - 1);
                result += triangles;
            }
        }
    }
    
    free(rowCounts);
    free(colCounts);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Two passes through the m×n grid: O(mn) + O(mn) = O(mn)

✓ Linear Growth

Space Complexity

O(m + n)

Storing counts for m rows and n columns

⚡ Linearithmic Space

28.3K Views

Medium-High Frequency

~18 min Avg. Time

856 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

🔺 Count Right Triangles in a Grid

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler