siliding window

Author: Dhananjay Nagargoje

Diff for: .idea/workspace.xml

@@ -0,0 +1,26 @@
+package problems.patterns.slidingwindows;
+import java.util.Arrays;
+
+class AverageOfSubarrayOfSizeK {
+    public static double[] findAverages(int K, int[] arr) {
+        double[] result = new double[arr.length - K + 1];
+        double windowSum = 0;
+        int windowStart = 0;
+        for (int windowEnd = 0; windowEnd < arr.length; windowEnd++) {
+            windowSum += arr[windowEnd]; // add the next element
+            // slide the window, we don't need to slide if we've not hit the required window size of 'k'
+            if (windowEnd >= K - 1) {
+                result[windowStart] = windowSum / K; // calculate the average
+                windowSum -= arr[windowStart]; // subtract the element going out
+                windowStart++; // slide the window ahead
+            }
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        double[] result = AverageOfSubarrayOfSizeK.findAverages(5, new int[] { 1, 3, 2, 6, -1, 4, 1, 8, 2 });
+        System.out.println("Averages of subarrays of size K: " + Arrays.toString(result));
+    }
+}

Diff for: out/production/main/problems/onmath/gfg/Allfactors.class

@@ -0,0 +1,44 @@
+package problems.patterns.slidingwindows;
+class MaxSumSubArrayOfSizeK {
+    /**
+     * Given an array of positive numbers and a positive number ‘k’, find the maximum sum of any contiguous subarray of size ‘k’.
+     *
+     * Example 1:
+     *
+     * Input: [2, 1, 5, 1, 3, 2], k=3
+     * Output: 9
+     * Explanation: Subarray with maximum sum is [5, 1, 3].
+     * Example 2:
+     *
+     * Input: [2, 3, 4, 1, 5], k=2
+     * Output: 7
+     * Explanation: Subarray with maximum sum is [3, 4].
+     * @param k
+     * @param arr
+     * @return
+     */
+
+
+    public static int findMaxSumSubArray(int k, int[] arr) {
+        int windowSum = 0, maxSum = 0;
+        int windowStart = 0;
+        for (int windowEnd = 0; windowEnd < arr.length; windowEnd++) {
+            windowSum += arr[windowEnd]; // add the next element
+            // slide the window, we don't need to slide if we've not hit the required window size of 'k'
+            if (windowEnd >= k - 1) {
+                maxSum = Math.max(maxSum, windowSum);
+                windowSum -= arr[windowStart]; // subtract the element going out
+                windowStart++; // slide the window ahead
+            }
+        }
+
+        return maxSum;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("Maximum sum of a subarray of size K: "
+                + MaxSumSubArrayOfSizeK.findMaxSumSubArray(3, new int[] { 2, 1, 5, 1, 3, 2 }));
+        System.out.println("Maximum sum of a subarray of size K: "
+                + MaxSumSubArrayOfSizeK.findMaxSumSubArray(2, new int[] { 2, 3, 4, 1, 5 }));
+    }
+}

Diff for: out/production/main/problems/onmath/gfg/Sieve.class

@@ -0,0 +1,51 @@
+package problems.patterns.slidingwindows;
+class MinSizeSubArraySum {
+
+    /**
+     * Given an array of positive numbers and a positive number ‘S’, find the length of the smallest contiguous subarray whose sum is greater than or equal to ‘S’. Return 0, if no such subarray exists.
+     *
+     * Example 1:
+     *
+     * Input: [2, 1, 5, 2, 3, 2], S=7
+     * Output: 2
+     * Explanation: The smallest subarray with a sum great than or equal to '7' is [5, 2].
+     * Example 2:
+     *
+     * Input: [2, 1, 5, 2, 8], S=7
+     * Output: 1
+     * Explanation: The smallest subarray with a sum greater than or equal to '7' is [8].
+     * Example 3:
+     *
+     * Input: [3, 4, 1, 1, 6], S=8
+     * Output: 3
+     * Explanation: Smallest subarrays with a sum greater than or equal to '8' are [3, 4, 1] or [1, 1, 6].
+     * @param S
+     * @param arr
+     * @return
+     */
+
+    public static int findMinSubArray(int S, int[] arr) {
+        int windowSum = 0, minLength = Integer.MAX_VALUE;
+        int windowStart = 0;
+        for (int windowEnd = 0; windowEnd < arr.length; windowEnd++) {
+            windowSum += arr[windowEnd]; // add the next element
+            // shrink the window as small as possible until the 'windowSum' is smaller than 'S'
+            while (windowSum >= S) {
+                minLength = Math.min(minLength, windowEnd - windowStart + 1);
+                windowSum -= arr[windowStart]; // subtract the element going out
+                windowStart++; // slide the window ahead
+            }
+        }
+
+        return minLength == Integer.MAX_VALUE ? 0 : minLength;
+    }
+
+    public static void main(String[] args) {
+        int result = MinSizeSubArraySum.findMinSubArray(7, new int[] { 2, 1, 5, 2, 3, 2 });
+        System.out.println("Smallest subarray length: " + result);
+        result = MinSizeSubArraySum.findMinSubArray(7, new int[] { 2, 1, 5, 2, 8 });
+        System.out.println("Smallest subarray length: " + result);
+        result = MinSizeSubArraySum.findMinSubArray(8, new int[] { 3, 4, 1, 1, 6 });
+        System.out.println("Smallest subarray length: " + result);
+    }
+}