Check Happy Number in JavaScript

Beginner
⏱️ 9 min read
📚 Updated: May 2026
🎯 2 Code examples + Try it
Cycle detection

What you’ll learn

  • The happy iteration: replace n by the sum of squared decimal digits until 1 or a repeat.
  • Visited-sum detection with a Set until you hit 1 or repeat (see FAQ for Floyd’s O(1)-memory variant).
  • A range scan for happy numbers in [1, 50], plus a live preview and unhappy-cycle notes.

Overview

Happy numbers are a small playground for iteration and cycle detection. The digit-square map has finite image for bounded n, so every orbit eventually cycles; our programs remember visited sums in a Set until 1 or the first repeat.

Two programs

19 classification and 1–50 listing from the reference.

Live preview

Positive safe integers; same visited-sum logic as the tutorial scripts.

Rigor

Positive definition, known unhappy cycle, and why storing visited sums correctly spots repeats.

Prerequisites

Digit extraction with % 10 and Math.floor(n / 10), loops, and functions returning booleans.

  • console.log, Number.isSafeInteger, for loops.
  • Set / object maps for visited values; Floyd (FAQ) trades memory for two pointers.

What is a happy number?

Let f(n) be the sum of the squares of the decimal digits of n. Starting from a positive integer n, iterate n ← f(n). If you reach 1, the start was happy; otherwise you enter a cycle that never contains 1.

For 19: 82 → 68 → 100 → 1, so 19 is happy (as in the reference walkthrough).

Happy orbit hits 1
Unhappy cycle ≠ {1}
Fixed point f(1)=1

Digit map

For n = ∑ di 10i with digits di ∈ {0,…,9}, define f(n) = ∑ di2. Happy numbers are exactly those n whose forward orbit under f reaches 1.

f(19)

12 + 92 = 82, then 82 + 22 = 68, 62 + 82 = 100, 12 + 02 + 02 = 1.

Intuition

19 Happy
Path
82 → 68 → 100 → 1
2 Unhappy
Enters
4 → 16 → … cycle

Takeaway: you never need unbounded memory: either you hit 1 or you eventually repeat.

Live preview

Positive integers in the JavaScript safe range. Uses the same Set-based detector as the examples below.

Try 1, 7, 2, or 23.

Live result
Press “Check happy”.

Algorithm

Goal: decide whether iterating f (sum of squared digits) reaches 1.

Implement f(n)

Peel decimal digits with n % 10, square, accumulate, assign n = Math.floor(n / 10).

Detect repeat or reach 1

Keep applying f. If 1 appears, happy. If you revisit any earlier sum, you found a non-1 cycle (not happy). A Set stores visited sums; Floyd (FAQ) does this with O(1) extra memory instead.

📜 Pseudocode

Pseudocode
function sum_square_digits(n):
    s = 0
    while n > 0:
        d = n mod 10
        s += d * d
        n = floor(n / 10)
    return s

function is_happy(n):
    seen = empty set
    cur = n
    while cur != 1:
        if cur in seen:
            return false
        seen.add(cur)
        cur = sum_square_digits(cur)
    return true
1

Single value: 19

Same structure as the reference: sumOfSquares, isHappy with a visited Set. Rejects n < 1 before classifying.

JavaScript
function sumOfSquares(n) {
  let sum = 0;

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

  return sum;
}

function isHappy(n) {
  const seen = new Set();
  let cur = n;

  while (cur !== 1) {
    if (seen.has(cur)) {
      return false;
    }

    seen.add(cur);
    cur = sumOfSquares(cur);
  }

  return true;
}

const number = 19;

if (number < 1) {
  console.log("Use a positive integer.");
} else if (isHappy(number)) {
  console.log(number + " is a Happy Number.");
} else {
  console.log(number + " is not a Happy Number.");
}
Try it Yourself

Explanation

When n = 1, the while guard fails immediately and returns true. Otherwise each new sum is checked against seen before continuing.

2

Happy numbers in [1, 50]

