Merge pull request Pradeepsingh61#493 from FirdausJawed/firdaus

Buy and sell stock code in java (all variations)

Author: Pradeepsingh61

Java/dynamic_programming/BuyAndSellStocks/BestTimeToBuyAndSellStockWithCooldown.java

@@ -0,0 +1,86 @@
+/*
+Best Time to Buy and Sell Stock with Cooldown
+
+Algorithm Description:
+This algorithm finds the maximum profit from buying and selling stocks with as many transactions as you like, but with a cooldown of one day after each sale. You cannot buy a stock on the day immediately after selling it. The approach uses dynamic programming with memoization to avoid redundant calculations. The state is defined by the current day and whether you can buy or must sell. At each step, you decide to buy, sell, or skip, and recursively compute the best outcome.
+
+Use Cases:
+- Stock trading with cooldown restrictions (e.g., to avoid rapid trading penalties)
+- Any scenario where actions are limited by a cooldown period
+
+Time Complexity: O(n)
+- Each state (day, buy/sell) is computed once, and there are 2*n states.
+
+Space Complexity: O(n)
+- The DP table stores results for each day and buy/sell state.
+*/
+
+package Java.dynamic_programming.BuyAndSellStocks;
+
+import java.util.Arrays;
+
+public class BestTimeToBuyAndSellStockWithCooldown {
+    public static void main(String[] args) {
+        BestTimeToBuyAndSellStockWithCooldown bss = new BestTimeToBuyAndSellStockWithCooldown();
+        int[] a = {1,2,3,0,2};
+        System.out.println(bss.maxProfit(a)); // Output: 3
+
+        // Additional test cases
+        System.out.println(bss.maxProfit(new int[]{1})); // Output: 0 (edge case: only one day)
+        System.out.println(bss.maxProfit(new int[]{2,1,4})); // Output: 3
+        System.out.println(bss.maxProfit(new int[]{})); // Output: 0 (edge case: empty array)
+    }
+
+    /**
+     * Recursive helper function to calculate max profit with cooldown.
+     * @param i   Current day index
+     * @param buy 1 if we can buy, 0 if we must sell
+     * @param a   Prices array
+     * @param dp  Memoization table
+     * @return    Maximum profit from day i with given state
+     */
+    private int f(int i, int buy, int[] a, int[][] dp) {
+        // Base case: If we've reached the end, no more profit can be made
+        if(i >= a.length){
+            return 0;
+        }
+        // Return cached result if already computed
+        if(dp[i][buy] != -1){
+            return dp[i][buy];
+        }
+        int profit = 0;
+        if(buy == 1){
+            // Option 1: Buy at current day, move to next day with buy=0 (must sell next)
+            // Option 2: Skip buying, move to next day with buy=1 (still can buy)
+            profit = Math.max(f(i+1,0,a,dp)-a[i], f(i+1,1,a,dp));
+        }
+        else{
+            // Option 1: Sell at current day, move to day after next (cooldown), can buy again
+            // Option 2: Skip selling, move to next day with buy=0 (still holding)
+            profit = Math.max(f(i+2, 1, a, dp) + a[i], f(i+1,0,a,dp));
+        }
+        // Store result in dp table and return
+        return dp[i][buy] = profit;
+    }
+
+    /**
+     * Calculates the maximum profit with cooldown after selling.
+     * @param a Prices array
+     * @return  Maximum profit
+     */
+    public int maxProfit(int[] a) {
+        int n = a.length;
+        // dp[i][buy]: Max profit at day i, buy/sell state
+        int[][] dp = new int[n+1][3];
+
+        // Initialize dp table with -1 (uncomputed)
+        for(int[] r: dp) {
+            Arrays.fill(r,-1);
+        }
+
+        // Start from day 0, can buy
+        return f(0,1,a,dp);
+    }
+}
+
+

Java/dynamic_programming/BuyAndSellStocks/BestTimeToBuyAndSellStockWithTransactionFee.java

