Happy Number - Practice Coding Problems

Happy Number - Problem

Imagine a magical transformation that turns numbers into either happy numbers or traps them in an endless cycle! 🎯

A happy number is defined by a fascinating process:

Start with any positive integer
Replace the number by the sum of the squares of its digits
Repeat this process until either:
- ✅ The number becomes 1 (happy!)
- ❌ It gets stuck in a cycle that never reaches 1 (not happy)

Example: Let's check if 19 is happy:

19 → 1² + 9² = 1 + 81 = 82
82 → 8² + 2² = 64 + 4 = 68
68 → 6² + 8² = 36 + 64 = 100
100 → 1² + 0² + 0² = 1 ✅

Since we reached 1, the number 19 is happy!

Your task: Write an algorithm that returns true if the given number n is happy, and false otherwise.

Input & Output

example_1.py — 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.py — Not Happy Number

$ Input: n = 2

› Output: false

💡 Note: 2 → 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4. We see that 4 appears again, creating a cycle. Since we never reach 1, 2 is not a happy number.

example_3.py — Single Digit Happy

$ Input: n = 7

› Output: true

💡 Note: 7 → 49 → 97 → 130 → 10 → 1. The transformation eventually leads to 1, so 7 is a happy number.

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Begin with your number and prepare to transform it

Transform Each Step

Calculate sum of squares of digits at each step

Check Destination

Did we reach 1? Or are we in a loop?

Detect Cycles

Use either hash set or two pointers to detect infinite loops

Key Takeaway

🎯 Key Insight: Happy numbers either reach 1 or cycle forever. We can detect cycles using either a hash set (intuitive) or Floyd's two-pointer technique (space-optimal).

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Same as hash set approach, but fast pointer does double work

⚡ Linearithmic

Space Complexity

O(1)

Only uses two pointer variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ n ≤ 2³¹ - 1
Follow up: Could you solve this with O(1) extra space?

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The Happy Number problem is a classic cycle detection challenge. The most intuitive approach uses a hash set to track visited numbers, while the space-optimal solution applies Floyd's cycle detection algorithm with two pointers. Both solutions have O(log n) time complexity, but the two-pointer approach achieves O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Floyd's Cycle Detection (Two Pointers)	O(log n)	O(1)	Use slow and fast pointers to detect cycles without extra space
Hash Set Cycle Detection	O(log n)	O(log n)	Track all seen numbers in a set to detect cycles

Floyd's Cycle Detection (Two Pointers) — Algorithm Steps

Initialize slow and fast pointers to the input number
Move slow pointer one transformation step
Move fast pointer two transformation steps
If fast pointer reaches 1, return true (happy)
If slow and fast pointers meet, there's a cycle (not happy)
Continue until one of the above conditions is met

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize both pointers at n=19

Slow and fast both start at 19

First iteration

Slow: 19→82, Fast: 19→82→68

Second iteration

Slow: 82→68, Fast: 68→100→1

Fast reaches 1

Fast pointer found 1, so 19 is happy!

Code -

solution.c — C

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

int getSumOfSquares(int n) {
    int sum = 0;
    while (n > 0) {
        int digit = n % 10;
        sum += digit * digit;
        n /= 10;
    }
    return sum;
}

bool isHappy(int n) {
    int slow = n;
    int fast = n;
    
    do {
        slow = getSumOfSquares(slow);
        fast = getSumOfSquares(getSumOfSquares(fast));
        
        if (fast == 1) return true;
    } while (slow != fast);
    
    return false;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", isHappy(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Same as hash set approach, but fast pointer does double work

⚡ Linearithmic

Space Complexity

O(1)

Only uses two pointer variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ n ≤ 2³¹ - 1
Follow up: Could you solve this with O(1) extra space?

42.4K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Floyd's Cycle Detection (Two Pointers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler