Happy Number (Digit Sum Cycle)

🎯

Happy Number (Digit Sum Cycle)

easyMATHAmazonGoogleBloomberg

Imagine a game where you repeatedly replace a number by the sum of the squares of its digits. Some numbers eventually reach 1 and are called 'happy', while others get stuck in a loop. Can you determine if a number is happy?

💡 This problem involves detecting cycles in a sequence generated by repeatedly transforming a number. Beginners often struggle because the sequence can loop infinitely, and they need to understand how to detect such cycles efficiently.

📋

Problem Statement

Given a positive integer n, determine if it is a happy number. A happy number is defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle that does not include 1. Return true if n is a happy number, and false otherwise.

1 ≤ n ≤ 10^5

💡

Example

Input"19"

Outputtrue

19 → 1² + 9² = 1 + 81 = 82 → 8² + 2² = 64 + 4 = 68 → 6² + 8² = 36 + 64 = 100 → 1² + 0² + 0² = 1, so 19 is happy.

Input"2"

Outputfalse

2 → 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 (cycle), so 2 is not happy.

• 1 → true (smallest happy number)
• 7 → true (happy number with short cycle to 1)
• 0 → false (not positive, but test robustness)
• 100000 → true (large number within constraints)

⚠️

Common Mistakes

Not detecting cycles and causing infinite loops

Program runs forever or crashes due to stack overflow

✅ Use a hash set or Floyd's cycle detection to detect cycles

Incorrectly computing sum of squares of digits

Wrong output because the transformation is incorrect

✅ Carefully extract each digit and square it before summing

Using recursion without cycle detection

Stack overflow for numbers that cycle endlessly

✅ Avoid recursion or add cycle detection to prevent infinite recursion

Assuming all numbers eventually reach 1 without cycle check

Incorrectly returns true for unhappy numbers

✅ Implement cycle detection or check known unhappy cycles

Not handling edge cases like 1 or very large numbers

Incorrect results or performance issues

✅ Test edge cases explicitly and ensure algorithm handles them

🧠

Brute Force (Cycle Detection with Hash Set)

💡 This approach exists to introduce the basic idea of cycle detection by storing all seen numbers. It helps beginners understand the problem's nature and why infinite loops occur.

Intuition

Repeatedly compute the sum of squares of digits and keep track of all numbers seen. If we reach 1, return true. If we see a number again, a cycle exists, return false.

Algorithm

1. Initialize an empty set to store seen numbers.
2. While n is not 1 and n is not in the set:
3. Add n to the set.
4. Replace n with the sum of the squares of its digits.
5. Return true if n is 1, else false.

💡 The key difficulty is understanding why storing seen numbers prevents infinite loops and how the sum of squares transformation works.

</>

Code

def isHappy(n: int) -> bool:
    def digit_square_sum(num: int) -> int:
        total = 0
        while num > 0:
            digit = num % 10
            total += digit * digit
            num //= 10
        return total

    seen = set()
    while n != 1 and n not in seen:
        seen.add(n)
        n = digit_square_sum(n)
    return n == 1

# Driver code
if __name__ == '__main__':
    test_cases = [19, 2, 7, 1]
    for num in test_cases:
        print(f"Is {num} a happy number? {isHappy(num)}")

Line Notes

def digit_square_sum(num: int) -> int:Helper function isolates the digit sum logic for clarity and reuse.

while num > 0:Extract digits one by one to compute their squares.

seen = set()Stores all previously seen numbers to detect cycles.

while n != 1 and n not in seen:Loop continues until we find 1 or detect a cycle.

seen.add(n)Mark current number as seen to detect future cycles.

return n == 1Return true if happy, false if cycle detected.

import java.util.HashSet;
import java.util.Set;

public class HappyNumber {
    public static boolean isHappy(int n) {
        Set<Integer> seen = new HashSet<>();
        while (n != 1 && !seen.contains(n)) {
            seen.add(n);
            n = digitSquareSum(n);
        }
        return n == 1;
    }

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