@@ -0,0 +1,89 @@
+/*
+Best Time to Buy and Sell Stock with Transaction Fee
+
+Algorithm Description:
+This algorithm computes the maximum profit from buying and selling stocks with as many transactions as you like, but each transaction (buy+sell) incurs a fixed fee. The approach uses dynamic programming with memoization. The state is defined by the current day and whether you can buy or must sell. At each step, you decide to buy, sell (paying the fee), or skip, and recursively compute the best outcome.
+
+Use Cases:
+- Stock trading where each transaction incurs a brokerage or transaction fee
+- Any scenario where actions have a fixed cost per transaction
+
+Time Complexity: O(n)
+- Each state (day, buy/sell) is computed once, and there are 2*n states.
+
+Space Complexity: O(n)
+- The DP table stores results for each day and buy/sell state.
+*/
+
+package Java.dynamic_programming.BuyAndSellStocks;
+
+import java.util.Arrays;
+
+public class BestTimeToBuyAndSellStockWithTransactionFee {
+    public static void main(String[] args) {
+        BestTimeToBuyAndSellStockWithTransactionFee bss = new BestTimeToBuyAndSellStockWithTransactionFee();
+        int[] a = {1,3,2,8,4,9};
+        int fee = 2;
+        System.out.println(bss.maxProfit(a,fee)); // Output: 8
+
+        // Additional test cases
+        System.out.println(bss.maxProfit(new int[]{1,3,7,5,10,3}, 3)); // Output: 6
+        System.out.println(bss.maxProfit(new int[]{1}, 1)); // Output: 0 (edge case: only one day)
+        System.out.println(bss.maxProfit(new int[]{}, 1)); // Output: 0 (edge case: empty array)
+    }
+
+    /**
+     * Recursive helper function to calculate max profit with transaction fee.
+     * @param i   Current day index
+     * @param buy 1 if we can buy, 0 if we must sell
+     * @param fee Transaction fee per transaction
+     * @param a   Prices array
+     * @param dp  Memoization table
+     * @return    Maximum profit from day i with given state
+     */
+    private int f(int i, int buy, int fee, int[] a, int[][] dp) {
+        // Base case: If we've reached the end, no more profit can be made
+        if(i>=a.length){
+            return 0;
+        }
+        // Return cached result if already computed
+        if(dp[i][buy] != -1){
+            return dp[i][buy];
+        }
+
+        int profit = 0;
+        if(buy == 1) {
+            // Option 1: Buy at current day, move to next day with buy=0 (must sell next)
+            // Option 2: Skip buying, move to next day with buy=1 (still can buy)
+            profit = Math.max(f(i+1,0,fee,a,dp)-a[i] , f(i+1,1,fee,a,dp));
+        }
+        else {
+            // Option 1: Sell at current day, pay fee, move to next day with buy=1 (can buy again)
+            // Option 2: Skip selling, move to next day with buy=0 (still holding)
+            profit = Math.max(f(i+1,1,fee,a,dp)+a[i]-fee , f(i+1,0,fee,a,dp));
+        }
+        // Store result in dp table and return
+        return dp[i][buy] = profit;
+    }
+
+    /**
+     * Calculates the maximum profit with unlimited transactions and a transaction fee.
+     * @param a   Prices array
+     * @param fee Transaction fee per transaction
+     * @return    Maximum profit
+     */
+    public int maxProfit(int[] a, int fee) {
+        int n = a.length;
+        // dp[i][buy]: Max profit at day i, buy/sell state
+        int[][] dp = new int[n+1][3];
+        // Initialize dp table with -1 (uncomputed)
+        for(int[] r : dp){
+            Arrays.fill(r,-1);
+        }
+        // Start from day 0, can buy
+        return f(0,1,fee,a,dp);
+    }
+}
+
+
+

Java/dynamic_programming/BuyAndSellStocks/BuyAndSellStock1.java

@@ -0,0 +1,52 @@
+/*
+Best Time to Buy and Sell Stock I
+
+Algorithm Description:
+This algorithm finds the maximum profit from a single buy and sell transaction. It iterates through the price array, tracking the minimum price seen so far and the maximum profit achievable by selling at the current price. The approach is greedy and uses only constant space.
+
+Use Cases:
+- Finding the best single buy/sell opportunity in a stock price history
+- Any scenario where only one transaction is allowed
+
+Time Complexity: O(n)
+- Single pass through the array.
+
+Space Complexity: O(1)
+- Only a few variables are used.
+*/
+
+package Java.dynamic_programming.BuyAndSellStocks;
+
+class BuyAndSellStock1 {
+    public static void main(String[] args) {
+        BuyAndSellStock1 bss = new BuyAndSellStock1();
+        int[] a = {7,1,5,3,6,4};
+        System.out.println(bss.maxProfit(a)); // Output: 5
+
+        // Additional test cases
+        System.out.println(bss.maxProfit(new int[]{7,6,4,3,1})); // Output: 0 (no profit possible)
+        System.out.println(bss.maxProfit(new int[]{1,2})); // Output: 1
+        System.out.println(bss.maxProfit(new int[]{})); // Output: 0 (edge case: empty array)
+    }
+
+    /**
+     * Calculates the maximum profit from a single buy and sell transaction.
+     * @param a Prices array
+     * @return  Maximum profit (0 if no profit is possible)
+     */
+    public int maxProfit(int[] a) {
+        if (a == null || a.length == 0) return 0;
+        int n = a.length;
+        int profit = Integer.MIN_VALUE; // Tracks the maximum profit found so far
+        int previousStock = a[0];       // Tracks the minimum price seen so far (best day to buy)
+
+        // Iterate through each day, starting from the second day
+        for(int i = 1; i < n; i++) {
+            int currProfit = a[i] - previousStock; // Profit if bought at previousStock and sold today
+            profit = Math.max(profit, currProfit); // Update max profit if current is better
+            previousStock = Math.min(previousStock, a[i]); // Update min price if current is lower
+        }
+        // If profit is negative or zero, return 0 (no profit possible)
+        return profit > 0 ? profit : 0;
+    }
+}

Java/dynamic_programming/BuyAndSellStocks/BuyAndSellStock2.java

@@ -0,0 +1,85 @@
+/*
+Best Time to Buy and Sell Stock II
+
+Algorithm Description:
+This algorithm finds the maximum profit from as many buy and sell transactions as you like, but you can only hold one stock at a time. The approach uses dynamic programming with memoization, where the state is defined by the current day and whether you are holding a stock. At each step, you decide to buy, sell, or skip, and recursively compute the best outcome.
+
+Use Cases:
+- Stock trading with unlimited transactions, but only one stock can be held at a time
+- Any scenario where you want to maximize profit with multiple transactions
+
+Time Complexity: O(n)
+- Each state (day, buy/sell) is computed once, and there are 2*n states.
+
+Space Complexity: O(n)
+- The DP table stores results for each day and buy/sell state.
+*/
+
+package Java.dynamic_programming.BuyAndSellStocks;
+
+import java.util.Arrays;
+
+class BuyAndSellStock2 {
+    public static void main(String[] args) {
+        BuyAndSellStock2 bss = new BuyAndSellStock2();
+        int[] a = {7,1,5,3,6,4};
+        System.out.println(bss.maxProfit(a)); // Output: 7
+
+        // Additional test cases
+        System.out.println(bss.maxProfit(new int[]{1,2,3,4,5})); // Output: 4
+        System.out.println(bss.maxProfit(new int[]{7,6,4,3,1})); // Output: 0
+        System.out.println(bss.maxProfit(new int[]{})); // Output: 0 (edge case: empty array)
+    }
+
+    /**
+     * Recursive helper function to calculate max profit.
+     * @param i   Current day index
+     * @param buy 1 if we can sell (currently holding), 0 if we can buy (not holding)
+     * @param a   Prices array
+     * @param dp  Memoization table
+     * @return    Maximum profit from day i with given state
+     */
+    private int f(int i, int buy, int[] a, int[][] dp) {
+        // Base case: If we've reached the end, no more profit can be made
+        if(i == a.length){
+            return 0;
+        }
+        // Return cached result if already computed
+        if(dp[i][buy] != -1){
+            return dp[i][buy];
+        }
+
+        int profit = 0;
+        if(buy == 1) {
+            // Option 1: Sell at current day, move to next day with buy=0 (can buy again)
+            // Option 2: Skip selling, move to next day with buy=1 (still holding)
+            profit = Math.max(f(i+1,0,a,dp)+a[i], f(i+1,1,a,dp));
+        }
+        else{
+            // Option 1: Buy at current day, move to next day with buy=1 (must sell next)
+            // Option 2: Skip buying, move to next day with buy=0 (still not holding)
+            profit = Math.max(f(i+1,1,a,dp)-a[i], f(i+1,0,a,dp));
+        }
+        // Store result in dp table and return
+        return dp[i][buy] = profit;
+    }
+
+    /**
+     * Calculates the maximum profit with unlimited transactions.
+     * @param a Prices array
+     * @return  Maximum profit
+     */
+    public int maxProfit(int[] a) {
+        int n = a.length;
+        // dp[i][buy]: Max profit at day i, buy/sell state
+        int[][] dp = new int[n][3];
+
+        // Initialize dp table with -1 (uncomputed)
+        for(int[] r:dp){
+            Arrays.fill(r,-1);
+        }
+
+        // Start from day 0, not holding any stock (can buy)
+        return f(0,0,a,dp);
+    }
+}