Add Pascal triangle algorithm

Author: sudheerj

src/images/pascal-triangle.png

@@ -0,0 +1,29 @@
+package java1.algorithms.array.pascalsTriangle;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PascalsTriangle {
+    private static List<List<Integer>> generatePascalTriangle(int numRows){
+        List<List<Integer>> triangle = new ArrayList<>();
+
+        for (int row = 0; row < numRows; row++) {
+            List<Integer> currentRow = new ArrayList<>(row+1);
+            currentRow.add(1);
+            for (int col = 1; col < row; col++) {
+                currentRow.add(triangle.get(row-1).get(col-1) + triangle.get(row-1).get(col));
+            }
+            if(row >0) {
+                currentRow.add(1);
+            }
+            triangle.add(currentRow);
+        }
+        return triangle;
+    }
+    public static void main(String[] args) {
+        int numRows1 = 5;
+        System.out.println(generatePascalTriangle(numRows1));
+        int numRows2 = 1;
+        System.out.println(generatePascalTriangle(numRows2));
+    }
+}

src/java1/algorithms/array/pascalsTriangle/PascalsTriangle.java

@@ -0,0 +1,37 @@
+**Description:**
+Given an integer `numRows`, find the first `numRows` of Pascal's triangle. In Pascal's triangle, each number is formed by the sum of the two numbers directly above it except for boundaries(with value 1).
+
+![Screenshot](../../../../images/pascal-triangle.png)
+
+### Examples
+Example 1:
+
+Input: numRows = 5
+Output: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+Example 2:
+
+Input: numRows = 1
+Output: [[1]]
+
+**Algorithmic Steps**
+This problem is solved with the help of sequential numbers sum and average calculations. The algorithmic approach can be summarized as follows:
+
+1. Initialize the triangle(`triangle`) with an empty to hold the rows of Pascal triangle.
+
+2. Iterate over the rows starting from `0` to the given number of rows(`numRows`) provided.
+
+3. Create each row initialized with `row+1` array elements and the first element is set to 1. This is because all border elements will be 1 in the triangle.
+
+4. Iterate over the columns starting from `1` to `row-1` to calculate the new row values. Each cell value is calculated by the sum of two elements directly above it from the previous row.
+
+5. Set the last element of each row to 1, except for the first row. 
+
+6. Add the completed row to the triangle list.
+
+7. Return the completed triangle upon generation of each row completed.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n^2)`, where `n` is the number of given rows. This is because we need to iterate over `n` rows and for each row, there can be upto `n` valued to be generated.
+ 
+The output array needs `O(n^2)` space to accomodate all the triangle elements, where `n` is the number of given rows.. Hence, the total space complexity is `O(n^2)`.

src/java1/algorithms/array/pascalsTriangle/PascalsTriangle.md

@@ -0,0 +1,18 @@
+function generatePascalsTriangle(numRows){
+    let triangle = [];
+
+    for (let row = 0; row < numRows; row++) {
+        let currentRow = Array(row+1).fill(1);
+        for (let col = 1; col < row; col++) {
+            currentRow[col] = triangle[row-1][col-1]+triangle[row-1][col];
+        }
+        triangle.push(currentRow);
+    }
+
+    return triangle;
+}
+
+let numRows1 = 5;
+console.log(generatePascalsTriangle(numRows1));
+let numRows2 = 1;
+console.log(generatePascalsTriangle(numRows2));

src/javascript/algorithms/array/17.pascalsTriangle/pascalsTriangle.js

@@ -0,0 +1,35 @@
+**Description:**
+Given an integer `numRows`, find the first `numRows` of Pascal's triangle. In Pascal's triangle, each number is formed by the sum of the two numbers directly above it except for boundaries(with value 1).
+
+![Screenshot](../../../../images/pascal-triangle.png)
+
+### Examples
+Example 1:
+
+Input: numRows = 5
+Output: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+Example 2:
+
+Input: numRows = 1
+Output: [[1]]
+
+**Algorithmic Steps**
+This problem is solved with the help of sequential numbers sum and average calculations. The algorithmic approach can be summarized as follows:
+
+1. Initialize the triangle(`triangle`) with an empty to hold the rows of Pascal triangle.
+
+2. Iterate over the rows starting from `0` to the given number of rows(`numRows`) provided.
+
+3. Create each row initialized with `row+1` array elements, all set to 1.
+
+4. Iterate over the columns starting from `1` to `row-1` to calculate the new row values. Each cell value is calculated by the sum of two elements directly above it from the previous row.
+
+5. Add the completed row to the triangle list.
+
+6. Return the completed triangle upon generation of each row completed.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n^2)`, where `n` is the number of given rows. This is because we need to iterate over `n` rows and for each row, there can be upto `n` valued to be generated.
+ 
+The output array needs `O(n^2)` space to accomodate all the triangle elements, where `n` is the number of given rows.. Hence, the total space complexity is `O(n^2)`.