C# Program for nth Catalan Number

Catalan numbers are defined as a mathematical sequence that consists of positive integers, which can be used to find the number of possibilities of various combinations. 

The nth term in the sequence denoted C_n, is found in the following formula: 

The first few Catalan numbers for n = 0, 1, 2, 3, … are : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, … 

Catalan numbers occur in many interesting counting problems like the following.

1. Count the number of expressions containing n pairs of parentheses that are correctly matched. For n = 3, possible expressions are ((())), ()(()), ()()(), (())(), (()()).
2. Count the number of possible Binary Search Trees with n keys (See this)
3. Count the number of full binary trees (A rooted binary tree is full if every vertex has either two children or no children) with n+1 leaves.
4. Given a number n, return the number of ways you can draw n chords in a circle with 2 x n points such that no 2 chords intersect.

Examples:

Input: n = 6
Output: 132

Input: n = 8
Output: 1430

C# Program for nth Catalan Number using Recursive Solution:

Catalan numbers satisfy the following recursive formula: 

Follow the steps below to implement the above recursive formula

• Base condition for the recursive approach, when n <= 1, return 1
• Iterate from i = 0 to i < n
  • Make a recursive call catalan(i) and catalan(n – i – 1) and keep adding the product of both into res.
• Return the res.

Below is the implementation of the above approach:

C#

// A recursive C# program to find
// nth catalan number
using System;

class GFG {

    // A recursive function to find
    // nth catalan number
    static int catalan(int n)
    {
        int res = 0;

        // Base case
        if (n <= 1) {
            return 1;
        }
        for (int i = 0; i < n; i++) {
            res += catalan(i) * catalan(n - i - 1);
        }
        return res;
    }

    // Driver Code
    public static void Main()
    {
        for (int i = 0; i < 10; i++)
            Console.Write(catalan(i) + " ");
    }
}

// This code is contributed by
// nitin mittal.

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: The above implementation is equivalent to nth Catalan number. 

The value of nth Catalan number is exponential which makes the time complexity exponential.
Auxiliary Space: O(n)

C# Program for nth Catalan Number using Dynamic Programming:

We can observe that the above recursive implementation does a lot of repeated work. Since there are overlapping subproblems, we can use dynamic programming for this.

Below is the implementation of the above idea:

• Create an array catalan[] for storing ith Catalan number.
• Initialize, catalan[0] and catalan[1] = 1
• Loop through i = 2 to the given Catalan number n.
  • Loop through j = 0 to j < i and Keep adding value of catalan[j] * catalan[i – j – 1] into catalan[i].
• Finally, return catalan[n]

Below is the implementation of the above approach:

C#

using System;

class GFG {

    // A dynamic programming based
    // function to find nth
    // Catalan number
    static uint catalanDP(uint n)
    {
        // Table to store results of subproblems
        uint[] catalan = new uint[n + 2];

        // Initialize first two values in table
        catalan[0] = catalan[1] = 1;

        // Fill entries in catalan[]
        // using recursive formula
        for (uint i = 2; i <= n; i++) {
            catalan[i] = 0;
            for (uint j = 0; j < i; j++)
                catalan[i]
                    += catalan[j] * catalan[i - j - 1];
        }

        // Return last entry
        return catalan[n];
    }

    // Driver code
    static void Main()
    {
        for (uint i = 0; i < 10; i++)
            Console.Write(catalanDP(i) + " ");
    }
}

// This code is contributed by Chandan_jnu

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: O(n²)
Auxiliary Space: O(n)

C# Program for nth Catalan Number using Binomial Coefficient:

We can also use the below formula to find nth Catalan number in O(n) time.

Below are the steps for calculating nC_r.

• Create a variable to store the answer and change r to n – r if r is greater than n – r because we know that C(n, r) = C(n, n-r) if r > n – r 
• Run a loop from 0 to r-1
  • In every iteration update ans as (ans*(n-i))/(i+1), where i is the loop counter.
• So the answer will be equal to ((n/1)*((n-1)/2)*…*((n-r+1)/r), which is equal to nC_r.

Below are steps to calculate Catalan numbers using the formula: 2nC_n/(n+1)

• Calculate 2nC_n using the similar steps that we use to calculate nC_r
• Return the value 2nC_n/ (n + 1)

Below is the implementation of the above approach:

C#

// C# program for nth Catalan Number
using System;
class GFG {

    // Returns value of Binomial Coefficient C(n, k)
    static long binomialCoeff(int n, int k)
    {
        long res = 1;

        // Since C(n, k) = C(n, n-k)
        if (k > n - k) {
            k = n - k;
        }

        // Calculate value of [n*(n-1)*---*(n-k+1)] /
        // [k*(k-1)*---*1]
        for (int i = 0; i < k; ++i) {
            res *= (n - i);
            res /= (i + 1);
        }

        return res;
    }

    // A Binomial coefficient based function to find nth
    // catalan number in O(n) time
    static long catalan(int n)
    {
        // Calculate value of 2nCn
        long c = binomialCoeff(2 * n, n);

        // return 2nCn/(n+1)
        return c / (n + 1);
    }

    // Driver code
    public static void Main()
    {
        for (int i = 0; i < 10; i++) {
            Console.Write(catalan(i) + " ");
        }
    }
}

// This code is contributed
// by Akanksha Rai

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: O(n).
Auxiliary Space: O(1)

We can also use the below formulas to find nth Catalan number in O(n) time. 

C# Program for nth Catalan Number using the previous Catalan Number:

Below are steps to calculate Catalan numbers using the above formula:

• Initialize a variable res = 1
• Print 1 as the first Catalan Number
• Iterate from i = 1 to i < n
  • Update res with res = (res * (4 * i – 2)) / (i + 1)
  • print res

Below is the implementation for the above approach:

C#

using System;

public class GFG {

    // Function to print first n Catalan numbers
    static void catalan(int n)
    {
        int res = 1;

        Console.Write(1 + " ");
        // Iterate till N
        for (int i = 1; i < n; i++) {
            // Calculate the ith Catalana Number
            res = (res * (4 * i - 2)) / (i + 1);
            Console.Write(res + " ");
        }
    }

    // Driver code
    public static void Main(String[] args)
    {
        int n = 10;
        // Function call
        catalan(n);
    }
}

// This code is contributed by Rajput-Ji

Output

1 1 2 5 14 42 132 429 1430 4862 

Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.

Please refer complete article on Program for nth Catalan Number for more details!