Step by Step solution about How to resolve the algorithm Abundant, deficient and perfect number classifications step by step in the C++ programming language

This C++ program finds the number of deficient, perfect, and abundant numbers between 1 and 20000.

Here's how the program works:

1. The program includes necessary header files like <iostream>, <algorithm>, and <vector>.

2. The findProperDivisors function takes an integer n and finds all its proper divisors (divisors excluding the number itself). It iterates through numbers from 1 to n/2 and checks if n is divisible by each number. If so, it adds the divisor to the divisors vector.

3. In the main function:

   • Three vectors, deficients, perfects, and abundants, are used to store deficient, perfect, and abundant numbers, respectively.
   • A loop iterates through numbers from 1 to 20000.
   • For each number n, it calls the findProperDivisors function to find its proper divisors and stores them in the divisors vector.
   • It calculates the sum of the divisors using std::accumulate.
   • Based on the relationship between the sum and n, it categorizes the number as deficient, perfect, or abundant.
   • Deficient numbers have a divisor sum less than n, perfect numbers have a divisor sum equal to n, and abundant numbers have a divisor sum greater than n.

4. Finally, the program prints the count of deficient, perfect, and abundant numbers found within the given range.

Example output:

Deficient : 14892
Perfect   : 3
Abundant  : 4622

#include <iostream>
#include <algorithm>
#include <vector>

std::vector<int> findProperDivisors ( int n ) {
   std::vector<int> divisors ;
   for ( int i = 1 ; i < n / 2 + 1 ; i++ ) {
      if ( n % i == 0 ) 
	 divisors.push_back( i ) ;
   }
   return divisors  ;
}

int main( ) {
   std::vector<int> deficients , perfects , abundants , divisors ;
   for ( int n = 1 ; n < 20001 ; n++ ) {
      divisors = findProperDivisors( n ) ;
      int sum = std::accumulate( divisors.begin( ) , divisors.end( ) , 0 ) ;
      if ( sum < n ) {
	 deficients.push_back( n ) ;
      }
      if ( sum == n ) {
	 perfects.push_back( n ) ;
      }
      if ( sum > n ) {
	 abundants.push_back( n ) ;
      }
   }
   std::cout << "Deficient : " << deficients.size( ) << std::endl ;
   std::cout << "Perfect   : " << perfects.size( ) << std::endl ;
   std::cout << "Abundant  : " << abundants.size( ) << std::endl ;
   return 0 ;
}