Find the Nth row in Pascal's Triangle

Given a non-negative integer n, the task is to find the n^th row of Pascal's Triangle.

Note: The row index starts from 1.

Examples:

Input: n = 4
Output: 1 3 3 1
Explanation: The elements in the 4th row are 1 3 3 1 as shown in Pascal Triangle.

Input: n = 1
Output: 1
Explanation: The elements in the 1th row is 1 as shown in Pascal Triangle.

Try It Yourself

Table of Content

[Naive Approach] Using Recursion - O(2^n) Time and O(n) Space
[Better Approach] Using Recursion Level by Level - O(n^2) Time and O(n) Space
[Expected Approach] Using Combinatorics - O(n) Time and O(n) Space

[Naive Approach] Using Recursion - O(2^n) Time and O(n) Space

The idea is to use the property that each element i in the Pascal triangle is equal to the sum of two elements directly above it (i-1 and i), with the base condition that the first and last element of any row will be equal to 1.

C++

// C++ program to Find the nth row in 
// Pascal’s Triangle using Recursion 
#include <bits/stdc++.h>
using namespace std;

// Function which recursively finds the 
// ith value of nth row.
int findVal(int i, int n) {
    
    // First and last value of each 
    // row will always be 1.
    if (i == 1 || i == n) {
        return 1;
    }
    
    // Find the (i-1)th and ith 
    // value of previous row 
    return findVal(i-1, n-1) + findVal(i, n-1);
}

// Function to find the elements 
// of n'th row in Pascal's Triangle 
vector<int> nthRowOfPascalTriangle(int n) { 
    vector<int> res;
    
    for (int i=1; i<=n; i++) {
        int val = findVal(i, n);
        res.push_back(val);
    }
    
    return res;
} 

int main() {
  
    int n = 4; 
    vector<int> ans = nthRowOfPascalTriangle(n); 

    for(int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    } 
    cout << endl;
    return 0;
}

Java

// Java program to Find the nth row in 
// Pascal’s Triangle using Recursion 
import java.util.*;

class GfG {

    // Function which recursively finds the 
    // ith value of nth row.
    static int findVal(int i, int n) {
        
        // First and last value of each 
        // row will always be 1.
        if (i == 1 || i == n) {
            return 1;
        }
        
        // Find the (i-1)th and ith 
        // value of previous row 
        return findVal(i - 1, n - 1) + findVal(i, n - 1);
    }

    // Function to find the elements 
    // of n'th row in Pascal's Triangle 
    static ArrayList<Integer> nthRowOfPascalTriangle(int n) { 
        ArrayList<Integer> res = new ArrayList<>();

        for (int i = 1; i <= n; i++) {
            int val = findVal(i, n);
            res.add(val);
        }

        return res;
    } 

    public static void main(String[] args) {
        int n = 4; 
        ArrayList<Integer> ans = nthRowOfPascalTriangle(n); 

        for (int i = 0; i < ans.size(); i++) {
            System.out.print(ans.get(i) + " ");
        } 
        System.out.println();
    }
}

Python

# Python program to Find the nth row in 
# Pascal’s Triangle using Recursion 

# Function which recursively finds the 
# ith value of nth row.
def findVal(i, n):
    
    # First and last value of each 
    # row will always be 1.
    if i == 1 or i == n:
        return 1
    
    # Find the (i-1)th and ith 
    # value of previous row 
    return findVal(i - 1, n - 1) + findVal(i, n - 1)

# Function to find the elements 
# of n'th row in Pascal's Triangle 
def nthRowOfPascalTriangle(n): 
    res = []
    
    for i in range(1, n + 1):
        val = findVal(i, n)
        res.append(val)
    
    return res

if __name__ == "__main__":
    n = 4 
    ans = nthRowOfPascalTriangle(n)

    for i in range(len(ans)):
        print(ans[i], end=" ")
    print()

// C# program to Find the nth row in 
// Pascal’s Triangle using Recursion 
using System;
using System.Collections.Generic;

class GfG {

    // Function which recursively finds the 
    // ith value of nth row.
    static int findVal(int i, int n) {
        
        // First and last value of each 
        // row will always be 1.
        if (i == 1 || i == n) {
            return 1;
        }
        
        // Find the (i-1)th and ith 
        // value of previous row 
        return findVal(i - 1, n - 1) + findVal(i, n - 1);
    }

