Bird
Raised Fist0
DSA Typescriptprogramming~20 mins

Sliding Window on Arrays in DSA Typescript - Practice Problems & Challenges

Choose your learning style10 modes available
Challenge - 5 Problems
🎖️
Sliding Window Master
Get all challenges correct to earn this badge!
Test your skills under time pressure!
❓ Predict Output
intermediate
2:00remaining
Output of sliding window maximum
What is the output of the following TypeScript code that finds the maximum in each sliding window of size 3?
DSA Typescript
function maxSlidingWindow(nums: number[], k: number): number[] {
  const result: number[] = [];
  for (let i = 0; i <= nums.length - k; i++) {
    let max = nums[i];
    for (let j = i + 1; j < i + k; j++) {
      if (nums[j] > max) max = nums[j];
    }
    result.push(max);
  }
  return result;
}

console.log(maxSlidingWindow([1,3,-1,-3,5,3,6,7], 3));
A[1, 3, -1, -3, 5, 3]
B[3, 3, 5, 5, 6, 7]
C[3, -1, -3, 5, 3, 6]
D[7, 6, 5, 3, -3, -1]
Attempts:
2 left
💡 Hint
Think about the maximum value in each group of 3 consecutive numbers.
🧠 Conceptual
intermediate
1:00remaining
Sliding window sum count
Given an array of integers and a window size k, how many sliding windows of size k are there in the array?
Anums.length / k
Bnums.length + k - 1
Cnums.length - k + 1
Dnums.length * k
Attempts:
2 left
💡 Hint
Think about how many times you can move a window of size k inside the array without going out of bounds.
🔧 Debug
advanced
2:00remaining
Find the bug in sliding window average calculation
What error does this TypeScript code produce when calculating the average of each sliding window of size 3?
DSA Typescript
function slidingWindowAverage(nums: number[], k: number): number[] {
  const result: number[] = [];
  let windowSum = 0;
  for (let i = 0; i < nums.length; i++) {
    windowSum += nums[i];
    if (i >= k) {
      windowSum -= nums[i - k];
    }
    if (i >= k - 1) {
      result.push(windowSum / k);
    }
  }
  return result;
}

console.log(slidingWindowAverage([1, 2, 3, 4, 5], 3));
A[3, 4, 5]
B[1, 2, 3]
CTypeError
D[2, 3, 4]
Attempts:
2 left
💡 Hint
Check how the window sum is updated and when averages are pushed.
❓ Predict Output
advanced
2:00remaining
Output of sliding window minimum with deque
What is the output of this TypeScript code that finds the minimum in each sliding window of size 2 using a deque?
DSA Typescript
function minSlidingWindow(nums: number[], k: number): number[] {
  const result: number[] = [];
  const deque: number[] = [];
  for (let i = 0; i < nums.length; i++) {
    while (deque.length && nums[deque[deque.length - 1]] > nums[i]) {
      deque.pop();
    }
    deque.push(i);
    if (deque[0] === i - k) {
      deque.shift();
    }
    if (i >= k - 1) {
      result.push(nums[deque[0]]);
    }
  }
  return result;
}

