Pascal's Triangle II - Practice Coding Problems

Pascal's Triangle II - Problem

Pascal's Triangle II challenges you to find a specific row in the famous mathematical structure known as 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. Your task is to return the rowIndex-th row (0-indexed) as an array.

Goal: Given an integer rowIndex, return the values in that specific row of Pascal's Triangle.

Example Triangle:

Row 0:     [1]
Row 1:    [1,1]
Row 2:   [1,2,1]
Row 3:  [1,3,3,1]
Row 4: [1,4,6,4,1]

Notice how each number (except the edges) equals the sum of the two numbers above it.

Input & Output

example_1.py — Basic Case

$ Input: rowIndex = 3

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

💡 Note: Row 3 of Pascal's Triangle is [1,3,3,1]. The middle elements are calculated as: position 1 = 1+2=3, position 2 = 2+1=3 from the previous row [1,2,1].

example_2.py — Edge Case

$ Input: rowIndex = 0

› Output: [1]

💡 Note: The first row (index 0) of Pascal's Triangle contains only one element: 1. This is the base case for the triangle.

example_3.py — Small Case

$ Input: rowIndex = 1

› Output: [1,1]

💡 Note: Row 1 of Pascal's Triangle is [1,1]. This row establishes the pattern where each row starts and ends with 1.

Constraints

0 ≤ rowIndex ≤ 33
The answer is guaranteed to fit in a 32-bit integer
Follow-up: Could you optimize your algorithm to use only O(rowIndex) extra space?

Visualization

Tap to expand

Understanding the Visualization

Start Simple

Begin with the base row [1]

Expand & Update

Add a new 1, then update middle elements from right to left

Repeat Process

Continue until we reach the target rowIndex

Mathematical Beauty

Each element equals the sum of elements directly above it

Key Takeaway

🎯 Key Insight: Pascal's Triangle has a beautiful mathematical property where each element is the sum of the two elements above it. We can generate any row efficiently by transforming a single array in-place, achieving optimal space complexity.

Asked in

🍎 Apple 15 ⊞ Microsoft 12 a Amazon 8 G Google 6

The optimal approach uses space-optimized in-place transformation with O(rowIndex) space complexity. We start with [1] and iteratively transform it into each subsequent row by updating elements from right to left, avoiding the need to store the entire triangle.

Common Approaches

Approach	Time	Space	Notes
✓ Space-Optimized Row Generation	O(rowIndex²)	O(1)	Generate only the target row by transforming a single array in-place

Space-Optimized Row Generation — Algorithm Steps

Initialize result array with [1]
For each iteration from 1 to rowIndex:
Expand array by adding a 1 at the end
Update elements from right to left (to avoid overwriting needed values)
Each element becomes sum of itself and previous element
Keep leftmost and rightmost elements as 1
Return the final transformed array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with [1]

Expand

Add 1 to make [1,1]

Transform

Update middle values [1,2,1]

Repeat

Continue until target row

Code -

solution.c — C

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

int* getRow(int rowIndex, int* returnSize) {
    *returnSize = rowIndex + 1;
    int* result = malloc((rowIndex + 1) * sizeof(int));
    result[0] = 1;
    
    for (int i = 1; i <= rowIndex; i++) {
        result[i] = 1;
        // Update from right to left to avoid overwriting
        for (int j = i - 1; j > 0; j--) {
            result[j] = result[j] + result[j - 1];
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(rowIndex²)

We perform rowIndex iterations, each processing up to rowIndex elements

✓ Linear Growth

Space Complexity

O(1)

Only use the output array, no extra space (excluding the result array)

✓ Linear Space

78.0K Views

Medium Frequency

~15 min Avg. Time

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

Space-Optimized Row Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler