Definition
Orbit to 1
Replace n by the sum of squared digits; happy if you reach 1.
Check Happy Number in C
Overview
What You’ll Learn
Happy numbers are a classic interview warm-up: digit extraction, iteration, and cycle detection. This tutorial covers the digit-square map, Floyd’s tortoise-and-hare, a live preview, algorithm steps, worked C examples, edge cases, and complexity.
Digit Map f(n)
Σ di²
Peel digits with % 10, square, accumulate, divide by 10.
Floyd
O(1) space
Tortoise and hare meet at 1 (happy) or another cycle (unhappy).
Unhappy Cycle
4 → …
Every non-happy orbit eventually enters the known 8-value cycle.
Live Preview
Check n
Classify any positive safe integer instantly in the browser.
Range Scan
1–50
List all happy numbers in a closed interval with the same helper.
Introduction
Happy numbers start from a positive integer n. Repeatedly replace n by the sum of the squares of its decimal digits. If the process reaches 1, n is happy; otherwise it enters a cycle that never contains 1.
In C interviews you are usually asked to implement the digit-square map, detect cycles with Floyd’s tortoise and hare (O(1) extra memory), and optionally list happy numbers in a range.
Why it matters?
It trains digit loops, functional-graph thinking, and cycle detection without a hash table — skills that transfer to linked-list cycles and other orbit problems.
Key Highlights
Happy ↔ Hits 1
The fixed point f(1) = 1 ends a happy orbit.
Floyd Detection
Two speeds on f; meet at 1 means happy.
Known Unhappy Cycle
All non-happy orbits share one 8-value loop.
Positive Only
Standard definition uses positive integers.
In short: iterate sum-of-squared-digits; if Floyd’s pointers meet at 1, the number is happy — otherwise it entered a non-1 cycle.
Foundation
📝 Problem & Approach
Given a positive integer n, decide whether iterating the sum of squared decimal digits eventually reaches 1.
c
/* Happy path for 19
* 19 → 1²+9² = 82
* 82 → 8²+2² = 68
* 68 → 6²+8² = 100
* 100 → 1²+0²+0² = 1 → happy
*/Inputs & Outputs
| Item | Type | Description |
|---|---|---|
n / number | int | Positive integer to classify (Example 1). |
| Range bounds | int | Inclusive interval such as [1, 50] (Example 2). |
| Result | flag / text | Happy or not; or a printed list of happy values. |
Minimal workflow
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):
slow = n
fast = n
repeat:
slow = sum_square_digits(slow)
fast = sum_square_digits(sum_square_digits(fast))
until slow == fast
return slow == 1Method comparison
| Method | Idea | Extra space |
|---|---|---|
| Floyd (this page) | Slow = one f step; fast = two f steps | O(1) |
| Visited set | Store every orbit value until repeat or 1 | O(k) for orbit length k |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Next digit square sum | digit = n % 10; sum += digit * digit; n /= 10; |
| Slow step | slow = sum_of_squares(slow); |
| Fast step | fast = sum_of_squares(sum_of_squares(fast)); |
| Happy test | return slow == 1; after pointers meet |
| Reject non-positive | if (number < 1) { … } |
Compare
📋 Floyd vs Hash Set vs Hard-Coded Cycle
All can classify happy numbers — memory and pedagogy differ.
Floyd
tortoise/hareO(1) space; interview-friendly cycle story
Hash set
visitedSimple to write; uses O(k) memory
Unhappy constants
hit 4?Fast once you know the cycle; less general
Interview tip
explain FloydTwo speeds meet inside the unique cycle
Context
When This Problem Shows Up
Reach for happy-number drills when digit maps and cycles matter.
Interview warm-ups
Digit loops plus a clear cycle-detection story.
Teaching Floyd
Same tortoise-and-hare idea as linked-list cycle detection.
Functional graphs
Each
nhas one successor underf— orbits end in cycles.Range / filter tasks
List or count happy numbers in
[L, R].Not for other bases blindly
Happy-in-base-
buses different digits — results change.
Key benefit: one small problem that covers digits, iteration, and O(1)-space cycle detection together.
Interactive
🔮 Live Preview
Enter a positive integer and classify it with the same Floyd logic as the C samples.
Hands-On
Examples Gallery
Two complete C programs — classify a single value, and list happy numbers in [1, 50]. Click View Output to reveal sample console results.
📚 Getting Started
Floyd cycle detection for n = 19.
Example 1 — Single Value: 19
Digit-square helper plus tortoise-and-hare; rejects n < 1 in main.
c
#include <stdio.h>
int sum_of_squares(int n) {
int sum = 0;
while (n > 0) {
int digit = n % 10;
sum += digit * digit;
n /= 10;
}
return sum;
}
int is_happy(int n) {
int slow = n;
int fast = n;
do {
slow = sum_of_squares(slow);
fast = sum_of_squares(sum_of_squares(fast));
} while (slow != fast);
return slow == 1;
}
int main(void) {
int number = 19;
if (number < 1) {
printf("Use a positive integer.\n");
return 0;
}
if (is_happy(number)) {
printf("%d is a Happy Number.\n", number);
} else {
printf("%d is not a Happy Number.\n", number);
}
return 0;
}How It Works
The do-while performs at least one advance so n = 1 is classified immediately: both pointers read 1 and the loop stops with slow == 1.
📈 Practical Patterns
Reuse the same helper across a closed interval.
Example 2 — Happy Numbers in [1, 50]
Scan each i independently; Floyd keeps extra memory O(1) per check.
c
#include <stdio.h>
int sum_of_squares(int num) {
int sum = 0;
while (num > 0) {
int digit = num % 10;
sum += digit * digit;
num /= 10;
}
return sum;
}
int is_happy(int num) {
int slow = num;
int fast = num;
do {
slow = sum_of_squares(slow);
fast = sum_of_squares(sum_of_squares(fast));
} while (slow != fast);
return slow == 1;
}
int main(void) {
int i;
printf("Happy numbers in the range 1 to 50:\n");
for (i = 1; i <= 50; ++i) {
if (is_happy(i)) {
printf("%d ", i);
}
}
printf("\n");
return 0;
}How It Works
Each i is tested independently; the happy test stays O(1) extra memory per call thanks to Floyd.
🧠 How the Algorithm Classifies n
1
Validate n
Require a positive integer; happy numbers are not defined for n < 1 here.
Guard
2
Compute f(n)
Sum the squares of decimal digits with % 10 and /= 10.
Map
3
Run Floyd
Advance slow by one f step and fast by two until they meet.
Cycle
=
Decide
Meeting at 1 → happy; otherwise → unhappy cycle.
Trace
🔎 Worked Walkthrough — 19
Trace the digit-square orbit until it reaches the fixed point 1.
| Step | Value | Digit squares | Next |
|---|---|---|---|
0 | 19 | 1² + 9² | 82 |
1 | 82 | 8² + 2² | 68 |
2 | 68 | 6² + 8² | 100 |
3 | 100 | 1² + 0² + 0² | 1 |
4 | 1 | 1² | 1 (happy) |
By contrast, 2 eventually enters 4 → 16 → 37 → … → 4 and never hits 1.
Use Cases
Where happy-number thinking shows up beyond the interview prompt.
1. Cycle Detection Practice
Same tortoise-and-hare idea as linked-list cycles.
Example: meet inside the unique orbit cycle.
2. Digit Extraction Drills
Build fluency with % 10 / /= 10 loops.
Example: sum-of-squares helper reused elsewhere.
3. Functional Graphs
Each value has one successor — orbits end in cycles.
Example: happy sink vs unhappy 8-cycle.
4. Range Filters
List or count numbers with a property in [L, R].
Example: happy numbers in 1–50.
5. Memory Trade-offs
Compare Floyd vs storing a visited set.
Example: O(1) vs O(k) extra space.
6. Related Digit Properties
Harshad, Disarium, and similar digit-sum problems.
Example: next pages in the interview chain.
Pro Tip: if the interviewer allows constants, mentioning the unhappy cycle is fine — but Floyd shows you understand general cycle detection.
Advantages
Why Floyd on the digit-square map earns interview points.
1. O(1) Extra Memory
No hash set of visited values — only two integers on the orbit.
2. Clear Correctness Story
Two speeds on a functional graph must meet inside the unique cycle.
3. Tiny Helper Surface
sum_of_squares+is_happyis easy to test and reuse in a range scan.4. Handles n = 1 Cleanly
A
do-whileFloyd loop classifies the fixed point without special cases.
Pro Tip: lead with Floyd; mention the unhappy cycle as optional constant-time early exit if asked about optimizations.
Usage Tips
Small habits that keep happy-number code clean in interviews.
1. Restrict to Positive n
Validate
n ≥ 1inmain(or your API) before callingis_happy.2. Prefer do-while for Floyd
Guarantees one advance so
n = 1works without a special branch.3. Keep Helpers Pure
sum_of_squaresshould only depend on its argument — Floyd assumes a pure map.4. Test Happy and Unhappy
Verify
1,7,19(happy) and2,4(unhappy).5. Reuse for Ranges
Call the same
is_happyfrom a loop — do not re-inline Floyd each time.
Pro Tip: dry-run 19 on paper (table above) before coding — it locks in the digit-square path.
Common Pitfalls
Mistakes that commonly break happy-number solutions in C.
1. Skipping Cycle Detection
A bare
while (n != 1)loop never stops on unhappy numbers.→ Use Floyd, a visited set, or the known unhappy cycle.
2. While Instead of do-while
Checking
slow != fastbefore any move can mishandlen = 1.→ Prefer
do { … } while (slow != fast);3. Accepting n < 1 Silently
0yields a fixed point at0, which is not happy under the usual definition.→ Reject non-positive inputs in the API.
4. Mutating Shared State
If
fis not pure, Floyd can miss or invent cycles.→ Keep
sum_of_squaresa pure function ofn.5. Confusing Bases
Happy-in-base-
bis a different problem from base-10 happy numbers.→ Confirm the radix with the interviewer.
Edge Cases
Check these inputs before calling the solution done.
n = 1
Immediate happy
The do-while still runs one round; both pointers land on 1.
n = 0
Not positive
Digit loop yields 0; treat n < 1 separately in APIs.
Unhappy
n = 2 or 4
Enters the standard cycle; Floyd meets at a value other than 1.
Overflow
Very large n
digit*digit fits in int for decimal digits; widen types if needed.
Negatives
Out of scope
Standard happy numbers are positive; reject or normalize explicitly.
Base
Other radices
Happy-base-b replaces decimal digits — results differ.
Reference
🔄 Sample Values
Known classifications for common interview inputs.
n | Happy? |
|---|---|
1 | Yes |
7 | Yes |
2 | No |
19 | Yes |
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Read n from stdin
- Use
scanfand validaten ≥ 1 - Print a clear happy / not-happy message
2. Visited-set variant
- Store orbit values until repeat or
1 - Compare space with Floyd
3. Count in a range
- Return how many happy numbers lie in
[L, R] - Reuse
is_happy
4. Early exit on cycle 4
- Return false as soon as any unhappy-cycle value appears
- Discuss trade-off vs general Floyd
Important
Notes
- Unhappy cycle. Every non-happy positive integer eventually hits
4 → 16 → … → 4. - Floyd needs no path storage — meeting at
1is the happy test. - Validate
n ≥ 1;n = 1is happy by the fixed-point definition. - For bounded
intinputs, orbit lengths stay small — complexity is effectively constant in practice.
Quick Takeaway: iterate sum-of-squared-digits; Floyd meets at 1 for happy numbers, otherwise at the unhappy cycle — all in O(1) extra space.
Analysis
⏱️ Time and Space Complexity
| Method | Time (per check) | Extra space |
|---|---|---|
| Floyd (this page) | O(μ + λ) digit-squaring steps | O(1) |
| Hash set of visited values | same asymptotic steps | O(k) for orbit length k |
Scan [1, N] | O(N) checks | O(1) beyond each check |
Here μ is the tail length before the cycle and λ the cycle length under f.
🎉 Conclusion
Happy numbers are a small digit-iteration exercise with big teaching payoff: pure maps, orbits, and O(1)-space cycle detection. Master Floyd on the digit-square function so you can explain both the happy path and the unhappy cycle in an interview.
Practice the two examples above, then continue to Harshad numbers for another digit-sum property check.
Iterate sum-of-squared-digits; Floyd meets at 1 for happy numbers — validate n ≥ 1 and know the unhappy cycle.
Pro Tips
💡 Best Practices
✅ Do
- Explain the digit-square map before coding Floyd
- Use
do-whileson = 1works - Validate
n ≥ 1at the API boundary - Keep
sum_of_squarespure - Mention the unhappy cycle as optional knowledge
❌ Don’t
- Loop until
n == 1without cycle detection - Accept
0or negatives without a defined policy - Store the whole path when O(1) Floyd works
- Forget to test an unhappy example like
2 - Assume another base without clarifying
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about happy numbers in C
Classify them the interview-friendly way.
5
Core concepts 01
Rule
Orbit hits 1
Definition 02
Map f(n)
Sum of digit²
Digits 03
Floyd
O(1) cycle detect
Code 04
Unhappy
Shared 8-cycle
Fact 05
Complexity
O(μ+λ) steps
Analysis❓ Frequently Asked Questions
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 in main 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. Floyd terminates in O(μ + λ) such steps where μ is the tail length and λ the cycle length—constants bounded for 32-bit int inputs in practice.
Every non-happy positive integer eventually enters 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4. Seeing any of those values proves unhappiness.
A do-while performs at least one advance so n = 1 is classified correctly: both pointers land on 1 and stop with slow == 1.
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).
Continue to Harshad Number
Learn how to check whether a number is divisible by the sum of its digits.
About the author
8 people found this page helpful