Using Sliding Window Pattern

function maxSumSubarray(arr, k) {
  let windowSum = arr.slice(0, k).reduce((a, b) => a + b, 0);
  let maxSum = windowSum;

  for (let i = k; i < arr.length; i++) {
    windowSum = windowSum - arr[i - k] + arr[i];
    maxSum = Math.max(maxSum, windowSum);
  }

  return maxSum;
}

// Example usage:
const nums = [2, 1, 5, 1, 3, 2];
const k = 3;
console.log(maxSumSubarray(nums, k)); // Output: 9

public static int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> charIndexMap = new HashMap<>();
    int maxLength = 0;
    int left = 0;

    for (int right = 0; right < s.length(); right++) {
        char currentChar = s.charAt(right);
        if (charIndexMap.containsKey(currentChar)) {
            left = Math.max(left, charIndexMap.get(currentChar) + 1);
        }
        charIndexMap.put(currentChar, right);
        maxLength = Math.max(maxLength, right - left + 1);
    }

    return maxLength;
}

function minWindow(s, t) {
    const requiredChars = {};
    for (let char of t) {
        requiredChars[char] = (requiredChars[char] || 0) + 1;
    }

    let left = 0, right = 0;
    let windowChars = {};
    let minStart = -1;
    let minLength = Infinity;
    let requiredCount = Object.keys(requiredChars).length;
    let formedCount = 0;

    while (right < s.length) {
        const rightChar = s[right];
        windowChars[rightChar] = (windowChars[rightChar] || 0) + 1;

        if (requiredChars[rightChar] &&
            windowChars[rightChar] === requiredChars[rightChar]) {
            formedCount++;
        }

        while (left <= right && formedCount === requiredCount) {
            const leftChar = s[left];
            if (right - left + 1 < minLength) {
                minLength = right - left + 1;
                minStart = left;
            }

            windowChars[leftChar]--;
            if (requiredChars[leftChar] &&
                windowChars[leftChar] < requiredChars[leftChar]) {
                formedCount--;
            }
            left++;
        }
        right++;
    }

    return minStart === -1 ? "" : s.substring(minStart, minStart + minLength);
}

function checkInclusion(pattern, s) {
  const patternCount = {};
  const windowSize = pattern.length;
  
  // Count characters in pattern
  for (let char of pattern) {
    patternCount[char] = (patternCount[char] || 0) + 1;
  }
  
  const windowCount = {};
  let left = 0;
  let matches = 0;
  
  for (let right = 0; right < s.length; right++) {
    const rightChar = s[right];
    windowCount[rightChar] = (windowCount[rightChar] || 0) + 1;
    
    // Shrink window if larger than pattern size
    if (right - left + 1 > windowSize) {
      const leftChar = s[left];
      windowCount[leftChar]--;
      if (windowCount[leftChar] === 0) {
        delete windowCount[leftChar];
      }
      left++;
    }
    
    // Check if current window matches pattern
    if (right - left + 1 === windowSize) {
      let match = true;
      for (let char in patternCount) {
        if (!(char in windowCount) || windowCount[char] !== patternCount[char]) {
          match = false;
          break;
        }
      }
      if (match) return true;
    }
  }
  
  return false;
}

// Example usage
console.log(checkInclusion("ab", "eidbaooo")); // true

function lengthOfLongestSubstringKDistinct(s, k) {
    if (s.length === 0 || k === 0) return 0;

    let left = 0;
    let maxLength = 0;
    const charCount = new Map();

    for (let right = 0; right < s.length; right++) {
        const rightChar = s[right];
        charCount.set(rightChar, (charCount.get(rightChar) || 0) + 1);

        while (charCount.size > k) {
            const leftChar = s[left];
            charCount.set(leftChar, charCount.get(leftChar) - 1);
            if (charCount.get(leftChar) === 0) {
                charCount.delete(leftChar);
            }
            left++;
        }

        maxLength = Math.max(maxLength, right - left + 1);
    }

    return maxLength;
}

// Example usage:
console.log(lengthOfLongestSubstringKDistinct("araaci", 2)); // Output: 4

function fruitsIntoBaskets(fruits) {
  let maxLength = 0;
  let windowStart = 0;
  let fruitFrequency = new Map();

  for (let windowEnd = 0; windowEnd < fruits.length; windowEnd++) {
    const rightFruit = fruits[windowEnd];
    fruitFrequency.set(rightFruit, (fruitFrequency.get(rightFruit) || 0) + 1);

    while (fruitFrequency.size > 2) {
      const leftFruit = fruits[windowStart];
      fruitFrequency.set(leftFruit, fruitFrequency.get(leftFruit) - 1);
      if (fruitFrequency.get(leftFruit) === 0) {
        fruitFrequency.delete(leftFruit);
      }
      windowStart++;
    }

    maxLength = Math.max(maxLength, windowEnd - windowStart + 1);
  }

  return maxLength;
}

// Example usage:
const fruits = ['A', 'B', 'C', 'A', 'C'];
console.log(fruitsIntoBaskets(fruits)); // Output: 3

function characterReplacement(s, k) {
    let maxCount = 0;
    let maxLength = 0;
    let left = 0;
    const charCount = {};

    for (let right = 0; right < s.length; right++) {
        const rightChar = s[right];
        charCount[rightChar] = (charCount[rightChar] || 0) + 1;
        maxCount = Math.max(maxCount, charCount[rightChar]);

        while (right - left + 1 - maxCount > k) {
            const leftChar = s[left];
            charCount[leftChar]--;
            left++;
        }

        maxLength = Math.max(maxLength, right - left + 1);
    }

    return maxLength;
}

// Example usage:
console.log(characterReplacement("ABAB", 2)); // Output: 4
console.log(characterReplacement("AABABBA", 1)); // Output: 4

function findMaxConsecutiveOnes(nums) {
  let maxCount = 0;
  let currentCount = 0;

  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === 1) {
      currentCount++;
      maxCount = Math.max(maxCount, currentCount);
    } else {
      currentCount = 0;
    }
  }

  return maxCount;
}

// Example usage:
const nums = [1, 1, 0, 1, 1, 1];
console.log(findMaxConsecutiveOnes(nums)); // Output: 3

function minSubArrayLen(target, nums) {
  let left = 0;
  let sum = 0;
  let minLength = Infinity;

  for (let right = 0; right < nums.length; right++) {
    sum += nums[right];

    while (sum >= target) {
      minLength = Math.min(minLength, right - left + 1);
      sum -= nums[left];
      left++;
    }
  }

  return minLength === Infinity ? 0 : minLength;
}

// Example usage:
const nums = [2, 3, 1, 2, 4, 3];
const target = 7;
console.log(minSubArrayLen(target, nums)); // Output: 2

function findAnagrams(text, pattern) {
  const result = [];
  const windowSize = pattern.length;
  const patternMap = new Map();
  const windowMap = new Map();

  // Build frequency map for pattern
  for (let char of pattern) {
    patternMap.set(char, (patternMap.get(char) || 0) + 1);
  }

  // Slide window over text
  for (let right = 0; right < text.length; right++) {
    const rightChar = text[right];
    windowMap.set(rightChar, (windowMap.get(rightChar) || 0) + 1);

    if (right - left + 1 > windowSize) {
      const leftChar = text[left];
      windowMap.set(leftChar, windowMap.get(leftChar) - 1);
      if (windowMap.get(leftChar) === 0) {
        windowMap.delete(leftChar);
      }
      left++;
    }

    if (right - left + 1 === windowSize && 
        areMapsEqual(windowMap, patternMap)) {
      result.push(left);
    }
  }

  return result;
}

function areMapsEqual(map1, map2) {
  if (map1.size !== map2.size) return false;
  for (let [key, value] of map1) {
    if (map2.get(key) !== value) return false;
  }
  return true;
}

// Example usage:
const text = "cbaebabacd";
const pattern = "abc";
console.log(findAnagrams(text, pattern)); // Output: [0, 6]

function findSubstring(s, words) {
    if (!s || !words || words.length === 0) return [];

    const wordLength = words[0].length;
    const totalLength = wordLength * words.length;
    const wordCount = {};
    const result = [];

    // Count occurrences of each word
    for (const word of words) {
        wordCount[word] = (wordCount[word] || 0) + 1;
    }

    // Slide window over each possible starting position
    for (let i = 0; i < wordLength; i++) {
        let left = i;
        let count = 0;
        const currentCount = {};

        for (let right = i; right <= s.length - wordLength; right += wordLength) {
            const word = s.substring(right, right + wordLength);
            if (wordCount[word]) {
                currentCount[word] = (currentCount[word] || 0) + 1;
                count++;

                // Adjust window if a word appears more times than allowed
                while (currentCount[word] > wordCount[word]) {
                    const leftWord = s.substring(left, left + wordLength);
                    currentCount[leftWord]--;
                    count--;
                    left += wordLength;
                }

                // If all words matched, record the index
                if (count === words.length) {
                    result.push(left);
                }
            } else {
                // Reset window if word not in list
                currentCount = {};
                count = 0;
                left = right + wordLength;
            }
        }
    }

    return result;
}

// Example usage:
const s = "barfoothefoobarman";
const words = ["foo", "bar"];
console.log(findSubstring(s, words)); // Output: [0, 9]