In mathematics, a happy number is defined as a number that eventually reaches 1 when replaced by the sum of the squares of each digit. If this process results in 1, then the number is considered happy; otherwise, it leads to an endless cycle of numbers.

Example: 19 is a happy number because:

1^2 + 9^2 = 1 + 81 = 82
8^2 + 2^2 = 64 + 4 = 68
6^2 + 8^2 = 36 + 64 = 100
1^2 + 0^2 + 0^2 = 1

Since the process eventually reaches 1, 19 is a happy number.

Below are the approaches to check if a given number is Happy or not using Javascript:

Using JavaScript Set

In this approach, we’ll repeatedly square the digits of the number and sum them up until we reach either 1 or encounter a number that has already been seen. We’ll use a set to keep track of the numbers encountered during the process and check if we encounter 1.

Example: To demonstrate checking the given number whether it is a happy number or not using the set data structure.

function isHappy(number) {
    let seen = new Set();
    while (number !== 1 && !seen.has(number)) {
        seen.add(number);
        let sum = 0;
        while (number > 0) {
            let digit = number % 10;
            sum += digit * digit;
            number = Math.floor(number / 10);
        }
        number = sum;
    }
    return number === 1;
}

console.log(isHappy(10));

true

Using Floyd’s Cycle Detection Algorithm

Floyd’s cycle detection algorithm involves using two pointers: one moving twice as fast as the other. If there’s a cycle, the two pointers will eventually meet. In this approach, we’ll apply Floyd’s algorithm to detect cycles in the sequence of numbers generated during the process.

Example: To demonstrate checking the given number whether it a happy number or not using floyd’s cycle detection algorithm.

function getNext(number) {
    let sum = 0;
    while (number > 0) {
        let digit = number % 10;
        sum += digit * digit;
        number = Math.floor(number / 10);
    }
    return sum;
}

function isHappy(number) {
    let slow = number;
    let fast = getNext(number);
    while (fast !== 1 && slow !== fast) {
        slow = getNext(slow);
        fast = getNext(getNext(fast));
    }
    return fast === 1;
}

console.log(isHappy(19));

true

Using Recursion and Memoization

Another approach to determine if a given number is a happy number is to use recursion combined with memoization. Memoization allows us to store the results of previous computations, which can help detect cycles more efficiently and reduce redundant calculations. This approach involves recursively computing the sum of the squares of the digits and using a map to store the intermediate results to detect any cycles.

Example: The following example demonstrates checking if a given number is a happy number using recursion and memoization.

function sumOfSquares(n) {
  let sum = 0;
  while (n > 0) {
    let digit = n % 10;
    sum += digit * digit;
    n = Math.floor(n / 10);
  }
  return sum;
}

function isHappyNumber(n, seen = new Map()) {
  if (n === 1) {
    return true;
  }
  if (seen.has(n)) {
    return false;
  }
  seen.set(n, true);
  const nextNumber = sumOfSquares(n);
  return isHappyNumber(nextNumber, seen);
}

const number = 19;
const result = isHappyNumber(number);
console.log(`${number} is a happy number: ${result}`); // Output: 19 is a happy number: true

19 is a happy number: true