    public static void main(String[] args) {
        int[] testCases = {19, 2, 7, 1};
        for (int num : testCases) {
            System.out.println("Is " + num + " a happy number? " + isHappy(num));
        }
    }
}

Line Notes

Set<Integer> seen = new HashSet<>();HashSet used to track seen numbers for cycle detection.

while (n != 1 && !seen.contains(n)) {Loop until happy or cycle detected.

seen.add(n);Add current number to seen set.

n = digitSquareSum(n);Update n to sum of squares of digits.

private static int digitSquareSum(int num) {Helper method to compute sum of squares of digits.

#include <iostream>
#include <unordered_set>

using namespace std;

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

bool isHappy(int n) {
    unordered_set<int> seen;
    while (n != 1 && seen.find(n) == seen.end()) {
        seen.insert(n);
        n = digitSquareSum(n);
    }
    return n == 1;
}

int main() {
    int testCases[] = {19, 2, 7, 1};
    for (int num : testCases) {
        cout << "Is " << num << " a happy number? " << (isHappy(num) ? "true" : "false") << endl;
    }
    return 0;
}

Line Notes

int digitSquareSum(int num) {Helper function to compute sum of squares of digits.

unordered_set<int> seen;Stores numbers seen to detect cycles efficiently.

while (n != 1 && seen.find(n) == seen.end()) {Loop until happy or cycle detected.

seen.insert(n);Mark current number as visited.

return n == 1;Return true if happy number, false otherwise.

function digitSquareSum(num) {
    let total = 0;
    while (num > 0) {
        let digit = num % 10;
        total += digit * digit;
        num = Math.floor(num / 10);
    }
    return total;
}

function isHappy(n) {
    const seen = new Set();
    while (n !== 1 && !seen.has(n)) {
        seen.add(n);
        n = digitSquareSum(n);
    }
    return n === 1;
}

// Test cases
[19, 2, 7, 1].forEach(num => {
    console.log(`Is ${num} a happy number? ${isHappy(num)}`);
});

Line Notes

function digitSquareSum(num) {Helper function to isolate digit sum logic.

const seen = new Set();Set to track visited numbers for cycle detection.

while (n !== 1 && !seen.has(n)) {Loop until happy or cycle detected.

seen.add(n);Add current number to set to detect cycles.

return n === 1;Return true if happy, false if cycle detected.

⏱

Complexity

TimeO(k * log n) where k is the number of iterations until cycle or 1

SpaceO(k) for the set storing seen numbers

Each iteration computes sum of squares of digits (O(log n)) and stores numbers seen. The sequence length k is bounded because numbers eventually fall below a threshold.

💡 For n=19, log n ~2 digits, and k is small (~8), so about 16 operations total.

Interview Verdict: Accepted

This approach works well for the input constraints but uses extra memory to detect cycles.

🧠

Floyd's Cycle Detection (Tortoise and Hare)

💡 This approach improves space by using two pointers moving at different speeds to detect cycles without extra memory.

Intuition

Use two pointers: slow moves one step (one sum of squares), fast moves two steps. If they meet and it's not 1, a cycle exists.

Algorithm

1. Define a function to compute sum of squares of digits.
2. Initialize slow and fast pointers to n.
3. Move slow by one step and fast by two steps repeatedly.
4. If fast or slow reaches 1, return true.
5. If slow equals fast and not 1, return false (cycle detected).

💡 Understanding why two pointers moving at different speeds detect cycles is the key challenge.

</>

Code

def isHappy(n: int) -> bool:
    def digit_square_sum(num: int) -> int:
        total = 0
        while num > 0:
            digit = num % 10
            total += digit * digit
            num //= 10
        return total

    slow = n
    fast = n
    while True:
        slow = digit_square_sum(slow)
        fast = digit_square_sum(digit_square_sum(fast))
        if slow == 1 or fast == 1:
            return True
        if slow == fast:
            return False

# Driver code
if __name__ == '__main__':
    test_cases = [19, 2, 7, 1]
    for num in test_cases:
        print(f"Is {num} a happy number? {isHappy(num)}")

Line Notes

slow = nInitialize slow pointer at start number.

fast = nInitialize fast pointer at start number.

slow = digit_square_sum(slow)Move slow pointer one step.

fast = digit_square_sum(digit_square_sum(fast))Move fast pointer two steps.

if slow == 1 or fast == 1:If either pointer reaches 1, number is happy.

if slow == fast:Pointers meet, cycle detected if not 1.

public class HappyNumber {
    public static boolean isHappy(int n) {
        int slow = n, fast = n;
        do {
            slow = digitSquareSum(slow);
            fast = digitSquareSum(digitSquareSum(fast));
            if (slow == 1 || fast == 1) return true;
        } while (slow != fast);
        return false;
    }

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

    public static void main(String[] args) {
        int[] testCases = {19, 2, 7, 1};
        for (int num : testCases) {
            System.out.println("Is " + num + " a happy number? " + isHappy(num));
        }
    }
}

Line Notes

int slow = n, fast = n;Initialize both pointers at start.

slow = digitSquareSum(slow);Slow pointer moves one step.

fast = digitSquareSum(digitSquareSum(fast));Fast pointer moves two steps.

if (slow == 1 || fast == 1) return true;If either pointer reaches 1, number is happy.

} while (slow != fast);Loop until pointers meet indicating cycle.

#include <iostream>
using namespace std;

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

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

int main() {
    int testCases[] = {19, 2, 7, 1};
    for (int num : testCases) {
        cout << "Is " << num << " a happy number? " << (isHappy(num) ? "true" : "false") << endl;
    }
    return 0;
}

Line Notes

int slow = n, fast = n;Initialize slow and fast pointers.

slow = digitSquareSum(slow);Slow pointer moves one step.

fast = digitSquareSum(digitSquareSum(fast));Fast pointer moves two steps.

if (slow == 1 || fast == 1) return true;If either pointer reaches 1, number is happy.

} while (slow != fast);Loop until pointers meet, indicating cycle.

function digitSquareSum(num) {
    let total = 0;
    while (num > 0) {
        let digit = num % 10;
        total += digit * digit;
        num = Math.floor(num / 10);
    }
    return total;
}

function isHappy(n) {
    let slow = n, fast = n;
    do {
        slow = digitSquareSum(slow);
        fast = digitSquareSum(digitSquareSum(fast));
        if (slow === 1 || fast === 1) return true;
    } while (slow !== fast);
    return false;
}

// Test cases
[19, 2, 7, 1].forEach(num => {
    console.log(`Is ${num} a happy number? ${isHappy(num)}`);
});

Line Notes

let slow = n, fast = n;Initialize pointers at start number.

slow = digitSquareSum(slow);Slow pointer moves one step.

fast = digitSquareSum(digitSquareSum(fast));Fast pointer moves two steps.

if (slow === 1 || fast === 1) return true;If either pointer reaches 1, number is happy.

} while (slow !== fast);Loop until pointers meet, indicating cycle.

⏱

Complexity

TimeO(k * log n) where k is number of iterations until cycle or 1

SpaceO(1) constant space

Each iteration computes sum of squares of digits (O(log n)) and uses two pointers without extra memory. The sequence length k is bounded.

💡 For n=19, about 8 iterations with 2-digit numbers means roughly 16 digit operations, but no extra memory used.

Interview Verdict: Accepted

This approach is optimal in space and preferred in interviews once cycle detection is understood.

🧠

Mathematical Insight with Known Cycle Detection

💡 This approach uses the known fact that all unhappy numbers eventually enter a fixed cycle. It avoids cycle detection by checking membership in this cycle.

Intuition

If the number becomes 1, it's happy. Otherwise, if it reaches any number in the known unhappy cycle {4,16,37,58,89,145,42,20}, it is not happy.

Algorithm

1. Define a set of known unhappy cycle numbers.
2. While n is not 1 and not in the unhappy set:
3. Replace n with the sum of squares of its digits.
4. Return true if n is 1, else false.

💡 The challenge is knowing the unhappy cycle beforehand and trusting this mathematical fact.

</>

Code

def isHappy(n: int) -> bool:
    unhappy_cycle = {4, 16, 37, 58, 89, 145, 42, 20}

    def digit_square_sum(num: int) -> int:
        total = 0
        while num > 0:
            digit = num % 10
            total += digit * digit
            num //= 10
        return total

    while n != 1 and n not in unhappy_cycle:
        n = digit_square_sum(n)
    return n == 1

# Driver code
if __name__ == '__main__':
    test_cases = [19, 2, 7, 1]
    for num in test_cases:
        print(f"Is {num} a happy number? {isHappy(num)}")

Line Notes

unhappy_cycle = {4, 16, 37, 58, 89, 145, 42, 20}Known cycle numbers where unhappy numbers get stuck.

while n != 1 and n not in unhappy_cycle:Loop until happy or known unhappy cycle detected.

n = digit_square_sum(n)Update n to sum of squares of digits.

return n == 1Return true if happy, false otherwise.

import java.util.Set;
import java.util.HashSet;

public class HappyNumber {
    private static final Set<Integer> unhappyCycle = new HashSet<>();
    static {
        unhappyCycle.add(4); unhappyCycle.add(16); unhappyCycle.add(37); unhappyCycle.add(58);
        unhappyCycle.add(89); unhappyCycle.add(145); unhappyCycle.add(42); unhappyCycle.add(20);
    }

    public static boolean isHappy(int n) {
        while (n != 1 && !unhappyCycle.contains(n)) {
            n = digitSquareSum(n);
        }
        return n == 1;
    }

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

    public static void main(String[] args) {
        int[] testCases = {19, 2, 7, 1};
        for (int num : testCases) {
            System.out.println("Is " + num + " a happy number? " + isHappy(num));
        }
    }
}

Line Notes

private static final Set<Integer> unhappyCycle = new HashSet<>();Stores known unhappy cycle numbers.

while (n != 1 && !unhappyCycle.contains(n)) {Loop until happy or known unhappy cycle detected.

n = digitSquareSum(n);Update n to sum of squares of digits.

return n == 1;Return true if happy, false otherwise.

#include <iostream>
#include <unordered_set>
using namespace std;

bool isHappy(int n) {
    static unordered_set<int> unhappyCycle = {4,16,37,58,89,145,42,20};

    auto digitSquareSum = [](int num) {
        int total = 0;
        while (num > 0) {
            int digit = num % 10;
            total += digit * digit;
            num /= 10;
        }
        return total;
    };

    while (n != 1 && unhappyCycle.find(n) == unhappyCycle.end()) {
        n = digitSquareSum(n);
    }
    return n == 1;
}

int main() {
    int testCases[] = {19, 2, 7, 1};
    for (int num : testCases) {
        cout << "Is " << num << " a happy number? " << (isHappy(num) ? "true" : "false") << endl;
    }
    return 0;
}

Line Notes

static unordered_set<int> unhappyCycle = {4,16,37,58,89,145,42,20};Known unhappy cycle stored statically for efficiency.

while (n != 1 && unhappyCycle.find(n) == unhappyCycle.end()) {Loop until happy or known unhappy cycle detected.

n = digitSquareSum(n);Update n to sum of squares of digits.

return n == 1;Return true if happy, false otherwise.

const unhappyCycle = new Set([4,16,37,58,89,145,42,20]);

function digitSquareSum(num) {
    let total = 0;
    while (num > 0) {
        let digit = num % 10;
        total += digit * digit;
        num = Math.floor(num / 10);
    }
    return total;
}

function isHappy(n) {
    while (n !== 1 && !unhappyCycle.has(n)) {
        n = digitSquareSum(n);
    }
    return n === 1;
}

// Test cases
[19, 2, 7, 1].forEach(num => {
    console.log(`Is ${num} a happy number? ${isHappy(num)}`);
});

Line Notes

const unhappyCycle = new Set([4,16,37,58,89,145,42,20]);Known unhappy cycle numbers stored in a set.

while (n !== 1 && !unhappyCycle.has(n)) {Loop until happy or known unhappy cycle detected.

n = digitSquareSum(n);Update n to sum of squares of digits.

return n === 1;Return true if happy, false otherwise.

⏱

Complexity

TimeO(k * log n) where k is number of iterations until 1 or cycle

SpaceO(1) constant space

Each iteration computes sum of squares of digits (O(log n)) and checks membership in a small fixed set.

💡 This approach is very fast and memory efficient because the unhappy cycle is small and known.

Interview Verdict: Accepted

This approach is optimal and elegant but requires prior knowledge of the unhappy cycle.

📊

All Approaches - One-Glance Tradeoffs

💡 In most interviews, Floyd's cycle detection is the best approach to code due to its optimal space and time balance.

Approach	Time	Space	Stack Risk	Reconstruct	Use In Interview
1. Brute Force (Hash Set)	O(k * log n)	O(k)	No	N/A	Good to mention for clarity, but not optimal to code.
2. Floyd's Cycle Detection	O(k * log n)	O(1)	No	N/A	Best approach to implement in interviews.
3. Known Cycle Check	O(k * log n)	O(1)	No	N/A	Mention as an optimization if interviewer is interested.

💼

Interview Strategy

💡 Use this guide to understand the problem deeply before interviews. Start with brute force to grasp the problem, then learn cycle detection optimizations. Practice explaining your approach clearly.

How to Present

Step 1: Clarify the problem and constraints.Step 2: Explain the brute force approach using a hash set to detect cycles.Step 3: Discuss the space optimization using Floyd's cycle detection.Step 4: Optionally mention the known unhappy cycle for further optimization.Step 5: Write clean, tested code and explain your reasoning.

Time Allocation

Clarify: 2min → Approach: 3min → Code: 8min → Test: 2min. Total ~15min

What the Interviewer Tests

The interviewer tests your understanding of cycle detection, ability to optimize space, and clarity in explaining your approach.

Common Follow-ups

• What if the input number is very large? → The approach still works as sum of squares reduces number size quickly.
• Can you detect cycles without extra space? → Yes, using Floyd's cycle detection algorithm.

💡 These follow-ups test your knowledge of cycle detection algorithms and handling large inputs efficiently.

🔍

Pattern Recognition

When to Use

1) Problem involves repeatedly transforming a number by digit operations; 2) Need to detect if sequence reaches 1 or loops; 3) Cycle detection is required; 4) Constraints allow iterative simulation.

Signature Phrases

sum of squares of digitsrepeat the processloops endlesslyhappy number

NOT This Pattern When

Problems that only require digit sums without cycle detection, or pure DP problems.

Similar Problems

Detect Cycle in Linked List - similar cycle detection techniqueSum of Digits Until One Digit - similar digit transformationPower of Three - number property checking

Practice

1. You need to count how many prime numbers are less than a given integer n. Which algorithmic approach guarantees the most efficient solution for this problem?

easy

A. Check each number from 2 to n-1 for primality by testing divisibility up to n-1.

B. Use a sieve method that iteratively marks multiples of primes starting from 2 up to sqrt(n).

C. Apply a dynamic programming approach that builds prime counts based on previous counts.

D. Use a greedy approach that picks primes by checking divisibility only by the last found prime.

Solution

1. Step 1: Understand the problem

   We want to count primes less than n efficiently, which requires avoiding repeated primality checks.

2. Step 2: Identify the optimal approach

   The sieve method marks multiples of primes starting from 2 up to sqrt(n), efficiently eliminating non-primes in O(n log log n) time.

3. Final Answer:

   Option B -> Option B

4. Quick Check:

   Sieve is the classic and optimal approach for counting primes [OK]

Hint: Sieve marks multiples up to sqrt(n) for efficiency [OK]

Common Mistakes:

• Thinking brute force primality check is efficient enough
• Confusing DP with sieve
• Assuming greedy divisibility checks suffice

2. Given an integer, determine if it reads the same backward as forward without converting it to a string. Which approach guarantees an optimal solution in terms of time and space complexity?

easy

A. Convert the integer to a string and compare characters from both ends.

B. Use a greedy approach to compare digits from left to right until mismatch.

C. Reverse half of the integer digits and compare with the other half.

D. Use dynamic programming to store palindrome states of digit substrings.

Solution

1. Step 1: Understand the problem constraints

   We want to check if an integer is a palindrome without extra space and efficiently.

2. Step 2: Evaluate approaches

   Converting to string uses extra space; DP is overkill and not applicable; greedy fails on some cases. Reversing half the number uses O(1) space and O(log n) time.

3. Final Answer:

   Option C -> Option C

4. Quick Check:

   Reversing half the digits avoids overflow and extra space [OK]

Hint: Optimal uses half reversal, not full string conversion [OK]

Common Mistakes:

• Thinking string conversion is optimal
• Using DP unnecessarily
• Greedy fails on middle digits

3. You need to reverse the digits of a 32-bit signed integer, returning 0 if the reversed integer overflows. Which approach guarantees an optimal solution that handles overflow correctly without converting the integer to a string?

easy

A. Greedy approach that swaps digits from ends until the middle is reached

B. Dynamic programming to store reversed prefixes and build the result

C. Brute force string conversion and reversal without overflow checks

D. Recursive digit extraction with overflow checks before each digit append

Solution

1. Step 1: Understand problem constraints

   The problem requires reversing digits without string conversion and must handle overflow safely.

2. Step 2: Identify approach that meets constraints

   Recursive digit extraction with overflow checks ensures digits are reversed one by one and stops if overflow would occur, guaranteeing correctness and optimality.

3. Final Answer:

   Option D -> Option D

4. Quick Check:

   Recursive digit extraction handles overflow and sign correctly [OK]

Hint: Overflow-safe digit extraction is key [OK]

Common Mistakes:

• Using string reversal without overflow checks
• Greedy swaps fail on overflow
• DP is unnecessary overhead

4. Consider the following buggy code snippet for converting an Excel column title to a number. Which line contains the subtle bug that causes incorrect results for inputs like "A" or "Z"?

medium

A. Line 4: powers computation loop

B. Line 7: initialization of result

C. Line 9: calculation of value using zero-based indexing

D. Line 10: accumulation of result using powers

Solution

1. Step 1: Identify how letter values are computed

   The code uses ord(ch) - ord('A'), which makes 'A' = 0 instead of 1.

2. Step 2: Understand impact on result

   This causes all results to be off by one, e.g., "A" returns 0 instead of 1.

3. Final Answer:

   Option C -> Option C

4. Quick Check:

   Correct letter values must be 1-based, not zero-based [OK]

Hint: Check if 'A' maps to 1, not 0 [OK]

Common Mistakes:

• Using zero-based indexing for letters
• Miscomputing powers array
• Incorrect accumulation order

5. Consider the following buggy code for finding the nth ugly number. Which line contains the subtle bug that causes incorrect results for some inputs?

import heapq

def nthUglyNumber(n):
    heap = [1]
    seen = set()
    ugly = 1
    for _ in range(n):
        ugly = heapq.heappop(heap)
        for factor in [2, 3, 5]:
            new_ugly = ugly * factor
            if new_ugly not in seen:
                seen.add(new_ugly)
                heapq.heappush(heap, new_ugly)
    return ugly

medium

A. Line 3: Initializing seen as an empty set instead of containing 1

B. Line 6: Popping from heap before checking if heap is empty

C. Line 9: Multiplying ugly by factor without checking for overflow

D. Line 11: Adding new_ugly to seen before pushing to heap

Solution

1. Step 1: Check initialization of seen set

   The seen set is empty initially, but 1 is already in the heap. This causes duplicates because 1 is not marked as seen.

2. Step 2: Understand impact of missing 1 in seen

   Without 1 in seen, the algorithm may push 1 multiple times, causing duplicates and incorrect nth ugly number.

3. Final Answer:

   Option A -> Option A

4. Quick Check:

   Adding 1 to seen fixes duplicates and ensures correctness [OK]

Hint: Always mark initial heap elements as seen to avoid duplicates [OK]

Common Mistakes:

• Forgetting to add initial element to seen set
• Assuming heap uniqueness without seen tracking
• Ignoring edge cases with initial values