Same output as the reference listing. Prints the header line, then space-separated happy values, then a newline.

JavaScript
function sumOfSquares(num) {
  let sum = 0;

  while (num > 0) {
    const digit = num % 10;
    sum += digit * digit;
    num = Math.floor(num / 10);
  }

  return sum;
}

function isHappy(num) {
  const seen = new Set();
  let cur = num;

  while (cur !== 1) {
    if (seen.has(cur)) {
      return false;
    }

    seen.add(cur);
    cur = sumOfSquares(cur);
  }

  return true;
}

console.log("Happy numbers in the range 1 to 50:");
const parts = [];

for (let i = 1; i <= 50; i++) {
  if (isHappy(i)) {
    parts.push(String(i));
  }
}
console.log(parts.join(" "));
Try it Yourself

Explanation

Each i is tested independently; each happy check allocates a fresh Set sized by the orbit length (tiny here).

Alternatives

Visited set. Store values in a Set until repeat or 1—simple to code, O(k) memory for orbit length k.

Hard-coded cycle. Because every unhappy orbit hits the 4 → … cycle, you can return false as soon as any of those eight values appears—fast constants, less general pedagogy.

Interview: explain Floyd correctness (two speeds on a functional graph eventually meet inside the unique cycle).

❓ FAQ

Start with a positive integer n. Repeatedly replace n by the sum of the squares of its decimal digits. If you eventually reach 1, n is happy; otherwise the process enters a cycle that never hits 1.
Yes. The sum of squared digits of 1 is 1, so the process terminates immediately at the fixed point 1.
The naive approach stores every visited value in a hash set. Floyd's tortoise-and-hare uses O(1) extra memory: two pointers advance through the iteration at different speeds; meeting with value 1 means happy, meeting otherwise means a non-1 cycle.
In the digit loop, while (n > 0) yields sum 0 for n = 0. For happy checks, restrict to positive n at the API boundary so the interpretation is clear.
Happy numbers are defined for positive integers. Squaring digits of -19 matches 19 in magnitude only if you normalize to absolute value first; this page keeps the interface nonnegative.
Each digit-sum step costs O(log n) digit operations in base 10. The orbit terminates after O(μ + λ) such steps where μ is the tail length and λ the cycle length—tiny constants for typical inputs; Floyd uses only O(1) extra memory (FAQ).

🔄 Input / output examples

Change number in Example 1 or the loop bounds in Example 2.

nHappy?
1Yes
7Yes
2No
19Yes

Edge cases and pitfalls

Assume sumOfSquares is pure; accidental mutation of the visited structure would hide repeats.

n = 1

Immediate happy

The do…while still runs one round; both pointers land on 1 and stop.

n = 0

Not positive

Digit loop yields 0; the orbit sticks at 0, not 1. Treat n < 1 separately in APIs.

Overflow

Very large n

digit * digit fits in Number for decimal digits; iterated sums shrink quickly. Stay within safe integers or switch to BigInt if you extend the puzzle.

Base

Other radices

Happy-base-b definitions replace decimal digits with base-b digits; results differ from base 10.

⏱️ Time and space complexity

MethodTime (per check)Extra space
Set visited sums (this page)O(μ + λ) digit-squaring stepsO(k) for orbit length k
Floyd tortoise-and-haresame asymptotic stepsO(1)
Scan [1, N]O(N) checksO(1) beyond each check

Here μ is the tail length before the cycle and λ the cycle length under f.

Summary

  • Happy: iterated digit-square sums eventually hit 1.
  • Detection: remember digit-square sums in a Set until 1 or repeat (see FAQ for Floyd).
  • Watch-outs: define behavior for n < 1; know the standard unhappy cycle.
Did you know?

If a positive integer is not happy, iterating digit-square sums always falls into the same unhappy cycle 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 (so Floyd’s detection need not store the whole path).

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

8 people found this page helpful

JavaScript Program to Perform Matrix Transpose JavaScript Program to Check Harshad Number