Pascal's Triangle II

Pascal's Triangle II - Problem

Given an integer rowIndex, return the rowIndex-th (0-indexed) row of Pascal's triangle.

In Pascal's triangle, each number is the sum of the two numbers directly above it. The triangle starts with 1 at the top, and each subsequent row begins and ends with 1.

Example: Row 0: [1], Row 1: [1,1], Row 2: [1,2,1], Row 3: [1,3,3,1]

Input & Output

Example 1 — Row 3

$ Input: rowIndex = 3

› Output: [1,3,3,1]

💡 Note: Row 3 of Pascal's triangle: The 4th row (0-indexed) contains the values [1,3,3,1], where each inner element is the sum of the two elements above it from the previous row.

Example 2 — Row 0

$ Input: rowIndex = 0

› Output: [1]

💡 Note: Row 0 is the first row of Pascal's triangle and contains only the value 1.

Example 3 — Row 1

$ Input: rowIndex = 1

› Output: [1,1]

💡 Note: Row 1 contains [1,1] - two 1s at the edges as every row starts and ends with 1.

Constraints

0 ≤ rowIndex ≤ 33

Visualization

Tap to expand

Asked in

🍎 Apple 15 🪟 Microsoft 12

The key insight is that Pascal's triangle row can be computed using binomial coefficients. The optimal approach uses the mathematical formula C(n,k) = C(n,k-1) × (n-k+1) ÷ k to calculate each element directly. Time: O(n), Space: O(n)

Common Approaches

✓ Build Entire Triangle

⏱️ Time: O(n²) Space: O(n²)

Build Pascal's triangle row by row from the beginning. Each row is constructed by adding adjacent elements from the previous row, with 1s at both ends.

Mathematical Formula (Binomial Coefficients)

⏱️ Time: O(n) Space: O(n)

Each element in Pascal's triangle is a binomial coefficient C(rowIndex, k). We can calculate each coefficient iteratively using the relation C(n,k) = C(n,k-1) * (n-k+1) / k.

Space Optimized - Two Arrays

⏱️ Time: O(n²) Space: O(n)

Instead of storing the entire triangle, maintain only the previous row to calculate the current row. This reduces space complexity while keeping the same time complexity.

Build Entire Triangle — Algorithm Steps

Start with first row [1]
For each subsequent row, calculate elements as sum of adjacent pairs from previous row
Return the target row

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty triangle

Build Rows

Generate each row using previous row

Return Target

Extract the rowIndex-th row

Code -

solution.c — C

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

int* solution(int rowIndex, int* returnSize) {
    int** triangle = (int**)malloc((rowIndex + 1) * sizeof(int*));
    
    for (int i = 0; i <= rowIndex; i++) {
        triangle[i] = (int*)malloc((i + 1) * sizeof(int));
        triangle[i][0] = triangle[i][i] = 1;
        
        for (int j = 1; j < i; j++) {
            triangle[i][j] = triangle[i-1][j-1] + triangle[i-1][j];
        }
    }
    
    int* result = (int*)malloc((rowIndex + 1) * sizeof(int));
    for (int i = 0; i <= rowIndex; i++) {
        result[i] = triangle[rowIndex][i];
    }
    
    *returnSize = rowIndex + 1;
    
    for (int i = 0; i <= rowIndex; i++) {
        free(triangle[i]);
    }
    free(triangle);
    
    return result;
}

int main() {
    int rowIndex;
    scanf("%d", &rowIndex);
    
    int returnSize;
    int* result = solution(rowIndex, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Building n rows, each row i has i+1 elements, total operations: 1+2+...+n = n(n+1)/2

⚠ Quadratic Growth

Space Complexity

O(n²)

Storing all rows from 0 to n, total elements: 1+2+...+(n+1) = (n+1)(n+2)/2

⚡ Linearithmic Space

155.4K Views

Medium Frequency

~15 min Avg. Time

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

Build Entire Triangle — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler