Add brute force solution of Rain Terraces problem.

Author: trekhleb

README.md

@@ -128,7 +128,7 @@ a set of rules that precisely define a sequence of operations.
 *`B`[Square Matrix Rotation](src/algorithms/uncategorized/square-matrix-rotation) - in-place algorithm
 *`B`[Jump Game](src/algorithms/uncategorized/jump-game) - backtracking, dynamic programming (top-down + bottom-up) and greedy examples 
 *`B`[Unique Paths](src/algorithms/uncategorized/unique-paths) - backtracking, dynamic programming and Pascal's Triangle based examples 
-*`B`[Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
+*`B`[Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem (dynamic programming and brute force versions)
 *`A`[N-Queens Problem](src/algorithms/uncategorized/n-queens)
 *`A`[Knight's Tour](src/algorithms/uncategorized/knight-tour)
 
@@ -140,6 +140,7 @@ algorithm is an abstraction higher than a computer program.
 
 ***Brute Force** - look at all the possibilities and selects the best solution
 *`B`[Linear Search](src/algorithms/search/linear-search)
+*`B`[Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
 *`A`[Maximum Subarray](src/algorithms/sets/maximum-subarray)
 *`A`[Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
 ***Greedy** - choose the best option at the current time, without any consideration for the future
@@ -164,6 +165,7 @@ algorithm is an abstraction higher than a computer program.
 *`B`[Fibonacci Number](src/algorithms/math/fibonacci)
 *`B`[Jump Game](src/algorithms/uncategorized/jump-game)
 *`B`[Unique Paths](src/algorithms/uncategorized/unique-paths)
+*`B`[Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
 *`A`[Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
 *`A`[Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
 *`A`[Longest Common Substring](src/algorithms/string/longest-common-substring)

src/algorithms/uncategorized/rain-terraces/README.md

@@ -62,16 +62,58 @@ be stored in every element of array. For example, consider the array
 `[3, 0, 0, 2, 0, 4]`, We can trap "3*2 units" of water between 3 an 2, "1 unit" 
 on top of bar 2 and "3 units" between 2 and 4. See below diagram also.
 
-A **simple solution** is to traverse every array element and find the highest 
-bars on left and right sides. Take the smaller of two heights. The difference 
-between smaller height and height of current element is the amount of water 
-that can be stored in this array element. Time complexity of this solution 
-is `O(n2)`.
+### Approach 1: Brute force
 
-An **efficient solution** is to pre-compute highest bar on left and right of 
-every bar in `O(n)` time. Then use these pre-computed values to find the 
-amount of water in every array element.
+**Intuition**
+
+For each element in the array, we find the maximum level of water it can trap 
+after the rain, which is equal to the minimum of maximum height of bars on both 
+the sides minus its own height.
+
+**Steps**
+
+- Initialize `answer = 0`
+- Iterate the array from left to right:
+- Initialize `max_left = 0 and `max_right = 0`
+- Iterate from the current element to the beginning of array updating: `max_left = max(max_left, height[j])`
+- Iterate from the current element to the end of array updating: `max_right = max(max_right, height[j])`
+- Add `min(max_left, max_right) − height[i]` to `answer`
+
+**Complexity Analysis**
+
+Time complexity: `O(n^2)`. For each element of array, we iterate the left and right parts.
+
+Auxiliary space complexity: `O(1)` extra space.
+
+### Approach 2: Dynamic Programming
+
+**Intuition**
+
+In brute force, we iterate over the left and right parts again and again just to 
+find the highest bar size up to that index. But, this could be stored. Voila, 
+dynamic programming.
+
+So we may pre-compute highest bar on left and right of every bar in `O(n)` time.
+Then use these pre-computed values to find the amount of water in every array element.
+
+The concept is illustrated as shown:
+
+![DP Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/Figures/42/trapping_rain_water.png)
+
+**Steps**
+
+- Find maximum height of bar from the left end up to an index `i` in the array `left_max`.
+- Find maximum height of bar from the right end up to an index `i` in the array `right_max`.
+- Iterate over the `height` array and update `answer`:
+- Add `min(max_left[i], max_right[i]) − height[i]` to `answer`.
+
+**Complexity Analysis**
+
+Time complexity: `O(n)`.
+
+Auxiliary space complexity: `O(n)` extra space.
 
 ## References
 
 -[GeeksForGeeks](https://www.geeksforgeeks.org/trapping-rain-water/)
+-[LeetCode](https://leetcode.com/problems/trapping-rain-water/solution/)

src/algorithms/uncategorized/rain-terraces/__test__/bfRainTerraces.test.js

@@ -0,0 +1,21 @@
+importbfRainTerracesfrom'../bfRainTerraces';
+
+describe('bfRainTerraces',()=>{
+it('should find the amount of water collected after raining',()=>{
+expect(bfRainTerraces([1])).toBe(0);
+expect(bfRainTerraces([1,0])).toBe(0);
+expect(bfRainTerraces([0,1])).toBe(0);
+expect(bfRainTerraces([0,1,0])).toBe(0);
+expect(bfRainTerraces([0,1,0,0])).toBe(0);
+expect(bfRainTerraces([0,1,0,0,1,0])).toBe(2);
+expect(bfRainTerraces([0,2,0,0,1,0])).toBe(2);
+expect(bfRainTerraces([2,0,2])).toBe(2);
+expect(bfRainTerraces([2,0,5])).toBe(2);
+expect(bfRainTerraces([3,0,0,2,0,4])).toBe(10);
+expect(bfRainTerraces([0,1,0,2,1,0,1,3,2,1,2,1])).toBe(6);
+expect(bfRainTerraces([1,1,1,1,1])).toBe(0);
+expect(bfRainTerraces([1,2,3,4,5])).toBe(0);
+expect(bfRainTerraces([4,1,3,1,2,1,2,1])).toBe(4);
+expect(bfRainTerraces([0,2,4,3,4,2,4,0,8,7,0])).toBe(7);
+});
+});

src/algorithms/uncategorized/rain-terraces/__test__/dpRainTerraces.test.js

@@ -0,0 +1,21 @@
+importdpRainTerracesfrom'../dpRainTerraces';
+
+describe('dpRainTerraces',()=>{
+it('should find the amount of water collected after raining',()=>{
+expect(dpRainTerraces([1])).toBe(0);
+expect(dpRainTerraces([1,0])).toBe(0);
+expect(dpRainTerraces([0,1])).toBe(0);
+expect(dpRainTerraces([0,1,0])).toBe(0);
+expect(dpRainTerraces([0,1,0,0])).toBe(0);
+expect(dpRainTerraces([0,1,0,0,1,0])).toBe(2);
+expect(dpRainTerraces([0,2,0,0,1,0])).toBe(2);
+expect(dpRainTerraces([2,0,2])).toBe(2);
+expect(dpRainTerraces([2,0,5])).toBe(2);
+expect(dpRainTerraces([3,0,0,2,0,4])).toBe(10);
+expect(dpRainTerraces([0,1,0,2,1,0,1,3,2,1,2,1])).toBe(6);
+expect(dpRainTerraces([1,1,1,1,1])).toBe(0);
+expect(dpRainTerraces([1,2,3,4,5])).toBe(0);
+expect(dpRainTerraces([4,1,3,1,2,1,2,1])).toBe(4);
+expect(dpRainTerraces([0,2,4,3,4,2,4,0,8,7,0])).toBe(7);
+});
+});

src/algorithms/uncategorized/rain-terraces/__test__/rainTerraces.test.js

@@ -0,0 +1,33 @@
+/**
+ * BRUTE FORCE approach of solving Trapping Rain Water problem.
+ *
+ * @param{number[]} terraces
+ * @return{number}
+ */
+exportdefaultfunctionbfRainTerraces(terraces){
+letwaterAmount=0;
+
+for(letterraceIndex=0;terraceIndex<terraces.length;terraceIndex+=1){
+// Get left most high terrace.
+letleftHighestLevel=0;
+for(letleftIndex=terraceIndex-1;leftIndex>=0;leftIndex-=1){
+leftHighestLevel=Math.max(leftHighestLevel,terraces[leftIndex]);
+}
+
+// Get right most high terrace.
+letrightHighestLevel=0;
+for(letrightIndex=terraceIndex+1;rightIndex<terraces.length;rightIndex+=1){
+rightHighestLevel=Math.max(rightHighestLevel,terraces[rightIndex]);
+}
+
+// Add current terrace water amount.
+constterraceBoundaryLevel=Math.min(leftHighestLevel,rightHighestLevel);
+if(terraceBoundaryLevel>terraces[terraceIndex]){
+// Terrace will be able to store the water if the lowest of two left and right highest
+// terraces are still higher than the current one.
+waterAmount+=Math.min(leftHighestLevel,rightHighestLevel)-terraces[terraceIndex];
+}
+}
+
+returnwaterAmount;
+}

src/algorithms/uncategorized/rain-terraces/bfRainTerraces.js

@@ -1,8 +1,10 @@
 /**
+ * DYNAMIC PROGRAMMING approach of solving Trapping Rain Water problem.
+ *
  * @param{number[]} terraces
  * @return{number}
  */
-exportdefaultfunctionrainTerraces(terraces){
+exportdefaultfunctiondpRainTerraces(terraces){
 /*
  * STEPS
  *