Friday, January 10, 2025
Google search engine
HomeData Modelling & AILength of largest subarray whose all elements are Perfect Number

Length of largest subarray whose all elements are Perfect Number

Given an array arr[] of integer elements, the task is to find the length of the largest sub-array of arr[] such that all the elements of the sub-array are Perfect number.
 

A perfect number is a positive integer that is equal to the sum of its proper divisors
 

Examples: 
 

Input: arr[] = {1, 7, 36, 4, 6, 28, 4} 
Output:
Explanation: 
Maximum length sub-array with all elements as perfect number is {6, 28}.
Input: arr[] = {25, 100, 2, 3, 9, 1} 
Output:
Explanation: 
None of the number is a perfect number 
 

 

Approach: 
 

  • Traverse the array from left to right and initialize a max_length and current_length variable with 0.
  • If the current element is a perfect number then increment current_length variable and continuethe process. Otherwise, set current_length to 0.
  • At each step, assign max_length as max_length = max(current_length, max_length).
  • Print the value of max_length in the end as it will store the required result.

Below is the implementation of the above approach:
 

C++




// C++ program to find the length of the
// largest sub-array of an array every
// element of whose is a perfect number
 
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if n is perfect
bool isPerfect(long long int n)
{
    // Variable to store sum of divisors
    long long int sum = 1;
 
    // Find all divisors and add them
    for (long long int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            if (i * i != n)
                sum = sum + i + n / i;
            else
                sum = sum + i;
        }
    }
    // Check if sum of divisors is equal to
    // n, then n is a perfect number
    if (sum == n && n != 1)
        return true;
 
    return false;
}
 
// Function to return the length of the
// largest sub-array of an array every
// element of whose is a perfect number
int contiguousPerfectNumber(int arr[], int n)
{
 
    int current_length = 0;
    int max_length = 0;
 
    for (int i = 0; i < n; i++) {
 
        // Check if arr[i] is a perfect number
        if (isPerfect(arr[i]))
            current_length++;
        else
            current_length = 0;
 
        max_length = max(max_length,
                         current_length);
    }
 
    return max_length;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 7, 36, 4, 6, 28, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << contiguousPerfectNumber(arr, n);
 
    return 0;
}


Java




// Java program to find the length of the
// largest sub-array of an array every
// element of whose is a perfect number
 
import java.util.*;    
 
class GFG
{
    // Function that returns true if n is perfect
    static boolean isPerfect(int n)
    {
        // Variable to store sum of divisors
        int sum = 1;
        int i;
         
        // Find all divisors and add them
        for ( i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                if (i * i != n)
                    sum = sum + i + n / i;
                else
                    sum = sum + i;
            }
        }
         
        // Check if sum of divisors is equal to
        // n, then n is a perfect number
        if (sum == n && n != 1)
            return true;
     
        return false;
    }
     
    // Function to return the length of the
    // largest sub-array of an array every
    // element of whose is a perfect number
    static int contiguousPerfectNumber(int arr[], int n)
    {
     
        int current_length = 0;
        int max_length = 0;
        int i;
        for (i = 0; i < n; i++) {
     
            // Check if arr[i] is a perfect number
            if (isPerfect(arr[i]))
                current_length++;
            else
                current_length = 0;
     
            max_length = Math.max(max_length,
                            current_length);
        }
     
        return max_length;
    }
     
    // Driver code
    public static void main(String []args)
    {
        int arr[] = { 1, 7, 36, 4, 6, 28, 4 };
        int n = arr.length;
     
        System.out.print(contiguousPerfectNumber(arr, n));
     
    }
}
 
//This code is contributed by chitranayal


Python3




# Python 3 program to find the length of
# the largest sub-array of an array every
# element of whose is a perfect number
 
 
# Function that returns true if n is perfect
def isPerfect( n ):
     
    # To store sum of divisors
    sum = 1
     
    # Find all divisors and add them
    i = 2
    while i * i <= n:
        if n % i == 0:
            sum = sum + i + n / i
        i += 1
     
    # check if the sum of divisors is equal to
    # n, then n is a perfect number
     
    return (True if sum == n and n != 1 else False)
 
 
# Function to return the length of the
# largest sub-array of an array every
# element of whose is a perfect number
def contiguousPerfectNumber(arr, n):
    current_length = 0
    max_length = 0
 
    for i in range(0, n, 1):
         
        # check if arr[i] is a perfect number
        if (isPerfect(arr[i])):
            current_length += 1
        else:
            current_length = 0
 
        max_length = max(max_length,
                        current_length)
     
    return max_length
 
# Driver code
if __name__ == '__main__':
    arr = [1, 7, 36, 4, 6, 28, 4]
    n = len(arr)
 
    print(contiguousPerfectNumber(arr, n))


C#




// C# program to find the length of the
// largest sub-array of an array every
// element of whose is a perfect number
using System;
 
class GFG{
     
// Function that returns true if n is perfect
static bool isPerfect(int n)
{
     
    // Variable to store sum of divisors
    int sum = 1;
    int i;
         
    // Find all divisors and add them
    for(i = 2; i * i <= n; i++)
    {
       if (n % i == 0)
       {
           if (i * i != n)
               sum = sum + i + n / i;
           else
               sum = sum + i;
       }
    }
         
    // Check if sum of divisors is equal to
    // n, then n is a perfect number
    if (sum == n && n != 1)
    {
        return true;
    }
    return false;
}
     
// Function to return the length of the
// largest sub-array of an array every
// element of whose is a perfect number
static int contiguousPerfectNumber(int []arr,
                                   int n)
{
    int current_length = 0;
    int max_length = 0;
    int i;
    for(i = 0; i < n; i++)
    {
        
       // Check if arr[i] is a perfect number
       if (isPerfect(arr[i]))
       {
           current_length++;
       }
       else
       {
           current_length = 0;
       }
       max_length = Math.Max(max_length,
                             current_length);
    }
    return max_length;
}
     
// Driver code
public static void Main(String []args)
{
    int []arr = { 1, 7, 36, 4, 6, 28, 4 };
    int n = arr.Length;
     
    Console.Write(contiguousPerfectNumber(arr, n));
}
}
 
// This code is contributed by sapnasingh4991


Javascript




<script>
 
// Javascript program to find the length of the
// largest sub-array of an array every
// element of whose is a perfect number
  
    // Function that returns true if n is perfect
    function isPerfect(n)
    {
        // Variable to store sum of divisors
        let sum = 1;
        let i;
           
        // Find all divisors and add them
        for ( i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                if (i * i != n)
                    sum = sum + i + n / i;
                else
                    sum = sum + i;
            }
        }
           
        // Check if sum of divisors is equal to
        // n, then n is a perfect number
        if (sum == n && n != 1)
            return true;
       
        return false;
    }
       
    // Function to return the length of the
    // largest sub-array of an array every
    // element of whose is a perfect number
    function contiguousPerfectNumber(arr, n)
    {
       
        let current_length = 0;
        let max_length = 0;
        let i;
        for (i = 0; i < n; i++) {
       
            // Check if arr[i] is a perfect number
            if (isPerfect(arr[i]))
                current_length++;
            else
                current_length = 0;
       
            max_length = Math.max(max_length,
                            current_length);
        }
       
        return max_length;
    }
 
// Driver Code
     
    let arr = [ 1, 7, 36, 4, 6, 28, 4 ];
    let n = arr.length;
       
    document.write(contiguousPerfectNumber(arr, n));
             
</script>


Output: 

2

 

Time Complexity: O(N×?N)
Auxiliary Space Complexity: O(1), since no extra space has been taken.
 

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments