Problem statement

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

Each number in the triangle is the sum of the two directly above it.

Example 1

Input: rowIndex = 3
Output: [1,3,3,1]

Example 2

Input: rowIndex = 0
Output: [1]

Example 3

Input: rowIndex = 4
Output: [1,4,6,4,1]

Constraints

• 0 <= rowIndex <= 30
• Every value fits in a signed 32-bit integer.

Follow-up: Can you build the row using only O(rowIndex) extra space?

Hints for Pascal's Triangle II

1. Hint 1

   Building the whole triangle costs O(n²) space; only the previous row is ever needed.

2. Hint 2

   Update one array in place, walking right to left so a slot is read before it is overwritten.

3. Hint 3

   The closed form also works: each entry is the previous one times (n - i + 1) / i.

How to solve Pascal's Triangle II

Only the previous row is needed; update a single array in place from right to left so each slot is read before it is overwritten.

Approach

1. Start with row = [1] * (rowIndex + 1).
2. For i from 1 to rowIndex, for j from i - 1 down to 1, set row[j] += row[j-1].
3. Return row.

Why it works

Row i of the triangle is row i - 1 with each interior entry replaced by the sum of the two above it. Walking right to left guarantees row[j-1] is still the old value when row[j] is updated.

Complexity

• Time — O(n²)
• Space — O(n)

Pitfalls

• Left-to-right updating uses already-updated neighbours and corrupts the row.
• The multiplicative closed form row[i] = row[i-1] · (n - i + 1) / i gives O(n).

Reference solution

Python

def getRow(rowIndex: int):
    row = [1] * (rowIndex + 1)
    for i in range(1, rowIndex + 1):
        for j in range(i - 1, 0, -1):
            row[j] += row[j - 1]
    return row

Java

public static int[] getRow(int rowIndex) {
    int[] row = new int[rowIndex + 1];
    Arrays.fill(row, 1);
    for (int i = 1; i <= rowIndex; i++) {
        for (int j = i - 1; j > 0; j--) row[j] += row[j - 1];
    }
    return row;
}

C++

vector<int> getRow(int rowIndex) {
    vector<int> row(rowIndex + 1, 1);
    for (int i = 1; i <= rowIndex; i++) {
        for (int j = i - 1; j > 0; j--) row[j] += row[j - 1];
    }
    return row;
}

JavaScript

var getRow = function(rowIndex) {
    const row = new Array(rowIndex + 1).fill(1);
    for (let i = 1; i <= rowIndex; i++) {
        for (let j = i - 1; j > 0; j--) {
            row[j] += row[j - 1];
        }
    }
    return row;
};

Also on the editorial tab: C, C#, Go, Kotlin, PHP, Ruby, Rust, Swift, TypeScript.

More arrays problems

• Brightest String of Diyas Easy
• Design Neighbor Sum Service Easy
• Design an Ordered Stream Easy
• Design HashMap Easy
• Design HashSet Easy
• Range Sum Query - Immutable Easy