console.log(minSlidingWindow([4, 2, 12, 3, 5, 1, 7], 2));
A[2, 2, 3, 3, 1, 1]
B[4, 2, 3, 3, 1, 7]
C[4, 12, 3, 5, 1, 7]
D[2, 12, 3, 5, 1, 7]
Attempts:
2 left
💡 Hint
The deque keeps indexes of minimum values in the current window.
🚀 Application
expert
3:00remaining
Longest substring with at most K distinct characters
What is the length of the longest substring with at most 2 distinct characters in the string 'eceba'?
DSA Typescript
function lengthOfLongestSubstringKDistinct(s: string, k: number): number {
  let left = 0;
  let right = 0;
  const map = new Map<string, number>();
  let maxLen = 0;

  while (right < s.length) {
    const char = s[right];
    map.set(char, (map.get(char) ?? 0) + 1);

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

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

  return maxLen;
}

console.log(lengthOfLongestSubstringKDistinct('eceba', 2));
A3
B2
C4
D5
Attempts:
2 left
💡 Hint
Use a sliding window to keep track of characters and their counts.

Practice

(1/5)
1. What is the main purpose of the sliding window technique on arrays?
easy
A. To find the maximum element in the entire array
B. To sort the array in ascending order
C. To reverse the elements of the array
D. To efficiently process subarrays of fixed size without repeated work

Solution

  1. Step 1: Understand the sliding window concept

    The sliding window technique moves a fixed-size window over the array to process subarrays efficiently.
  2. Step 2: Identify the purpose

    It avoids recalculating values for overlapping parts of subarrays, improving performance.
  3. Final Answer:

    To efficiently process subarrays of fixed size without repeated work -> Option D
  4. Quick Check:

    Sliding window = efficient fixed-size subarray processing [OK]
Hint: Think of a moving window over array parts for efficiency [OK]
Common Mistakes:
  • Confusing sliding window with sorting
  • Thinking it reverses the array
  • Assuming it finds max of whole array
2. Which of the following is the correct TypeScript syntax to start a sliding window loop for an array arr with window size k?
easy
A. for (let i = 0; i < arr.length; i += k)
B. for (let i = 0; i < arr.length + k; i++)
C. for (let i = 0; i <= arr.length - k; i++)
D. for (let i = 1; i <= arr.length - k; i++)

Solution

  1. Step 1: Determine loop range for sliding window

    The window of size k must fit inside the array, so the last start index is arr.length - k.
  2. Step 2: Check loop syntax correctness

    Loop from i = 0 up to and including arr.length - k ensures all windows are covered.
  3. Final Answer:

    for (let i = 0; i <= arr.length - k; i++) -> Option C
  4. Quick Check:

    Loop runs from 0 to arr.length - k inclusive [OK]
Hint: Loop until index allows full window inside array [OK]
Common Mistakes:
  • Using < instead of <= causing last window to miss
  • Starting loop at 1 instead of 0
  • Incrementing by k skipping windows
3. What is the output of this TypeScript code?
const arr = [1, 3, 2, 6, -1, 4, 1, 8, 2];
const k = 5;
const result: number[] = [];
let windowSum = 0;

for (let i = 0; i < k; i++) {
  windowSum += arr[i];
}
result.push(windowSum);

for (let i = k; i < arr.length; i++) {
  windowSum += arr[i] - arr[i - k];
  result.push(windowSum);
}

console.log(result);
medium
A. [11, 14, 12, 18, 14]
B. [11, 10, 12, 15, 13]
C. [11, 14, 17, 20, 23]
D. [11, 13, 15, 17, 19]

Solution

  1. Step 1: Calculate initial window sum for first 5 elements

    1 + 3 + 2 + 6 + (-1) = 11. result = [11]
  2. Step 2: Slide window and update sums

    i=5: 11 - 1 + 4 = 14
    i=6: 14 - 3 + 1 = 12
    i=7: 12 - 2 + 8 = 18
    i=8: 18 - 6 + 2 = 14
    result = [11, 14, 12, 18, 14]
  3. Final Answer:

    [11, 14, 12, 18, 14] -> Option A
  4. Quick Check:

    windowSum += arr[i] - arr[i - k] each slide [OK]
Hint: Add new element, subtract old element for each slide [OK]
Common Mistakes:
  • Not subtracting the element leaving the window
  • Incorrect initial sum calculation
  • Off-by-one errors in loop indices
4. Identify the error in this sliding window code snippet and choose the fix:
const arr = [2, 1, 5, 1, 3, 2];
const k = 3;
let maxSum = 0;
let windowSum = 0;

for (let i = 0; i < k; i++) {
  windowSum += arr[i];
}
maxSum = windowSum;

for (let i = k; i < arr.length; i++) {
  windowSum = windowSum + arr[i] - arr[i + k];
  if (windowSum > maxSum) {
    maxSum = windowSum;
  }
}
console.log(maxSum);
medium
A. Initialize maxSum to Number.MIN_VALUE
B. Change arr[i + k] to arr[i - k] in the second loop
C. Change first loop to run from i = 1 to k
D. Add a check if i + k < arr.length before subtraction

Solution

  1. Step 1: Analyze the sliding window update

    The window slides by removing the element leaving the window and adding the new element entering it. The element leaving is at index i - k, not i + k.
  2. Step 2: Correct the subtraction index

    Change arr[i + k] to arr[i - k] to correctly remove the leftmost element of the previous window.
  3. Final Answer:

    Change arr[i + k] to arr[i - k] in the second loop -> Option B
  4. Quick Check:

    Subtract element leaving window at i-k [OK]
Hint: Subtract element at i-k, not i+k, when sliding window [OK]
Common Mistakes:
  • Using wrong index for element leaving window
  • Not initializing maxSum correctly
  • Loop range errors
5. Given an array of integers, write a sliding window algorithm to find the maximum sum of any subarray of size k. Which approach below correctly implements this in TypeScript?
hard
A. Initialize sum of first k elements, then slide window adding new element and subtracting old, updating max sum each time
B. Sort the array and sum the first k elements
C. Use nested loops to sum every subarray of size k and track max sum
D. Add all elements and divide by k to get average, then multiply by k for max sum

Solution

  1. Step 1: Understand the sliding window max sum approach

    Calculate sum of first k elements as initial window sum.
  2. Step 2: Slide window across array

    For each new element, add it and subtract the element leaving the window, update max sum if current sum is higher.
  3. Step 3: Avoid inefficient methods

    Sorting or nested loops are less efficient; averaging does not find max sum.
  4. Final Answer:

    Initialize sum of first k elements, then slide window adding new element and subtracting old, updating max sum each time -> Option A
  5. Quick Check:

    Sliding window updates sum and tracks max [OK]
Hint: Slide window, update sum and max in one pass [OK]
Common Mistakes:
  • Using nested loops causing slow performance
  • Sorting array which changes element order
  • Calculating average instead of max sum
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard