Fixed-length sliding window coding interview problems are a subset of the sliding window problems where the window’s size remains constant throughout the operation.

Approach to solve Fixed-Length Sliding Window Problems

1. Understand the Problem: Make sure you thoroughly understand the problem. Know the fixed length of the window and what you’re required to compute (max, min, average, etc.) within that window.

2. Initialize Pointers and Variables:

• Use two pointers, start and end.
• Initialize necessary variables to store the result, window sum, etc.

3. Slide the Window:

• Increase the end pointer till you reach the window’s size.
• Compute the desired result for the current window.
• Slide the window by incrementing both start and end pointers.
• Update variables accordingly.

4. Handle Edge Cases: Make sure to handle edge cases such as when the array’s size is less than the window’s size.

Java Template for Fixed-Length Sliding Window Problems

Use the following template to solve fixed length sliding window coding interview questions:

public class SlidingWindow {

    public static int[] fixedLengthSlidingWindow(int[] arr, int k) {
        if (arr == null || arr.length == 0 || k <= 0) {
            return new int[0];
        }
        
        int n = arr.length;
        int[] result = new int[n - k + 1];
        
        int windowSum = 0;
        for (int i = 0; i < k; i++) {
            windowSum += arr[i];
        }
        
        result[0] = windowSum;
        int start = 0;

        for (int end = k; end < n; end++) {
            windowSum += arr[end] - arr[start]; // Slide window to the right
            result[end - k + 1] = windowSum;
            start++;
        }

        return result;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11};
        int k = 3;
        int[] result = fixedLengthSlidingWindow(arr, k);

        for (int r : result) {
            System.out.println(r);
        }
    }
}

This template calculates the sum of each fixed-length window in the given array. Adjust the calculations inside the loop depending on the problem’s requirements (e.g., maximum value, minimum value, etc.).

Practice Problems on Fixed-Length Sliding Window Pattern

1. Maximum Average Subarray I: Given an array consisting of n integers, find the contiguous subarray of given length k that has the maximum average value.
2. Subarray Sum Equals K: Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k. Note that this problem can also be solved using a hashmap approach.
3. Minimum Size Subarray Sum: Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn’t one, return 0 instead.
4. Binary Subarrays With Sum: In an array A of 0s and 1s, how many non-empty subarrays have sum S?
5. Permutation in String: Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1.
6. Replace the Substring for Balanced String: You are given a string containing only 4 kinds of characters ‘Q’, ‘W’, ‘E’, and ‘R’. A string is said to be balanced if each of its characters appears n/4 times where n is the length of the string. Return the minimum length of the substring that can be replaced with any other string of the same length to make the original string s balanced.
7. Check if a Word Occurs As a Prefix of Any Word in a Sentence: Given a sentence that consists of some words separated by a single space, and a searchWord. Check if searchWord is a prefix of any word in the sentence.