Update buy sell stock problem

Author: sudheerj

README.md

@@ -74,7 +74,7 @@ List of Programs related to data structures and algorithms
 
    14. First missing positive number: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.js) [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.md)
 
-   15. Best time to buy stock and sell stock: [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/buySellStock/buySellStock.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/buySellStock/buySellStock.md)
+   15. Best time to buy stock and sell stock: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/15.buySellStock/buySellStock.js) [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/15.buySellStock/buySellStock.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/15.buySellStock/buySellStock.md)
 
 ### String
 

src/java1/algorithms/array/buySellStock/BuySellStock.java

@@ -2,22 +2,25 @@
 //Greedy approach/Sliding window: TC:O(n), SC:O(1)
 
 class BuySellStock {
-    private static int maxProfit(int[] stockPrices) {
+    private static int buySellStock(int[] stockPrices) {
         if(stockPrices.length < 2) return 0;
 
-        int maxProfit = 0, left=0;
-        for(int right=1; right< stockPrices.length; right++) {
+        int maxProfit = 0, left=0, right = 1;
+        while(right< stockPrices.length) {
             if(stockPrices[right]>stockPrices[left]) {
                 maxProfit = Math.max(maxProfit, stockPrices[right]-stockPrices[left]);
             } else {
                 left = right;
             }
+            right++;
         }
         return maxProfit;
     }
 
     public static void main(String[] args) {
-        int[] stockPrices = {8,3,6,4,7,5};
-        System.out.println(maxProfit(stockPrices));
+        int[] stockPrices1 = {8,3,6,4,7,5};
+        System.out.println(buySellStock(stockPrices1));
+        int[] stockPrices2 = {7, 6, 5, 4, 3, 2, 1};
+        System.out.println(buySellStock(stockPrices2));
     }
 }

src/java1/algorithms/array/buySellStock/BuySellStock.md

@@ -1,19 +1,30 @@
+**Description:**
+Given an array `prices` where `prices[i]` is the price of a given stock on the `i`th day. The profit can be maximized by choosing a single day to buy one stock and choosing a different day in the future to sell that stock. Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, just return 0.
+
+### Examples
+Example 1:
+
+Input: prices = [8, 3, 6, 4, 7, 5]
+Output: 4
+
+Input: prices = [7, 6, 5, 4, 3, 2, 1]
+Output: 0
+
 **Algorithmic Steps**
 This problem is solved with the help of sliding window approach to calculate the maximum profit(as known as **greedy algorithm**). The algorithmic approach can be summarized as follows:
 
-1. Write a preliminary case by returning profit as `0` if the number of stock prices are less than 2.
+1. Write a preliminary case by returning profit as `0` if the number of stock prices in the array are less than  2.
 
-2. Initialize `maxProfit` variable as 0 to indicate maximum profit for buying and selling the stock at different days. 
+2. Initialize `maxProfit` variable to `0` to indicate maximum profit achieved for buying and selling the stock at different days. 
 
-3. Initialize `left` variable(left pointer) as 0, which denotes the buying stock index.
+3. Initialize left pointer(i.e,`left`) to `0`, which denotes the buying stock index.
 
-4. Iterate over the input stock prices and compare the current stock price(i.e, `stockPrices[right]`) with previous day stock price(i.e, `stockPrices[left]`). If the current stock price is higher, calculate the maximum profit between previous maxProfit and current stock difference.
+4. Iterate over the input stock prices and compare the current stock price(i.e, `stockPrices[right]`) with previous day stock price(i.e, `stockPrices[left]`). If the current stock price is higher, calculate the maximum profit between previous maxProfit and current profit.
 
-5. If the current stock price is lower than previous stock price, consider the current stock price as buying stock with the help of their indexes in an array(i.e, `left = right`). 
+5. If the current stock price is lower than previous stock price, consider the current stock price as buying stock with the help of their index pointers(i.e, `left = right`). 
 
 6. Return `maxProfit` which represents best time(or max proft scenario) to buy and sell stock prices.
 
-
 **Time and Space complexity:**
-This algorithm has a time complexity of O(n), where n is the number of stock prices. This is because we are traversing the array at most once. 
-Here, we don't use any additional datastructure other than two pointers. Hence, the space complexity will be O(1).
+This algorithm has a time complexity of `O(n)`, where ``n is the number of stock prices. This is because we are traversing the array at most once. 
+Here, we don't use any additional datastructure other than two pointers. Hence, the space complexity will be `O(1)`.

src/javascript/algorithms/array/14.firstMissingPositive/firstMissingPositive.md

@@ -1,3 +1,5 @@
+**Description:**
+
 **Algorithmic Steps**
 This problem is solved with the help of in-place input array using its index as hash key. This is known as **in-place hashing** technique. The algorithmic approach can be summarized as follows:
 

src/javascript/algorithms/array/buySellStock/buySellStock.js renamed to src/javascript/algorithms/array/15.buySellStock/buySellStock.js

@@ -2,13 +2,15 @@ function buySellStock(stockPrices) {
     if(stockPrices.length < 2) return 0;
 
     let maxProfit = left = 0;
+    let right = 1;
 
-    for (let right = 0; right < stockPrices.length; right++) {
+    while(right < stockPrices.length) {
         if(stockPrices[right] > stockPrices[left]) {
             maxProfit = Math.max(maxProfit, stockPrices[right] - stockPrices[left]);
         } else {
             left = right;
         } 
+        right++;
     }
 
     return maxProfit;
@@ -17,6 +19,6 @@ function buySellStock(stockPrices) {
 let stockPrices1 = [8, 3, 6, 4, 7, 5];
 let stockPrices2 = [7, 6, 5, 4, 3, 2, 1];
 
-console.log(maxProfit(stockPrices1));
-console.log(maxProfit(stockPrices2));
+console.log(buySellStock(stockPrices1));
+console.log(buySellStock(stockPrices2));
 

src/javascript/algorithms/array/15.buySellStock/buySellStock.md

@@ -0,0 +1,30 @@
+**Description:**
+Given an array `prices` where `prices[i]` is the price of a given stock on the `i`th day. The profit can be maximized by choosing a single day to buy one stock and choosing a different day in the future to sell that stock. Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, just return 0.
+
+### Examples
+Example 1:
+
+Input: prices = [8, 3, 6, 4, 7, 5]
+Output: 4
+
+Input: prices = [7, 6, 5, 4, 3, 2, 1]
+Output: 0
+
+**Algorithmic Steps**
+This problem is solved with the help of sliding window approach to calculate the maximum profit(as known as **greedy algorithm**). The algorithmic approach can be summarized as follows:
+
+1. Write a preliminary case by returning profit as `0` if the number of stock prices in the array are less than  2.
+
+2. Initialize `maxProfit` variable to `0` to indicate maximum profit achieved for buying and selling the stock at different days. 
+
+3. Initialize left pointer(i.e,`left`) to `0`, which denotes the buying stock index.
+
+4. Iterate over the input stock prices and compare the current stock price(i.e, `stockPrices[right]`) with previous day stock price(i.e, `stockPrices[left]`). If the current stock price is higher, calculate the maximum profit between previous maxProfit and current profit.
+
+5. If the current stock price is lower than previous stock price, consider the current stock price as buying stock with the help of their index pointers(i.e, `left = right`). 
+
+6. Return `maxProfit` which represents best time(or max proft scenario) to buy and sell stock prices.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where ``n is the number of stock prices. This is because we are traversing the array at most once. 
+Here, we don't use any additional datastructure other than two pointers. Hence, the space complexity will be `O(1)`.