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;
+ }
+}