    // Function to find the elements 
    // of n'th row in Pascal's Triangle 
    static List<int> nthRowOfPascalTriangle(int n) { 
        List<int> res = new List<int>();

        for (int i = 1; i <= n; i++) {
            int val = findVal(i, n);
            res.Add(val);
        }

        return res;
    } 

    static void Main(string[] args) {
        int n = 4; 
        List<int> ans = nthRowOfPascalTriangle(n); 

        for (int i = 0; i < ans.Count; i++) {
            Console.Write(ans[i] + " ");
        } 
        Console.WriteLine();
    }
}

JavaScript

// Function which recursively finds the 
// ith value of nth row.
function findVal(i, n) {
    
    // First and last value of each 
    // row will always be 1.
    if (i === 1 || i === n) {
        return 1;
    }
    
    // Find the (i-1)th and ith 
    // value of previous row 
    return findVal(i - 1, n - 1) + findVal(i, n - 1);
}

// Function to find the elements 
// of n'th row in Pascal's Triangle 
function nthRowOfPascalTriangle(n) {
    let res = [];

    for (let i = 1; i <= n; i++) {
        let val = findVal(i, n);
        res.push(val);
    }

    return res;
}

// Driver code
let n = 4;
let ans = nthRowOfPascalTriangle(n);
console.log(ans.join(' '));

Output

1 3 3 1

[Better Approach] Using Recursion Level by Level - O(n^2) Time and O(n) Space

The idea is to recursively find the n'th row by recursively finding the previous row. Then use the previous row to calculate the values of current row.

C++

// C++ program to Find the nth row in 
// Pascal’s Triangle using Recursion 
#include <bits/stdc++.h>
using namespace std;

// Function to find the elements 
// of n'th row in Pascal's Triangle 
vector<int> nthRowOfPascalTriangle(int n) { 
    vector<int> curr; 
    
    // 1st element of every row is 1 
    curr.push_back(1); 
    
    // Check if the row that has to 
    // be returned is the first row 
    if (n == 1) { 
        return curr; 
    } 
    
    // Generate the previous row 
    vector<int> prev = nthRowOfPascalTriangle(n - 1); 

    for(int i = 1; i < prev.size(); i++) {
        
        // Generate the elements of the current
        // row with the help of the previous row 
        int val = prev[i - 1] + prev[i]; 
        curr.push_back(val); 
    } 
    curr.push_back(1); 
    
    // Return the row 
    return curr; 
} 

int main() {
  
    int n = 4; 
    vector<int> ans = nthRowOfPascalTriangle(n); 

    for(int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    } 
    cout << endl;
    return 0;
}

Java

// Java program to Find the nth row in 
// Pascal’s Triangle using Recursion 
import java.util.*;

class GfG {

    // Function to find the elements 
    // of n'th row in Pascal's Triangle 
    static ArrayList<Integer> nthRowOfPascalTriangle(int n) {
        ArrayList<Integer> curr = new ArrayList<>();

        // 1st element of every row is 1 
        curr.add(1);

        // Check if the row that has to 
        // be returned is the first row 
        if (n == 1) {
            return curr;
        }

        // Generate the previous row 
        ArrayList<Integer> prev = nthRowOfPascalTriangle(n - 1);

        for (int i = 1; i < prev.size(); i++) {

            // Generate the elements of the current
            // row with the help of the previous row 
            int val = prev.get(i - 1) + prev.get(i);
            curr.add(val);
        }
        curr.add(1);

        // Return the row 
        return curr;
    }

    public static void main(String[] args) {
        int n = 4;
        ArrayList<Integer> ans = nthRowOfPascalTriangle(n);

        for (int i = 0; i < ans.size(); i++) {
            System.out.print(ans.get(i) + " ");
        }
        System.out.println();
    }
}

Python

# Python program to Find the nth row in 
# Pascal’s Triangle using Recursion 

