Second Problem:-

Pascal's Triangle: Try It

Now, Understand the Problem First Basically we have given an Integer (numRows) and We have to return Pascal's Triangle Whose number of rows is equal to numRows.

What is Pascal's Triangle?

Now a question comes to your mind what is Pascal's Triangle?

In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:

Note: Pascal's triangle is a triangular array of binomial coefficients.

1  
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1

First(Brute-Force) Approach:

The number of entries in every line is equal to the line number. For example, the first line has "1", the second line has "1 1", the third line has "1 2 1",.. and so on. Every entry in a line is the value of a Binomial Coefficient. The value of the ith entry in line number line is C(line, i). The value can be calculated using the following formula.

C(line, i)   = line! / ( (line-i)! * i! )

Time-Complexity: O(N^3)

Space-Complexity: O(1)

Code:

//  C++ code for Pascal's Triangle
#include <iostream>
using namespace std;

// for details of this function
int binomialCoeff(int n, int k);

// Function to print first
// n lines of Pascal's 
// Triangle
void printPascal(int n)
{
    // Iterate through every line and
    // print entries in it
    for (int line = 0; line < n; line++)
    {
        // Every line has number of 
        // integers equal to line 
        // number
        for (int i = 0; i <= line; i++)
            cout <<" "<< binomialCoeff(line, i);
        cout <<"\n";
    }
}


// for details of this function
int binomialCoeff(int n, int k)
{
    int res = 1;
    if (k > n - k)
    k = n - k;
    for (int i = 0; i < k; ++i)
    {
        res *= (n - i);
        res /= (i + 1);
    }

    return res;
}

// Driver program 
int main()
{
    int n = 7;
    printPascal(n);
    return 0;
}

Second Approach:

If we take a closer at the triangle, we observe that every entry is the sum of the two values above it. So we can create a 2D array that stores previously generated values. To generate a value in a line, we can use the previously stored values from an array.

Time-Complexity: O(N^2).

Space-Complexity: O(n^2).

Code:

// C++ program for Pascal’s Triangle
// method for Pascal's Triangle
#include <bits/stdc++.h>
using namespace std;

void printPascal(int n)
{

    // An auxiliary array to store 
    // generated pascal triangle values
    int arr[n][n]; 

    // Iterate through every line and 
    // print integer(s) in it
    for (int line = 0; line < n; line++)
    {
        // Every line has number of integers 
        // equal to line number
        for (int i = 0; i <= line; i++)
        {
        // First and last values in every row are 1
        if (line == i || i == 0)
            arr[line][i] = 1;
        // Other values are sum of values just 
        // above and left of above
        else
            arr[line][i] = arr[line - 1][i - 1] + 
                            arr[line - 1][i];
        cout << arr[line][i] << " ";
        }
        cout << "\n";
    }
}

// Driver code
int main()
{
    int n = 5;
    printPascal(n);
    return 0;
}

Third Approach:

This method is based on method 1. We know that ith entry in a line number line is Binomial Coefficient C(line, i) and all lines start with value 1. The idea is to calculate C(line, i) using C(line, i-1). It can be calculated in O(1) time using the following.

C(line, i)   = line! / ( (line-i)! * i! )
C(line, i-1) = line! / ( (line - i + 1)! * (i-1)! )
We can derive following expression from above two expressions.
C(line, i) = C(line, i-1) * (line - i + 1) / i

So C(line, i) can be calculated from C(line, i-1) in O(1) time

Time-Complexity: O(N^2).

Space-Complexity: O(1).

Code:

// C++ program for Pascal’s Triangle
// function for Pascal's Triangle
#include <bits/stdc++.h>

using namespace std;
void printPascal(int n)
{

for (int line = 1; line <= n; line++)
{
    int C = 1; // used to represent C(line, i)
    for (int i = 1; i <= line; i++) 
    {

        // The first value in a line is always 1
        cout<< C<<" "; 
        C = C * (line - i) / i; 
    }
    cout<<"\n";
}
}

// Driver code
int main()
{
    int n = 5;
    printPascal(n);
    return 0;
}

Thank You so much everyone for reading this blog I hope it will be helpful for you in that case do like it and follow me on my socials:

My Twitter

My LinkedIn

First of all Why this Series?

You must have seen many Folks, said on their socials that he/she has solved 500 Problems, 1000 Problems etc. But I believe the Number of Questions does not matter it you don't know concept behind the Data Structure and Algorithm.

So Yeah In this Series we will solve 184 Questions which is more than enough to learn and revise the concepts of DSA.

Prerequisites 🤔:

So, You must be familiar with an Object Oriented Programming language like CPP, Java, and Python. But In this series, we will focus on concepts, not languages.

I will code in CPP but you can convert it to any language you want using an AI tool 🔧.

First Problem:-

Set Matrix Zero: Try this

Let's understand the Problem First, basically, it says you have a m*n matrix and in that whenever you see 0 then set all the row elements and column elements of that particular row into 0.

Example:

in the above example if you carefully observe, at (1,1) index element is Zero so we have to initialize row=1 and column=1 to 0.

First (Brute-Force) Approach:

The Brute-force solution that everyone can think of is traversing the entire matrix.

Steps:

• Traverse in the matrix and when you got 0 then convert the entire column and row=-1.

• and then initialize all the -1 into 0.

Now many of you have doubts that why we are converting the entire column and row into -1 Why NOT 0?

You can see the difference below:

when we use 0, then remember we are also traversing at the same time so there are possibilities that another zero can occur (which is converted by a Zero not in the initial problem) that's why we are using -1 so that we can keep track of index which are actually change because of a 0.

Time Complexity: O(n*m) [Traversing Matrix] + O(n*m) [Converting row and column into -1] + O(n*M) [Initilizing -1 to 0].

Space Complexity: We are not using any extra space so O(1)

code:

void markRow(vector<vector<int>> &matrix, int n, int m, int i) {
    // set all non-zero elements as -1 in the row i:
    for (int j = 0; j < m; j++) {
        if (matrix[i][j] != 0) {
            matrix[i][j] = -1;
        }
    }
}


void markCol(vector<vector<int>> &matrix, int n, int m, int j) {
    // set all non-zero elements as -1 in the col j:
    for (int i = 0; i < n; i++) {
        if (matrix[i][j] != 0) {
            matrix[i][j] = -1;
        }
    }
}

vector<vector<int>> zeroMatrix(vector<vector<int>> &matrix, int n, int m) {

    // Set -1 for rows and cols
    // that contains 0. Don't mark any 0 as -1:

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (matrix[i][j] == 0) {
                markRow(matrix, n, m, i);
                markCol(matrix, n, m, j);
            }
        }
    }

    // Finally, mark all -1 as 0:
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (matrix[i][j] == -1) {
                matrix[i][j] = 0;
            }
        }
    }

    return matrix;
}

Optimal Approach:

Using Column and Row array to store the index of Zero:

Steps:

• Traverse Matrix and whenever you get 0 stores the index of the row into the row array and column into the column array.

• Traver Matrix again for Row and Column which we have to initialize with 0 and do that.

Time Complexity: O(n*m) [Traversing First time] + O(n*m) [Traversing Second time].

Space Complexity: O(n) + O(m) where n is the number of element in column and m is the number of element in row.

Code:

void setZeros(vector<vector<int>> &matrix)
{
        int m = matrix[0].size();
        int n = matrix.size();
        vector<int>x;
        vector<int>y;

        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(matrix[i][j] == 0){
                    x.push_back(i);
                    y.push_back(j);
                }
            }
        }

        // for coverting rows into zero
        for(int i=0; i<x.size(); i++){
            int ind = x[i];
            for(int j=0; j<m; j++){
                matrix[ind][j] = 0;
            }
        }
        // for converting columns into zero
        for(int i=0; i<y.size(); i++){
            int ind = y[i];
            for(int j=0; j<n; j++){
                matrix[j][ind] = 0;
            }
        }
}

Thank You so much everyone for reading this blog I hope it will be helpful for you in that case do like it and follow me at my socials:

My Twitter

My LinkedIn