Wednesday, September 25, 2024
Google search engine
HomeData Modelling & AIPrint all Perfect Numbers from an array whose sum of digits is...

Print all Perfect Numbers from an array whose sum of digits is also a Perfect Number

Given an array arr[] of size N, the task is to print all the perfect numbers from an array whose sum of digits is also a perfect number.

Examples:

Input: arr[] = { 3, 8, 12, 28, 6 }
Output: 6
Explanation: The array element arr[4] (= 6) is a perfect number. The array element arr[3] (= 28) is a perfect number but its sum of digits (= 10) is not a perfect number.

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

Approach: Follow the steps below to solve the problem:

  1. Declare a function, isPerfect() to check if the number is a perfect number or not.
  2. Declare another function, sumOfDigits() to calculate the sum of all the digits of a number.
  3. Traverse the array arr[]:
    • If arr[i] is a perfect number:
      • Initialize a variable, say digitSum, to store the sum of digits of the current array element.
      • If digitSum is also a perfect number, print that number.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if a number
// is perfect number or not
int isPerfect(int N)
{
    // Stores sum of proper divisors
    int sumOfDivisors = 1;
    for (int i = 2; i <= N / 2; ++i) {
       
        if (N % i == 0) {
            sumOfDivisors += i;
        }
    }
 
    // If sum of digits is equal to N,
    // then it's a perfect number
    if (sumOfDivisors == N) {
        return 1;
    }
 
    // Otherwise, not a perfect number
    else
        return 0;
}
 
// Function to find the
// sum of digits of a number
int sumOfDigits(int N)
{
    // Stores sum of digits
    int sum = 0;
 
    while (N != 0) {
        sum += (N % 10);
        N = N / 10;
    }
 
    // Return sum of digits
    return sum;
}
 
// Function to count perfect numbers from
// an array whose sum of digits is also perfect
void countPerfectNumbers(int arr[], int N)
{
    // Traverse the array
    for (int i = 0; i < N; ++i) {
       
        // If number is perfect
        if (isPerfect(arr[i])) {
           
            // Stores sum of digits
            // of the number
            int sum = sumOfDigits(arr[i]);
 
            // If that is also perfect number
            if (isPerfect(sum)) {
               
                // Print that number
                cout << arr[i] << " ";
            }
        }
    }
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 3, 8, 12, 28, 6 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call to count perfect numbers
    // having sum of digits also perfect
    countPerfectNumbers(arr, N);
 
    return 0;
}


Java




// Java Program to implement
// the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
  // Function to check if a number
  // is perfect number or not
  static boolean isPerfect(int N)
  {
    // Stores sum of proper divisors
    int sumOfDivisors = 1;
    for (int i = 2; i <= N / 2; ++i) {
 
      if (N % i == 0) {
        sumOfDivisors += i;
      }
    }
 
    // If sum of digits is equal to N,
    // then it's a perfect number
    if (sumOfDivisors == N) {
      return true;
    }
 
    // Otherwise, not a perfect number
    else
      return false;
  }
 
  // Function to find the
  // sum of digits of a number
  static int sumOfDigits(int N)
  {
    // Stores sum of digits
    int sum = 0;
 
    while (N != 0) {
      sum += (N % 10);
      N = N / 10;
    }
 
    // Return sum of digits
    return sum;
  }
 
  // Function to count perfect numbers from
  // an array whose sum of digits is also perfect
  static void countPerfectNumbers(int arr[], int N)
  {
    // Traverse the array
    for (int i = 0; i < N; ++i) {
 
      // If number is perfect
      if (isPerfect(arr[i])) {
 
        // Stores sum of digits
        // of the number
        int sum = sumOfDigits(arr[i]);
 
        // If that is also perfect number
        if (isPerfect(sum)) {
 
          // Print that number
          System.out.print(arr[i] + " ");
        }
      }
    }
  }
 
  // Driver Code
  public static void main(String[] args)
  {
     
    // Given array
    int arr[] = { 3, 8, 12, 28, 6 };
 
    // Size of the array
    int N = arr.length;
 
    // Function call to count perfect numbers
    // having sum of digits also perfect
    countPerfectNumbers(arr, N);
  }
}
 
// This code is contributed by Kingash.


Python3




# Python Program to implement
# the above approach
 
# Function to check if a number
# is perfect number or not
def isPerfect(N):
   
    # Stores sum of proper divisors
    sumOfDivisors = 1;
    for i in range(2, int(N / 2) + 1):
 
        if (N % i == 0):
            sumOfDivisors += i;
 
    # If sum of digits is equal to N,
    # then it's a perfect number
    if (sumOfDivisors == N):
        return True;
 
    # Otherwise, not a perfect number
    else:
        return False;
 