# Function to find the elements 
# of n'th row in Pascal's Triangle 
def nthRowOfPascalTriangle(n):
    curr = []

    # 1st element of every row is 1 
    curr.append(1)

    # Check if the row that has to 
    # be returned is the first row 
    if n == 1:
        return curr

    # Generate the previous row 
    prev = nthRowOfPascalTriangle(n - 1)

    for i in range(1, len(prev)):

        # Generate the elements of the current
        # row with the help of the previous row 
        val = prev[i - 1] + prev[i]
        curr.append(val)

    curr.append(1)

    # Return the row 
    return curr

if __name__ == "__main__":
    n = 4
    ans = nthRowOfPascalTriangle(n)

    for val in ans:
        print(val, end=" ")
    print()

// C# program to Find the nth row in 
// Pascal’s Triangle using Recursion 
using System;
using System.Collections.Generic;

class GfG {

    // Function to find the elements 
    // of n'th row in Pascal's Triangle 
    static List<int> nthRowOfPascalTriangle(int n) {
        List<int> curr = new List<int>();

        // 1st element of every row is 1 
        curr.Add(1);

        // Check if the row that has to 
        // be returned is the first row 
        if (n == 1) {
            return curr;
        }

        // Generate the previous row 
        List<int> prev = nthRowOfPascalTriangle(n - 1);

        for (int i = 1; i < prev.Count; i++) {

            // Generate the elements of the current
            // row with the help of the previous row 
            int val = prev[i - 1] + prev[i];
            curr.Add(val);
        }
        curr.Add(1);

        // Return the row 
        return curr;
    }

    static void Main(string[] args) {
        int n = 4;
        List<int> ans = nthRowOfPascalTriangle(n);

        for (int i = 0; i < ans.Count; i++) {
            Console.Write(ans[i] + " ");
        }
        Console.WriteLine();
    }
}

JavaScript

// JavaScript program to Find the nth row in 
// Pascal’s Triangle using Recursion 

// Function to find the elements 
// of n'th row in Pascal's Triangle 
function nthRowOfPascalTriangle(n) {
    let curr = [];

    // 1st element of every row is 1 
    curr.push(1);

    // Check if the row that has to 
    // be returned is the first row 
    if (n === 1) {
        return curr;
    }

    // Generate the previous row 
    let prev = nthRowOfPascalTriangle(n - 1);

    for (let i = 1; i < prev.length; i++) {

        // Generate the elements of the current
        // row with the help of the previous row 
        let val = prev[i - 1] + prev[i];
        curr.push(val);
    }
    curr.push(1);

    // Return the row 
    return curr;
}

let n = 4;
let ans = nthRowOfPascalTriangle(n);
console.log(ans.join(' '));

Output

1 3 3 1

[Expected Approach] Using Combinatorics - O(n) Time and O(n) Space

The idea is to use the mathematical relationship between consecutive elements in a Pascal's Triangle row, rather than computing the entire triangle. Since the nth row consists of binomial coefficients nC0, nC1, ..., nCn, we can calculate each element directly from the previous one using the formula: nCr = (nCr-1 * (n-r+1))/r. This approach starts with nC0 = 1 and efficiently computes each subsequent value

Note: This approach uses 0-based indexing because the mathematical formula used for calculating binomial coefficients aligns with 0-based indexing.

Step by step approach:

Start with first element of the row as 1 (nC0 = 1).
For each subsequent element, use the formula nCr = (nCr-1 * (n-r+1))/r.
Build the row progressively by calculating one element at a time.
Adjust for 1-based indexing by decrementing n before calculations.

How is the formula calculated?

nCi = n! / (i! * (n-i)!) : ith element of nth row
nCi+1 = n! / ((i+1)! * (n-(i+1))!) : (i+1)th element of nth row
Dividing (i+1)th element by ith element: nCi+1 / nCi = [n! / ((i+1)! * (n-i-1)!)] / [n! / (i! * (n-i)!)]
Simplifying: nCi+1 = nCi * (n-i) / (i+1) - This lets us compute each element from the previous one

C++

// C++ program to Find the nth row in Pascal’s
// Triangle using efficient approach 
#include <bits/stdc++.h>
using namespace std;

// Function to find the elements 
// of n'th row in Pascal's Triangle 
vector<int> nthRowOfPascalTriangle(int n) { 
    
    // To follow 0 based indexing, decrement n 
    n--;
    
    vector<int> res;
  
    // nC0 = 1
    int prev = 1;
    res.push_back(prev);

    for (int i = 1; i <= n; i++) {
      
        // nCr = (nCr-1 * (n - r + 1))/r 
        int curr = (prev * (n - i + 1)) / i;
        res.push_back(curr);
        prev = curr;
    }
    return res;
} 

int main() {
  
    int n = 4; 
    vector<int> ans = nthRowOfPascalTriangle(n); 

    for(int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    } 
    cout << endl;
    return 0;
}

Java

// Java program to Find the nth row in Pascal’s
// Triangle using efficient approach 
import java.util.*;

class GfG {

    // Function to find the elements 
    // of n'th row in Pascal's Triangle 
    static ArrayList<Integer> nthRowOfPascalTriangle(int n) {

        // To follow 0 based indexing, decrement n 
        n--;

        ArrayList<Integer> res = new ArrayList<>();

        // nC0 = 1
        int prev = 1;
        res.add(prev);

        for (int i = 1; i <= n; i++) {

            // nCr = (nCr-1 * (n - r + 1))/r 
            int curr = (prev * (n - i + 1)) / i;
            res.add(curr);
            prev = curr;
        }
        return res;
    }

    public static void main(String[] args) {
        int n = 4;
        ArrayList<Integer> ans = nthRowOfPascalTriangle(n);

        for (int i = 0; i < ans.size(); i++) {
            System.out.print(ans.get(i) + " ");
        }
        System.out.println();
    }
}

Python

# Python program to Find the nth row in Pascal’s
# Triangle using efficient approach 

# Function to find the elements 
# of n'th row in Pascal's Triangle 
def nthRowOfPascalTriangle(n):

    # To follow 0 based indexing, decrement n 
    n -= 1

    res = []

    # nC0 = 1
    prev = 1
    res.append(prev)

    for i in range(1, n + 1):

        # nCr = (nCr-1 * (n - r + 1))/r 
        curr = (prev * (n - i + 1)) // i
        res.append(curr)
        prev = curr

    return res

if __name__ == "__main__":
    n = 4
    ans = nthRowOfPascalTriangle(n)

    for val in ans:
        print(val, end=" ")
    print()

// C# program to Find the nth row in Pascal’s
// Triangle using efficient approach 
using System;
using System.Collections.Generic;

class GfG {

    // Function to find the elements 
    // of n'th row in Pascal's Triangle 
    static List<int> nthRowOfPascalTriangle(int n) {

        // To follow 0 based indexing, decrement n 
        n--;

        List<int> res = new List<int>();

        // nC0 = 1
        int prev = 1;
        res.Add(prev);

        for (int i = 1; i <= n; i++) {

            // nCr = (nCr-1 * (n - r + 1))/r 
            int curr = (prev * (n - i + 1)) / i;
            res.Add(curr);
            prev = curr;
        }
        return res;
    }

    static void Main(string[] args) {
        int n = 4;
        List<int> ans = nthRowOfPascalTriangle(n);

        for (int i = 0; i < ans.Count; i++) {
            Console.Write(ans[i] + " ");
        }
        Console.WriteLine();
    }
}

JavaScript

// Function to find the elements 
// of n'th row in Pascal's Triangle 
function nthRowOfPascalTriangle(n) {

    // To follow 0 based indexing, decrement n 
    n--;

    let res = [];

    // nC0 = 1
    let prev = 1;
    res.push(prev);

    for (let i = 1; i <= n; i++) {

        // nCr = (nCr-1 * (n - r + 1))/r 
        let curr = Math.floor((prev * (n - i + 1)) / i);
        res.push(curr);
        prev = curr;
    }
    return res;
}

let n = 4;
let ans = nthRowOfPascalTriangle(n);
console.log(ans.join(' '));

Output

1 3 3 1

Find the Nth row in Pascal's Triangle

[Naive Approach] Using Recursion - O(2^n) Time and O(n) Space

[Better Approach] Using Recursion Level by Level - O(n^2) Time and O(n) Space

[Expected Approach] Using Combinatorics - O(n) Time and O(n) Space

Explore