Happy Number

Like0

Can a number actually be "happy"? In the world of algorithms, the answer is a resounding yes! A number is considered Happy if, when you repeatedly replace it with the sum of the squares of its digits, you eventually land on 1. But be careful—some numbers are destined to loop endlessly in a "unhappy" cycle, never reaching that peaceful 1.

The "secret sauce" here is a Hash Set for cycle detection. Think of it like a breadcrumb trail. As you calculate each new sum, you check your Set: "Have I been to this number before?" If you hit a number that’s already in your Set, you know you’re stuck in an infinite loop and the number is officially unhappy. If you reach 1, you’ve found happiness!

This challenge is a brilliant way to practice using Sets to prevent infinite loops. It turns a mathematical puzzle into a clean, searchable logic problem that's both fast and elegant to solve.

Examples

Example 1

Input

n = 19

Output

true

Explanation

19 reaches 1 through repeated square-sum.

Example 2

Input

n = 2

Output

false

Explanation

2 falls into a cycle not including 1.

Example 3

Input

n = 1

Output

true

Explanation

1 is already happy.

Algorithm Flow

Recommendation Algorithm Flow for Happy Number - Budibadu

Best Answers

java

import java.util.*;
class Solution {
    public boolean happy_number(int n) {
        Set<Integer> seen = new HashSet<>();
        while (n != 1 && !seen.contains(n)) {
            seen.add(n);
            int total = 0;
            while (n > 0) {
                int d = n % 10;
                total += d * d;
                n /= 10;
            }
            n = total;
        }
        return n == 1;
    }
}

javascript

function happy_number(n) {
    function nextNum(x) {
        let total = 0;
        while (x > 0) {
            const d = x % 10;
            total += d * d;
            x = Math.floor(x / 10);
        }
        return total;
    }
    const seen = {};
    while (n !== 1 && !seen[n]) {
        seen[n] = true;
        n = nextNum(n);
    }
    return n === 1;
}

php

<?php
function happy_number($n) {
    $seen = [];
    while ($n != 1 && !isset($seen[(string)$n])) {
        $seen[(string)$n] = true;
        $sum = 0;
        while ($n > 0) {
            $d = $n % 10;
            $sum += $d * $d;
            $n = intdiv($n, 10);
        }
        $n = $sum;
    }
    return $n == 1;
}
?>

python

def happy_number(n: int) -> bool:
    def next_num(x: int) -> int:
        total = 0
        while x > 0:
            d = x % 10
            total += d * d
            x //= 10
        return total
    seen = set()
    while n != 1 and n not in seen:
        seen.add(n)
        n = next_num(n)
    return n == 1

rust

use std::collections::HashSet;
fn happy_number(mut n: i32) -> bool {
    let mut seen: HashSet<i32> = HashSet::new();
    while n != 1 && !seen.contains(&n) {
        seen.insert(n);
        let mut x = n;
        let mut sum = 0;
        while x > 0 {
            let d = x % 10;
            sum += d * d;
            x /= 10;
        }
        n = sum;
    }
    n == 1
}

typescript

function happy_number(n: number): boolean {
    function nextNum(x: number): number {
        var total = 0;
        while (x > 0) {
            var d = x % 10;
            total += d * d;
            x = Math.floor(x / 10);
        }
        return total;
    }
    var seen: { [key: string]: boolean } = {};
    while (n !== 1 && !seen[String(n)]) {
        seen[String(n)] = true;
        n = nextNum(n);
    }
    return n === 1;
}

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this problem.

Happy Number

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Hash Table Problems

Duplicate Indices Map

First Unique Character

Contains Duplicate

Valid Anagram

Ransom Note

Two Sum Indices

Comments (0)

Join the Discussion