Pascal's Triangle - Practice Coding Problems

Pascal's Triangle - Problem

Pascal's Triangle is one of the most beautiful mathematical constructs! Your task is to generate the first numRows rows of Pascal's Triangle.

In Pascal's Triangle, each row starts and ends with 1, and every other number is the sum of the two numbers directly above it from the previous row. This creates a triangular pattern where each number represents a binomial coefficient.

Example: If numRows = 5, you should return:

🎯 Goal: Return a 2D array where each inner array represents a row of Pascal's Triangle.
📥 Input: An integer numRows (1 ≤ numRows ≤ 30)
📤 Output: A 2D array containing the first numRows of Pascal's Triangle

Input & Output

example_1.py — Basic Triangle

$ Input: numRows = 5

› Output: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

💡 Note: The first 5 rows of Pascal's Triangle. Each number is the sum of the two numbers above it. Row 0 has [1], Row 1 has [1,1], Row 2 has [1,2,1] where 2 = 1+1, and so on.

example_2.py — Single Row

$ Input: numRows = 1

› Output: [[1]]

💡 Note: When numRows is 1, we only return the first row of Pascal's Triangle, which contains just the number 1.

example_3.py — Small Triangle

$ Input: numRows = 3

› Output: [[1],[1,1],[1,2,1]]

💡 Note: The first 3 rows show the basic pattern: edges are always 1, and middle elements are sums of the pair above (1+1=2 in the third row).

Visualization

Tap to expand

Red triangles: Always 1 (edges of the triangle)🔵 Blue/Orange triangles: Sum of the two triangles directly above them

Understanding the Visualization

Foundation

Place the first block with value 1 at the top

Second Level

Place two blocks with value 1 each, supported by the first block

Pattern Formation

Each new level starts and ends with 1

Addition Rule

Interior blocks get the sum of their two supporting blocks

Key Takeaway

🎯 Key Insight: Pascal's Triangle naturally builds itself row by row using simple addition - no complex formulas needed!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of the n² elements, we calculate factorials which take O(n) time in the worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

We store the entire triangle which has n² elements in total

⚠ Quadratic Space

Constraints

1 ≤ numRows ≤ 30
All elements will fit in a 32-bit integer
Note: The triangle grows quadratically in size

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 Apple 22

The optimal approach builds Pascal's Triangle row by row, using the key insight that each element equals the sum of two elements from the previous row. This achieves O(n²) time complexity with no redundant calculations, making it both elegant and efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Binomial Coefficient)	O(n³)	O(n²)	Calculate each element using the binomial coefficient formula C(n,r) = n! / (r! * (n-r)!)
Row-by-Row Construction (Optimal)	O(n²)	O(n²)	Build each row using values from the previous row, leveraging the additive property

Brute Force (Binomial Coefficient) — Algorithm Steps

Create a 2D result array of size numRows
For each row i from 0 to numRows-1:
For each column j from 0 to i:
Calculate C(i,j) = i! / (j! * (i-j)!)
Store the result in result[i][j]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty triangle

Initialize 2D array structure

For each position (i,j)

Calculate C(i,j) using factorial formula

Compute factorials

Calculate i!, j!, and (i-j)! separately

Apply formula

Divide i! by (j! × (i-j)!) to get the coefficient

Code -

solution.c — C

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

long long factorial(int n) {
    if (n <= 1) return 1;
    long long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

int binomialCoefficient(int n, int r) {
    return (int)(factorial(n) / (factorial(r) * factorial(n - r)));
}

int** generate(int numRows, int* returnSize, int** returnColumnSizes) {
    *returnSize = numRows;
    *returnColumnSizes = (int*)malloc(numRows * sizeof(int));
    int** result = (int**)malloc(numRows * sizeof(int*));
    
    for (int i = 0; i < numRows; i++) {
        (*returnColumnSizes)[i] = i + 1;
        result[i] = (int*)malloc((i + 1) * sizeof(int));
        for (int j = 0; j <= i; j++) {
            result[i][j] = binomialCoefficient(i, j);
        }
    }
    
    return result;
}

int main() {
    int numRows;
    scanf("%d", &numRows);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = generate(numRows, &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");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of the n² elements, we calculate factorials which take O(n) time in the worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

We store the entire triangle which has n² elements in total

⚠ Quadratic Space

Constraints

1 ≤ numRows ≤ 30
All elements will fit in a 32-bit integer
Note: The triangle grows quadratically in size

95.4K Views

High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Binomial Coefficient) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler