202. Happy Number

At a Glance

Topic: math-geometry
Pattern: Cycle detection (Fast & Slow Pointers); digit simulation
Difficulty: Easy
Companies: Amazon, Google, Meta, Bloomberg, Apple
Frequency: High
LeetCode: 202

Given a positive integer value, repeatedly replace it by the sum of the squares of its digits until the process reaches 1 (happy) or enters a cycle that never hits 1 (not happy). Return whether it is a happy number.

Recognition Cues

"Sum of the squares of its digits"
"Eventually equals 1" vs "loops endlessly"
Implicit linked-list / successor graph on integers

Diagram

At-a-glance flow (replace with problem-specific Mermaid as you refine this note). camelCase node IDs; no spaces in IDs.

Loading diagram…

Approaches

Brute force — O(?) unbounded — simulate with a set of seen sums; may grow large.
Better — hash set of visited sums — O(log n) per step typical — stop on repeat.
Optimal — Floyd cycle detection on the successor function — O(log n) time per phase / O(1) space — treat slow/fast digit-sum as linked list cycle.

Optimal Solution

Go

package main

func isHappy(value int) bool {
	slow := value
	fast := nextDigitSquareSum(value)
	for fast != slow && fast != 1 {
		slow = nextDigitSquareSum(slow)
		fast = nextDigitSquareSum(nextDigitSquareSum(fast))
	}
	return fast == 1
}

func nextDigitSquareSum(value int) int {
	sum := 0
	for value > 0 {
		digit := value % 10
		sum += digit * digit
		value /= 10
	}
	return sum
}

JavaScript

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

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