Happy Number

Happy Number - Problem

Write an algorithm to determine if a number n is happy.

A happy number is a number defined by the following process:

Starting with any positive integer, replace the number by the sum of the squares of its digits.
Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.
Those numbers for which this process ends in 1 are happy.

Return true if n is a happy number, and false if not.

Input & Output

Example 1 — Happy Number

$ Input: n = 19

› Output: true

💡 Note: 19 → 1² + 9² = 82 → 8² + 2² = 68 → 6² + 8² = 100 → 1² + 0² + 0² = 1. Since we reached 1, 19 is a happy number.

Example 2 — Unhappy Number

$ Input: n = 2

› Output: false

💡 Note: 2 → 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4. We detect a cycle that doesn't include 1, so 2 is not happy.

Example 3 — Single Digit Happy

$ Input: n = 1

› Output: true

💡 Note: 1 → 1² = 1. Already at 1, so it's happy by definition.

Constraints

1 ≤ n ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 🍎 Apple 4

A happy number reaches 1 through digit square sums, while unhappy numbers cycle forever. The key insight is detecting cycles efficiently. Best approaches: Hash Set O(log n) space or Floyd's Algorithm O(1) space. Time: O(log n), Space: O(1) optimal.

Common Approaches

✓ Floyd's Cycle Detection - Tortoise and Hare

⏱️ Time: O(log n) Space: O(1)

Apply Floyd's cycle detection algorithm. Use two pointers: slow (moves one step) and fast (moves two steps). If there's a cycle, fast will eventually meet slow. If we reach 1, it's happy.

Hash Set - Track All Seen Numbers

⏱️ Time: O(log n) Space: O(log n)

Keep transforming the number by summing squares of digits. Use a hash set to track all numbers we've encountered. If we see a number twice, we're in a cycle (not happy). If we reach 1, it's happy.

Mathematical Optimization - Hardcode Known Cycles

⏱️ Time: O(log n) Space: O(1)

Mathematical analysis shows that all numbers either reach 1 or enter the cycle: 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4. We can optimize by checking if we hit any number in this known cycle.

Floyd's Cycle Detection - Tortoise and Hare — Algorithm Steps

Step 1: Initialize slow and fast pointers to n
Step 2: Move slow one step, fast two steps in each iteration
Step 3: If slow equals fast, there's a cycle (not happy)
Step 4: If either reaches 1, it's happy

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set slow=19, fast=82

Move Pointers

Slow moves 1 step, fast moves 2 steps

Check

If fast=1 (happy) or fast=slow (cycle)

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int getNext(int num) {
    int total = 0;
    while (num > 0) {
        int digit = num % 10;
        total += digit * digit;
        num /= 10;
    }
    return total;
}

bool solution(int n) {
    int slow = n;
    int fast = getNext(n);
    
    while (fast != 1 && fast != slow) {
        slow = getNext(slow);
        fast = getNext(getNext(fast));
    }
    
    return fast == 1;
}

int main() {
    int n;
    scanf("%d", &n);
    bool result = solution(n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Same as hash set - limited cycles exist, each step reduces number

⚡ Linearithmic

Space Complexity

O(1)

Only uses two pointer variables, no extra data structures

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Floyd's Cycle Detection - Tortoise and Hare — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler