add sliding window pattern

Author: ashishps1

patterns/c#/SlidingWindow.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+
+public class SlidingWindow {
+    public double FindMaxAverageBruteForce(int[] nums, int k) {
+        int n = nums.Length;
+        double maxAvg = double.MinValue;
+
+        for (int i = 0; i <= n - k; i++) {
+            int sum = 0;
+            for (int j = i; j < i + k; j++) {
+                sum += nums[j];
+            }
+            maxAvg = Math.Max(maxAvg, (double)sum / k);
+        }
+        return maxAvg;
+    }
+
+    public double FindMaxAverageSlidingWindow(int[] nums, int k) {
+        int n = nums.Length;
+        int sum = 0;
+
+        for (int i = 0; i < k; i++) {
+            sum += nums[i];
+        }
+
+        int maxSum = sum;
+
+        for (int i = k; i < n; i++) {
+            sum += nums[i];
+            sum -= nums[i - k];
+            maxSum = Math.Max(maxSum, sum);
+        }
+
+        return (double)maxSum / k;
+    }
+
+    public int LengthOfLongestSubstringSlidingWindow(string s) {
+        HashSet<char> seen = new HashSet<char>();
+        int maxLength = 0, left = 0;
+
+        for (int right = 0; right < s.Length; right++) {
+            while (seen.Contains(s[right])) {
+                seen.Remove(s[left]);
+                left++;
+            }
+            seen.Add(s[right]);
+            maxLength = Math.Max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+
+    public int LengthOfLongestSubstringSlidingWindowFrequencyArray(string s) {
+        int[] freq = new int[128];
+        int maxLength = 0, left = 0;
+
+        for (int right = 0; right < s.Length; right++) {
+            freq[s[right]]++;
+
+            while (freq[s[right]] > 1) {
+                freq[s[left]]--;
+                left++;
+            }
+
+            maxLength = Math.Max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+}

patterns/c++/SlidingWindow.cpp

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+#include <algorithm>
+
+using namespace std;
+
+class SlidingWindow {
+public:
+    double findMaxAverageBruteForce(vector<int>& nums, int k) {
+        int n = nums.size();
+        double maxAvg = INT_MIN;
+
+        for (int i = 0; i <= n - k; i++) {
+            int sum = 0;
+            for (int j = i; j < i + k; j++) {
+                sum += nums[j];
+            }
+            maxAvg = max(maxAvg, (double)sum / k);
+        }
+        return maxAvg;
+    }
+
+    double findMaxAverageSlidingWindow(vector<int>& nums, int k) {
+        int n = nums.size();
+        int sum = 0;
+
+        for (int i = 0; i < k; i++) {
+            sum += nums[i];
+        }
+
+        int maxSum = sum;
+
+        for (int i = k; i < n; i++) {
+            sum += nums[i];
+            sum -= nums[i - k];
+            maxSum = max(maxSum, sum);
+        }
+
+        return (double)maxSum / k;
+    }
+
+    int lengthOfLongestSubstringSlidingWindow(string s) {
+        unordered_set<char> seen;
+        int maxLength = 0, left = 0;
+
+        for (int right = 0; right < s.size(); right++) {
+            while (seen.count(s[right])) {
+                seen.erase(s[left]);
+                left++;
+            }
+            seen.insert(s[right]);
+            maxLength = max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+
+    int lengthOfLongestSubstringSlidingWindowFrequencyArray(string s) {
+        vector<int> freq(128, 0);
+        int maxLength = 0, left = 0;
+
+        for (int right = 0; right < s.size(); right++) {
+            freq[s[right]]++;
+
+            while (freq[s[right]] > 1) {
+                freq[s[left]]--;
+                left++;
+            }
+
+            maxLength = max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+};

patterns/go/sliding_window.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"math"
+)
+
+// Brute Force Approach - O(n * k)
+func findMaxAverageBruteForce(nums []int, k int) float64 {
+	n := len(nums)
+	maxAvg := math.Inf(-1)
+
+	for i := 0; i <= n-k; i++ {
+		sum := 0
+		for j := i; j < i+k; j++ {
+			sum += nums[j]
+		}
+		maxAvg = math.Max(maxAvg, float64(sum)/float64(k))
+	}
+	return maxAvg
+}
+
+// Sliding Window Approach - O(n)
+func findMaxAverageSlidingWindow(nums []int, k int) float64 {
+	sum := 0
+	for i := 0; i < k; i++ {
+		sum += nums[i]
+	}
+
+	maxSum := sum
+
+	for i := k; i < len(nums); i++ {
+		sum += nums[i] - nums[i-k]
+		if sum > maxSum {
+			maxSum = sum
+		}
+	}
+
+	return float64(maxSum) / float64(k)
+}
+
+// Sliding Window for Longest Substring Without Repeating Characters
+func lengthOfLongestSubstringSlidingWindow(s string) int {
+	seen := make(map[byte]bool)
+	maxLength, left := 0, 0
+
+	for right := 0; right < len(s); right++ {
+		for seen[s[right]] {
+			delete(seen, s[left])
+			left++
+		}
+		seen[s[right]] = true
+		maxLength = max(maxLength, right-left+1)
+	}
+	return maxLength
+}
+
+// Sliding Window using Frequency Array
+func lengthOfLongestSubstringSlidingWindowFrequencyArray(s string) int {
+	freq := make([]int, 128)
+	maxLength, left := 0, 0
+
+	for right := 0; right < len(s); right++ {
+		freq[s[right]]++
+
+		for freq[s[right]] > 1 {
+			freq[s[left]]--
+			left++
+		}
+
+		maxLength = max(maxLength, right-left+1)
+	}
+	return maxLength
+}
+
+// Helper function to get max of two numbers
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

patterns/java/SlidingWindow.java

@@ -0,0 +1,90 @@
+package patterns.java;
+
+import java.util.HashSet;
+
+public class SlidingWindow {
+    public double findMaxAverageBruteForce(int[] nums, int k) {
+        int n = nums.length;
+        double maxAvg = Integer.MIN_VALUE;
+
+        // Iterate through all possible subarrays of length k
+        for (int i = 0; i <= n - k; i++) {
+            int sum = 0;
+
+            // Calculate sum of subarray starting at index i
+            for (int j = i; j < i + k; j++) {
+                sum += nums[j];
+            }
+
+            // Compute average and update maxAvg
+            maxAvg = Math.max(maxAvg, (double) sum / k);
+        }
+        return maxAvg;
+    }
+
+    public double findMaxAverageSlidingWindow(int[] nums, int k) {
+        int n = nums.length;
+        
+        // Compute the sum of the first 'k' elements
+        int sum = 0;
+        for (int i = 0; i < k; i++) {
+            sum += nums[i];
+        }
+        
+        // Initialize maxSum as the sum of the first window
+        int maxSum = sum;
+
+        // Slide the window across the array
+        for (int i = k; i < n; i++) {
+            sum += nums[i];      // Add new element entering window
+            sum -= nums[i - k];  // Remove element leaving window
+            maxSum = Math.max(maxSum, sum); // Update maxSum
+        }
+        
+        // Return maximum average
+        return (double) maxSum / k;
+    }
+
+    public int lengthOfLongestSubstringSlidingWindow(String s) {
+        int n = s.length();
+        HashSet<Character> seen = new HashSet<>(); // Store characters in the current window
+        int maxLength = 0;
+        int left = 0;        
+
+        // Expand window by moving 'right'
+        for (int right = 0; right < n; right++) {
+            // If a duplicate is found, shrink the window from the left
+            while (seen.contains(s.charAt(right))) {
+                seen.remove(s.charAt(left));
+                left++;
+            }
+            // Add current character to window and update max length
+            seen.add(s.charAt(right));
+            maxLength = Math.max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+
+    public int lengthOfLongestSubstringSlidingWindowFrequencyArray(String s) {
+        int n = s.length();
+        int[] freq = new int[128]; // ASCII character frequency array
+        int maxLength = 0;
+        int left = 0;        
+
+        // Expand window by moving 'right'
+        for (int right = 0; right < n; right++) {
+            char currentChar = s.charAt(right);
+            freq[currentChar]++; // Increase frequency of the current character
+
+            // If there is a duplicate, shrink the window from the left
+            while (freq[currentChar] > 1) {
+                freq[s.charAt(left)]--; // Remove character at left pointer
+                left++; // Shrink window
+            }
+
+            // Update maximum window size
+            maxLength = Math.max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }    
+}

patterns/javascript/slidingWindow.js

@@ -0,0 +1,62 @@
+class SlidingWindow {
+    // Brute Force Approach - O(n * k)
+    findMaxAverageBruteForce(nums, k) {
+        let maxAvg = -Infinity;
+
+        for (let i = 0; i <= nums.length - k; i++) {
+            let sum = 0;
+            for (let j = i; j < i + k; j++) {
+                sum += nums[j];
+            }
+            maxAvg = Math.max(maxAvg, sum / k);
+        }
+        return maxAvg;
+    }
+
+    // Sliding Window Approach - O(n)
+    findMaxAverageSlidingWindow(nums, k) {
+        let sum = nums.slice(0, k).reduce((a, b) => a + b, 0);
+        let maxSum = sum;
+
+        for (let i = k; i < nums.length; i++) {
+            sum += nums[i] - nums[i - k];
+            maxSum = Math.max(maxSum, sum);
+        }
+
+        return maxSum / k;
+    }
+
+    // Sliding Window for Longest Substring Without Repeating Characters
+    lengthOfLongestSubstringSlidingWindow(s) {
+        let seen = new Set();
+        let maxLength = 0, left = 0;
+
+        for (let right = 0; right < s.length; right++) {
+            while (seen.has(s[right])) {
+                seen.delete(s[left]);
+                left++;
+            }
+            seen.add(s[right]);
+            maxLength = Math.max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+
+    // Sliding Window using Frequency Array
+    lengthOfLongestSubstringSlidingWindowFrequencyArray(s) {
+        let freq = new Array(128).fill(0);
+        let maxLength = 0, left = 0;
+
+        for (let right = 0; right < s.length; right++) {
+            freq[s.charCodeAt(right)]++;
+
+            while (freq[s.charCodeAt(right)] > 1) {
+                freq[s.charCodeAt(left)]--;
+                left++;
+            }
+
+            maxLength = Math.max(maxLength, right - left + 1);
+        }
+        return maxLength;
+    }
+}