Leetcode 202. Happy Number

Earlier posts gave the algorithm but did not explain why it is valid mathematically, and this is what this post is about: present a "short" mathematical proof.

First of all, it is easy to argue that starting from a number I, if some value - say a - appears again during the process after k steps, the initial number I cannot be a happy number. Because a will continuously become a after every k steps.

Therefore, as long as we can show that there is a loop after running the process continuously, the number is not a happy number.

There is another detail not clarified yet: For any non-happy number, will it definitely end up with a loop during the process? This is important, because it is possible for a non-happy number to follow the process endlessly while having no loop.

To show that a non-happy number will definitely generate a loop, we only need to show that for any non-happy number, all outcomes during the process are bounded by some large but finite integer N. If all outcomes can only be in a finite set (2,N], and since there are infinitely many outcomes for a non-happy number, there has to be at least one duplicate, meaning a loop!

Suppose after a couple of processes, we end up with a large outcome O1 with D digits where D is kind of large, say D>=4, i.e., O1 > 999 (If we cannot even reach such a large outcome, it means all outcomes are bounded by 999 ==> loop exists). We can easily see that after processing O1, the new outcome O2 can be at most 9^2*D < 100D, meaning that O2 can have at most 2+d(D) digits, where d(D) is the number of digits D have. It is obvious that 2+d(D) < D. We can further argue that O1 is the maximum (or boundary) of all outcomes afterwards. This can be shown by contradictory: Suppose after some steps, we reach another large number O3 > O1. This means we process on some number W <= 999 that yields O3. However, this cannot happen because the outcome of W can be at most 9^2*3 < 300 < O1.

 1 class Solution {
 2 public:
 3     bool isHappy(int n) {
 4         map<int,int> thash;
 5         while(n&&!thash[n]){
 6             thash[n]=n;
 7             int temp=0,low;
 8             while(n){
 9                 low=n%10;
10                 temp+=low*low;
11                 n/=10;
12             }
13             n=temp;
14         }
15         if(n==1){
16             return true;
17         }
18         return false;
19     }
20 };

 1 class Solution {
 2 public:
 3     int next(int n){
 4         int temp=0,low;
 5         while(n){
 6             low=n%10;
 7             temp+=low*low;
 8             n/=10;
 9         }
10         return temp;
11     }
12     bool isHappy(int n) {
13         while(n>9){
14             n=next(n);
15         }
16         if(n==1||n==7){
17             return true;
18         }
19         return false;
20     }
21 };

 1 class Solution {
 2 public:
 3     int next(int n){
 4         int temp=0,low;
 5         while(n){
 6             low=n%10;
 7             temp+=low*low;
 8             n/=10;
 9         }
10         return temp;
11     }
12     bool isHappy(int n) {
13         int fast=next(n),slow=n;
14         while(fast!=slow){
15             slow=next(slow);
16             fast=next(next(fast));
17         }
18         if(fast==1){
19             return true;
20         }
21         return false;
22     }
23 };