add more solutions

Author: ashishps1

c#/3Sum.md

@@ -1,2 +1,86 @@
-# 3Sum.md
+# [15. 3Sum](https://leetcode.com/problems/3sum/)
+
+## Approach 1: Brute Force (Basic)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n^3)
+// Space Complexity: O(1) (excluding output list)
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class Solution {
+    public IList<IList<int>> ThreeSum(int[] nums) {
+        var result = new HashSet<IList<int>>();
+        int n = nums.Length;
+
+        // Iterate through all possible triplets
+        for (int i = 0; i < n - 2; i++) {
+            for (int j = i + 1; j < n - 1; j++) {
+                for (int k = j + 1; k < n; k++) {
+                    if (nums[i] + nums[j] + nums[k] == 0) {
+                        var triplet = new List<int> { nums[i], nums[j], nums[k] };
+                        triplet.Sort(); // Ensure the triplet is in sorted order
+                        result.Add(triplet); // Add triplet to the set to avoid duplicates
+                    }
+                }
+            }
+        }
+
+        return result.ToList(); // Convert set to list for the output
+    }
+}
+```
+
+## Approach 2: Two Pointers (Optimal)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n^2)
+// Space Complexity: O(n) (for sorting or output list)
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class Solution {
+    public IList<IList<int>> ThreeSum(int[] nums) {
+        var result = new List<IList<int>>();
+        Array.Sort(nums); // Sort the array to use two-pointer technique
+
+        for (int i = 0; i < nums.Length - 2; i++) {
+            // Skip duplicates for the first element
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            int left = i + 1;
+            int right = nums.Length - 1;
+
+            // Two-pointer approach
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+                if (sum == 0) {
+                    result.Add(new List<int> { nums[i], nums[left], nums[right] });
+
+                    // Skip duplicates for the second and third elements
+                    while (left < right && nums[left] == nums[left + 1]) left++;
+                    while (left < right && nums[right] == nums[right - 1]) right--;
+
+                    left++;
+                    right--;
+                } else if (sum < 0) {
+                    left++; // Increase the sum
+                } else {
+                    right--; // Decrease the sum
+                }
+            }
+        }
+
+        return result;
+    }
+}
+```
 

c#/best_time_to_buy_and_sell_stock_with_cooldown.md

@@ -1,2 +1,100 @@
-# best_time_to_buy_and_sell_stock_with_cooldown.md
+# 309. [Best Time to Buy and Sell Stock with Cooldown](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
+
+## Approach 1: Recursive with Memoization
+
+### Solution
+c#
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+using System;
+
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        int n = prices.Length;
+        int?[] memo = new int?[n];
+        return CalculateMaxProfit(prices, 0, memo);
+    }
+    
+    private int CalculateMaxProfit(int[] prices, int currentDay, int?[] memo) {
+        if (currentDay >= prices.Length) {
+            return 0;
+        }
+        if (memo[currentDay] != null) {
+            return memo[currentDay].Value;
+        }
+
+        int maxProfit = 0;
+        for (int sellDay = currentDay + 1; sellDay < prices.Length; sellDay++) {
+            // Calculate the profit for the current transaction
+            int profit = prices[sellDay] - prices[currentDay] + CalculateMaxProfit(prices, sellDay + 2, memo);
+            maxProfit = Math.Max(maxProfit, profit);
+        }
+
+        memo[currentDay] = Math.Max(maxProfit, CalculateMaxProfit(prices, currentDay + 1, memo));
+        return memo[currentDay].Value;
+    }
+}
+
+## Approach 2: Dynamic Programming with State Variables
+
+### Solution
+c#
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+using System;
+
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        if (prices.Length == 0) {
+            return 0;
+        }
+        int n = prices.Length;
+
+        int[] buy = new int[n];
+        int[] sell = new int[n];
+        int[] cooldown = new int[n];
+
+        buy[0] = -prices[0];
+        sell[0] = 0;
+        cooldown[0] = 0;
+
+        for (int i = 1; i < n; i++) {
+            buy[i] = Math.Max(buy[i - 1], cooldown[i - 1] - prices[i]);
+            sell[i] = Math.Max(sell[i - 1], buy[i - 1] + prices[i]);
+            cooldown[i] = Math.Max(cooldown[i - 1], sell[i - 1]);
+        }
+
+        return Math.Max(sell[n - 1], cooldown[n - 1]);
+    }
+}
+
+## Approach 3: Optimized Space Dynamic Programming
+
+### Solution
+c#
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+using System;
+
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        if (prices.Length == 0) {
+            return 0;
+        }
+
+        int buy = -prices[0];
+        int sell = 0;
+        int cooldown = 0;
+
+        for (int i = 1; i < prices.Length; i++) {
+            int newSell = Math.Max(sell, buy + prices[i]);
+            int newBuy = Math.Max(buy, cooldown - prices[i]);
+            cooldown = Math.Max(cooldown, sell);
+            buy = newBuy;
+            sell = newSell;
+        }
+
+        return Math.Max(sell, cooldown);
+    }
+}
 

c#/climbing_stairs.md

@@ -1,2 +1,78 @@
-# climbing_stairs.md
+# [70. Climbing Stairs](https://leetcode.com/problems/climbing-stairs/)
+
+## Approach 1: Recursion with Memoization
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+using System.Collections.Generic;
+
+public class Solution {
+    private Dictionary<int, int> memo = new Dictionary<int, int>();
+
+    public int ClimbStairs(int n) {
+        if (n <= 2) return n;
+        if (memo.ContainsKey(n)) return memo[n];
+
+        // Recurrence relation: f(n) = f(n-1) + f(n-2)
+        int result = ClimbStairs(n - 1) + ClimbStairs(n - 2);
+        memo[n] = result; // Store the result in a map to avoid recalculating
+        return result;
+    }
+}
+```
+
+## Approach 2: Dynamic Programming
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+public class Solution {
+    public int ClimbStairs(int n) {
+        if (n <= 2) return n;
+
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        dp[2] = 2;
+
+        // Build the dp array with previous solutions
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+
+        return dp[n]; // The answer is stored in the last element
+    }
+}
+```
+
+## Approach 3: Optimized Dynamic Programming
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+public class Solution {
+    public int ClimbStairs(int n) {
+        if (n <= 2) return n;
+
+        int first = 1;  // Represents dp[i-2]
+        int second = 2; // Represents dp[i-1]
+        int current = 0;
+
+        // Use two variables to avoid full dp array and update them iteratively
+        for (int i = 3; i <= n; i++) {
+            current = first + second; // Current step number is sum of previous two steps
+            first = second; // Move second to first
+            second = current; // Update second to the current
+        }
+
+        return current; // Result is stored in current
+    }
+}
+```
 

c#/coin_change_2.md

@@ -1,2 +1,94 @@
-# coin_change_2.md
+# 518. [Coin Change II](https://leetcode.com/problems/coin-change-ii/)
+
+## Approach 1: Recursive Approach
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(2^n), where n is the number of coins
+// Space Complexity: O(n)
+public class Solution {
+    public int Change(int amount, int[] coins) {
+        return CountWays(coins, coins.Length, amount);
+    }
+
+    // Recursive function to count ways to make change
+    private int CountWays(int[] coins, int numOfCoins, int amount) {
+        // Base case: If amount is 0, there is 1 solution (to use no coins)
+        if (amount == 0) return 1;
+        
+        // If amount is less than 0, there's no solution
+        if (amount < 0) return 0;
+        
+        // If there are no coins and amount is more than 0, no solution
+        if (numOfCoins <= 0 && amount > 0) return 0;
+
+        // Count is the sum of solutions including coins[numOfCoins-1]
+        // and excluding coins[numOfCoins-1]
+        return CountWays(coins, numOfCoins - 1, amount) 
+                + CountWays(coins, numOfCoins, amount - coins[numOfCoins - 1]);
+    }
+}
+```
+
+## Approach 2: Dynamic Programming (2D Array)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n * m), where n is the number of coins and m is the amount
+// Space Complexity: O(n * m)
+public class Solution {
+    public int Change(int amount, int[] coins) {
+        // dp[i][j] means the number of ways to make change for amount j using first i types of coins
+        int[,] dp = new int[coins.Length + 1, amount + 1];
+
+        // Base case: If amount is 0, then there's exactly one way to make change: select no coin
+        for (int i = 0; i <= coins.Length; i++) {
+            dp[i, 0] = 1;
+        }
+
+        // Fill the dp array
+        for (int i = 1; i <= coins.Length; i++) {
+            for (int j = 1; j <= amount; j++) {
+                // If we don't pick the coin, we have dp[i-1][j] possible ways
+                dp[i, j] = dp[i - 1, j];
+
+                // If we pick the coin, we add the ways we can make up the amount with this coin
+                if (j >= coins[i - 1]) {
+                    dp[i, j] += dp[i, j - coins[i - 1]];
+                }
+            }
+        }
+
+        return dp[coins.Length, amount];
+    }
+}
+```
+
+## Approach 3: Dynamic Programming (1D Array)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n * m), where n is the number of coins and m is the amount
+// Space Complexity: O(m)
+public class Solution {
+    public int Change(int amount, int[] coins) {
+        // dp[j] means the number of ways to make change for amount j
+        int[] dp = new int[amount + 1];
+        dp[0] = 1; // Base case: one way to make zero amount
+
+        // Traverse each coin
+        foreach (int coin in coins) {
+            // Update dp array by considering the current coin
+            for (int j = coin; j <= amount; j++) {
+                dp[j] += dp[j - coin];
+            }
+        }
+
+        return dp[amount];
+    }
+}
+```