feat: add NeetCode 150 - Sliding Window category with complete solutions

- Added 6 problems from Sliding Window category:
  - Best Time to Buy and Sell Stock
  - Longest Substring Without Repeating Characters
  - Longest Repeating Character Replacement
  - Permutation in String
  - Minimum Window Substring
  - Sliding Window Maximum

- Each problem includes:
  - Comprehensive explanation with approach, algorithm, and insights
  - Solutions in Java, JavaScript, and Python
  - Multiple approaches and optimizations
  - Edge cases and applications
  - Time and space complexity analysis

- Sliding Window technique patterns:
  - Fixed window size (Permutation in String, Sliding Window Maximum)
  - Variable window size (Longest Substring, Minimum Window Substring)
  - Optimization problems (Best Time to Buy and Sell Stock)
  - Character frequency tracking (Longest Repeating Character Replacement)

Author: TechnoBlogger14o3

neetcode-150/sliding-window/best-time-to-buy-and-sell-stock/explanation.md

@@ -0,0 +1,90 @@
+# Best Time to Buy and Sell Stock
+
+## Problem Statement
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+You want to maximize your profit 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, return `0`.
+
+## Examples
+
+**Example 1:**
+```
+Input: prices = [7,1,5,3,6,4]
+Output: 5
+Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+```
+
+**Example 2:**
+```
+Input: prices = [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transactions are done and the max profit = 0.
+```
+
+## Approach
+
+### Method 1: One Pass (Recommended)
+1. Keep track of minimum price seen so far
+2. For each day, calculate profit if we sell today
+3. Update maximum profit if current profit is better
+
+**Time Complexity:** O(n) - Single pass through the array
+**Space Complexity:** O(1) - Only using two variables
+
+### Method 2: Brute Force
+1. Check all possible buy-sell pairs
+2. Return maximum profit
+
+**Time Complexity:** O(n²) - Nested loops
+**Space Complexity:** O(1) - No extra space
+
+## Algorithm
+
+```
+1. Initialize minPrice = prices[0], maxProfit = 0
+2. For each price in prices:
+   a. Update minPrice = min(minPrice, price)
+   b. Calculate profit = price - minPrice
+   c. Update maxProfit = max(maxProfit, profit)
+3. Return maxProfit
+```
+
+## Key Insights
+
+- **One Pass**: Can solve in single iteration
+- **Minimum Tracking**: Keep track of lowest price seen
+- **Greedy Strategy**: Always consider selling at current price
+- **No Future Knowledge**: Can only use past and current information
+
+## Alternative Approaches
+
+1. **Brute Force**: Check all pairs - O(n²) time
+2. **Dynamic Programming**: More complex state tracking
+3. **Divide and Conquer**: Recursive approach
+
+## Edge Cases
+
+- Empty array: Return 0
+- Single element: Return 0
+- Decreasing prices: Return 0
+- All same prices: Return 0
+- Single transaction: Only one buy-sell pair
+
+## Applications
+
+- Financial analysis
+- Algorithm design patterns
+- Interview preparation
+- Trading algorithms
+- Optimization problems
+
+## Optimization Opportunities
+
+- **Single Pass**: Most efficient approach
+- **Early Exit**: Stop if no profit possible
+- **Memory Efficient**: O(1) space solution
+- **Greedy Choice**: Always consider current day for selling

neetcode-150/sliding-window/best-time-to-buy-and-sell-stock/solution.java

