Ques Sliding window

Author: SH7072

18_SlidingWindowQuestions/1_MaxSumSubarray.cpp

@@ -0,0 +1,50 @@
+// For a given array and integers k & x find the
+// maximum sum subarray of size k and having sum less than x.
+// Approach sliding window
+// Time O(n)
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int maxSumSubarray(vector<int> arr, int n, int k, int x)
+{
+    int sum = 0;
+    int ans = 0;
+
+    for (int i = 0; i < k; i++)
+    {
+        sum += arr[i];
+    }
+
+    if (sum < x)
+    {
+        ans = sum;
+    }
+
+    for (int i = k; i < n; i++)
+    {
+        sum = sum + arr[i] - arr[i - k];
+
+        if (sum < x)
+        {
+            ans = max(ans, sum);
+        }
+    }
+
+    return ans;
+}
+
+int main()
+{
+
+    vector<int> arr = {7, 5, 4, 6, 8, 9};
+
+    int k = 3;
+    int x = 20;
+    int n = arr.size();
+
+    cout << maxSumSubarray(arr, n, k, x);
+
+    return 0;
+}

18_SlidingWindowQuestions/2_MinSubarraySize.cpp

@@ -0,0 +1,44 @@
+// For a given array and an integer x, find the Minimum Subarray size
+// for which sum > x.
+// APP- Sliding Window
+// Time O(n)
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int MinSubarraySize(vector<int>arr,int n,int x)
+{
+
+    int sum=0,ans=n+1;
+    int j=0;
+    for (int i = 0; i < n; i++)
+    {
+        sum+=arr[i];
+
+        while(sum>x)
+        {
+            ans=min(ans,i-j+1);
+            sum=sum-arr[j];
+            j++;
+        }
+    }
+    
+    return ans;
+
+}
+
+int main()
+{
+
+    
+    vector<int> arr = {1, 45, 6, 10, 54};
+
+    // int k = 3;
+    int x = 51;
+    int n = arr.size();
+
+    cout << MinSubarraySize(arr, n,  x);
+    //if min length is n+1 no such element exist
+    return 0;
+}

18_SlidingWindowQuestions/3_NumberDivisibleBy3.cpp

@@ -0,0 +1,70 @@
+// for a given array and an integer k, check if ant subarray of size
+// k in the array such that elements in the subarray form a number
+// divisible by 3.
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+void makeNumberFromSubarray(vector<int> arr, int k)
+{
+    pair<int, int> ans;
+    int n = arr.size();
+
+    int sum = 0;
+
+    for (int i = 0; i < k; i++)
+    {
+        sum += arr[i];
+    }
+
+    bool found = false;
+
+    if (sum % 3 == 0)
+    {
+        ans = make_pair(0, k - 1);
+        found = true;
+    }
+
+    for (int j = k; j < n; j++)
+    {
+        if (found)
+        {
+            break;
+        }
+        sum = sum + arr[j] - arr[j - k];
+        if (sum % 3 == 0)
+        {
+            ans = make_pair(j - k + 1, j);
+            found = true;
+        }
+    }
+
+    if (!found)
+    {
+        ans = make_pair(-1, 0);
+    }
+    if (ans.first == -1)
+    {
+        cout << "Does not exist" << endl;
+    }
+    else
+    {
+        for (int i = ans.first; i <= ans.second; i++)
+        {
+            cout << arr[i] << " ";
+        }
+    }
+}
+
+int main()
+{
+
+    vector<int> arr = {23, 45, 12, 56, 82};
+
+    int k = 3;
+
+    makeNumberFromSubarray(arr, k);
+
+    return 0;
+}

18_SlidingWindowQuestions/4_SubarrayWithPalindromeConcatination.cpp

@@ -0,0 +1,75 @@
+// For a given array and an integer k check if any subarray of size
+// k exist in the array such that concatenation of elements form a palindrome.
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+bool isPalindrome(int num)
+{
+    int temp = num, rev = 0;
+
+    while (temp > 0)
+    {
+        rev = rev * 10 + temp % 10;
+        temp = temp / 10;
+    }
+
+    if (rev == num)
+    {
+        return true;
+    }
+    return false;
+}
+
+int findPalindromicSubarray(vector<int> arr, int k)
+{
+
+    int n = arr.size();
+    int num = 0;
+    for (int i = 0; i < k; i++)
+    {
+        num = num * 10 + arr[i];
+    }
+
+    if (isPalindrome(num))
+    {
+        return 0;
+    }
+
+    for (int j = k; j < n; j++)
+    {
+        num = (num % (int)pow(10, k - 1)) * 10 + arr[j];
+        if (isPalindrome(num))
+        {
+            return j - k + 1;
+        }
+    }
+
+    return -1;
+}
+
+int main()
+{
+    vector<int> arr = {2, 3, 5, 1, 1, 5};
+
+    int k = 4;
+    // int x = 51;
+    int n = arr.size();
+
+    int ans = findPalindromicSubarray(arr, k);
+
+    if (ans == -1)
+    {
+        cout << "DNE" << endl;
+    }
+    else
+    {
+        for (int i = ans; i < ans + k; i++)
+        {
+            cout << arr[i] << " ";
+        }
+        cout << endl;
+    }
+    return 0;
+}

18_SlidingWindowQuestions/5_PerfectNumbersInSubarray.cpp

@@ -0,0 +1,89 @@
+// For a given array and integer k, find the maximum perfect numbers
+// in a subarray of size k.
+// Perfect Number- number which is equal to the sum of its proper
+// divisors(+ve) except for the number itself.
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+bool isNumberPerfect(int num)
+{
+    int sum = 1;
+    for (int i = 2; i < sqrt(num); i++)
+    {
+        if (num % i == 0)
+        {
+            if (i == num / i)
+            {
+                sum += i;
+            }
+            else
+            {
+                sum += i + num / i;
+            }
+        }
+    }
+
+    if (sum == num && num != 1)
+    {
+        return true;
+    }
+
+    return false;   
+}
+
+int maxSum(vector<int> arr, int n, int k)
+{
+    if (n < k)
+    {
+        cout << "NP" << endl;
+        return -1;
+    }
+
+    int sum = 0, res = 0;
+    for (int i = 0; i < k; i++)
+    {
+        sum += arr[i];
+    }
+    res = sum;
+    for (int j = k; j < n; j++)
+    {
+        sum = sum + arr[j] - arr[j - k];
+        res = max(res, sum);
+    }
+
+    return res;
+}
+
+int maxNumberOfPerfects(vector<int> arr, int n, int k)
+{  
+
+    for (int i = 0; i < n; i++)
+    {
+        if (isNumberPerfect(arr[i]))
+        {
+            arr[i] = 1;
+        }
+        else
+        {
+            arr[i] = 0;
+        }
+    }
+
+    return maxSum(arr, n, k);
+}
+
+int main()
+{
+
+    vector<int> arr = {28, 2, 3, 6, 496, 99, 8128, 24 };
+
+    int k = 4;
+
+    int n = arr.size();
+
+    cout << maxNumberOfPerfects(arr, n, k) << endl;
+
+    return 0;
+}