# Function to find the
# sum of digits of a number
def sumOfDigits(N):
   
    # Stores sum of digits
    sum = 0;
 
    while (N != 0):
        sum += (N % 10);
        N = N // 10;
 
    # Return sum of digits
    return sum;
 
# Function to count perfect numbers from
# an array whose sum of digits is also perfect
def countPerfectNumbers(arr, N):
   
    # Traverse the array
    for i in range(N):
 
        # If number is perfect
        if (isPerfect(arr[i])):
 
            # Stores sum of digits
            # of the number
            sum = sumOfDigits(arr[i]);
 
            # If that is also perfect number
            if (isPerfect(sum)):
               
                # Print that number
                print(arr[i], end=" ");
 
# Driver Code
if __name__ == '__main__':
   
    # Given array
    arr = [3, 8, 12, 28, 6];
 
    # Size of the array
    N = len(arr);
 
    # Function call to count perfect numbers
    # having sum of digits also perfect
    countPerfectNumbers(arr, N);
 
    # This code is contributed by 29AjayKumar


C#




// C# program for the above approach
using System;
class GFG
{
 
  // Function to check if a number
  // is perfect number or not
  static bool isPerfect(int N)
  {
     
    // Stores sum of proper divisors
    int sumOfDivisors = 1;
    for (int i = 2; i <= N / 2; ++i) {
 
      if (N % i == 0) {
        sumOfDivisors += i;
      }
    }
 
    // If sum of digits is equal to N,
    // then it's a perfect number
    if (sumOfDivisors == N) {
      return true;
    }
 
    // Otherwise, not a perfect number
    else
      return false;
  }
 
  // Function to find the
  // sum of digits of a number
  static int sumOfDigits(int N)
  {
     
    // Stores sum of digits
    int sum = 0;
 
    while (N != 0) {
      sum += (N % 10);
      N = N / 10;
    }
 
    // Return sum of digits
    return sum;
  }
 
  // Function to count perfect numbers from
  // an array whose sum of digits is also perfect
  static void countPerfectNumbers(int []arr, int N)
  {
     
    // Traverse the array
    for (int i = 0; i < N; ++i) {
 
      // If number is perfect
      if (isPerfect(arr[i])) {
 
        // Stores sum of digits
        // of the number
        int sum = sumOfDigits(arr[i]);
 
        // If that is also perfect number
        if (isPerfect(sum)) {
 
          // Print that number
          Console.Write(arr[i] + " ");
        }
      }
    }
  }
 
// Driver Code
static public void Main()
{
   
    // Given array
    int []arr = { 3, 8, 12, 28, 6 };
 
    // Size of the array
    int N = arr.Length;
 
    // Function call to count perfect numbers
    // having sum of digits also perfect
    countPerfectNumbers(arr, N);
}
}
 
// This code is contributed by jana_sayantan.


Javascript




<script>
// JavaScript program for the above approach
 
// Function to check if a number
// is perfect number or not
function isPerfect(N)
{
 
    // Stores sum of proper divisors
    let sumOfDivisors = 1;
    for (let i = 2; i <= Math.floor(N / 2); ++i)
    {
     
        if (N % i === 0)
        {
            sumOfDivisors += i;
        }
    }
 
    // If sum of digits is equal to N,
    // then it's a perfect number
    if (sumOfDivisors === N) {
        return 1;
    }
 
    // Otherwise, not a perfect number
    else
        return 0;
}
 
// Function to find the
// sum of digits of a number
function sumOfDigits(N)
{
    // Stores sum of digits
    let sum = 0;
 
    while (N != 0) {
        sum += (N % 10);
        N = Math.floor(N / 10);
    }
 
    // Return sum of digits
    return sum;
}
 
// Function to count perfect numbers from
// an array whose sum of digits is also perfect
function countPerfectNumbers(arr, N)
{
    // Traverse the array
    for (let i = 0; i < N; ++i) {
     
        // If number is perfect
        if (isPerfect(arr[i])) {
         
            // Stores sum of digits
            // of the number
            let sum = sumOfDigits(arr[i]);
 
            // If that is also perfect number
            if (isPerfect(sum)) {
             
                // Print that number
                document.write(arr[i] + " ");
            }
        }
    }
}
 
// Driver Code
 
    // Given array
    let arr = [ 3, 8, 12, 28, 6 ];
 
    // Size of the array
    let N = arr.length;
 
    // Function call to count perfect numbers
    // having sum of digits also perfect
    countPerfectNumbers(arr, N);
 
// This code is contributed by Surbhi Tyagi.
</script>


Output: 

6

 

Time Complexity: O(N3 * log N)
Auxiliary Space: O(1)

 

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