@@ -0,0 +1,73 @@
+/**
+ * Time Complexity: O(n) - Single pass through the array
+ * Space Complexity: O(1) - Only using two variables
+ */
+class Solution {
+    public int maxProfit(int[] prices) {
+        if (prices.length == 0) return 0;
+        
+        int minPrice = prices[0];
+        int maxProfit = 0;
+        
+        for (int i = 1; i < prices.length; i++) {
+            // Update minimum price seen so far
+            minPrice = Math.min(minPrice, prices[i]);
+            
+            // Calculate profit if we sell today
+            int profit = prices[i] - minPrice;
+            
+            // Update maximum profit
+            maxProfit = Math.max(maxProfit, profit);
+        }
+        
+        return maxProfit;
+    }
+}
+
+// Alternative approach using brute force
+class SolutionBruteForce {
+    public int maxProfit(int[] prices) {
+        int maxProfit = 0;
+        
+        for (int i = 0; i < prices.length; i++) {
+            for (int j = i + 1; j < prices.length; j++) {
+                int profit = prices[j] - prices[i];
+                maxProfit = Math.max(maxProfit, profit);
+            }
+        }
+        
+        return maxProfit;
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public int maxProfit(int[] prices) {
+        int minPrice = Integer.MAX_VALUE;
+        int maxProfit = 0;
+        
+        for (int price : prices) {
+            minPrice = Math.min(minPrice, price);
+            maxProfit = Math.max(maxProfit, price - minPrice);
+        }
+        
+        return maxProfit;
+    }
+}
+
+// Using streams for functional approach
+class SolutionStreams {
+    public int maxProfit(int[] prices) {
+        if (prices.length == 0) return 0;
+        
+        int minPrice = prices[0];
+        return Arrays.stream(prices)
+                .skip(1)
+                .map(price -> {
+                    minPrice = Math.min(minPrice, price);
+                    return price - minPrice;
+                })
+                .max()
+                .orElse(0);
+    }
+}

neetcode-150/sliding-window/best-time-to-buy-and-sell-stock/solution.js

@@ -0,0 +1,61 @@
+/**
+ * Time Complexity: O(n) - Single pass through the array
+ * Space Complexity: O(1) - Only using two variables
+ */
+var maxProfit = function(prices) {
+    if (prices.length === 0) return 0;
+    
+    let minPrice = prices[0];
+    let maxProfit = 0;
+    
+    for (let i = 1; i < prices.length; i++) {
+        // Update minimum price seen so far
+        minPrice = Math.min(minPrice, prices[i]);
+        
+        // Calculate profit if we sell today
+        const profit = prices[i] - minPrice;
+        
+        // Update maximum profit
+        maxProfit = Math.max(maxProfit, profit);
+    }
+    
+    return maxProfit;
+};
+
+// Alternative approach using brute force
+var maxProfitBruteForce = function(prices) {
+    let maxProfit = 0;
+    
+    for (let i = 0; i < prices.length; i++) {
+        for (let j = i + 1; j < prices.length; j++) {
+            const profit = prices[j] - prices[i];
+            maxProfit = Math.max(maxProfit, profit);
+        }
+    }
+    
+    return maxProfit;
+};
+
+// More concise version
+var maxProfitConcise = function(prices) {
+    let minPrice = Infinity;
+    let maxProfit = 0;
+    
+    for (const price of prices) {
+        minPrice = Math.min(minPrice, price);
+        maxProfit = Math.max(maxProfit, price - minPrice);
+    }
+    
+    return maxProfit;
+};
+
+// Using reduce for functional approach
+var maxProfitFunctional = function(prices) {
+    if (prices.length === 0) return 0;
+    
+    let minPrice = prices[0];
+    return prices.slice(1).reduce((maxProfit, price) => {
+        minPrice = Math.min(minPrice, price);
+        return Math.max(maxProfit, price - minPrice);
+    }, 0);
+};

neetcode-150/sliding-window/best-time-to-buy-and-sell-stock/solution.py

@@ -0,0 +1,70 @@
+"""
+Time Complexity: O(n) - Single pass through the array
+Space Complexity: O(1) - Only using two variables
+"""
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        if not prices:
+            return 0
+        
+        min_price = prices[0]
+        max_profit = 0
+        
+        for i in range(1, len(prices)):
+            # Update minimum price seen so far
+            min_price = min(min_price, prices[i])
+            
+            # Calculate profit if we sell today
+            profit = prices[i] - min_price
+            
+            # Update maximum profit
+            max_profit = max(max_profit, profit)
+        
+        return max_profit
+
+# Alternative approach using brute force
+class SolutionBruteForce:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        
+        for i in range(len(prices)):
+            for j in range(i + 1, len(prices)):
+                profit = prices[j] - prices[i]
+                max_profit = max(max_profit, profit)
+        
+        return max_profit
+
+# More concise version
+class SolutionConcise:
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = float('inf')
+        max_profit = 0
+        
+        for price in prices:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+        
+        return max_profit
+
+# Using enumerate for more Pythonic approach
+class SolutionPythonic:
+    def maxProfit(self, prices: List[int]) -> int:
+        if not prices:
+            return 0
+        
+        min_price = prices[0]
+        max_profit = 0
+        
+        for price in prices[1:]:
+            min_price = min(min_price, price)
+            max_profit = max(max_profit, price - min_price)
+        
+        return max_profit
+
+# One-liner using reduce
+from functools import reduce
+
+class SolutionOneLiner:
+    def maxProfit(self, prices: List[int]) -> int:
+        return reduce(lambda acc, price: (min(acc[0], price), max(acc[1], price - acc[0])), 
+                     prices, (float('inf'), 0))[1] if prices else 0

neetcode-150/sliding-window/longest-repeating-character-replacement/explanation.md

@@ -0,0 +1,84 @@
+# Longest Repeating Character Replacement
+
+## Problem Statement
+
+You are given a string `s` and an integer `k`. You can choose any character of the string and change it to any other uppercase English letter. You can perform this operation at most `k` times.
+
+Return the length of the longest substring containing the same letter you can get after performing the above operations.
+
+## Examples
+
+**Example 1:**
+```
+Input: s = "ABAB", k = 2
+Output: 4
+Explanation: Replace the two 'A's with two 'B's or vice versa.
+```
+
+**Example 2:**
+```
+Input: s = "AABABBA", k = 1
+Output: 4
+Explanation: Replace the one 'A' in the middle with 'B' and form "AABBBBA".
+The substring "BBBB" has the longest repeating letters, which is 4.
+```
+
+## Approach
+
+### Method 1: Sliding Window (Recommended)
+1. Use two pointers to define window
+2. Track frequency of each character in window
+3. Keep track of most frequent character
+4. If window size - most frequent count > k, contract window
+
+**Time Complexity:** O(n) - Single pass through the string
+**Space Complexity:** O(1) - At most 26 characters
+
+## Algorithm
+
+```
+1. Initialize left = 0, maxLength = 0, maxCount = 0
+2. Use HashMap to track character frequencies
+3. For each right pointer:
+   a. Update character frequency
+   b. Update maxCount = max(maxCount, frequency)
+   c. If window size - maxCount > k:
+      - Contract window from left
+   d. Update maxLength
+4. Return maxLength
+```
+
+## Key Insights
+
+- **Sliding Window**: Expand right, contract left when needed
+- **Character Frequency**: Track most frequent character
+- **Replacement Logic**: Window size - max frequency <= k
+- **Greedy Strategy**: Always try to maximize window size
+
+## Alternative Approaches
+
+1. **Brute Force**: Check all substrings - O(n²) time
+2. **Fixed Window**: Try all possible window sizes
+3. **Character-wise**: Process each character separately
+
+## Edge Cases
+
+- Empty string: Return 0
+- k = 0: Return length of longest same-character substring
+- All same characters: Return string length
+- k >= string length: Return string length
+
+## Applications
+
+- String processing
+- Data analysis
+- Algorithm design patterns
+- Interview preparation
+- Text optimization
+
+## Optimization Opportunities
+
+- **Sliding Window**: Most efficient approach
+- **Frequency Tracking**: O(1) updates
+- **Single Pass**: Linear time complexity
+- **Memory Efficient**: Constant space