Update climbing stairs problem

Author: sudheerj

README.md

@@ -71,7 +71,7 @@ List of Programs related to data structures and algorithms
 
 ### Dynamic programming
 
-   1. Climbing stairs: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/dynamicProgramming/climbingStairs.js)
+   1. Climbing stairs: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/dynamicProgramming/1.climbingStairs/climbingStairs.js)
 
    2. Coin change: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/dynamicProgramming/coinsChange.js)
 

src/java1/algorithms/dynamicProgramming/ClimbingStairs.java renamed to src/java1/algorithms/dynamicProgramming/climbingStairs/ClimbingStairs.java

@@ -1,12 +1,12 @@
-package java1.algorithms.dynamicProgramming;
+package java1.algorithms.dynamicProgramming.climbingStairs;
 
 public class ClimbingStairs {
     // TC: O(n) SC: O(1)
     private static int climbStairs1(int n) {
-        if(n == 1 || n == 2) return 1;
+        if(n <= 2) return n;
 
-        int first = 1, second = 1, temp;
-        for(int i=0; i< n-1; i++) {
+        int first = 1, second = 2, temp;
+        for(int i=2; i< n; i++) {
             temp = first + second;
             first = second;
             second = temp;
@@ -16,10 +16,11 @@ private static int climbStairs1(int n) {
 
     // TC:O(n) SC: O(n)
     private static int climbStairs2(int n) {
-        if(n == 1 || n == 2) return 1;
+        if(n <= 2) return n;
 
         int[] dp = new int[n+1];
-        dp[0] = dp[1] = 1;
+        dp[0] = 1; 
+        dp[1] = 1;
         for(int i=2; i<n+1; i++) {
             dp[i] = dp[i-1] + dp[i-2];
         } 

src/java1/algorithms/dynamicProgramming/climbingStairs/ClimbingStairs.md

@@ -0,0 +1,38 @@
+**Description:**
+You are required to climb a staircase that consists of `n` individual steps. Determine the total number of distinct ways to reach the top of the staircase.
+
+**Note:** Each time you can either climb 1 or 2 steps.
+
+## Examples:
+Example 1:
+
+Input: n = 5
+Output: 8
+
+Example 2: 
+
+Input: n = 6
+Output: 13
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved efficiently using **dynamic programming** approach by avoiding the recomputations of same subproblems. The algorithmic approach can be summarized as follows: 
+
+1. Add a preliminary check like if the step value is less than or equal to 2, return the possible ways to reach them as step's value.
+
+2. Create two variables(`first` and `second`) to store the possible ways to reach the current step and the next step. Since the first step takes one possible way and second step takes two possible ways, those varaibles needs to be  initialized to 1 & 2 respectively.
+
+3. Iterate `n-1` times to calculate the next step until `n`th step is reached.
+
+4. The number of possible ways to reach next step is the combination of previous two steps possibilities. Because any particular step is reached either through 1 step or 2 steps.
+
+5. Calculate the sum of first and second pointers in a temporary variable(`temp`). Assign the second pointer variable to first and update the second pointer variable to temporary variable.
+
+6. Repeat steps 4-5 until the nth step is reached.
+
+7. Return second pointer value which indicates the possible ways to reach top stair.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of steps. This is because we are traversing all the steps to calculate the possible ways for nth step. 
+
+Here, we don't use any additional datastructure other than two variables. Hence, the space complexity will be `O(1)`.

src/javascript/algorithms/dynamicProgramming/climbingStairs.js renamed to src/javascript/algorithms/dynamicProgramming/1.climbingStairs/climbingStairs.js

@@ -1,20 +1,20 @@
-// TC: O(n) SC: O(1)
+// Optimized fibonacci series- TC: O(n) SC: O(1)
 function climbStairs1(n) {
-    if(n ===1 || n === 2) return 1;
+    if(n <= 2) return n;
 
-    let first = 1, second = 1;
+    let first = 1, second = 2;
     let temp = 0;
-    for(let i=0; i<n-1; i++) {
+    for(let i=2; i<n; i++) {
         temp = first + second;
         first = second;
         second = temp;
     }
     return second;
 }
 
-// TC: O(n) SC: O(n)
+// Bottomup DP -TC: O(n) SC: O(n)
 function climbStairs2(n) {
-    if(n ===1 || n === 2) return 1;
+    if(n <= 2) return n;
 
     let dp = new Array(n+1);
     dp[0] = 1, dp[1] = 1;

src/javascript/algorithms/dynamicProgramming/1.climbingStairs/climbingStairs.md

@@ -0,0 +1,38 @@
+**Description:**
+You are required to climb a staircase that consists of `n` individual steps. Determine the total number of distinct ways to reach the top of the staircase.
+
+**Note:** Each time you can either climb 1 or 2 steps.
+
+## Examples:
+Example 1:
+
+Input: n = 5
+Output: 8
+
+Example 2: 
+
+Input: n = 6
+Output: 13
+
+**Algorithmic Steps(Approach 1&2)**
+This problem is solved efficiently using **dynamic programming** approach by avoiding the recomputations of same subproblems. The algorithmic approach can be summarized as follows: 
+
+1. Add a preliminary check like if the step value is less than or equal to 2, return the possible ways to reach them as step's value.
+
+2. Create two variables(`first` and `second`) to store the possible ways to reach the current step and the next step. Since the first step takes one possible way and second step takes two possible ways, those varaibles needs to be  initialized to 1 & 2 respectively.
+
+3. Iterate `n-1` times to calculate the next step until `n`th step is reached.
+
+4. The number of possible ways to reach next step is the combination of previous two steps possibilities. Because any particular step is reached either through 1 step or 2 steps.
+
+5. Calculate the sum of first and second pointers in a temporary variable(`temp`). Assign the second pointer variable to first and update the second pointer variable to temporary variable.
+
+6. Repeat steps 4-5 until the nth step is reached.
+
+7. Return second pointer value which indicates the possible ways to reach top stair.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of steps. This is because we are traversing all the steps to calculate the possible ways for nth step. 
+
+Here, we don't use any additional datastructure other than two variables. Hence, the space complexity will be `O(1)`.

src/javascript/algorithms/misc/lodash/dropRightWhile/dropRightWhile.js

@@ -0,0 +1,17 @@
+function dropRightWhile(arr, predicate){
+    let endIndex = arr.length-1;
+
+    while(endIndex >=0 && predicate(arr[endIndex], endIndex, arr)){
+        endIndex--;
+    }
+
+    return arr.slice(0, endIndex+1);
+}
+
+
+const arr1 = [{
+    name: 'banana', type: 'fruit'},
+    {name: 'tomato', type: 'veggie'},
+    {name: 'apple', type: 'fruit'}
+];
+console.log(dropRightWhile(arr1, (el) => el.name === 'apple'));