JavaScript Program to Check Abundant Number

Posted in JavaScript Tutorial

Updated on Jan 11, 2024

By Mari Selvan

👁️ 90 - Views

⏳ 4 mins

💬 1 Comment

JavaScript Program to Check Abundant Number

Photo Credit to CodeToFun

🙋 Introduction

In the realm of programming, understanding and identifying special types of numbers is a fascinating exploration. One such category is abundant numbers.

An abundant number, also known as an excessive number, is a positive integer that is smaller than the sum of its proper divisors (excluding itself).

In this tutorial, we will dive into a JavaScript program designed to check whether a given number is an abundant number or not.

The program will employ logic to calculate the sum of the proper divisors of a number and determine if it exceeds the number itself.

📄 Example

Let's take a look at the JavaScript code that achieves this functionality.

isAbundant.js

Copied

// Function to check if a number is abundant
function isAbundant(num) {
  let sum = 1; // Start with 1 as every number is divisible by 1

  // Iterate from 2 to the square root of the number
  for (let i = 2; i * i <= num; ++i) {
    if (num % i === 0) {
      sum += i;
      if (i !== num / i) {
        sum += num / i;
      }
    }
  }

  // If the sum of divisors exceeds the number, it is abundant
  return sum > num;
}

// Driver program
// Replace this value with your desired number
const number = 12;

// Check if the number is abundant
if (isAbundant(number)) {
  console.log(`${number} is an abundant number.`);
} else {
  console.log(`${number} is not an abundant number.`);
}

💻 Testing the Program

To test the program with different numbers, simply replace the value of number in the code.

Output

12 is an abundant number.

Run the script to check if the number is an abundant number.

🧠 How the Program Works

The program defines a function isAbundant that takes a number as input and returns true if the number is abundant and false otherwise.
The program defines a function isAbundant that takes a number as input and returns true if the number is abundant and false otherwise.
For each divisor found, it adds it to the sum, including the corresponding divisor on the other side of the square root.
For each divisor found, it adds it to the sum, including the corresponding divisor on the other side of the square root.

📏 Between the Given Range

Let's dive into the JavaScript code that identifies abundant numbers within the given range.

findAbundantNumbersInRange.js

Copied

// Function to check if a number is abundant
function isAbundantNumber(number) {
  let sum = 1; // Start with 1 as it is always a divisor

  // Iterate from 2 to the square root of the number
  for (let i = 2; i * i <= number; i++) {
    if (number % i === 0) {
      sum += i;

      // If the divisors are not the same, add the other divisor
      if (i * i !== number) {
        sum += number / i;
      }
    }
  }

  // Check if the sum of divisors is greater than the number
  return sum > number;
}

// Function to find abundant numbers in a given range
function findAbundantNumbersInRange(start, end) {
  console.log(`Abundant numbers between ${start} and ${end}: `);

  for (let i = start; i <= end; i++) {
    if (isAbundantNumber(i)) {
      console.log(i);
    }
  }
}

// Define the range
const startRange = 1;
const endRange = 50;

// Call the function to find abundant numbers in the range
findAbundantNumbersInRange(startRange, endRange);

💻 Testing the Program

The program is set to check for abundant numbers in the range from 1 to 50. You can adjust the range by modifying the values of startRange and endRange in the code.

Output

Abundant numbers between 1 and 50:
12 18 20 24 30 36 40 42 48

Run the script to see the abundant numbers within the specified range.

🧠 How the Program Works

The program defines a function isAbundantNumber that checks if a given number is abundant.
Inside the function, it iterates through potential divisors up to the square root of the number, summing up proper divisors.
Another function, findAbundantNumbersInRange, iterates through the specified range and calls the isAbundantNumber function to identify and print abundant numbers.

🧐 Understanding the Concept of Abundant Number

Before diving into the code, let's take a moment to understand abundant numbers. An abundant number is a positive integer for which the sum of its proper divisors (excluding itself) is greater than the number itself.

For example, the number 12 is abundant because its divisors (excluding 12) are 1, 2, 3, 4, 6, and the sum of these divisors is 16, which is greater than 12.

🎢 Optimizing the Program

While the provided program is effective, there are opportunities for optimization, such as caching previously calculated divisor sums to avoid redundant computations.

Feel free to incorporate and modify this code as needed for your specific use case. Happy coding!