1004. Max Consecutive Ones III☆

function longestOnes(nums: number[], k: number): number {
  let L = 0;
  let zeros = 0;
  let best = 0;

  for (let R = 0; R < nums.length; R++) {
    if (nums[R] === 0) zeros++;       // a 0 entered the window

    while (zeros > k) {               // too many 0s to flip
      if (nums[L] === 0) zeros--;     // a 0 is leaving on the left
      L++;
    }

    best = Math.max(best, R - L + 1); // window now has <= k zeros
  }

  return best;
}

function minWindow(s: string, t: string): string {
  if (t.length === 0) return '';

  // Build the "need" map: how many of each t-char we require
  const need = new Map<string, number>();
  for (const c of t) need.set(c, (need.get(c) ?? 0) + 1);
  const required = need.size; // distinct chars we must satisfy

  const window = new Map<string, number>(); // current window counts
  let have = 0;   // distinct chars currently satisfied
  let L = 0;

  let bestLen = Infinity;
  let bestL = 0, bestR = 0;

  for (let R = 0; R < s.length; R++) {
    // 1. Expand: add s[R] to the window
    const c = s[R];
    window.set(c, (window.get(c) ?? 0) + 1);
    if (need.has(c) && window.get(c) === need.get(c)) {
      have++; // this char's count just hit its requirement
    }

    // 2. Contract: shrink from the left while window is valid
    while (have === required) {
      const len = R - L + 1;
      if (len < bestLen) { bestLen = len; bestL = L; bestR = R; }

      const lc = s[L];
      window.set(lc, window.get(lc)! - 1);
      if (need.has(lc) && window.get(lc)! < need.get(lc)!) {
        have--; // we dropped below requirement; window invalid
      }
      L++;
    }
  }

  return bestLen === Infinity ? '' : s.slice(bestL, bestR + 1);
}

function maxSlidingWindow(nums: number[], k: number): number[] {
  const result: number[] = [];
  const deque: number[] = []; // stores INDICES; values decreasing front→back

  for (let i = 0; i < nums.length; i++) {
    // 1 · evict the front if it has slid out of the window
    if (deque.length && deque[0] <= i - k) {
      deque.shift();
    }
    // 2 · drain the back of all values ≤ the incoming value
    while (deque.length && nums[deque[deque.length - 1]] <= nums[i]) {
      deque.pop();
    }
    // 3 · push the current index
    deque.push(i);
    // 4 · record the max once the first window is complete
    if (i >= k - 1) {
      result.push(nums[deque[0]]);
    }
  }
  return result;
}

function findAnagrams(s: string, p: string): number[] {
  const res: number[] = [];
  const k = p.length;
  if (k > s.length) return res;

  // Frequency arrays for p (need) and the current window of s (have)
  const need = new Array<number>(26).fill(0);
  const have = new Array<number>(26).fill(0);
  const a = 'a'.charCodeAt(0);

  for (const c of p) need[c.charCodeAt(0) - a]++;

  // matches = number of letters whose count in 'have' equals 'need'
  let matches = 0;

  for (let r = 0; r < s.length; r++) {
    // Add s[r] to the window
    const rIdx = s.charCodeAt(r) - a;
    have[rIdx]++;
    if (have[rIdx] === need[rIdx]) matches++;
    else if (have[rIdx] - 1 === need[rIdx]) matches--;

    // Once the window exceeds size k, evict the leftmost char
    if (r >= k) {
      const lIdx = s.charCodeAt(r - k) - a;
      have[lIdx]--;
      if (have[lIdx] === need[lIdx]) matches++;
      else if (have[lIdx] + 1 === need[lIdx]) matches--;
    }

    // Window is exactly size k once r >= k - 1
    if (r >= k - 1 && matches === 26) res.push(r - k + 1);
  }
  return res;
}