Related Articles
Maximum number of Perfect Numbers present in a subarray of size K
• Difficulty Level : Hard
• Last Updated : 26 Oct, 2020

Given an array arr[ ] consisting of N integers, the task is to determine the maximum number of perfect Numbers in any subarray of size K.

Examples:

Input: arr[ ] = {28, 2, 3, 6, 496, 99, 8128, 24}, K = 4
Output: 3
Explanation: The sub-array {6, 496, 99, 8128} has 3 perfect numbers which is maximum.

Input: arr[ ]= {1, 2, 3, 6}, K=2
Output: 1

Naive Approach: The approach is to generate all possible subarrays of size K and for each subarray, count the number of elements that are a Perfect Number. Print the maximum count obtained for any subarray.

Time Complexity: O(N*K)
Auxiliary Space: O(1)

Efficient Approach:
To optimize the above approach, convert the given array arr[ ] into a binary array where the ith element is 1 if it is a Perfect Number. Otherwise, the ith element is 0. Therefore, the problem reduces to finding the maximum sum subarray of size K in the binary array using the Sliding Window technique. Follow the steps below to solve the problem:

1. Traverse the array and for each element of the array arr[], check if it is a Perfect Number or not.
2. If arr[i] is a Perfect Number then convert arr[i] equal to 1. Otherwise, convert arr[i] equal to 0.
3. To check if a number is a perfect number or not:
1. Initialize a variable sum to store the sum of divisors.
2. Traverse every number in the range [1, arr[i] – 1] and check if it is a divisor of arr[i] or not. Add all the divisors.
3. If the sum of all the divisors is equal to arr[i], then the number is a perfect number. Otherwise, the number is not a Perfect Number.
4. Compute the sum of the first subarray of size K in the modified array.
5. Using the sliding window technique, find the maximum sum of a subarray from all possible subarrays of size K.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to check a number` `// is Perfect Number or not` `int` `isPerfect(``int` `N)` `{` `    ``// Stores sum of divisors` `    ``int` `sum = 1;`   `    ``// Find all divisors and add them` `    ``for` `(``int` `i = 2; i < ``sqrt``(N); i++) ` `    ``{`   `        ``if` `(N % i == 0) {`   `            ``if` `(i == N / i) ` `            ``{`   `                ``sum += i;` `            ``}` `            ``else` `            ``{`   `                ``sum += i + N / i;` `            ``}` `        ``}` `    ``}`   `    ``// If sum of divisors` `    ``// is equal to N` `    ``if` `(sum == N && N != 1)` `        ``return` `1;`   `    ``return` `0;` `}`   `// Function to return maximum` `// sum of a subarray of size K` `int` `maxSum(``int` `arr[], ``int` `N, ``int` `K)` `{` `    ``// If k is greater than N` `    ``if` `(N < K) ` `    ``{`   `        ``cout << ``"Invalid"``;` `        ``return` `-1;` `    ``}`   `    ``// Compute sum of first window of size K` `    ``int` `res = 0;` `    ``for` `(``int` `i = 0; i < K; i++) ` `    ``{`   `        ``res += arr[i];` `    ``}`   `    ``// Compute sums of remaining windows by` `    ``// removing first element of previous` `    ``// window and adding last element of` `    ``// current window` `    ``int` `curr_sum = res;` `    ``for` `(``int` `i = K; i < N; i++) ` `    ``{`   `        ``curr_sum += arr[i] - arr[i - K];` `        ``res = max(res, curr_sum);` `    ``}`   `    ``// return the answer` `    ``return` `res;` `}`   `// Function to find all the` `// perfect numbers in the array` `int` `max_PerfectNumbers(``int` `arr[], ``int` `N, ``int` `K)` `{` `    ``// The given array is converted into binary array` `    ``for` `(``int` `i = 0; i < N; i++) ` `    ``{`   `        ``arr[i] = isPerfect(arr[i]) ? 1 : 0;` `    ``}`   `    ``return` `maxSum(arr, N, K);` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 28, 2, 3, 6, 496, 99, 8128, 24 };` `    ``int` `K = 4;` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``cout << max_PerfectNumbers(arr, N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for the ` `// above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to check a number` `// is Perfect Number or not` `static` `int` `isPerfect(``int` `N)` `{` `  ``// Stores sum of divisors` `  ``int` `sum = ``1``;`   `  ``// Find all divisors and ` `  ``// add them` `  ``for` `(``int` `i = ``2``; ` `           ``i < Math.sqrt(N); i++) ` `  ``{` `    ``if` `(N % i == ``0``) ` `    ``{` `      ``if` `(i == N / i)` `      ``{` `        ``sum += i;` `      ``}` `      ``else` `      ``{` `        ``sum += i + N / i;` `      ``}` `    ``}` `  ``}`   `  ``// If sum of divisors` `  ``// is equal to N` `  ``if` `(sum == N && N != ``1``)` `    ``return` `1``;` `  `  `  ``return` `0``;` `}`   `// Function to return maximum` `// sum of a subarray of size K` `static` `int` `maxSum(``int` `arr[], ` `                  ``int` `N, ``int` `K)` `{` `  ``// If k is greater than N` `  ``if` `(N < K) ` `  ``{` `    ``System.out.print(``"Invalid"``);` `    ``return` `-``1``;` `  ``}`   `  ``// Compute sum of first ` `  ``// window of size K` `  ``int` `res = ``0``;` `  `  `  ``for` `(``int` `i = ``0``; i < K; i++) ` `  ``{` `    ``res += arr[i];` `  ``}`   `  ``// Compute sums of remaining windows by` `  ``// removing first element of previous` `  ``// window and adding last element of` `  ``// current window` `  ``int` `curr_sum = res;` `  `  `  ``for` `(``int` `i = K; i < N; i++) ` `  ``{` `    ``curr_sum += arr[i] - arr[i - K];` `    ``res = Math.max(res, curr_sum);` `  ``}`   `  ``// return the answer` `  ``return` `res;` `}`   `// Function to find all the` `// perfect numbers in the array` `static` `int` `max_PerfectNumbers(``int` `arr[], ` `                              ``int` `N, ``int` `K)` `{` `  ``// The given array is converted ` `  ``// into binary array` `  ``for` `(``int` `i = ``0``; i < N; i++) ` `  ``{` `    ``arr[i] = isPerfect(arr[i]) == ` `             ``1` `? ``1` `: ``0``;` `  ``}`   `  ``return` `maxSum(arr, N, K);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``int` `arr[] = {``28``, ``2``, ``3``, ``6``, ``496``,` `               ``99``, ``8128``, ``24``};` `  ``int` `K = ``4``;` `  ``int` `N = arr.length;` `  ``System.out.print(max_PerfectNumbers(arr, ` `                                      ``N, K));` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach`   `# Function to check a number` `# is Perfect Number or not` `def` `isPerfect(N):` `    `  `    ``# Stores sum of divisors` `    ``sum` `=` `1`   `    ``# Find all divisors and add them` `    ``for` `i ``in` `range``(``2``, N):` `        ``if` `i ``*` `i > N:` `            ``break`   `        ``if` `(N ``%` `i ``=``=` `0``):` `            ``if` `(i ``=``=` `N ``/``/` `i):` `                ``sum` `+``=` `i` `            ``else``:` `                ``sum` `+``=` `i ``+` `N ``/``/` `i`   `    ``# If sum of divisors` `    ``# is equal to N` `    ``if` `(``sum` `=``=` `N ``and` `N !``=` `1``):` `        ``return` `1`   `    ``return` `0`   `# Function to return maximum` `# sum of a subarray of size K` `def` `maxSum(arr, N, K):` `    `  `    ``# If k is greater than N` `    ``if` `(N < K):` `        ``print``(``"Invalid"``)` `        ``return` `-``1`   `    ``# Compute sum of first ` `    ``# window of size K` `    ``res ``=` `0` `    `  `    ``for` `i ``in` `range``(K):` `        ``res ``+``=` `arr[i]`   `    ``# Compute sums of remaining windows by` `    ``# removing first element of previous` `    ``# window and adding last element of` `    ``# current window` `    ``curr_sum ``=` `res` `    `  `    ``for` `i ``in` `range``(K, N):` `        ``curr_sum ``+``=` `arr[i] ``-` `arr[i ``-` `K]` `        ``res ``=` `max``(res, curr_sum)` `        `  `    ``# print(res)`   `    ``# Return the answer` `    ``return` `res`   `# Function to find all the` `# perfect numbers in the array` `def` `max_PerfectNumbers(arr, N, K):` `    `  `    ``# The given array is converted` `    ``# into binary array` `    ``for` `i ``in` `range``(N):` `        ``if` `isPerfect(arr[i]):` `            ``arr[i] ``=` `1` `        ``else``:` `            ``arr[i] ``=` `0`   `    ``return` `maxSum(arr, N, K)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``arr ``=` `[ ``28``, ``2``, ``3``, ``6``, ` `            ``496``, ``99``, ``8128``, ``24` `]` `    ``K ``=` `4` `    ``N ``=` `len``(arr)`   `    ``print``(max_PerfectNumbers(arr, N, K))` `    `  `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the ` `// above approach` `using` `System;` `class` `GFG{`   `// Function to check a number` `// is Perfect Number or not` `static` `int` `isPerfect(``int` `N)` `{` `  ``// Stores sum of divisors` `  ``int` `sum = 1;`   `  ``// Find all divisors and ` `  ``// add them` `  ``for` `(``int` `i = 2; ` `           ``i < Math.Sqrt(N); i++) ` `  ``{` `    ``if` `(N % i == 0) ` `    ``{` `      ``if` `(i == N / i)` `      ``{` `        ``sum += i;` `      ``}` `      ``else` `      ``{` `        ``sum += i + N / i;` `      ``}` `    ``}` `  ``}`   `  ``// If sum of divisors` `  ``// is equal to N` `  ``if` `(sum == N && N != 1)` `    ``return` `1;` `  `  `  ``return` `0;` `}`   `// Function to return maximum` `// sum of a subarray of size K` `static` `int` `maxSum(``int` `[]arr, ` `                  ``int` `N, ``int` `K)` `{` `  ``// If k is greater than N` `  ``if` `(N < K) ` `  ``{` `    ``Console.Write(``"Invalid"``);` `    ``return` `-1;` `  ``}`   `  ``// Compute sum of first ` `  ``// window of size K` `  ``int` `res = 0;` `  `  `  ``for` `(``int` `i = 0; i < K; i++) ` `  ``{` `    ``res += arr[i];` `  ``}`   `  ``// Compute sums of remaining ` `  ``// windows by removing first ` `  ``// element of previous window ` `  ``// and adding last element of` `  ``// current window` `  ``int` `curr_sum = res;` `  `  `  ``for` `(``int` `i = K; i < N; i++) ` `  ``{` `    ``curr_sum += arr[i] - arr[i - K];` `    ``res = Math.Max(res, curr_sum);` `  ``}`   `  ``// return the answer` `  ``return` `res;` `}`   `// Function to find all the` `// perfect numbers in the array` `static` `int` `max_PerfectNumbers(``int` `[]arr, ` `                              ``int` `N, ``int` `K)` `{` `  ``// The given array is converted ` `  ``// into binary array` `  ``for` `(``int` `i = 0; i < N; i++) ` `  ``{` `    ``arr[i] = isPerfect(arr[i]) == ` `             ``1 ? 1 : 0;` `  ``}`   `  ``return` `maxSum(arr, N, K);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``int` `[]arr = {28, 2, 3, 6, 496,` `               ``99, 8128, 24};` `  ``int` `K = 4;` `  ``int` `N = arr.Length;` `  ``Console.Write(max_PerfectNumbers(arr, ` `                                   ``N, K));` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:

```3
```

Time Complexity: O( N * sqrt(N)  )
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :