Add Pascal's triangle.

Author: trekhleb

README.md

@@ -57,25 +57,26 @@ a set of rules that precisely define a sequence of operations.
 *`B`[Primality Test](src/algorithms/math/primality-test) (trial division method)
 *`B`[Euclidean Algorithm](src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD)
 *`B`[Least Common Multiple](src/algorithms/math/least-common-multiple) (LCM)
-*`A`[Integer Partition](src/algorithms/math/integer-partition)
 *`B`[Sieve of Eratosthenes](src/algorithms/math/sieve-of-eratosthenes) - finding all prime numbers up to any given limit
 *`B`[Is Power of Two](src/algorithms/math/is-power-of-two) - check if the number is power of two (naive and bitwise algorithms)
+*`B`[Pascal's Triangle](src/algorithms/math/pascal-triangle)
+*`A`[Integer Partition](src/algorithms/math/integer-partition)
 *`A`[Liu Hui π Algorithm](src/algorithms/math/liu-hui) - approximate π calculations based on N-gons
 ***Sets**
 *`B`[Cartesian Product](src/algorithms/sets/cartesian-product) - product of multiple sets
+*`B`[Fisher–Yates Shuffle](src/algorithms/sets/fisher-yates) - random permutation of a finite sequence
 *`A`[Power Set](src/algorithms/sets/power-set) - all subsets of a set
 *`A`[Permutations](src/algorithms/sets/permutations) (with and without repetitions)
 *`A`[Combinations](src/algorithms/sets/combinations) (with and without repetitions)
-*`B`[Fisher–Yates Shuffle](src/algorithms/sets/fisher-yates) - random permutation of a finite sequence
 *`A`[Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
 *`A`[Longest Increasing Subsequence](src/algorithms/sets/longest-increasing-subsequence)
 *`A`[Shortest Common Supersequence](src/algorithms/sets/shortest-common-supersequence) (SCS)
 *`A`[Knapsack Problem](src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
 *`A`[Maximum Subarray](src/algorithms/sets/maximum-subarray) - "Brute Force" and "Dynamic Programming" (Kadane's) versions
 *`A`[Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
 ***Strings**
-*`A`[Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
 *`B`[Hamming Distance](src/algorithms/string/hamming-distance) - number of positions at which the symbols are different
+*`A`[Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
 *`A`[Knuth–Morris–Pratt Algorithm](src/algorithms/string/knuth-morris-pratt) (KMP Algorithm) - substring search (pattern matching)
 *`A`[Z Algorithm](src/algorithms/string/z-algorithm) - substring search (pattern matching)
 *`A`[Rabin Karp Algorithm](src/algorithms/string/rabin-karp) - substring search
@@ -100,11 +101,11 @@ a set of rules that precisely define a sequence of operations.
 ***Graphs**
 *`B`[Depth-First Search](src/algorithms/graph/depth-first-search) (DFS)
 *`B`[Breadth-First Search](src/algorithms/graph/breadth-first-search) (BFS)
+*`B`[Kruskal’s Algorithm](src/algorithms/graph/kruskal) - finding Minimum Spanning Tree (MST) for weighted undirected graph
 *`A`[Dijkstra Algorithm](src/algorithms/graph/dijkstra) - finding shortest path to all graph vertices
 *`A`[Bellman-Ford Algorithm](src/algorithms/graph/bellman-ford) - finding shortest path to all graph vertices
 *`A`[Detect Cycle](src/algorithms/graph/detect-cycle) - for both directed and undirected graphs (DFS and Disjoint Set based versions)
 *`A`[Prim’s Algorithm](src/algorithms/graph/prim) - finding Minimum Spanning Tree (MST) for weighted undirected graph
-*`B`[Kruskal’s Algorithm](src/algorithms/graph/kruskal) - finding Minimum Spanning Tree (MST) for weighted undirected graph
 *`A`[Topological Sorting](src/algorithms/graph/topological-sorting) - DFS method
 *`A`[Articulation Points](src/algorithms/graph/articulation-points) - Tarjan's algorithm (DFS based)
 *`A`[Bridges](src/algorithms/graph/bridges) - DFS based algorithm
@@ -114,9 +115,9 @@ a set of rules that precisely define a sequence of operations.
 *`A`[Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
 ***Uncategorized**
 *`B`[Tower of Hanoi](src/algorithms/uncategorized/hanoi-tower)
+*`B`[Square Matrix Rotation](src/algorithms/uncategorized/square-matrix-rotation) - in-place algorithm
 *`A`[N-Queens Problem](src/algorithms/uncategorized/n-queens)
 *`A`[Knight's Tour](src/algorithms/uncategorized/knight-tour)
-*`B`[Square Matrix Rotation](src/algorithms/uncategorized/square-matrix-rotation) - in-place algorithm
 
 ### Algorithms by Paradigm
 
@@ -135,13 +136,14 @@ algorithm is an abstraction higher than a computer program.
 ***Divide and Conquer** - divide the problem into smaller parts and then solve those parts
 *`B`[Binary Search](src/algorithms/search/binary-search)
 *`B`[Tower of Hanoi](src/algorithms/uncategorized/hanoi-tower)
+*`B`[Pascal's Triangle](src/algorithms/math/pascal-triangle)
 *`B`[Euclidean Algorithm](src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD)
-*`A`[Permutations](src/algorithms/sets/permutations) (with and without repetitions)
-*`A`[Combinations](src/algorithms/sets/combinations) (with and without repetitions)
 *`B`[Merge Sort](src/algorithms/sorting/merge-sort)
 *`B`[Quicksort](src/algorithms/sorting/quick-sort)
 *`B`[Tree Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
 *`B`[Graph Depth-First Search](src/algorithms/graph/depth-first-search) (DFS)
+*`A`[Permutations](src/algorithms/sets/permutations) (with and without repetitions)
+*`A`[Combinations](src/algorithms/sets/combinations) (with and without repetitions)
 ***Dynamic Programming** - build up a solution using previously found sub-solutions
 *`B`[Fibonacci Number](src/algorithms/math/fibonacci)
 *`A`[Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences

src/algorithms/math/pascal-triangle/README.md

@@ -0,0 +1,39 @@
+# Pascal's Triangle
+
+In mathematics, **Pascal's triangle** is a triangular array of 
+the binomial coefficients.
+
+The rows of Pascal's triangle are conventionally enumerated 
+starting with row `n = 0` at the top (the `0th` row). The 
+entries in each row are numbered from the left beginning 
+with `k = 0` and are usually staggered relative to the 
+numbers in the adjacent rows. The triangle may be constructed
+in the following manner: In row `0` (the topmost row), there 
+is a unique nonzero entry `1`. Each entry of each subsequent
+row is constructed by adding the number above and to the 
+left with the number above and to the right, treating blank 
+entries as `0`. For example, the initial number in the 
+first (or any other) row is `1` (the sum of `0` and `1`),
+whereas the numbers `1` and `3` in the third row are added 
+to produce the number `4` in the fourth row.
+
+![Pascal's Triangle](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
+
+## Formula
+
+The entry in the `nth` row and `kth` column of Pascal's 
+triangle is denoted ![Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/206415d3742167e319b2e52c2ca7563b799abad7).
+For example, the unique nonzero entry in the topmost 
+row is ![Formula example](https://wikimedia.org/api/rest_v1/media/math/render/svg/b7e35f86368d5978b46c07fd6dddca86bd6e635c).
+
+With this notation, the construction of the previous 
+paragraph may be written as follows:
+
+![Formula](https://wikimedia.org/api/rest_v1/media/math/render/svg/203b128a098e18cbb8cf36d004bd7282b28461bf)
+
+for any non-negative integer `n` and any 
+integer `k` between `0` and `n`, inclusive.
+
+## References
+
+-[Wikipedia](https://en.wikipedia.org/wiki/Pascal%27s_triangle)

src/algorithms/math/pascal-triangle/__test__/pascalTriangleRecursive.test.js

@@ -0,0 +1,14 @@
+importpascalTriangleRecursivefrom'../pascalTriangleRecursive';
+
+describe('pascalTriangleRecursive',()=>{
+it('should calculate Pascal Triangle coefficients for specific line number',()=>{
+expect(pascalTriangleRecursive(0)).toEqual([1]);
+expect(pascalTriangleRecursive(1)).toEqual([1,1]);
+expect(pascalTriangleRecursive(2)).toEqual([1,2,1]);
+expect(pascalTriangleRecursive(3)).toEqual([1,3,3,1]);
+expect(pascalTriangleRecursive(4)).toEqual([1,4,6,4,1]);
+expect(pascalTriangleRecursive(5)).toEqual([1,5,10,10,5,1]);
+expect(pascalTriangleRecursive(6)).toEqual([1,6,15,20,15,6,1]);
+expect(pascalTriangleRecursive(7)).toEqual([1,7,21,35,35,21,7,1]);
+});
+});

src/algorithms/math/pascal-triangle/pascalTriangleRecursive.js

@@ -0,0 +1,30 @@
+/**
+ * @param{number} lineNumber
+ * @return{number[]}
+ */
+exportdefaultfunctionpascalTriangleRecursive(lineNumber){
+if(lineNumber===0){
+return[1];
+}
+
+constcurrentLineSize=lineNumber+1;
+constpreviousLineSize=currentLineSize-1;
+
+// Create container for current line values.
+constcurrentLine=[];
+
+// We'll calculate current line based on previous one.
+constpreviousLine=pascalTriangleRecursive(lineNumber-1);
+
+// Let's go through all elements of current line except the first and
+// last one (since they were and will be filled with 1's) and calculate
+// current coefficient based on previous line.
+for(letnumIndex=0;numIndex<currentLineSize;numIndex+=1){
+constleftCoefficient=(numIndex-1)>=0 ? previousLine[numIndex-1] : 0;
+constrightCoefficient=numIndex<previousLineSize ? previousLine[numIndex] : 0;
+
+currentLine[numIndex]=leftCoefficient+rightCoefficient;
+}
+
+returncurrentLine;
+}