Sliding Window menggunakan "jendela" yang bergeser sepanjang array untuk menghitung sesuatu secara efisien, tanpa menghitung ulang seluruh window.

Dari O(n × k) jadi O(n)!

Fixed-size window:

// Cari jumlah terbesar dari k elemen berturut-turut
function maxSumSubarray(arr, k) {
  // Hitung sum window pertama
  let windowSum = 0;
  for (let i = 0; i < k; i++) {
    windowSum += arr[i];
  }

  let maxSum = windowSum;

  // Geser window: tambah elemen baru, buang elemen lama
  for (let i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k]; // Slide!
    maxSum = Math.max(maxSum, windowSum);
  }

  return maxSum;
}

maxSumSubarray([2, 1, 5, 1, 3, 2], 3); // 9 (5+1+3)

Variable-size window:

// Substring terpendek yang mengandung sum ≥ target
function minSubarrayLen(target, arr) {
  let left = 0;
  let sum = 0;
  let minLen = Infinity;

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

    while (sum >= target) {
      minLen = Math.min(minLen, right - left + 1);
      sum -= arr[left];
      left++; // Shrink window
    }
  }

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

minSubarrayLen(7, [2, 3, 1, 2, 4, 3]); // 2 → [4, 3]

Kapan pakai Sliding Window?

• Masalah tentang subarray/substring berturut-turut
• "Cari min/max dari k elemen berurutan"
• "Longest/shortest substring yang..."
• Menggantikan brute force nested loop

🎭 Analogi sehari-hari: Lihat film lewat jendela kereta yang bergerak. Sebagian frame masuk dari kanan (right pointer), sebagian keluar dari kiri (left pointer). Kamu gak ngitung ulang seluruh pemandangan setiap detik — cuma update yang masuk dan keluar. Itu inti sliding window: incremental update, bukan recompute.

💡 Mengapa Sliding Window cepat? Brute force = untuk setiap window posisi, hitung dari awal = O(n × k). Sliding = setiap geser cuma 1 add + 1 remove = O(1) per geser. Total O(n). Hilangin nested loop dengan reuse hasil sebelumnya.

⚠️ Jebakan umum:

• Lupa shrink window di variable-size case = window selalu tumbuh, hasil salah
• Off-by-one window size — right - left + 1 bukan right - left
• Lupa state cleanup saat shrink — hash map count harus decrement
• Confuse fixed vs variable — fixed pakai for, variable pakai while shrink

🎯 Pola "ini sliding window":

• "Subarray berturut-turut..." (consecutive elements)
• "Window size k" → fixed window
• "Longest/shortest substring with property" → variable window
• Klasik: max sum subarray, longest substring no repeat, min window substring, permutation in string
• Tip interview: kalau brute force pake nested loop di consecutive elements, coba sliding window

🧪 Tebakan cepat: Max sum 3 elemen berturut dari [1,4,2,10,2,3,1,0,20]. Brute: untuk tiap i, sum 3 elemen = O(nk) = 27 ops. Sliding: 9 + 7 update = ~16 ops. Speedup makin besar untuk k besar.

TL;DR: Sliding Window = window geser dengan incremental update. Ubah O(nk) jadi O(n). Pakai untuk subarray/substring berturut-turut. Fixed-size atau variable-size pattern.