Happy numbers
(Redirected from Happy Number)
You are encouraged to solve this task according to the task description, using any language you may know.
From Wikipedia, the free encyclopedia:
- 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 which does not include 1.
- Those numbers for which this process end in 1 are happy numbers,
- while those numbers that do not end in 1 are unhappy numbers.
- Task
Find and print the first 8 happy numbers.
Display an example of your output here on this page.
- Related tasks
- See also
- The OEIS entry: The happy numbers: A007770
- The OEIS entry: The unhappy numbers; A031177
11l
F happy(=n)
Set[Int] past
L n != 1
n = sum(String(n).map(с -> Int(с)^2))
I n C past
R 0B
past.add(n)
R 1B
print((0.<500).filter(x -> happy(x))[0.<8])- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
8080 Assembly
This is not just a demonstration of 8080 assembly, but also of why it pays to look closely at the problem domain. The following program only does 8-bit unsigned integer math, which not only fits the 8080's instruction set very well, it also means the cycle detection can be done using only an array of 256 flags, and all other state fits in the registers. This makes the program a good deal simpler than it would've been otherwise.
In general, 8-bit math is not good enough for numerical problems, but in this particular case, the problem only asks for the first eight happy numbers, none of which (nor any of the unhappy numbers in between) have a cycle that ever goes above 145, so eight bits is good enough. In fact, for any input under 256, the cycle never goes above 163; this program could be trivially changed to print up to 39 happy numbers.
flags: equ 2 ; 256-byte page in which to keep track of cycles
puts: equ 9 ; CP/M print string
bdos: equ 5 ; CP/M entry point
org 100h
lxi d,0108h ; D=current number to test, E=amount of numbers
;;; Is D happy?
number: mvi a,1 ; We haven't seen any numbers yet, set flags to 1
lxi h,256*flags
init: mov m,a
inr l
jnz init
mov a,d ; Get digits
step: call digits
mov l,a ; L = D1 * D1
mov h,a
xra a
sqr1: add h
dcr l
jnz sqr1
mov l,a
mov h,b ; L += D10 * D10
xra a
sqr10: add h
dcr b
jnz sqr10
add l
mov l,a
mov h,c ; L += D100 * D100
xra a
sqr100: add h
dcr c
jnz sqr100
add l
mov l,a
mvi h,flags ; Look up corresponding flag
dcr m ; Will give 0 the first time and not-0 afterwards
mov a,l ; If we haven't seen the number before, another step
jz step
dcr l ; If we _had_ seen it, then is it 1?
jz happy ; If so, it is happy
next: inr d ; Afterwards, try next number
jmp number
happy: mov a,d ; D is happy - get its digits (for output)
lxi h,string+3
call digits ; Write digits into string for output
call sdgt ; Ones digit,
mov a,b ; Tens digit,
call sdgt
mov a,c ; Hundreds digit
call sdgt
push d ; Keep counters on stack
mvi c,puts ; Print string using CP/M call
xchg
call bdos
pop d ; Restore counters
dcr e ; One fewer happy number left
jnz next ; If we need more, do the next one
ret
;;; Store A as ASCII digit in [HL] and go to previous digit
sdgt: adi '0'
dcx h
mov m,a
ret
;;; Get digits of 8-bit number in A.
;;; Input: A = number
;;; Output: C=100s digit, B=10s digit, A=1s digit
digits: lxi b,-1 ; Set B and C to -1 (correct for extra loop cycle)
d100: inr c ; Calculate hundreds digit
sui 100 ; By trial subtraction of 100
jnc d100 ; Until underflow occurs
adi 100 ; Loop runs one cycle too many, so add 100 back
d10: inr b ; Calculate 10s digit in the same way
sui 10
jnc d10
adi 10
ret ; 1s digit is left in A afterwards
string: db '000',13,10,'$'- Output:
001 007 010 013 019 023 028 031
8th
: until! "not while!" eval i;
with: w
with: n
: sumsqd \ n -- n
0 swap repeat
0; 10 /mod -rot sqr + swap
again ;
: cycle \ n xt -- n
>r
dup r@ exec \ -- tortoise, hare
repeat
swap r@ exec
swap r@ exec r@ exec
2dup = until!
rdrop drop ;
: happy? ' sumsqd cycle 1 = ;
: .happy \ n --
1 repeat
dup happy? if dup . space swap 1- swap then 1+
over 0 > while!
2drop cr ;
;with
;with- Output:
ok> 8 .happy 1 7 10 13 19 23 28 31
ABC
HOW TO RETURN square.digit.sum n:
PUT 0 IN sum
WHILE n>0:
PUT n mod 10 IN digit
PUT sum + digit ** 2 IN sum
PUT floor (n/10) IN n
RETURN sum
HOW TO REPORT happy n:
PUT {} IN seen
WHILE n not.in seen:
INSERT n IN seen
PUT square.digit.sum n IN n
REPORT n=1
HOW TO RETURN next.happy n:
PUT n+1 IN n
WHILE NOT happy n: PUT n+1 IN n
RETURN n
PUT 0 IN n
FOR i IN {1..8}:
PUT next.happy n IN n
WRITE n/- Output:
1 7 10 13 19 23 28 31
ACL2
(include-book "arithmetic-3/top" :dir :system)
(defun sum-of-digit-squares (n)
(if (zp n)
0
(+ (expt (mod n 10) 2)
(sum-of-digit-squares (floor n 10)))))
(defun is-happy-r (n seen)
(let ((next (sum-of-digit-squares n)))
(cond ((= next 1) t)
((member next seen) nil)
(t (is-happy-r next (cons next seen))))))
(defun is-happy (n)
(is-happy-r n nil))
(defun first-happy-nums-r (n i)
(cond ((zp n) nil)
((is-happy i)
(cons i (first-happy-nums-r (1- n) (1+ i))))
(t (first-happy-nums-r n (1+ i)))))
(defun first-happy-nums (n)
(first-happy-nums-r n 1))
Output:
(1 7 10 13 19 23 28 31)
Action!
BYTE FUNC SumOfSquares(BYTE x)
BYTE sum,d
sum=0
WHILE x#0
DO
d=x MOD 10
d==*d
sum==+d
x==/10
OD
RETURN (sum)
BYTE FUNC Contains(BYTE ARRAY a BYTE count,x)
BYTE i
FOR i=0 TO count-1
DO
IF a(i)=x THEN RETURN (1) FI
OD
RETURN (0)
BYTE FUNC IsHappyNumber(BYTE x)
BYTE ARRAY cache(100)
BYTE count
count=0
WHILE x#1
DO
cache(count)=x
count==+1
x=SumOfSquares(x)
IF Contains(cache,count,x) THEN
RETURN (0)
FI
OD
RETURN (1)
PROC Main()
BYTE x,count
x=1 count=0
WHILE count<8
DO
IF IsHappyNumber(x) THEN
count==+1
PrintF("%I: %I%E",count,x)
FI
x==+1
OD
RETURN- Output:
Screenshot from Atari 8-bit computer
1: 1 2: 7 3: 10 4: 13 5: 19 6: 23 7: 28 8: 31
ActionScript
function sumOfSquares(n:uint)
{
var sum:uint = 0;
while(n != 0)
{
sum += (n%10)*(n%10);
n /= 10;
}
return sum;
}
function isInArray(n:uint, array:Array)
{
for(var k = 0; k < array.length; k++)
if(n == array[k]) return true;
return false;
}
function isHappy(n)
{
var sequence:Array = new Array();
while(n != 1)
{
sequence.push(n);
n = sumOfSquares(n);
if(isInArray(n,sequence))return false;
}
return true;
}
function printHappy()
{
var numbersLeft:uint = 8;
var numberToTest:uint = 1;
while(numbersLeft != 0)
{
if(isHappy(numberToTest))
{
trace(numberToTest);
numbersLeft--;
}
numberToTest++;
}
}
printHappy();
Sample output:
1 7 10 13 19 23 28 31
Ada
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Ordered_Sets;
procedure Test_Happy_Digits is
function Is_Happy (N : Positive) return Boolean is
package Sets_Of_Positive is new Ada.Containers.Ordered_Sets (Positive);
use Sets_Of_Positive;
function Next (N : Positive) return Natural is
Sum : Natural := 0;
Accum : Natural := N;
begin
while Accum > 0 loop
Sum := Sum + (Accum mod 10) ** 2;
Accum := Accum / 10;
end loop;
return Sum;
end Next;
Current : Positive := N;
Visited : Set;
begin
loop
if Current = 1 then
return True;
elsif Visited.Contains (Current) then
return False;
else
Visited.Insert (Current);
Current := Next (Current);
end if;
end loop;
end Is_Happy;
Found : Natural := 0;
begin
for N in Positive'Range loop
if Is_Happy (N) then
Put (Integer'Image (N));
Found := Found + 1;
exit when Found = 8;
end if;
end loop;
end Test_Happy_Digits;
Sample output:
1 7 10 13 19 23 28 31
ALGOL 68
INT base10 = 10, num happy = 8;
PROC next = (INT in n)INT: (
INT n := in n;
INT out := 0;
WHILE n NE 0 DO
out +:= ( n MOD base10 ) ** 2;
n := n OVER base10
OD;
out
);
PROC is happy = (INT in n)BOOL: (
INT n := in n;
FOR i WHILE n NE 1 AND n NE 4 DO n := next(n) OD;
n=1
);
INT count := 0;
FOR i WHILE count NE num happy DO
IF is happy(i) THEN
count +:= 1;
print((i, new line))
FI
ODOutput:
+1
+7
+10
+13
+19
+23
+28
+31
ALGOL-M
begin
integer function mod(a,b);
integer a,b;
mod := a-(a/b)*b;
integer function sumdgtsq(n);
integer n;
sumdgtsq :=
if n = 0 then 0
else mod(n,10)*mod(n,10) + sumdgtsq(n/10);
integer function happy(n);
integer n;
begin
integer i;
integer array seen[0:200];
for i := 0 step 1 until 200 do seen[i] := 0;
while seen[n] = 0 do
begin
seen[n] := 1;
n := sumdgtsq(n);
end;
happy := if n = 1 then 1 else 0;
end;
integer i, n;
i := n := 0;
while n < 8 do
begin
if happy(i) = 1 then
begin
write(i);
n := n + 1;
end;
i := i + 1;
end;
end- Output:
1
7
10
13
19
23
28
31
ALGOL W
begin % find some happy numbers: numbers whose digit-square sums become 1 %
% when repeatedly applied %
% returns true if n is happy, false otherwise %
logical procedure isHappy ( integer value n ) ;
begin
% in base ten, numbers either reach 1 or loop around a sequence %
% containing 4 (see the Wikipedia article) %
integer v, dSum, d;
v := abs n;
if v > 1 then begin
while begin
dSum := 0;
while v not = 0 do begin
d := v rem 10;
v := v div 10;
dSum := dSum + ( d * d )
end while_v_ne_0 ;
v := dSum;
v not = 1 and v not = 4
end do begin end
end if_v_ne_0 ;
v = 1
end isHappy ;
begin % find the first 8 happy numbers %
integer n, hCount;
hCount := 0;
n := 1;
while hCount < 8 do begin
if isHappy( n ) then begin
writeon( i_w := 1, s_w := 0, " ", n );
hCount := hCount + 1
end if_isHappy__n ;
n := n + 1
end while_hCount_lt_10
end
end.- Output:
1 7 10 13 19 23 28 31
APL
Tradfn
∇ HappyNumbers arg;⎕IO;∆roof;∆first;bin;iroof
[1] ⍝0: Happy number
[2] ⍝1: http://rosettacode.org/wiki/Happy_numbers
[3] ⎕IO←1 ⍝ Index origin
[4] ∆roof ∆first←2↑arg,10 ⍝
[5]
[6] bin←{
[7] ⍺←⍬ ⍝ Default left arg
[8] ⍵=1:1 ⍝ Always happy!
[9]
[10] numbers←⍎¨1⊂⍕⍵ ⍝ Split numbers into parts
[11] next←+/{⍵*2}¨numbers ⍝ Sum and square of numbers
[12]
[13] next∊⍺:0 ⍝ Return 0, if already exists
[14] (⍺,next)∇ next ⍝ Check next number (recursive)
[15]
[16] }¨iroof←⍳∆roof ⍝ Does all numbers upto ∆root smiles?
[17]
[18] ⎕←~∘0¨∆first↑bin/iroof ⍝ Show ∆first numbers, but not 0
∇
HappyNumbers 100 8 1 7 10 13 19 23 28 31
Dfn
HappyNumbers←{ ⍝ return the first ⍵ Happy Numbers
⍺←⍬ ⍝ initial list
⍵=+/⍺:⍸⍺ ⍝ 1's mark happy numbers
sq←×⍨ ⍝ square function (times selfie)
isHappy←{ ⍝ is ⍵ a happy number?
⍺←⍬ ⍝ previous sums
⍵=1:1 ⍝ if we get to 1, it's happy
n←+/sq∘⍎¨⍕⍵ ⍝ sum of the square of the digits
n∊⍺:0 ⍝ if we hit this sum before, it's not happy
(⍺,n)∇ n} ⍝ recurse until it's happy or not
(⍺,isHappy 1+≢⍺)∇ ⍵ ⍝ recurse until we have ⍵ happy numbers
}
HappyNumbers 8
1 7 10 13 19 23 28 31
AppleScript
Iteration
on run
set howManyHappyNumbers to 8
set happyNumberList to {}
set globalCounter to 1
repeat howManyHappyNumbers times
repeat while not isHappy(globalCounter)
set globalCounter to globalCounter + 1
end repeat
set end of happyNumberList to globalCounter
set globalCounter to globalCounter + 1
end repeat
log happyNumberList
end run
on isHappy(numberToCheck)
set localCycle to {}
repeat while (numberToCheck ≠ 1)
if localCycle contains numberToCheck then
exit repeat
end if
set end of localCycle to numberToCheck
set tempNumber to 0
repeat while (numberToCheck > 0)
set digitOfNumber to numberToCheck mod 10
set tempNumber to tempNumber + (digitOfNumber ^ 2)
set numberToCheck to (numberToCheck - digitOfNumber) / 10
end repeat
set numberToCheck to tempNumber
end repeat
return (numberToCheck = 1)
end isHappy
Result: (*1, 7, 10, 13, 19, 23, 28, 31*)
Functional composition
---------------------- HAPPY NUMBERS -----------------------
-- isHappy :: Int -> Bool
on isHappy(n)
-- endsInOne :: [Int] -> Int -> Bool
script endsInOne
-- sumOfSquaredDigits :: Int -> Int
script sumOfSquaredDigits
-- digitSquared :: Int -> Int -> Int
script digitSquared
on |λ|(a, x)
(a + (x as integer) ^ 2) as integer
end |λ|
end script
on |λ|(n)
foldl(digitSquared, 0, splitOn("", n as string))
end |λ|
end script
-- [Int] -> Int -> Bool
on |λ|(s, n)
if n = 1 then
true
else
if s contains n then
false
else
|λ|(s & n, |λ|(n) of sumOfSquaredDigits)
end if
end if
end |λ|
end script
endsInOne's |λ|({}, n)
end isHappy
--------------------------- TEST ---------------------------
on run
-- seriesLength :: {n:Int, xs:[Int]} -> Bool
script seriesLength
property target : 8
on |λ|(rec)
length of xs of rec = target of seriesLength
end |λ|
end script
-- succTest :: {n:Int, xs:[Int]} -> {n:Int, xs:[Int]}
script succTest
on |λ|(rec)
tell rec to set {xs, n} to {its xs, its n}
script testResult
on |λ|(x)
if isHappy(x) then
xs & x
else
xs
end if
end |λ|
end script
{n:n + 1, xs:testResult's |λ|(n)}
end |λ|
end script
xs of |until|(seriesLength, succTest, {n:1, xs:{}})
--> {1, 7, 10, 13, 19, 23, 28, 31}
end run
-------------------- GENERIC FUNCTIONS ---------------------
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- splitOn :: String -> String -> [String]
on splitOn(pat, src)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, pat}
set xs to text items of src
set my text item delimiters to dlm
return xs
end splitOn
-- until :: (a -> Bool) -> (a -> a) -> a -> a
on |until|(p, f, x)
set mp to mReturn(p)
set v to x
tell mReturn(f)
repeat until mp's |λ|(v)
set v to |λ|(v)
end repeat
end tell
return v
end |until|
- Output:
{1, 7, 10, 13, 19, 23, 28, 31}
Arturo
ord0: to :integer `0`
happy?: function [x][
n: x
past: new []
while [n <> 1][
s: to :string n
n: 0
loop s 'c [
i: (to :integer c) - ord0
n: n + i * i
]
if contains? past n -> return false
'past ++ n
]
return true
]
loop 0..31 'x [
if happy? x -> print x
]
- Output:
1 7 10 13 19 23 28 31
AutoHotkey
Loop {
If isHappy(A_Index) {
out .= (out="" ? "" : ",") . A_Index
i ++
If (i = 8) {
MsgBox, The first 8 happy numbers are: %out%
ExitApp
}
}
}
isHappy(num, list="") {
list .= (list="" ? "" : ",") . num
Loop, Parse, num
sum += A_LoopField ** 2
If (sum = 1)
Return true
Else If sum in %list%
Return false
Else Return isHappy(sum, list)
}
The first 8 happy numbers are: 1,7,10,13,19,23,28,31
Alternative version
while h < 8
if (Happy(A_Index)) {
Out .= A_Index A_Space
h++
}
MsgBox, % Out
Happy(n) {
Loop, {
Loop, Parse, n
t += A_LoopField ** 2
if (t = 89)
return, 0
if (t = 1)
return, 1
n := t, t := 0
}
}
1 7 10 13 19 23 28 31
AutoIt
$c = 0
$k = 0
While $c < 8
$k += 1
$n = $k
While $n <> 1
$s = StringSplit($n, "")
$t = 0
For $i = 1 To $s[0]
$t += $s[$i] ^ 2
Next
$n = $t
Switch $n
Case 4,16,37,58,89,145,42,20
ExitLoop
EndSwitch
WEnd
If $n = 1 Then
ConsoleWrite($k & " is Happy" & @CRLF)
$c += 1
EndIf
WEnd
Use a set of numbers (4,16,37,58,89,145,42,20) to indicate a loop and exit. Output: 1 is Happy 7 is Happy 10 is Happy 13 is Happy 19 is Happy 23 is Happy 28 is Happy 31 is Happy
Alternative version
$c = 0
$k = 0
While $c < 8
$a = ObjCreate("System.Collections.ArrayList")
$k += 1
$n = $k
While $n <> 1
If $a.Contains($n) Then
ExitLoop
EndIf
$a.add($n)
$s = StringSplit($n, "")
$t = 0
For $i = 1 To $s[0]
$t += $s[$i] ^ 2
Next
$n = $t
WEnd
If $n = 1 Then
ConsoleWrite($k & " is Happy" & @CRLF)
$c += 1
EndIf
$a.Clear
WEnd
Saves all numbers in a list, duplicate entry indicates a loop. Output: 1 is Happy 7 is Happy 10 is Happy 13 is Happy 19 is Happy 23 is Happy 28 is Happy 31 is Happy
AWK
function is_happy(n)
{
if ( n in happy ) return 1;
if ( n in unhappy ) return 0;
cycle[""] = 0
while( (n!=1) && !(n in cycle) ) {
cycle[n] = n
new_n = 0
while(n>0) {
d = n % 10
new_n += d*d
n = int(n/10)
}
n = new_n
}
if ( n == 1 ) {
for (i_ in cycle) {
happy[cycle[i_]] = 1
delete cycle[i_]
}
return 1
} else {
for (i_ in cycle) {
unhappy[cycle[i_]] = 1
delete cycle[i_]
}
return 0
}
}
BEGIN {
cnt = 0
happy[""] = 0
unhappy[""] = 0
for(j=1; (cnt < 8); j++) {
if ( is_happy(j) == 1 ) {
cnt++
print j
}
}
}
Result:
1 7 10 13 19 23 28 31
Alternative version
Alternately, for legibility one might write:
BEGIN {
for (i = 1; i < 50; ++i){
if (isHappy(i)) {
print i;
}
}
exit
}
function isHappy(n, seen) {
delete seen;
while (1) {
n = sumSqrDig(n)
if (seen[n]) {
return n == 1
}
seen[n] = 1
}
}
function sumSqrDig(n, d, tot) {
while (n) {
d = n % 10
tot += d * d
n = int(n/10)
}
return tot
}
BASIC
Applesoft BASIC
0 C = 8: DIM S(16):B = 10: PRINT "THE FIRST "C" HAPPY NUMBERS": FOR R = C TO 0 STEP 0:N = H: GOSUB 1: PRINT MID$ (" " + STR$ (H),1 + (R = C),255 * I);:R = R - I:H = H + 1: NEXT R: END
1 S = 0: GOSUB 3:I = N = 1: IF NOT Q THEN RETURN
2 FOR Q = 1 TO 0 STEP 0:S(S) = N:S = S + 1: GOSUB 6:N = T: GOSUB 3: NEXT Q:I = N = 1: RETURN
3 Q = N > 1: IF NOT Q OR NOT S THEN RETURN
4 Q = 0: FOR I = 0 TO S - 1: IF N = S(I) THEN RETURN
5 NEXT I:Q = 1: RETURN
6 T = 0: FOR I = N TO 0 STEP 0:M = INT (I / B):T = INT (T + (I - M * B) ^ 2):I = M: NEXT I: RETURN
- Output:
THE FIRST 8 HAPPY NUMBERS 1 7 10 13 19 23 28 31
BASIC256
n = 1 : cnt = 0
print "The first 8 isHappy numbers are:"
print
while cnt < 8
if isHappy(n) = 1 then
cnt += 1
print cnt; " => "; n
end if
n += 1
end while
function isHappy(num)
isHappy = 0
cont = 0
while cont < 50 and isHappy <> 1
num$ = string(num)
cont += 1
isHappy = 0
for i = 1 to length(num$)
isHappy += int(mid(num$,i,1)) ^ 2
next i
num = isHappy
end while
end function
BBC BASIC
number% = 0
total% = 0
REPEAT
number% += 1
IF FNhappy(number%) THEN
PRINT number% " is a happy number"
total% += 1
ENDIF
UNTIL total% = 8
END
DEF FNhappy(num%)
LOCAL digit&()
DIM digit&(10)
REPEAT
digit&() = 0
$$^digit&(0) = STR$(num%)
digit&() AND= 15
num% = MOD(digit&())^2 + 0.5
UNTIL num% = 1 OR num% = 4
= (num% = 1)
Output:
1 is a happy number
7 is a happy number
10 is a happy number
13 is a happy number
19 is a happy number
23 is a happy number
28 is a happy number
31 is a happy number
Commodore BASIC
The array sizes here are tuned to the minimum values required to find the first 8 happy numbers in numerical order. The H and U arrays are used for memoization, so the subscripts H(n) and U(n) must exist for the highest n encountered. The array N must have room to hold the longest chain examined in the course of determining whether a single number is happy, which thanks to the memoization is only ten elements long.
100 C=8:DIM H(145),U(145),N(9)
110 PRINT CHR$(147):PRINT "THE FIRST"C"HAPPY NUMBERS:":PRINT
120 H(1)=1:N=1
130 FOR C=C TO 0 STEP 0
140 : GOSUB 200
150 : IF H THEN PRINT N,:C=C-1
160 : N=N+1
170 NEXT C
180 PRINT
190 END
200 K=0:N(K)=N
210 IF H(N(K)) THEN H=1:FOR J=0 TO K:U(N(J))=0:H(N(J))=1:NEXT J:RETURN
220 IF U(N(K)) THEN H=0:RETURN
230 U(N(K))=1
240 N$=MID$(STR$(N(K)),2)
250 L=LEN(N$)
260 K=K+1:N(K)=0
270 FOR I=1 TO L
280 : D = VAL(MID$(N$,I,1))
290 : N(K) = N(K) + D * D
300 NEXT I
310 GOTO 210
- Output:
THE FIRST 8 HAPPY NUMBERS: 1 7 10 13 19 23 28 31 READY.
FreeBASIC
' FB 1.05.0 Win64
Function isHappy(n As Integer) As Boolean
If n < 0 Then Return False
' Declare a dynamic array to store previous sums.
' If a previous sum is duplicated before a sum of 1 is reached
' then the number can't be "happy" as the cycle will just repeat
Dim prevSums() As Integer
Dim As Integer digit, ub, sum = 0
Do
While n > 0
digit = n Mod 10
sum += digit * digit
n \= 10
Wend
If sum = 1 Then Return True
ub = UBound(prevSums)
If ub > -1 Then
For i As Integer = 0 To ub
If sum = prevSums(i) Then Return False
Next
End If
ub += 1
Redim Preserve prevSums(0 To ub)
prevSums(ub) = sum
n = sum
sum = 0
Loop
End Function
Dim As Integer n = 1, count = 0
Print "The first 8 happy numbers are : "
Print
While count < 8
If isHappy(n) Then
count += 1
Print count;" =>"; n
End If
n += 1
Wend
Print
Print "Press any key to quit"
Sleep
- Output:
1 => 1 2 => 7 3 => 10 4 => 13 5 => 19 6 => 23 7 => 28 8 => 31
Liberty BASIC
ct = 0
n = 0
DO
n = n + 1
IF HappyN(n, sqrInt$) = 1 THEN
ct = ct + 1
PRINT ct, n
END IF
LOOP UNTIL ct = 8
END
FUNCTION HappyN(n, sqrInts$)
n$ = Str$(n)
sqrInts = 0
FOR i = 1 TO Len(n$)
sqrInts = sqrInts + Val(Mid$(n$, i, 1)) ^ 2
NEXT i
IF sqrInts = 1 THEN
HappyN = 1
EXIT FUNCTION
END IF
IF Instr(sqrInts$, ":";Str$(sqrInts);":") > 0 THEN
HappyN = 0
EXIT FUNCTION
END IF
sqrInts$ = sqrInts$ + Str$(sqrInts) + ":"
HappyN = HappyN(sqrInts, sqrInts$)
END FUNCTIONOutput:-
1 1 2 7 3 10 4 13 5 19 6 23 7 28 8 31
Locomotive Basic
10 mode 1:defint a-z
20 for i=1 to 100
30 i2=i
40 for l=1 to 20
50 a$=str$(i2)
60 i2=0
70 for j=1 to len(a$)
80 d=val(mid$(a$,j,1))
90 i2=i2+d*d
100 next j
110 if i2=1 then print i;"is a happy number":n=n+1:goto 150
120 if i2=4 then 150 ' cycle found
130 next l
140 ' check if we have reached 8 numbers yet
150 if n=8 then end
160 next i
PureBasic
#ToFind=8
#MaxTests=100
#True = 1: #False = 0
Declare is_happy(n)
If OpenConsole()
Define i=1,Happy
Repeat
If is_happy(i)
Happy+1
PrintN("#"+Str(Happy)+RSet(Str(i),3))
EndIf
i+1
Until Happy>=#ToFind
;
Print(#CRLF$+#CRLF$+"Press ENTER to exit"): Input()
CloseConsole()
EndIf
Procedure is_happy(n)
Protected i,j=n,dig,sum
Repeat
sum=0
While j
dig=j%10
j/10
sum+dig*dig
Wend
If sum=1: ProcedureReturn #True: EndIf
j=sum
i+1
Until i>#MaxTests
ProcedureReturn #False
EndProcedure
Sample output:
#1 1 #2 7 #3 10 #4 13 #5 19 #6 23 #7 28 #8 31
Run BASIC
for i = 1 to 100
if happy(i) = 1 then
cnt = cnt + 1
PRINT cnt;". ";i;" is a happy number "
if cnt = 8 then end
end if
next i
FUNCTION happy(num)
while count < 50 and happy <> 1
num$ = str$(num)
count = count + 1
happy = 0
for i = 1 to len(num$)
happy = happy + val(mid$(num$,i,1)) ^ 2
next i
num = happy
wend
end function1. 1 is a happy number 2. 7 is a happy number 3. 10 is a happy number 4. 13 is a happy number 5. 19 is a happy number 6. 23 is a happy number 7. 28 is a happy number 8. 31 is a happy number
uBasic/4tH
' ************************
' MAIN
' ************************
PROC _PRINT_HAPPY(20)
END
' ************************
' END MAIN
' ************************
' ************************
' SUBS & FUNCTIONS
' ************************
' --------------------
_is_happy PARAM(1)
' --------------------
LOCAL (5)
f@ = 100
c@ = a@
b@ = 0
DO WHILE b@ < f@
e@ = 0
DO WHILE c@
d@ = c@ % 10
c@ = c@ / 10
e@ = e@ + (d@ * d@)
LOOP
UNTIL e@ = 1
c@ = e@
b@ = b@ + 1
LOOP
RETURN(b@ < f@)
' --------------------
_PRINT_HAPPY PARAM(1)
' --------------------
LOCAL (2)
b@ = 1
c@ = 0
DO
IF FUNC (_is_happy(b@)) THEN
c@ = c@ + 1
PRINT b@
ENDIF
b@ = b@ + 1
UNTIL c@ + 1 > a@
LOOP
RETURN
' ************************
' END SUBS & FUNCTIONS
' ************************
VBA
Option Explicit
Sub Test_Happy()
Dim i&, Cpt&
For i = 1 To 100
If Is_Happy_Number(i) Then
Debug.Print "Is Happy : " & i
Cpt = Cpt + 1
If Cpt = 8 Then Exit For
End If
Next
End Sub
Public Function Is_Happy_Number(ByVal N As Long) As Boolean
Dim i&, Number$, Cpt&
Is_Happy_Number = False 'default value
Do
Cpt = Cpt + 1 'Count Loops
Number = CStr(N) 'conversion Long To String to be able to use Len() function
N = 0
For i = 1 To Len(Number)
N = N + CInt(Mid(Number, i, 1)) ^ 2
Next i
'If Not N = 1 after 50 Loop ==> Number Is Not Happy
If Cpt = 50 Then Exit Function
Loop Until N = 1
Is_Happy_Number = True
End Function
- Output:
Is Happy : 1 Is Happy : 7 Is Happy : 10 Is Happy : 13 Is Happy : 19 Is Happy : 23 Is Happy : 28 Is Happy : 31
VBScript
count = 0
firsteigth=""
For i = 1 To 100
If IsHappy(CInt(i)) Then
firsteight = firsteight & i & ","
count = count + 1
End If
If count = 8 Then
Exit For
End If
Next
WScript.Echo firsteight
Function IsHappy(n)
IsHappy = False
m = 0
Do Until m = 60
sum = 0
For j = 1 To Len(n)
sum = sum + (Mid(n,j,1))^2
Next
If sum = 1 Then
IsHappy = True
Exit Do
Else
n = sum
m = m + 1
End If
Loop
End Function
- Output:
1,7,10,13,19,23,28,31,
Visual Basic .NET
This version uses Linq to carry out the calculations.
Module HappyNumbers
Sub Main()
Dim n As Integer = 1
Dim found As Integer = 0
Do Until found = 8
If IsHappy(n) Then
found += 1
Console.WriteLine("{0}: {1}", found, n)
End If
n += 1
Loop
Console.ReadLine()
End Sub
Private Function IsHappy(ByVal n As Integer)
Dim cache As New List(Of Long)()
Do Until n = 1
cache.Add(n)
n = Aggregate c In n.ToString() _
Into Total = Sum(Int32.Parse(c) ^ 2)
If cache.Contains(n) Then Return False
Loop
Return True
End Function
End Module
The output is:
1: 1 2: 7 3: 10 4: 13 5: 19 6: 23 7: 28 8: 31
Cacheless version
Curiously, this runs in about two thirds of the time of the cacheless C# version on Tio.run.
Module Module1
Dim sq As Integer() = {1, 4, 9, 16, 25, 36, 49, 64, 81}
Function isOne(x As Integer) As Boolean
While True
If x = 89 Then Return False
Dim t As Integer, s As Integer = 0
Do
t = (x Mod 10) - 1 : If t >= 0 Then s += sq(t)
x \= 10
Loop While x > 0
If s = 1 Then Return True
x = s
End While
Return False
End Function
Sub Main(ByVal args As String())
Const Max As Integer = 10_000_000
Dim st As DateTime = DateTime.Now
Console.Write("---Happy Numbers---" & vbLf & "The first 8:")
Dim i As Integer = 1, c As Integer = 0
While c < 8
If isOne(i) Then Console.Write("{0} {1}", If(c = 0, "", ","), i, c) : c += 1
i += 1
End While
Dim m As Integer = 10
While m <= Max
Console.Write(vbLf & "The {0:n0}th: ", m)
While c < m
If isOne(i) Then c += 1
i += 1
End While
Console.Write("{0:n0}", i - 1)
m = m * 10
End While
Console.WriteLine(vbLf & "Computation time {0} seconds.", (DateTime.Now - st).TotalSeconds)
End Sub
End Module
- Output:
---Happy Numbers--- The first 8: 1, 7, 10, 13, 19, 23, 28, 31 The 10th: 44 The 100th: 694 The 1,000th: 6,899 The 10,000th: 67,169 The 100,000th: 692,961 The 1,000,000th: 7,105,849 The 10,000,000th: 71,313,350 Computation time 19.235551 seconds.
ZX Spectrum Basic
10 FOR i=1 TO 100
20 GO SUB 1000
30 IF isHappy=1 THEN PRINT i;" is a happy number"
40 NEXT i
50 STOP
1000 REM Is Happy?
1010 LET isHappy=0: LET count=0: LET num=i
1020 IF count=50 OR isHappy=1 THEN RETURN
1030 LET n$=STR$ (num)
1040 LET count=count+1
1050 LET isHappy=0
1060 FOR j=1 TO LEN n$
1070 LET isHappy=isHappy+VAL n$(j)^2
1080 NEXT j
1090 LET num=isHappy
1100 GO TO 1020
Batch File
happy.bat
@echo off
setlocal enableDelayedExpansion
::Define a list with 10 terms as a convenience for defining a loop
set "L10=0 1 2 3 4 5 6 7 8 9"
shift /1 & goto %1
exit /b
:list min count
:: This routine prints all happy numbers > min (arg1)
:: until it finds count (arg2) happy numbers.
set /a "n=%~1, cnt=%~2"
call :listInternal
exit /b
:test min [max]
:: This routine sequentially tests numbers between min (arg1) and max (arg2)
:: to see if they are happy. If max is not specified then it defaults to min.
set /a "min=%~1"
if "%~2" neq "" (set /a "max=%~2") else set max=%min%
::The FOR /L loop does not detect integer overflow, so must protect against
::an infinite loop when max=0x7FFFFFFFF
set end=%max%
if %end% equ 2147483647 set /a end-=1
for /l %%N in (%min% 1 %end%) do (
call :testInternal %%N && (echo %%N is happy :^)) || echo %%N is sad :(
)
if %end% neq %max% call :testInternal %max% && (echo %max% is happy :^)) || echo %max% is sad :(
exit /b
:listInternal
:: This loop sequentially tests each number >= n. The loop conditionally
:: breaks within the body once cnt happy numbers have been found, or if
:: the max integer value is reached. Performance is improved by using a
:: FOR loop to perform most of the looping, with a GOTO only needed once
:: per 100 iterations.
for %%. in (
%L10% %L10% %L10% %L10% %L10% %L10% %L10% %L10% %L10% %L10%
) do (
call :testInternal !n! && (
echo !n!
set /a cnt-=1
if !cnt! leq 0 exit /b 0
)
if !n! equ 2147483647 (
>&2 echo ERROR: Maximum integer value reached
exit /b 1
)
set /a n+=1
)
goto :listInternal
:testInternal n
:: This routine loops until the sum of squared digits converges on 1 (happy)
:: or it detects a cycle (sad). It exits with errorlevel 0 for happy and 1 for sad.
:: Performance is improved by using a FOR loop for the looping instead of a GOTO.
:: Numbers less than 1000 never neeed more than 20 iterations, and any number
:: with 4 or more digits shrinks by at least one digit each iteration.
:: Since Windows batch can't handle more than 10 digits, allowance for 27
:: iterations is enough, and 30 is more than adequate.
setlocal
set n=%1
for %%. in (%L10% %L10% %L10%) do (
if !n!==1 exit /b 0
%= Only numbers < 1000 can cycle =%
if !n! lss 1000 (
if defined t.!n! exit /b 1
set t.!n!=1
)
%= Sum the squared digits =%
%= Batch can't handle numbers greater than 10 digits so we can use =%
%= a constrained FOR loop and avoid a slow goto =%
set sum=0
for /l %%N in (1 1 10) do (
if !n! gtr 0 set /a "sum+=(n%%10)*(n%%10), n/=10"
)
set /a n=sum
)
Sample usage and output
>happy list 1 8 1 7 10 13 19 23 28 31 >happy list 1000000000 10 1000000000 1000000003 1000000009 1000000029 1000000030 1000000033 1000000039 1000000067 1000000076 1000000088 >happy test 30 30 is sad :( >happy test 31 31 is happy :) >happy test 1 10 1 is happy :) 2 is sad :( 3 is sad :( 4 is sad :( 5 is sad :( 6 is sad :( 7 is happy :) 8 is sad :( 9 is sad :( 10 is happy :) >happy test "50 + 10 * 5" 100 is happy :) >happy test 0x7fffffff 2147483647 is sad :( >happy test 0x7ffffffd 2147483645 is happy :) >happy list 0x7ffffff0 10 2147483632 2147483645 ERROR: Maximum integer value reached
BCPL
get "libhdr"
let sumdigitsq(n) =
n=0 -> 0, (n rem 10)*(n rem 10)+sumdigitsq(n/10)
let happy(n) = valof
$( let seen = vec 255
for i = 0 to 255 do i!seen := false
$( n!seen := true
n := sumdigitsq(n)
$) repeatuntil n!seen
resultis 1!seen
$)
let start() be
$( let n, i = 0, 0
while n < 8 do
$( if happy(i) do
$( n := n + 1
writef("%N ",i)
$)
i := i + 1
$)
wrch('*N')
$)- Output:
1 7 10 13 19 23 28 31
Bori
bool isHappy (int n)
{
ints cache;
while (n != 1)
{
int sum = 0;
if (cache.contains(n))
return false;
cache.add(n);
while (n != 0)
{
int digit = n % 10;
sum += (digit * digit);
n = (int)(n / 10);
}
n = sum;
}
return true;
}
void test ()
{
int num = 1;
ints happynums;
while (happynums.count() < 8)
{
if (isHappy(num))
happynums.add(num);
num++;
}
puts("First 8 happy numbers : " + str.newline + happynums);
}Output:
First 8 happy numbers : [1, 7, 10, 13, 19, 23, 28, 31]
BQN
SumSqDgt ← +´2⋆˜ •Fmt-'0'˙
Happy ← ⟨⟩{𝕨((⊑∊˜ )◶⟨∾𝕊(SumSqDgt⊢),1=⊢⟩)𝕩}⊢
8↑Happy¨⊸/↕50
- Output:
⟨ 1 7 10 13 19 23 28 31 ⟩
Brat
include :set
happiness = set.new 1
sadness = set.new
sum_of_squares_of_digits = { num |
num.to_s.dice.reduce 0 { sum, n | sum = sum + n.to_i ^ 2 }
}
happy? = { n, seen = set.new |
when {true? happiness.include? n } { happiness.merge seen << n; true }
{ true? sadness.include? n } { sadness.merge seen; false }
{ true? seen.include? n } { sadness.merge seen; false }
{ true } { seen << n; happy? sum_of_squares_of_digits(n), seen }
}
num = 1
happies = []
while { happies.length < 8 } {
true? happy?(num)
{ happies << num }
num = num + 1
}
p "First eight happy numbers: #{happies}"
p "Happy numbers found: #{happiness.to_array.sort}"
p "Sad numbers found: #{sadness.to_array.sort}"Output:
First eight happy numbers: [1, 7, 10, 13, 19, 23, 28, 31] Happy numbers found: [1, 7, 10, 13, 19, 23, 28, 31, 49, 68, 82, 97, 100, 130] Sad numbers found: [2, 3, 4, 5, 6, 8, 9, 11, 12, 14, 15, 16, 17, 18, 20, 21, 22, 24, 25, 26, 27, 29, 30, 34, 36, 37, 40, 41, 42, 45, 50, 52, 53, 58, 61, 64, 65, 81, 85, 89, 145]
C
Recursively look up if digit square sum is happy.
#include <stdio.h>
#define CACHE 256
enum { h_unknown = 0, h_yes, h_no };
unsigned char buf[CACHE] = {0, h_yes, 0};
int happy(int n)
{
int sum = 0, x, nn;
if (n < CACHE) {
if (buf[n]) return 2 - buf[n];
buf[n] = h_no;
}
for (nn = n; nn; nn /= 10) x = nn % 10, sum += x * x;
x = happy(sum);
if (n < CACHE) buf[n] = 2 - x;
return x;
}
int main()
{
int i, cnt = 8;
for (i = 1; cnt || !printf("\n"); i++)
if (happy(i)) --cnt, printf("%d ", i);
printf("The %dth happy number: ", cnt = 1000000);
for (i = 1; cnt; i++)
if (happy(i)) --cnt || printf("%d\n", i);
return 0;
}
output
1 7 10 13 19 23 28 31 The 1000000th happy number: 7105849
Without caching, using cycle detection:
#include <stdio.h>
int dsum(int n)
{
int sum, x;
for (sum = 0; n; n /= 10) x = n % 10, sum += x * x;
return sum;
}
int happy(int n)
{
int nn;
while (n > 999) n = dsum(n); /* 4 digit numbers can't cycle */
nn = dsum(n);
while (nn != n && nn != 1)
n = dsum(n), nn = dsum(dsum(nn));
return n == 1;
}
int main()
{
int i, cnt = 8;
for (i = 1; cnt || !printf("\n"); i++)
if (happy(i)) --cnt, printf("%d ", i);
printf("The %dth happy number: ", cnt = 1000000);
for (i = 1; cnt; i++)
if (happy(i)) --cnt || printf("%d\n", i);
return 0;
}
Output is same as above, but much slower.
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HappyNums
{
class Program
{
public static bool ishappy(int n)
{
List<int> cache = new List<int>();
int sum = 0;
while (n != 1)
{
if (cache.Contains(n))
{
return false;
}
cache.Add(n);
while (n != 0)
{
int digit = n % 10;
sum += digit * digit;
n /= 10;
}
n = sum;
sum = 0;
}
return true;
}
static void Main(string[] args)
{
int num = 1;
List<int> happynums = new List<int>();
while (happynums.Count < 8)
{
if (ishappy(num))
{
happynums.Add(num);
}
num++;
}
Console.WriteLine("First 8 happy numbers : " + string.Join(",", happynums));
}
}
}
First 8 happy numbers : 1,7,10,13,19,23,28,31
Alternate (cacheless)
Instead of caching and checking for being stuck in a loop, one can terminate on the "unhappy" endpoint of 89. One might be temped to try caching the so-far-found happy and unhappy numbers and checking the cache to speed things up. However, I have found that the cache implementation overhead reduces performance compared to this cacheless version.
Reaching 10 million, the <34 second computation time was from Tio.run. It takes under 5 seconds on a somewhat modern CPU. If you edit it to max out at 100 million, it takes about 50 seconds (on the somewhat modern CPU).
using System;
using System.Collections.Generic;
class Program
{
static int[] sq = { 1, 4, 9, 16, 25, 36, 49, 64, 81 };
static bool isOne(int x)
{
while (true)
{
if (x == 89) return false;
int s = 0, t;
do if ((t = (x % 10) - 1) >= 0) s += sq[t]; while ((x /= 10) > 0);
if (s == 1) return true;
x = s;
}
}
static void Main(string[] args)
{
const int Max = 10_000_000; DateTime st = DateTime.Now;
Console.Write("---Happy Numbers---\nThe first 8:");
int c = 0, i; for (i = 1; c < 8; i++)
if (isOne(i)) Console.Write("{0} {1}", c == 0 ? "" : ",", i, ++c);
for (int m = 10; m <= Max; m *= 10)
{
Console.Write("\nThe {0:n0}th: ", m);
for (; c < m; i++) if (isOne(i)) c++;
Console.Write("{0:n0}", i - 1);
}
Console.WriteLine("\nComputation time {0} seconds.", (DateTime.Now - st).TotalSeconds);
}
}
- Output:
---Happy Numbers--- The first 8: 1, 7, 10, 13, 19, 23, 28, 31 The 10th: 44 The 100th: 694 The 1,000th: 6,899 The 10,000th: 67,169 The 100,000th: 692,961 The 1,000,000th: 7,105,849 The 10,000,000th: 71,313,350 Computation time 33.264518 seconds.
C++
#include <map>
#include <set>
bool happy(int number) {
static std::map<int, bool> cache;
std::set<int> cycle;
while (number != 1 && !cycle.count(number)) {
if (cache.count(number)) {
number = cache[number] ? 1 : 0;
break;
}
cycle.insert(number);
int newnumber = 0;
while (number > 0) {
int digit = number % 10;
newnumber += digit * digit;
number /= 10;
}
number = newnumber;
}
bool happiness = number == 1;
for (std::set<int>::const_iterator it = cycle.begin();
it != cycle.end(); it++)
cache[*it] = happiness;
return happiness;
}
#include <iostream>
int main() {
for (int i = 1; i < 50; i++)
if (happy(i))
std::cout << i << std::endl;
return 0;
}
Output:
1 7 10 13 19 23 28 31 32 44 49
Alternative version without caching:
unsigned int happy_iteration(unsigned int n)
{
unsigned int result = 0;
while (n > 0)
{
unsigned int lastdig = n % 10;
result += lastdig*lastdig;
n /= 10;
}
return result;
}
bool is_happy(unsigned int n)
{
unsigned int n2 = happy_iteration(n);
while (n != n2)
{
n = happy_iteration(n);
n2 = happy_iteration(happy_iteration(n2));
}
return n == 1;
}
#include <iostream>
int main()
{
unsigned int current_number = 1;
unsigned int happy_count = 0;
while (happy_count != 8)
{
if (is_happy(current_number))
{
std::cout << current_number << " ";
++happy_count;
}
++current_number;
}
std::cout << std::endl;
}
Output:
1 7 10 13 19 23 28 31
Cycle detection in is_happy() above is done using Floyd's cycle-finding algorithm.
Clojure
(defn happy? [n]
(loop [n n, seen #{}]
(cond
(= n 1) true
(seen n) false
:else
(recur (->> (str n)
(map #(Character/digit % 10))
(map #(* % %))
(reduce +))
(conj seen n)))))
(def happy-numbers (filter happy? (iterate inc 1)))
(println (take 8 happy-numbers))
Output:
(1 7 10 13 19 23 28 31)
Alternate Version (with caching)
(require '[clojure.set :refer [union]])
(def ^{:private true} cache {:happy (atom #{}) :sad (atom #{})})
(defn break-apart [n]
(->> (str n)
(map str)
(map #(Long/parseLong %))))
(defn next-number [n]
(->> (break-apart n)
(map #(* % %))
(apply +)))
(defn happy-or-sad? [prev n]
(cond (or (= n 1) ((deref (:happy cache)) n)) :happy
(or ((deref (:sad cache)) n) (some #(= % n) prev)) :sad
:else :unknown))
(defn happy-algo [n]
(let [get-next (fn [[prev n]] [(conj prev n) (next-number n)])
my-happy-or-sad? (fn [[prev n]] [(happy-or-sad? prev n) (conj prev n)])
unknown? (fn [[res nums]] (= res :unknown))
[res nums] (->> [#{} n]
(iterate get-next)
(map my-happy-or-sad?)
(drop-while unknown?)
first)
_ (swap! (res cache) union nums)]
res))
(def happy-numbers (->> (iterate inc 1)
(filter #(= :happy (happy-algo %)))))
(println (take 8 happy-numbers))
Same output.
CLU
sum_dig_sq = proc (n: int) returns (int)
sum_sq: int := 0
while n > 0 do
sum_sq := sum_sq + (n // 10) ** 2
n := n / 10
end
return (sum_sq)
end sum_dig_sq
is_happy = proc (n: int) returns (bool)
nn: int := sum_dig_sq(n)
while nn ~= n cand nn ~= 1 do
n := sum_dig_sq(n)
nn := sum_dig_sq(sum_dig_sq(nn))
end
return (nn = 1)
end is_happy
happy_numbers = iter (start, num: int) yields (int)
n: int := start
while num > 0 do
if is_happy(n) then
yield (n)
num := num-1
end
n := n+1
end
end happy_numbers
start_up = proc ()
po: stream := stream$primary_output()
for i: int in happy_numbers(1, 8) do
stream$putl(po, int$unparse(i))
end
end start_up- Output:
1 7 10 13 19 23 28 31
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. HAPPY.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 VARIABLES.
03 CANDIDATE PIC 9(4).
03 SQSUM-IN PIC 9(4).
03 FILLER REDEFINES SQSUM-IN.
05 DIGITS PIC 9 OCCURS 4 TIMES.
03 SQUARE PIC 9(4).
03 SUM-OF-SQUARES PIC 9(4).
03 N PIC 9.
03 TORTOISE PIC 9(4).
03 HARE PIC 9(4).
88 HAPPY VALUE 1.
03 SEEN PIC 9 VALUE ZERO.
03 OUT-FMT PIC ZZZ9.
PROCEDURE DIVISION.
BEGIN.
PERFORM DISPLAY-IF-HAPPY VARYING CANDIDATE FROM 1 BY 1
UNTIL SEEN IS EQUAL TO 8.
STOP RUN.
DISPLAY-IF-HAPPY.
PERFORM CHECK-HAPPY.
IF HAPPY,
MOVE CANDIDATE TO OUT-FMT,
DISPLAY OUT-FMT,
ADD 1 TO SEEN.
CHECK-HAPPY.
MOVE CANDIDATE TO TORTOISE, SQSUM-IN.
PERFORM CALC-SUM-OF-SQUARES.
MOVE SUM-OF-SQUARES TO HARE.
PERFORM CHECK-HAPPY-STEP UNTIL TORTOISE IS EQUAL TO HARE.
CHECK-HAPPY-STEP.
MOVE TORTOISE TO SQSUM-IN.
PERFORM CALC-SUM-OF-SQUARES.
MOVE SUM-OF-SQUARES TO TORTOISE.
MOVE HARE TO SQSUM-IN.
PERFORM CALC-SUM-OF-SQUARES.
MOVE SUM-OF-SQUARES TO SQSUM-IN.
PERFORM CALC-SUM-OF-SQUARES.
MOVE SUM-OF-SQUARES TO HARE.
CALC-SUM-OF-SQUARES.
MOVE ZERO TO SUM-OF-SQUARES.
PERFORM ADD-DIGIT-SQUARE VARYING N FROM 1 BY 1
UNTIL N IS GREATER THAN 4.
ADD-DIGIT-SQUARE.
MULTIPLY DIGITS(N) BY DIGITS(N) GIVING SQUARE.
ADD SQUARE TO SUM-OF-SQUARES.
- Output:
1 7 10 13 19 23 28 31
CoffeeScript
happy = (n) ->
seen = {}
while true
n = sum_digit_squares(n)
return true if n == 1
return false if seen[n]
seen[n] = true
sum_digit_squares = (n) ->
sum = 0
for c in n.toString()
d = parseInt(c)
sum += d*d
sum
i = 1
cnt = 0
while cnt < 8
if happy(i)
console.log i
cnt += 1
i += 1
output
> coffee happy.coffee 1 7 10 13 19 23 28 31
Common Lisp
(defun sqr (n)
(* n n))
(defun sum-of-sqr-dgts (n)
(loop for i = n then (floor i 10)
while (plusp i)
sum (sqr (mod i 10))))
(defun happy-p (n &optional cache)
(or (= n 1)
(unless (find n cache)
(happy-p (sum-of-sqr-dgts n)
(cons n cache)))))
(defun happys (&aux (happys 0))
(loop for i from 1
while (< happys 8)
when (happy-p i)
collect i and do (incf happys)))
(print (happys))
Output:
(1 7 10 13 19 23 28 31)
Cowgol
include "cowgol.coh";
sub sumDigitSquare(n: uint8): (s: uint8) is
s := 0;
while n != 0 loop
var d := n % 10;
s := s + d * d;
n := n / 10;
end loop;
end sub;
sub isHappy(n: uint8): (h: uint8) is
var seen: uint8[256];
MemZero(&seen[0], @bytesof seen);
while seen[n] == 0 loop
seen[n] := 1;
n := sumDigitSquare(n);
end loop;
if n == 1 then
h := 1;
else
h := 0;
end if;
end sub;
var n: uint8 := 1;
var seen: uint8 := 0;
while seen < 8 loop
if isHappy(n) != 0 then
print_i8(n);
print_nl();
seen := seen + 1;
end if;
n := n + 1;
end loop;- Output:
1 7 10 13 19 23 28 31
Crystal
def happy?(n)
past = [] of Int32 | Int64
until n == 1
sum = 0; while n > 0; sum += (n % 10) ** 2; n //= 10 end
return false if past.includes? (n = sum)
past << n
end
true
end
i = count = 0
until count == 8; (puts i; count += 1) if happy?(i += 1) end
puts
(99999999999900..99999999999999).each { |i| puts i if happy?(i) }
- Output:
1 7 10 13 19 23 28 31 99999999999901 99999999999910 99999999999914 99999999999915 99999999999916 99999999999937 99999999999941 99999999999951 99999999999956 99999999999961 99999999999965 99999999999973
D
bool isHappy(int n) pure nothrow {
int[int] past;
while (true) {
int total = 0;
while (n > 0) {
total += (n % 10) ^^ 2;
n /= 10;
}
if (total == 1)
return true;
if (total in past)
return false;
n = total;
past[total] = 0;
}
}
void main() {
import std.stdio, std.algorithm, std.range;
int.max.iota.filter!isHappy.take(8).writeln;
}
- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Alternative Version
import std.stdio, std.algorithm, std.range, std.conv, std.string;
bool isHappy(int n) pure nothrow {
int[int] seen;
while (true) {
immutable t = n.text.representation.map!q{(a - '0') ^^ 2}.sum;
if (t == 1)
return true;
if (t in seen)
return false;
n = t;
seen[t] = 0;
}
}
void main() {
int.max.iota.filter!isHappy.take(8).writeln;
}
Same output.
Dart
main() {
HashMap<int,bool> happy=new HashMap<int,bool>();
happy[1]=true;
int count=0;
int i=0;
while(count<8) {
if(happy[i]==null) {
int j=i;
Set<int> sequence=new Set<int>();
while(happy[j]==null && !sequence.contains(j)) {
sequence.add(j);
int sum=0;
int val=j;
while(val>0) {
int digit=val%10;
sum+=digit*digit;
val=(val/10).toInt();
}
j=sum;
}
bool sequenceHappy=happy[j];
Iterator<int> it=sequence.iterator();
while(it.hasNext()) {
happy[it.next()]=sequenceHappy;
}
}
if(happy[i]) {
print(i);
count++;
}
i++;
}
}
dc
[lcI~rscd*+lc0<H]sH
[0rsclHxd4<h]sh
[lIp]s_
0sI[lI1+dsIlhx2>_z8>s]dssxOutput:
1 7 10 13 19 23 28 31
DCL
$ happy_1 = 1
$ found = 0
$ i = 1
$ loop1:
$ n = i
$ seen_list = ","
$ loop2:
$ if f$type( happy_'n ) .nes. "" then $ goto happy
$ if f$type( unhappy_'n ) .nes. "" then $ goto unhappy
$ if f$locate( "," + n + ",", seen_list ) .eq. f$length( seen_list )
$ then
$ seen_list = seen_list + f$string( n ) + ","
$ else
$ goto unhappy
$ endif
$ ns = f$string( n )
$ nl = f$length( ns )
$ j = 0
$ sumsq = 0
$ loop3:
$ digit = f$integer( f$extract( j, 1, ns ))
$ sumsq = sumsq + digit * digit
$ j = j + 1
$ if j .lt. nl then $ goto loop3
$ n = sumsq
$ goto loop2
$ unhappy:
$ j = 1
$ loop4:
$ x = f$element( j, ",", seen_list )
$ if x .eqs. "" then $ goto continue
$ unhappy_'x = 1
$ j = j + 1
$ goto loop4
$ happy:
$ found = found + 1
$ found_'found = i
$ if found .eq. 8 then $ goto done
$ j = 1
$ loop5:
$ x = f$element( j, ",", seen_list )
$ if x .eqs. "" then $ goto continue
$ happy_'x = 1
$ j = j + 1
$ goto loop5
$ continue:
$ i = i + 1
$ goto loop1
$ done:
$ show symbol found*
- Output:
FOUND = 8 Hex = 00000008 Octal = 00000000010 FOUND_1 = 1 Hex = 00000001 Octal = 00000000001 FOUND_2 = 7 Hex = 00000007 Octal = 00000000007 FOUND_3 = 10 Hex = 0000000A Octal = 00000000012 FOUND_4 = 13 Hex = 0000000D Octal = 00000000015 FOUND_5 = 19 Hex = 00000013 Octal = 00000000023 FOUND_6 = 23 Hex = 00000017 Octal = 00000000027 FOUND_7 = 28 Hex = 0000001C Octal = 00000000034 FOUND_8 = 31 Hex = 0000001F Octal = 00000000037
Delphi
Adaptation of #Pascal. The lib Boost.Int can be found here [1]
program Happy_numbers;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
Boost.Int;
type
TIntegerDynArray = TArray<Integer>;
TIntHelper = record helper for Integer
function IsHappy: Boolean;
procedure Next;
end;
{ TIntHelper }
function TIntHelper.IsHappy: Boolean;
var
cache: TIntegerDynArray;
sum, n: integer;
begin
n := self;
repeat
sum := 0;
while n > 0 do
begin
sum := sum + (n mod 10) * (n mod 10);
n := n div 10;
end;
if sum = 1 then
exit(True);
if cache.Has(sum) then
exit(False);
n := sum;
cache.Add(sum);
until false;
end;
procedure TIntHelper.Next;
begin
inc(self);
end;
var
count, n: integer;
begin
n := 1;
count := 0;
while count < 8 do
begin
if n.IsHappy then
begin
count.Next;
write(n, ' ');
end;
n.Next;
end;
writeln;
readln;
end.
- Output:
1 7 10 13 19 23 28 31
Draco
proc nonrec dsumsq(byte n) byte:
byte r, d;
r := 0;
while n~=0 do
d := n % 10;
n := n / 10;
r := r + d * d
od;
r
corp
proc nonrec happy(byte n) bool:
[256] bool seen;
byte i;
for i from 0 upto 255 do seen[i] := false od;
while not seen[n] do
seen[n] := true;
n := dsumsq(n)
od;
seen[1]
corp
proc nonrec main() void:
byte n, seen;
n := 1;
seen := 0;
while seen < 8 do
if happy(n) then
writeln(n:3);
seen := seen + 1
fi;
n := n + 1
od
corp- Output:
1 7 10 13 19 23 28 31
DWScript
function IsHappy(n : Integer) : Boolean;
var
cache : array of Integer;
sum : Integer;
begin
while True do begin
sum := 0;
while n>0 do begin
sum += Sqr(n mod 10);
n := n div 10;
end;
if sum = 1 then
Exit(True);
if sum in cache then
Exit(False);
n := sum;
cache.Add(sum);
end;
end;
var n := 8;
var i : Integer;
while n>0 do begin
Inc(i);
if IsHappy(i) then begin
PrintLn(i);
Dec(n);
end;
end;
Output:
1 7 10 13 19 23 28 31
Dyalect
func happy(n) {
var m = []
while n > 1 {
m.Add(n)
var x = n
n = 0
while x > 0 {
var d = x % 10
n += d * d
x /= 10
}
if m.IndexOf(n) != -1 {
return false
}
}
return true
}
var (n, found) = (1, 0)
while found < 8 {
if happy(n) {
print("\(n) ", terminator: "")
found += 1
}
n += 1
}
print()- Output:
1 7 10 13 19 23 28 31
Déjà Vu
next-num:
0
while over:
over
* dup % swap 10
+
swap floor / swap 10 swap
drop swap
is-happy happies n:
if has happies n:
return happies! n
local :seq set{ n }
n
while /= 1 dup:
next-num
if has seq dup:
drop
set-to happies n false
return false
if has happies dup:
set-to happies n dup happies!
return
set-to seq over true
drop
set-to happies n true
true
local :h {}
1 0
while > 8 over:
if is-happy h dup:
!print( "A happy number: " over )
swap ++ swap
++
drop
drop- Output:
A happy number: 1 A happy number: 7 A happy number: 10 A happy number: 13 A happy number: 19 A happy number: 23 A happy number: 28 A happy number: 31
E
def isHappyNumber(var x :int) {
var seen := [].asSet()
while (!seen.contains(x)) {
seen with= x
var sum := 0
while (x > 0) {
sum += (x % 10) ** 2
x //= 10
}
x := sum
if (x == 1) { return true }
}
return false
}
var count := 0
for x ? (isHappyNumber(x)) in (int >= 1) {
println(x)
if ((count += 1) >= 8) { break }
}EasyLang
func dsum n .
while n > 0
d = n mod 10
s += d * d
n = n div 10
.
return s
.
func happy n .
while n > 999
n = dsum n
.
len seen[] 999
repeat
n = dsum n
until seen[n] = 1
seen[n] = 1
.
return if n = 1
.
while cnt < 8
n += 1
if happy n = 1
cnt += 1
write n & " "
.
.
- Output:
1 7 10 13 19 23 28 31
Eiffel
class
APPLICATION
create
make
feature {NONE} -- Initialization
make
-- Run application.
local
l_val: INTEGER
do
from
l_val := 1
until
l_val > 100
loop
if is_happy_number (l_val) then
print (l_val.out)
print ("%N")
end
l_val := l_val + 1
end
end
feature -- Happy number
is_happy_number (a_number: INTEGER): BOOLEAN
-- Is `a_number' a happy number?
require
positive_number: a_number > 0
local
l_number: INTEGER
l_set: ARRAYED_SET [INTEGER]
do
from
l_number := a_number
create l_set.make (10)
until
l_number = 1 or l_set.has (l_number)
loop
l_set.put (l_number)
l_number := square_sum_of_digits (l_number)
end
Result := (l_number = 1)
end
feature{NONE} -- Implementation
square_sum_of_digits (a_number: INTEGER): INTEGER
-- Sum of the sqares of digits of `a_number'.
require
positive_number: a_number > 0
local
l_number, l_digit: INTEGER
do
from
l_number := a_number
until
l_number = 0
loop
l_digit := l_number \\ 10
Result := Result + l_digit * l_digit
l_number := l_number // 10
end
end
end
Elena
ELENA 6.x :
import extensions;
import system'collections;
import system'routines;
isHappy(int n)
{
auto cache := new List<int>(5);
int sum := 0;
int num := n;
while (num != 1)
{
if (cache.indexOfElement(num) != -1)
{
^ false
};
cache.append(num);
while (num != 0)
{
int digit := num.mod(10);
sum += (digit*digit);
num /= 10
};
num := sum;
sum := 0
};
^ true
}
public program()
{
auto happynums := new List<int>(8);
int num := 1;
while (happynums.Length < 8)
{
if (isHappy(num))
{
happynums.append(num)
};
num += 1
};
console.printLine("First 8 happy numbers: ", happynums.asEnumerable())
}- Output:
First 8 happy numbers: 1,7,10,13,19,23,28,31
Elixir
defmodule Happy do
def task(num) do
Process.put({:happy, 1}, true)
Stream.iterate(1, &(&1+1))
|> Stream.filter(fn n -> happy?(n) end)
|> Enum.take(num)
end
defp happy?(n) do
sum = square_sum(n, 0)
val = Process.get({:happy, sum})
if val == nil do
Process.put({:happy, sum}, false)
val = happy?(sum)
Process.put({:happy, sum}, val)
end
val
end
defp square_sum(0, sum), do: sum
defp square_sum(n, sum) do
r = rem(n, 10)
square_sum(div(n, 10), sum + r*r)
end
end
IO.inspect Happy.task(8)
- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Erlang
-module(tasks).
-export([main/0]).
-import(lists, [map/2, member/2, sort/1, sum/1]).
is_happy(X, XS) ->
if
X == 1 ->
true;
X < 1 ->
false;
true ->
case member(X, XS) of
true -> false;
false ->
is_happy(sum(map(fun(Z) -> Z*Z end,
[Y - 48 || Y <- integer_to_list(X)])),
[X|XS])
end
end.
main(X, XS) ->
if
length(XS) == 8 ->
io:format("8 Happy Numbers: ~w~n", [sort(XS)]);
true ->
case is_happy(X, []) of
true -> main(X + 1, [X|XS]);
false -> main(X + 1, XS)
end
end.
main() ->
main(0, []).
Command:
erl -run tasks main -run init stop -noshell
Output:
8 Happy Numbers: [1,7,10,13,19,23,28,31]
In a more functional style (assumes integer_to_list/1 will convert to the ASCII value of a number, which then has to be converted to the integer value by subtracting 48):
-module(tasks).
-export([main/0]).
main() -> io:format("~w ~n", [happy_list(1, 8, [])]).
happy_list(_, N, L) when length(L) =:= N -> lists:reverse(L);
happy_list(X, N, L) ->
Happy = is_happy(X),
if Happy -> happy_list(X + 1, N, [X|L]);
true -> happy_list(X + 1, N, L) end.
is_happy(1) -> true;
is_happy(4) -> false;
is_happy(N) when N > 0 ->
N_As_Digits = [Y - 48 || Y <- integer_to_list(N)],
is_happy(lists:foldl(fun(X, Sum) -> (X * X) + Sum end, 0, N_As_Digits));
is_happy(_) -> false.
Output:
[1,7,10,13,19,23,28,31]
Euphoria
function is_happy(integer n)
sequence seen
integer k
seen = {}
while n > 1 do
seen &= n
k = 0
while n > 0 do
k += power(remainder(n,10),2)
n = floor(n/10)
end while
n = k
if find(n,seen) then
return 0
end if
end while
return 1
end function
integer n,count
n = 1
count = 0
while count < 8 do
if is_happy(n) then
? n
count += 1
end if
n += 1
end whileOutput:
1 7 10 13 19 23 28 31
F#
This requires the F# power pack to be referenced and the 2010 beta of F#
open System.Collections.Generic
open Microsoft.FSharp.Collections
let answer =
let sqr x = x*x // Classic square definition
let rec AddDigitSquare n =
match n with
| 0 -> 0 // Sum of squares for 0 is 0
| _ -> sqr(n % 10) + (AddDigitSquare (n / 10)) // otherwise add square of bottom digit to recursive call
let dict = new Dictionary<int, bool>() // Dictionary to memoize values
let IsHappy n =
if dict.ContainsKey(n) then // If we've already discovered it
dict.[n] // Return previously discovered value
else
let cycle = new HashSet<_>(HashIdentity.Structural) // Set to keep cycle values in
let rec isHappyLoop n =
if cycle.Contains n then n = 1 // If there's a loop, return true if it's 1
else
cycle.Add n |> ignore // else add this value to the cycle
isHappyLoop (AddDigitSquare n) // and check the next number in the cycle
let f = isHappyLoop n // Keep track of whether we're happy or not
cycle |> Seq.iter (fun i -> dict.[i] <- f) // and apply it to all the values in the cycle
f // Return the boolean
1 // Starting with 1,
|> Seq.unfold (fun i -> Some (i, i + 1)) // make an infinite sequence of consecutive integers
|> Seq.filter IsHappy // Keep only the happy ones
|> Seq.truncate 8 // Stop when we've found 8
|> Seq.iter (Printf.printf "%d\n") // Print results
Output:
1 7 10 13 19 23 28 31
Factor
USING: combinators kernel make math sequences ;
: squares ( n -- s )
0 [ over 0 > ] [ [ 10 /mod sq ] dip + ] while nip ;
: (happy?) ( n1 n2 -- ? )
[ squares ] [ squares squares ] bi* {
{ [ dup 1 = ] [ 2drop t ] }
{ [ 2dup = ] [ 2drop f ] }
[ (happy?) ]
} cond ;
: happy? ( n -- ? )
dup (happy?) ;
: happy-numbers ( n -- seq )
[
0 [ over 0 > ] [
dup happy? [ dup , [ 1 - ] dip ] when 1 +
] while 2drop
] { } make ;
- Output:
8 happy-numbers ! { 1 7 10 13 19 23 28 31 }
FALSE
[$10/$10*@\-$*\]m: {modulo squared and division}
[$m;![$9>][m;!@@+\]#$*+]s: {sum of squares}
[$0[1ø1>][1ø3+ø3ø=|\1-\]#\%]f: {look for duplicates}
{check happy number}
[
$1[f;!~2ø1=~&][1+\s;!@]# {loop over sequence until 1 or duplicate}
1ø1= {return value}
\[$0=~][@%1-]#% {drop sequence and counter}
]h:
0 1
"Happy numbers:"
[1ø8=~][h;![" "$.\1+\]?1+]#
%%- Output:
Happy numbers: 1 7 10 13 19 23 28 31
Fantom
class Main
{
static Bool isHappy (Int n)
{
Int[] record := [,]
while (n != 1 && !record.contains(n))
{
record.add (n)
// find sum of squares of digits
newn := 0
while (n > 0)
{
newn += (n.mod(10) * n.mod(10))
n = n.div(10)
}
n = newn
}
return (n == 1)
}
public static Void main ()
{
i := 1
count := 0
while (count < 8)
{
if (isHappy (i))
{
echo (i)
count += 1
}
i += 1
}
}
}Output:
1 7 10 13 19 23 28 31
FOCAL
01.10 S J=0;S N=1;T %2
01.20 D 3;I (K-2)1.5
01.30 S N=N+1
01.40 I (J-8)1.2;Q
01.50 T N,!
01.60 S J=J+1
01.70 G 1.3
02.10 S A=K;S R=0
02.20 S B=FITR(A/10)
02.30 S R=R+(A-10*B)^2
02.40 S A=B
02.50 I (-A)2.2
03.10 F X=0,162;S S(X)=-1
03.20 S K=N
03.30 S S(K)=0
03.40 D 2;S K=R
03.50 I (S(K))3.3- Output:
= 1 = 7 = 10 = 13 = 19 = 23 = 28 = 31
Forth
: next ( n -- n )
0 swap begin 10 /mod >r dup * + r> ?dup 0= until ;
: cycle? ( n -- ? )
here dup @ cells +
begin dup here >
while 2dup @ = if 2drop true exit then
1 cells -
repeat
1 over +! dup @ cells + ! false ;
: happy? ( n -- ? )
0 here ! begin next dup cycle? until 1 = ;
: happy-numbers ( n -- )
0 swap 0 do
begin 1+ dup happy? until dup .
loop drop ;
8 happy-numbers \ 1 7 10 13 19 23 28 31
Lookup Table
Every sequence either ends in 1, or contains a 4 as part of a cycle. Extending the table through 9 is a (modest) optimization/memoization. This executes '500000 happy-numbers' about 5 times faster than the above solution.
CREATE HAPPINESS 0 C, 1 C, 0 C, 0 C, 0 C, 0 C, 0 C, 1 C, 0 C, 0 C,
: next ( n -- n')
0 swap BEGIN dup WHILE 10 /mod >r dup * + r> REPEAT drop ;
: happy? ( n -- t|f)
BEGIN dup 10 >= WHILE next REPEAT chars HAPPINESS + C@ 0<> ;
: happy-numbers ( n --) >r 0
BEGIN r@ WHILE
BEGIN 1+ dup happy? UNTIL dup . r> 1- >r
REPEAT r> drop drop ;
8 happy-numbers
- Output:
1 7 10 13 19 23 28 31
Produces the 1 millionth happy number with:
: happy-number ( n -- n') \ produce the nth happy number
>r 0 BEGIN r@ WHILE
BEGIN 1+ dup happy? UNTIL r> 1- >r
REPEAT r> drop ;
1000000 happy-number . \ 7105849
in about 9 seconds.
Fortran
program happy
implicit none
integer, parameter :: find = 8
integer :: found
integer :: number
found = 0
number = 1
do
if (found == find) then
exit
end if
if (is_happy (number)) then
found = found + 1
write (*, '(i0)') number
end if
number = number + 1
end do
contains
function sum_digits_squared (number) result (result)
implicit none
integer, intent (in) :: number
integer :: result
integer :: digit
integer :: rest
integer :: work
result = 0
work = number
do
if (work == 0) then
exit
end if
rest = work / 10
digit = work - 10 * rest
result = result + digit * digit
work = rest
end do
end function sum_digits_squared
function is_happy (number) result (result)
implicit none
integer, intent (in) :: number
logical :: result
integer :: turtoise
integer :: hare
turtoise = number
hare = number
do
turtoise = sum_digits_squared (turtoise)
hare = sum_digits_squared (sum_digits_squared (hare))
if (turtoise == hare) then
exit
end if
end do
result = turtoise == 1
end function is_happy
end program happy
Output:
1 7 10 13 19 23 28 31
Frege
module Happy where
import Prelude.Math
-- ugh, since Frege doesn't have Set, use Map instead
import Data.Map (member, insertMin, empty emptyMap)
digitToInteger :: Char -> Integer
digitToInteger c = fromInt $ (ord c) - (ord '0')
isHappy :: Integer -> Bool
isHappy = p emptyMap
where p _ 1n = true
p s n | n `member` s = false
| otherwise = p (insertMin n () s) (f n)
f = sum . map (sqr . digitToInteger) . unpacked . show
main _ = putStrLn $ unwords $ map show $ take 8 $ filter isHappy $ iterate (+ 1n) 1n- Output:
1 7 10 13 19 23 28 31 runtime 0.614 wallclock seconds.
FutureBasic
include "NSLog.incl"
local fn IsHappy( num as NSUInteger ) as NSUInteger
NSUInteger i, happy = 0, count = 0
while ( count < 50 ) and ( happy != 1 )
CFStringRef numStr = str( num )
count++ : happy = 0
for i = 1 to len( numStr )
happy = happy + fn StringIntegerValue( mid( numStr, i, 1 ) ) ^ 2
next
num = happy
wend
end fn = num
void local fn HappyNumbers
NSUInteger i, count = 0
for i = 1 to 100
if ( fn IsHappy(i) == 1 )
count++
NSLog( @"%2lu. %2lu is a happy number", count, i )
if count == 8 then exit fn
end if
next
end fn
fn HappyNumbers
HandleEvents- Output:
1. 1 is a happy number 2. 7 is a happy number 3. 10 is a happy number 4. 13 is a happy number 5. 19 is a happy number 6. 23 is a happy number 7. 28 is a happy number 8. 31 is a happy number
Fōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution.
The following function returns whether a given number is happy or not:
Retrieving the first 8 happy numbers
Go
package main
import "fmt"
func happy(n int) bool {
m := make(map[int]bool)
for n > 1 {
m[n] = true
var x int
for x, n = n, 0; x > 0; x /= 10 {
d := x % 10
n += d * d
}
if m[n] {
return false
}
}
return true
}
func main() {
for found, n := 0, 1; found < 8; n++ {
if happy(n) {
fmt.Print(n, " ")
found++
}
}
fmt.Println()
}
- Output:
1 7 10 13 19 23 28 31
Groovy
Number.metaClass.isHappy = {
def number = delegate as Long
def cycle = new HashSet<Long>()
while (number != 1 && !cycle.contains(number)) {
cycle << number
number = (number as String).collect { d = (it as Long); d * d }.sum()
}
number == 1
}
def matches = []
for (int i = 0; matches.size() < 8; i++) {
if (i.happy) { matches << i }
}
println matches
- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Harbour
PROCEDURE Main()
LOCAL i := 8, nH := 0
? hb_StrFormat( "The first %d happy numbers are:", i )
?
WHILE i > 0
IF IsHappy( ++nH )
?? hb_NtoS( nH ) + " "
--i
ENDIF
END
RETURN
STATIC FUNCTION IsHappy( nNumber )
STATIC aUnhappy := {}
LOCAL nDigit, nSum := 0, cNumber := hb_NtoS( nNumber )
FOR EACH nDigit IN cNumber
nSum += Val( nDigit ) ^ 2
NEXT
IF nSum == 1
aUnhappy := {}
RETURN .T.
ELSEIF AScan( aUnhappy, nSum ) > 0
RETURN .F.
ENDIF
AAdd( aUnhappy, nSum )
RETURN IsHappy( nSum )
Output:
The first 8 happy numbers are: 1 7 10 13 19 23 28 31
Haskell
import Data.Char (digitToInt)
import Data.Set (member, insert, empty)
isHappy :: Integer -> Bool
isHappy = p empty
where
p _ 1 = True
p s n
| n `member` s = False
| otherwise = p (insert n s) (f n)
f = sum . fmap ((^ 2) . toInteger . digitToInt) . show
main :: IO ()
main = mapM_ print $ take 8 $ filter isHappy [1 ..]
- Output:
1 7 10 13 19 23 28 31
We can create a cache for small numbers to greatly speed up the process:
import Data.Array (Array, (!), listArray)
happy :: Int -> Bool
happy x
| xx <= 150 = seen ! xx
| otherwise = happy xx
where
xx = dsum x
seen :: Array Int Bool
seen =
listArray (1, 150) $ True : False : False : False : (happy <$> [5 .. 150])
dsum n
| n < 10 = n * n
| otherwise =
let (q, r) = n `divMod` 10
in r * r + dsum q
main :: IO ()
main = print $ sum $ take 10000 $ filter happy [1 ..]
- Output:
327604323
Icon and Unicon
Usage and Output:
| happynum.exe The first 8 happy numbers are: 1 7 10 13 19 23 28 31
J
8{. (#~1=+/@(*:@(,.&.":))^:(1&~:*.4&~:)^:_ "0) 1+i.100
1 7 10 13 19 23 28 31
This is a repeat while construction
f ^: cond ^: _ input
that produces an array of 1's and 4's, which is converted to 1's and 0's forming a binary array having a 1 for a happy number. Finally the happy numbers are extracted by a binary selector.
(binary array) # 1..100
So for easier reading the solution could be expressed as:
cond=: 1&~: *. 4&~: NB. not equal to 1 and not equal to 4
sumSqrDigits=: +/@(*:@(,.&.":))
sumSqrDigits 123 NB. test sum of squared digits
14
8{. (#~ 1 = sumSqrDigits ^: cond ^:_ "0) 1 + i.100
1 7 10 13 19 23 28 31
Java
import java.util.HashSet;
public class Happy{
public static boolean happy(long number){
long m = 0;
int digit = 0;
HashSet<Long> cycle = new HashSet<Long>();
while(number != 1 && cycle.add(number)){
m = 0;
while(number > 0){
digit = (int)(number % 10);
m += digit*digit;
number /= 10;
}
number = m;
}
return number == 1;
}
public static void main(String[] args){
for(long num = 1,count = 0;count<8;num++){
if(happy(num)){
System.out.println(num);
count++;
}
}
}
}
Output:
1 7 10 13 19 23 28 31
Java 1.8
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
public class HappyNumbers {
public static void main(String[] args) {
for (int current = 1, total = 0; total < 8; current++)
if (isHappy(current)) {
System.out.println(current);
total++;
}
}
public static boolean isHappy(int number) {
HashSet<Integer> cycle = new HashSet<>();
while (number != 1 && cycle.add(number)) {
List<String> numStrList = Arrays.asList(String.valueOf(number).split(""));
number = numStrList.stream().map(i -> Math.pow(Integer.parseInt(i), 2)).mapToInt(i -> i.intValue()).sum();
}
return number == 1;
}
}
Output:
1 7 10 13 19 23 28 31
JavaScript
ES5
Iteration
function happy(number) {
var m, digit ;
var cycle = [] ;
while(number != 1 && cycle[number] !== true) {
cycle[number] = true ;
m = 0 ;
while (number > 0) {
digit = number % 10 ;
m += digit * digit ;
number = (number - digit) / 10 ;
}
number = m ;
}
return (number == 1) ;
}
var cnt = 8 ;
var number = 1 ;
while(cnt-- > 0) {
while(!happy(number))
number++ ;
document.write(number + " ") ;
number++ ;
}
Output:
1 7 10 13 19 23 28 31
ES6
Functional composition
(() => {
// isHappy :: Int -> Bool
const isHappy = n => {
const f = n =>
foldl(
(a, x) => a + raise(read(x), 2), // ^2
0,
splitOn('', show(n))
),
p = (s, n) => n === 1 ? (
true
) : member(n, s) ? (
false
) : p(
insert(n, s), f(n)
);
return p(new Set(), n);
};
// GENERIC FUNCTIONS ------------------------------------------------------
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);
// filter :: (a -> Bool) -> [a] -> [a]
const filter = (f, xs) => xs.filter(f);
// foldl :: (b -> a -> b) -> b -> [a] -> b
const foldl = (f, a, xs) => xs.reduce(f, a);
// insert :: Ord a => a -> Set a -> Set a
const insert = (e, s) => s.add(e);
// member :: Ord a => a -> Set a -> Bool
const member = (e, s) => s.has(e);
// read :: Read a => String -> a
const read = JSON.parse;
// show :: a -> String
const show = x => JSON.stringify(x);
// splitOn :: String -> String -> [String]
const splitOn = (cs, xs) => xs.split(cs);
// raise :: Num -> Int -> Num
const raise = (n, e) => Math.pow(n, e);
// take :: Int -> [a] -> [a]
const take = (n, xs) => xs.slice(0, n);
// TEST -------------------------------------------------------------------
return show(
take(8, filter(isHappy, enumFromTo(1, 50)))
);
})()
- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Or, to stop immediately at the 8th member of the series, we can preserve functional composition while using an iteratively implemented until() function:
(() => {
// isHappy :: Int -> Bool
const isHappy = n => {
const f = n =>
foldl(
(a, x) => a + raise(read(x), 2), // ^2
0,
splitOn('', show(n))
),
p = (s, n) => n === 1 ? (
true
) : member(n, s) ? (
false
) : p(
insert(n, s), f(n)
);
return p(new Set(), n);
};
// GENERIC FUNCTIONS ------------------------------------------------------
// filter :: (a -> Bool) -> [a] -> [a]
const filter = (f, xs) => xs.filter(f);
// foldl :: (b -> a -> b) -> b -> [a] -> b
const foldl = (f, a, xs) => xs.reduce(f, a);
// insert :: Ord a => a -> Set a -> Set a
const insert = (e, s) => s.add(e);
// member :: Ord a => a -> Set a -> Bool
const member = (e, s) => s.has(e);
// read :: Read a => String -> a
const read = JSON.parse;
// show :: a -> String
const show = x => JSON.stringify(x);
// splitOn :: String -> String -> [String]
const splitOn = (cs, xs) => xs.split(cs);
// raise :: Num -> Int -> Num
const raise = (n, e) => Math.pow(n, e);
// until :: (a -> Bool) -> (a -> a) -> a -> a
const until = (p, f, x) => {
let v = x;
while (!p(v)) v = f(v);
return v;
};
// TEST -------------------------------------------------------------------
return show(
until(
m => m.xs.length === 8,
m => {
const n = m.n;
return {
n: n + 1,
xs: isHappy(n) ? m.xs.concat(n) : m.xs
};
}, {
n: 1,
xs: []
}
)
.xs
);
})();
- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
jq
def is_happy_number:
def next: tostring | explode | map( (. - 48) | .*.) | add;
def last(g): reduce g as $i (null; $i);
# state: either 1 or [i, o]
# where o is an an object with the previously encountered numbers as keys
def loop:
recurse( if . == 1 then empty # all done
elif .[0] == 1 then 1 # emit 1
else (.[0]| next) as $n
| if $n == 1 then 1
elif .[1]|has($n|tostring) then empty
else [$n, (.[1] + {($n|tostring):true}) ]
end
end );
1 == last( [.,{}] | loop );Emit a stream of the first n happy numbers:
# Set n to -1 to continue indefinitely:
def happy(n):
def subtask: # state: [i, found]
if .[1] == n then empty
else .[0] as $n
| if ($n | is_happy_number) then $n, ([ $n+1, .[1]+1 ] | subtask)
else (.[0] += 1) | subtask
end
end;
[0,0] | subtask;
happy($n|tonumber)- Output:
$ jq --arg n 8 -n -f happy.jq
1
7
10
13
19
23
28
31
Julia
function happy(x)
happy_ints = Int[]
int_try = 1
while length(happy_ints) < x
n = int_try
past = Int[]
while n != 1
n = sum(y^2 for y in digits(n))
n in past && break
push!(past, n)
end
n == 1 && push!(happy_ints,int_try)
int_try += 1
end
return happy_ints
end
Output
julia> happy(8) 8-element Int32 Array: 1 7 10 13 19 23 28 31
A recursive version:
sumhappy(n) = sum(x->x^2, digits(n))
function ishappy(x, mem = Int[])
x == 1 ? true :
x in mem ? false :
ishappy(sumhappy(x), [mem ; x])
end
nexthappy(x) = ishappy(x+1) ? x+1 : nexthappy(x+1)
happy(n) = accumulate((a, b) -> nexthappy(a), 1:n)
- Output:
julia> show(happy(8)) [1,7,10,13,19,23,28,31,32]
Alternate, Translation of C
Faster with use of cache
const CACHE = 256
buf = zeros(Int, CACHE)
buf[begin] = 1
function happy(n)
if n < CACHE
buf[n] > 0 && return 2-buf[n]
buf[n] = 2
end
sqsum = 0
nn = n
while nn != 0
nn, x = divrem(nn, 10)
sqsum += x * x
end
x = happy(sqsum)
n < CACHE && (buf[n] = 2 - x)
return x
end
function main()
i, counter = 1, 1000000
while counter > 0
if happy(i) != 0
counter -= 1
end
i += 1
end
return i - 1
end
K
hpy: {x@&1={~|/x=1 4}{_+/_sqr 0$'$x}//:x}
hpy 1+!100
1 7 10 13 19 23 28 31 32 44 49 68 70 79 82 86 91 94 97 100
8#hpy 1+!100
1 7 10 13 19 23 28 31
Another implementation which is easy to follow is given below:
/ happynum.k
/ sum of squares of digits of an integer
dgtsmsqr: {d::(); (0<){d::d,x!10; x%:10}/x; +/d*d}
/ Test if an integer is a Happy number
isHappy: {s::(); while[1<x;a:(dgtsmsqr x); :[(a _in s); :0; s::s,a]; x:a];:1} / Returns 1 if Happy
/ Generate first x Happy numbers and display the list
hnum: {[x]; h::();i:1;while[(#h)<x; :[(isHappy i); h::(h,i)]; i+:1]; `0: ,"List of ", ($x), " Happy Numbers"; h}
The output of a session with this implementation is given below:
- Output:
K Console - Enter \ for help \l happynum hnum 8 List of 8 Happy Numbers 1 7 10 13 19 23 28 31
Kotlin
// version 1.0.5-2
fun isHappy(n: Int): Boolean {
val cache = mutableListOf<Int>()
var sum = 0
var nn = n
var digit: Int
while (nn != 1) {
if (nn in cache) return false
cache.add(nn)
while (nn != 0) {
digit = nn % 10
sum += digit * digit
nn /= 10
}
nn = sum
sum = 0
}
return true
}
fun main(args: Array<String>) {
var num = 1
val happyNums = mutableListOf<Int>()
while (happyNums.size < 8) {
if (isHappy(num)) happyNums.add(num)
num++
}
println("First 8 happy numbers : " + happyNums.joinToString(", "))
}
- Output:
First 8 happy numbers : 1, 7, 10, 13, 19, 23, 28, 31
Lambdatalk
{def happy
{def happy.sum
{lambda {:n}
{if {= {W.length :n} 1}
then {pow {W.first :n} 2}
else {+ {pow {W.first :n} 2}
{happy.sum {W.rest :n}}}}}}
{def happy.is
{lambda {:x :a}
{if {= :x 1}
then true
else {if {> {A.in? :x :a} -1}
then false
else {happy.is {happy.sum :x}
{A.addlast! :x :a}}}}}}
{def happy.rec
{lambda {:n :a :i}
{if {= {A.length :a} :n}
then :a
else {happy.rec :n
{if {happy.is :i {A.new}}
then {A.addlast! :i :a}
else :a}
{+ :i 1}}}}}
{lambda {:n}
{happy.rec :n {A.new} 0}}}
-> happy
{happy 8}
-> [1,7,10,13,19,23,28,31]
Lasso
#!/usr/bin/lasso9
define isHappy(n::integer) => {
local(past = set)
while(#n != 1) => {
#n = with i in string(#n)->values sum math_pow(integer(#i), 2)
#past->contains(#n) ? return false | #past->insert(#n)
}
return true
}
with x in generateSeries(1, 500)
where isHappy(#x)
take 8
select #x
Output:
1, 7, 10, 13, 19, 23, 28, 31
Logo
to sum_of_square_digits :number
output (apply "sum (map [[d] d*d] ` :number))
end
to is_happy? :number [:seen []]
output cond [
[ [:number = 1] "true ]
[ [member? :number :seen] "false ]
[ else (is_happy? (sum_of_square_digits :number) (lput :number :seen))]
]
end
to n_happy :count [:start 1] [:result []]
output cond [
[ [:count <= 0] :result ]
[ [is_happy? :start]
(n_happy (:count-1) (:start+1) (lput :start :result)) ]
[ else
(n_happy :count (:start+1) :result) ]
]
end
print n_happy 8
byeOutput:
1 7 10 13 19 23 28 31
LOLCODE
OBTW
Happy Numbers Rosetta Code task in LOLCODE
Requires 1.3 for BUKKIT availability
TLDR
HAI 1.3
CAN HAS STDIO?
BTW Simple list implementation.
BTW Used for the list of numbers already seen in IZHAPPY
BTW Create a list
HOW IZ I MAEKLIST
I HAS A LIST ITZ A BUKKIT
LIST HAS A LENGTH ITZ 0
FOUND YR LIST
IF U SAY SO
BTW Append an item to list
HOW IZ I PUTIN YR LIST AN YR ITEM
LIST HAS A SRS LIST'Z LENGTH ITZ ITEM
LIST'Z LENGTH R SUM OF LIST'Z LENGTH AN 1
IF U SAY SO
BTW Check for presence of an item in the list
HOW IZ I DUZLISTHAS YR HAYSTACK AN YR NEEDLE
IM IN YR BARN UPPIN YR INDEX WILE DIFFRINT INDEX AN HAYSTACK'Z LENGTH
I HAS A ITEM ITZ HAYSTACK'Z SRS INDEX
BOTH SAEM ITEM AN NEEDLE
O RLY?
YA RLY
FOUND YR WIN
OIC
IM OUTTA YR BARN
FOUND YR FAIL
IF U SAY SO
BTW Calculate the next number using the happy formula
HOW IZ I HAPPYSTEP YR NUM
I HAS A NEXT ITZ 0
IM IN YR LOOP
BOTH SAEM NUM AN 0
O RLY?
YA RLY
GTFO
OIC
I HAS A DIGIT ITZ MOD OF NUM AN 10
NUM R QUOSHUNT OF NUM AN 10
I HAS A SQUARE ITZ PRODUKT OF DIGIT AN DIGIT
NEXT R SUM OF NEXT AN SQUARE
IM OUTTA YR LOOP
FOUND YR NEXT
IF U SAY SO
BTW Check to see if a number is happy
HOW IZ I IZHAPPY YR NUM
I HAS A SEENIT ITZ I IZ MAEKLIST MKAY
IM IN YR LOOP
BOTH SAEM NUM AN 1
O RLY?
YA RLY
FOUND YR WIN
OIC
I IZ DUZLISTHAS YR SEENIT AN YR NUM MKAY
O RLY?
YA RLY
FOUND YR FAIL
OIC
I IZ PUTIN YR SEENIT AN YR NUM MKAY
NUM R I IZ HAPPYSTEP YR NUM MKAY
IM OUTTA YR LOOP
IF U SAY SO
BTW Print out the first 8 happy numbers
I HAS A KOUNT ITZ 0
IM IN YR LOOP UPPIN YR NUM WILE DIFFRINT KOUNT AN 8
I IZ IZHAPPY YR NUM MKAY
O RLY?
YA RLY
KOUNT R SUM OF KOUNT AN 1
VISIBLE NUM
OIC
IM OUTTA YR LOOP
KTHXBYEOutput:
1 7 10 13 19 23 28 31
Lua
function digits(n)
if n > 0 then return n % 10, digits(math.floor(n/10)) end
end
function sumsq(a, ...)
return a and a ^ 2 + sumsq(...) or 0
end
local happy = setmetatable({true, false, false, false}, {
__index = function(self, n)
self[n] = self[sumsq(digits(n))]
return self[n]
end } )
i, j = 0, 1
repeat
i, j = happy[j] and (print(j) or i+1) or i, j + 1
until i == 8
Output:
1 7 10 13 19 23 28 31
M2000 Interpreter
Lambda Function PrintHappy has a closure another lambda function IsHappy which has a closure of another lambda function the sumOfSquares.
Function FactoryHappy {
sumOfSquares= lambda (n) ->{
k$=str$(abs(n),"")
Sum=0
For i=1 to len(k$)
sum+=val(mid$(k$,i,1))**2
Next i
=sum
}
IsHappy=Lambda sumOfSquares (n) ->{
Inventory sequence
While n<>1 {
Append sequence, n
n=sumOfSquares(n)
if exist(sequence, n) then =false : Break
}
=True
}
=Lambda IsHappy ->{
numleft=8
numToTest=1
While numleft {
if ishappy(numToTest) Then {
Print numToTest
numleft--
}
numToTest++
}
}
}
PrintHappy=factoryHappy()
Call PrintHappy()- Output:
1 7 10 13 19 23 28 31
MACRO-11
.TITLE HAPPY
.MCALL .TTYOUT,.EXIT
HAPPY:: MOV #^D8,R5 ; 8 HAPPY NUMBERS
CLR R4
1$: INC R4
MOV R4,R0
JSR PC,CHECK
BNE 1$
MOV R4,R0
JSR PC,PR0
SOB R5,1$
.EXIT
; CHECK IF R0 IS HAPPY: ZERO FLAG SET IF TRUE
CHECK: MOV #200,R1
MOV #3$,R2
1$: CLR (R2)+
SOB R1,1$
2$: INCB 3$(R0)
JSR PC,SUMSQ
TST 3$(R0)
BEQ 2$
DEC R0
RTS PC
3$: .BLKW 200
; LET R0 = SUM OF SQUARES OF DIGITS OF R0
SUMSQ: CLR R2
1$: MOV #-1,R1
2$: INC R1
SUB #12,R0
BCC 2$
ADD #12,R0
MOVB 3$(R0),R0
ADD R0,R2
MOV R1,R0
BNE 1$
MOV R2,R0
RTS PC
3$: .BYTE ^D 0,^D 1,^D 4,^D 9,^D16
.BYTE ^D25,^D36,^D49,^D64,^D81
; PRINT NUMBER IN R0 AS DECIMAL.
PR0: MOV #4$,R1
1$: MOV #-1,R2
2$: INC R2
SUB #12,R0
BCC 2$
ADD #72,R0
MOVB R0,-(R1)
MOV R2,R0
BNE 1$
3$: MOVB (R1)+,R0
.TTYOUT
BNE 3$
RTS PC
.ASCII /...../
4$: .BYTE 15,12,0
.END HAPPY- Output:
1 7 10 13 19 23 28 31
MAD
NORMAL MODE IS INTEGER
BOOLEAN CYCLE
DIMENSION CYCLE(200)
VECTOR VALUES OUTFMT = $I2*$
SEEN = 0
I = 0
NEXNUM THROUGH ZERO, FOR K=0, 1, K.G.200
ZERO CYCLE(K) = 0B
I = I + 1
SUMSQR = I
CHKLP N = SUMSQR
SUMSQR = 0
SUMLP DIG = N-N/10*10
SUMSQR = SUMSQR + DIG*DIG
N = N/10
WHENEVER N.NE.0, TRANSFER TO SUMLP
WHENEVER SUMSQR.E.1, TRANSFER TO HAPPY
WHENEVER CYCLE(SUMSQR), TRANSFER TO NEXNUM
CYCLE(SUMSQR) = 1B
TRANSFER TO CHKLP
HAPPY PRINT FORMAT OUTFMT,I
SEEN = SEEN+1
WHENEVER SEEN.L.8, TRANSFER TO NEXNUM
END OF PROGRAM- Output:
1 7 10 13 19 23 28 31
Maple
To begin, here is a procedure to compute the sum of the squares of the digits of a positive integer. It uses the built-in procedure irem, which computes the integer remainder and, if passed a name as the optional third argument, assigns it the corresponding quotient. (In other words, it performs integer division with remainder. There is also a dual, companion procedure iquo, which returns the integer quotient and assigns the remainder to the (optional) third argument.)
SumSqDigits := proc( n :: posint )
local s := 0;
local m := n;
while m <> 0 do
s := s + irem( m, 10, 'm' )^2
end do;
s
end proc:(Note that the unevaluation quotes on the third argument to irem are essential here, as that argument must be a name and, if m were passed without quotes, it would evaluate to a number.)
For example,
> SumSqDigits( 1234567890987654321 );
570We can check this by computing it another way (more directly).
> n := 1234567890987654321:
> `+`( op( map( parse, StringTools:-Explode( convert( n, 'string' ) ) )^~2) );
570The most straight-forward way to check whether a number is happy or sad seems also to be the fastest (that I could think of).
Happy? := proc( n )
if n = 1 then
true
elif n = 4 then
false
else
local s := SumSqDigits( n );
while not ( s in { 1, 4 } ) do
s := SumSqDigits( s )
end do;
evalb( s = 1 )
end if
end proc:We can use this to determine the number of happy (H) and sad (S) numbers up to one million as follows.
> H, S := selectremove( Happy?, [seq]( 1 .. N ) ):
> nops( H ), nops( S );
143071, 856929Finally, to solve the stated problem, here is a completely straight-forward routine to locate the first N happy numbers, returning them in a set.
FindHappiness := proc( N )
local count := 0;
local T := table();
for local i while count < N do
if Happy?( i ) then
count := 1 + count;
T[ count ] := i
end if
end do;
{seq}( T[ i ], i = 1 .. count )
end proc:With input equal to 8, we get
> FindHappiness( 8 );
{1, 7, 10, 13, 19, 23, 28, 31}For completeness, here is an implementation of the cycle detection algorithm for recognizing happy numbers. It is much slower, however.
Happy? := proc( n :: posint )
local a, b;
a, b := n, SumSqDigits( n );
while a <> b do
a := SumSqDigits( a );
b := (SumSqDigits@@2)( b )
end do;
evalb( a = 1 )
end proc:Mathematica / Wolfram Language
Custom function HappyQ:
AddSumSquare[input_]:=Append[input,Total[IntegerDigits[Last[input]]^2]]
NestUntilRepeat[a_,f_]:=NestWhile[f,{a},!MemberQ[Most[Last[{##}]],Last[Last[{##}]]]&,All]
HappyQ[a_]:=Last[NestUntilRepeat[a,AddSumSquare]]==1
Examples for a specific number:
HappyQ[1337]
HappyQ[137]
gives back:
True
False
Example finding the first 8:
m = 8;
n = 1;
i = 0;
happynumbers = {};
While[n <= m,
i++;
If[HappyQ[i],
n++;
AppendTo[happynumbers, i]
]
]
happynumbers
gives back:
{1, 7, 10, 13, 19, 23, 28, 31}
MATLAB
Recursive version:
function findHappyNumbers
nHappy = 0;
k = 1;
while nHappy < 8
if isHappyNumber(k, [])
fprintf('%d ', k)
nHappy = nHappy+1;
end
k = k+1;
end
fprintf('\n')
end
function hap = isHappyNumber(k, prev)
if k == 1
hap = true;
elseif ismember(k, prev)
hap = false;
else
hap = isHappyNumber(sum((sprintf('%d', k)-'0').^2), [prev k]);
end
end
- Output:
1 7 10 13 19 23 28 31
Maxima
/* Function that decomposes te number into a list */
decompose(N) := block(
digits: [],
while N > 0 do
(remainder: mod(N, 10),
digits: cons(remainder, digits),
N: floor(N/10)),
digits
)$
/* Function that given a number returns the sum of their digits */
sum_squares_digits(n):=block(
decompose(n),
map(lambda([x],x^2),%%),
apply("+",%%))$
/* Predicate function based on the task iterated digits squaring */
happyp(n):=if n=1 then true else if n=89 then false else block(iter:n,while not member(iter,[1,89]) do iter:sum_squares_digits(iter),iter,if iter=1 then true)$
/* Test case */
/* First eight happy numbers */
block(
happy:[],i:1,
while length(happy)<8 do (if happyp(i) then happy:endcons(i,happy),i:i+1),
happy);
- Output:
[1,7,10,13,19,23,28,31]
MAXScript
fn isHappyNumber n =
(
local pastNumbers = #()
while n != 1 do
(
n = n as string
local newNumber = 0
for i = 1 to n.count do
(
local digit = n[i] as integer
newNumber += pow digit 2
)
n = newNumber
if (finditem pastNumbers n) != 0 do return false
append pastNumbers newNumber
)
n == 1
)
printed = 0
for i in (for h in 1 to 500 where isHappyNumber h collect h) do
(
if printed == 8 do exit
print i as string
printed += 1
)Output:
1
7
10
13
19
23
28
31Mercury
:- module happy.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module int, list, set_tree234.
main(!IO) :-
print_line(get_n_happy_numbers(8, 1), !IO).
:- func get_n_happy_numbers(int, int) = list(int).
get_n_happy_numbers(NumToFind, N) =
( if NumToFind > 0 then
( if is_happy(N, init)
then [N | get_n_happy_numbers(NumToFind - 1, N + 1)]
else get_n_happy_numbers(NumToFind, N + 1)
)
else
[]
).
:- pred is_happy(int::in, set_tree234(int)::in) is semidet.
is_happy(1, _).
is_happy(N, !.Seen) :-
not member(N, !.Seen),
insert(N, !Seen),
is_happy(sum_sqr_digits(N), !.Seen).
:- func sum_sqr_digits(int) = int.
sum_sqr_digits(N) =
( if N < 10 then sqr(N) else sqr(N mod 10) + sum_sqr_digits(N div 10) ).
:- func sqr(int) = int.
sqr(X) = X * X.- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
MiniScript
This solution uses the observation that any infinite cycle of this algorithm hits the number 89, and so that can be used to know when we've found an unhappy number.
isHappy = function(x)
while true
if x == 89 then return false
sum = 0
while x > 0
sum = sum + (x % 10)^2
x = floor(x / 10)
end while
if sum == 1 then return true
x = sum
end while
end function
found = []
i = 1
while found.len < 8
if isHappy(i) then found.push i
i = i + 1
end while
print "First 8 happy numbers: " + found
- Output:
First 8 happy numbers: [1, 7, 10, 13, 19, 23, 28, 31]
Miranda
main :: [sys_message]
main = [Stdout (lay (map show (take 8 happynumbers)))]
happynumbers :: [num]
happynumbers = filter ishappy [1..]
ishappy :: num->bool
ishappy n = 1 $in loop (iterate sumdigitsquares n)
sumdigitsquares :: num->num
sumdigitsquares 0 = 0
sumdigitsquares n = (n mod 10)^2 + sumdigitsquares (n div 10)
loop :: [*]->[*]
loop = loop' []
where loop' mem (a:as) = mem, if a $in mem
= loop' (a:mem) as, otherwise
in :: *->[*]->bool
in val [] = False
in val (a:as) = True, if a=val
= val $in as, otherwise- Output:
1 7 10 13 19 23 28 31
ML
mLite
(*
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 which does not include 1. Those numbers for which this process ends
in 1 are happy numbers, while those that do not end in 1 are unhappy numbers. Display an example of your
output here.
*)
local
fun get_digits
(d, s) where (d = 0) = s
| (d, s) = get_digits( d div 10, (d mod 10) :: s)
| n = get_digits( n div 10, [n mod 10] )
;
fun mem
(x, []) = false
| (x, a :: as) where (x = a) = true
| (x, _ :: as) = mem (x, as)
in
fun happy
1 = "happy"
| n =
let
val this = (fold (+,0) ` map (fn n = n ^ 2) ` get_digits n);
val sads = [2, 4, 16, 37, 58, 89, 145, 42, 20]
in
if (mem (n,sads)) then
"unhappy"
else
happy this
end
end
;
foreach (fn n = (print n; print " is "; println ` happy n)) ` iota 10;
Output:
1 is happy 2 is unhappy 3 is unhappy 4 is unhappy 5 is unhappy 6 is unhappy 7 is happy 8 is unhappy 9 is unhappy 10 is happy
Modula-2
MODULE HappyNumbers;
FROM InOut IMPORT WriteCard, WriteLn;
CONST Amount = 8;
VAR seen, num: CARDINAL;
PROCEDURE SumDigitSquares(n: CARDINAL): CARDINAL;
VAR sum, digit: CARDINAL;
BEGIN
sum := 0;
WHILE n>0 DO
digit := n MOD 10;
n := n DIV 10;
sum := sum + digit * digit;
END;
RETURN sum;
END SumDigitSquares;
PROCEDURE Happy(n: CARDINAL): BOOLEAN;
VAR i: CARDINAL;
seen: ARRAY [0..255] OF BOOLEAN;
BEGIN
FOR i := 0 TO 255 DO
seen[i] := FALSE;
END;
REPEAT
seen[n] := TRUE;
n := SumDigitSquares(n);
UNTIL seen[n];
RETURN seen[1];
END Happy;
BEGIN
seen := 0;
num := 0;
WHILE seen < Amount DO
IF Happy(num) THEN
INC(seen);
WriteCard(num,2);
WriteLn();
END;
INC(num);
END;
END HappyNumbers.- Output:
1 7 10 13 19 23 28 31
MUMPS
ISHAPPY(N)
;Determines if a number N is a happy number
;Note that the returned strings do not have a leading digit unless it is a happy number
IF (N'=N\1)!(N<0) QUIT "Not a positive integer"
NEW SUM,I
;SUM is the sum of the square of each digit
;I is a loop variable
;SEQ is the sequence of previously checked SUMs from the original N
;If it isn't set already, initialize it to an empty string
IF $DATA(SEQ)=0 NEW SEQ SET SEQ=""
SET SUM=0
FOR I=1:1:$LENGTH(N) DO
.SET SUM=SUM+($EXTRACT(N,I)*$EXTRACT(N,I))
QUIT:(SUM=1) SUM
QUIT:$FIND(SEQ,SUM)>1 "Part of a sequence not containing 1"
SET SEQ=SEQ_","_SUM
QUIT $$ISHAPPY(SUM)
HAPPY(C) ;Finds the first C happy numbers
NEW I
;I is a counter for what integer we're looking at
WRITE !,"The first "_C_" happy numbers are:"
FOR I=1:1 QUIT:C<1 SET Q=+$$ISHAPPY(I) WRITE:Q !,I SET:Q C=C-1
KILL I
QUITOutput:
USER>D HAPPY^ROSETTA(8) The first 8 happy numbers are: 1 7 10 13 19 23 28 31 USER>W:+$$ISHAPPY^ROSETTA(320) "Happy Number" Happy Number USER>W:+$$ISHAPPY^ROSETTA(321) "Happy Number" USER>
NetRexx
/*NetRexx program to display the 1st 8 (or specified arg) happy numbers*/
limit = arg[0] /*get argument for LIMIT. */
say limit
if limit = null, limit ='' then limit=8 /*if not specified, set LIMIT to 8*/
haps = 0 /*count of happy numbers so far. */
loop n=1 while haps < limit /*search integers starting at one.*/
q=n /*Q may or may not be "happy". */
a=0
loop forever /*see if Q is a happy number. */
if q==1 then do /*if Q is unity, then it's happy*/
haps = haps + 1 /*bump the count of happy numbers.*/
say n /*display the number. */
iterate n /*and then keep looking for more. */
end
sum=0 /*initialize sum to zero. */
loop j=1 for q.length /*add the squares of the numerals.*/
sum = sum + q.substr(j,1) ** 2
end
if a[sum] then iterate n /*if already summed, Q is unhappy.*/
a[sum]=1 /*mark the sum as being found. */
q=sum /*now, lets try the Q sum. */
end
end- Output
1 7 10 13 19 23 28 31
Sample output when 100 is specified as the program's argument.
1 7 10 13 19 23 28 31 32 44 49 68 70 79 82 86 91 94 97 100 103 109 129 130 133 139 167 176 188 190 192 193 203 208 219 226 230 236 239 262 263 280 291 293 301 302 310 313 319 320 326 329 331 338 356 362 365 367 368 376 379 383 386 391 392 397 404 409 440 446 464 469 478 487 490 496 536 556 563 565 566 608 617 622 623 632 635 637 638 644 649 653 655 656 665 671 673 680 683 694
Nim
import intsets
proc happy(n: int): bool =
var
n = n
past = initIntSet()
while n != 1:
let s = $n
n = 0
for c in s:
let i = ord(c) - ord('0')
n += i * i
if n in past:
return false
past.incl(n)
return true
for x in 0..31:
if happy(x):
echo xOutput:
1 7 10 13 19 23 28 31
Objeck
use IO;
use Structure;
bundle Default {
class HappyNumbers {
function : native : IsHappy(n : Int) ~ Bool {
cache := IntVector->New();
sum := 0;
while(n <> 1) {
if(cache->Has(n)) {
return false;
};
cache->AddBack(n);
while(n <> 0) {
digit := n % 10;
sum += (digit * digit);
n /= 10;
};
n := sum;
sum := 0;
};
return true;
}
function : Main(args : String[]) ~ Nil {
num := 1;
happynums := IntVector->New();
while(happynums->Size() < 8) {
if(IsHappy(num)) {
happynums->AddBack(num);
};
num += 1;
};
Console->Print("First 8 happy numbers: ");
each(i : happynums) {
Console->Print(happynums->Get(i))->Print(",");
};
Console->PrintLine("");
}
}
}output:
First 8 happy numbers: 1,7,10,13,19,23,28,31,
OCaml
Using Floyd's cycle-finding algorithm.
open Num
let step =
let rec aux s n =
if n =/ Int 0 then s else
let q = quo_num n (Int 10)
and r = mod_num n (Int 10)
in aux (s +/ (r */ r)) q
in aux (Int 0) ;;
let happy n =
let rec aux x y =
if x =/ y then x else aux (step x) (step (step y))
in (aux n (step n)) =/ Int 1 ;;
let first n =
let rec aux v x n =
if n = 0 then v else
if happy x
then aux (x::v) (x +/ Int 1) (n - 1)
else aux v (x +/ Int 1) n
in aux [ ] (Int 1) n ;;
List.iter print_endline (
List.rev_map string_of_num (first 8)) ;;Output:
$ ocaml nums.cma happy_numbers.ml 1 7 10 13 19 23 28 31
Oforth
: isHappy(n)
| cycle |
ListBuffer new ->cycle
while(n 1 <>) [
cycle include(n) ifTrue: [ false return ]
cycle add(n)
0 n asString apply(#[ asDigit sq + ]) ->n
]
true ;
: happyNum(N)
| numbers |
ListBuffer new ->numbers
1 while(numbers size N <>) [ dup isHappy ifTrue: [ dup numbers add ] 1+ ]
numbers println ;Output:
>happyNum(8) [1, 7, 10, 13, 19, 23, 28, 31]
Ol
(define (number->list num)
(let loop ((num num) (lst #null))
(if (zero? num)
lst
(loop (quotient num 10) (cons (remainder num 10) lst)))))
(define (** x) (* x x))
(define (happy? num)
(let loop ((num num) (seen #null))
(cond
((= num 1) #true)
((memv num seen) #false)
(else
(loop (apply + (map ** (number->list num)))
(cons num seen))))))
(display "happy numbers: ")
(let loop ((n 1) (count 0))
(unless (= count 8)
(if (happy? n)
then
(display n) (display " ")
(loop (+ n 1) (+ count 1))
else
(loop (+ n 1) count))))
(print)happy numbers: 1 7 10 13 19 23 28 31
ooRexx
count = 0
say "First 8 happy numbers are:"
loop i = 1 while count < 8
if happyNumber(i) then do
count += 1
say i
end
end
::routine happyNumber
use strict arg number
-- use to trace previous cycle results
previous = .set~new
loop forever
-- stop when we hit the target
if number = 1 then return .true
-- stop as soon as we start cycling
if previous[number] \== .nil then return .false
previous~put(number)
next = 0
-- loop over all of the digits
loop digit over number~makearray('')
next += digit * digit
end
-- and repeat the cycle
number = next
endFirst 8 happy numbers are: 1 7 10 13 19 23 28 31
Oz
functor
import
System
define
fun {IsHappy N}
{IsHappy2 N nil}
end
fun {IsHappy2 N Seen}
if N == 1 then true
elseif {Member N Seen} then false
else
Next = {Sum {Map {Digits N} Square}}
in
{IsHappy2 Next N|Seen}
end
end
fun {Sum Xs}
{FoldL Xs Number.'+' 0}
end
fun {Digits N}
{Map {Int.toString N} fun {$ D} D - &0 end}
end
fun {Square N} N*N end
fun lazy {Nat I}
I|{Nat I+1}
end
%% List.filter is eager. But we need a lazy Filter:
fun lazy {LFilter Xs P}
case Xs of X|Xr andthen {P X} then X|{LFilter Xr P}
[] _|Xr then {LFilter Xr P}
[] nil then nil
end
end
HappyNumbers = {LFilter {Nat 1} IsHappy}
in
{System.show {List.take HappyNumbers 8}}
endOutput:
[1 7 10 13 19 23 28 31]
PARI/GP
- This code uses the select() function, which was added in PARI version 2.4.2. The order of the arguments changed between versions; to use in 2.4.2 change
select(function, vector)toselect(vector, function).
If the number has more than three digits, the sum of the squares of its digits has fewer digits than the number itself. If the number has three digits, the sum of the squares of its digits is at most 3 * 9^2 = 243. A simple solution is to look up numbers up to 243 and calculate the sum of squares only for larger numbers.
H=[1,7,10,13,19,23,28,31,32,44,49,68,70,79,82,86,91,94,97,100,103,109,129,130,133,139,167,176,188,190,192,193,203,208,219,226,230,236,239];
isHappy(n)={
if(n<262,
setsearch(H,n)>0
,
n=eval(Vec(Str(n)));
isHappy(sum(i=1,#n,n[i]^2))
)
};
select(isHappy, vector(31,i,i))Output:
%1 = [1, 7, 10, 13, 19, 23, 28, 31]
Pascal
Program HappyNumbers (output);
uses
Math;
function find(n: integer; cache: array of integer): boolean;
var
i: integer;
begin
find := false;
for i := low(cache) to high(cache) do
if cache[i] = n then
find := true;
end;
function is_happy(n: integer): boolean;
var
cache: array of integer;
sum: integer;
begin
setlength(cache, 1);
repeat
sum := 0;
while n > 0 do
begin
sum := sum + (n mod 10)**2;
n := n div 10;
end;
if sum = 1 then
begin
is_happy := true;
break;
end;
if find(sum, cache) then
begin
is_happy := false;
break;
end;
n := sum;
cache[high(cache)]:= sum;
setlength(cache, length(cache)+1);
until false;
end;
var
n, count: integer;
begin
n := 1;
count := 0;
while count < 8 do
begin
if is_happy(n) then
begin
inc(count);
write(n, ' ');
end;
inc(n);
end;
writeln;
end.Output:
:> ./HappyNumbers 1 7 10 13 19 23 28 31
alternative for counting fast
The Cache is limited to maximum value of the sum of squared digits and filled up in a blink of an eye.Even for cDigit2=1e9 takes 0.7s.Calculation of sum of squared digits is improved.Saving this SqrdSumCache speeds up tremendous. So i am able to check if the 1'000'000 th happy number is 7105849 as stated in C language.This seems to be true. Extended to 10e18 Tested with Free Pascal 3.0.4
Program HappyNumbers (output);
{$IFDEF FPC}
{$MODE DELPHI}
{$OPTIMIZATION ON,All}
{$ELSE}
{$APPLICATION CONSOLE}
{$ENDIF}
//{$DEFINE Use1E9}
uses
sysutils,//Timing
strutils;//Numb2USA
const
base = 10;
HighCache = 20*(sqr(base-1));//sum of sqr digit of Uint64
{$IFDEF Use1E9}
cDigit1 = sqr(base)*sqr(base);//must be power of base
cDigit2 = Base*sqr(cDigit1);// 1e9
cMaxPot = 18;
{$ELSE}
cDigit1 = base*sqr(base);//must be power of base
cDigit2 = sqr(cDigit1);// 1e6
cMaxPot = 14;
{$ENDIF}
type
tSumSqrDgts = array[0..cDigit2] of word;
tCache = array[0..2*HighCache] of word;
tSqrdSumCache = array[0..2*HighCache] of Uint32;
var
SumSqrDgts :tSumSqrDgts;
Cache : tCache;
SqrdSumCache1,
SqrdSumCache2 :tSqrdSumCache;
T1,T0 : TDateTime;
MAX2,Max1 : NativeInt;
procedure InitSumSqrDgts;
//calc all sum of squared digits 0..cDigits2
//using already calculated values
var
i,j,n,sq,Base1: NativeInt;
begin
For i := 0 to Base-1 do
SumSqrDgts[i] := i*i;
Base1 := Base;
n := Base;
repeat
For i := 1 to base-1 do
Begin
sq := SumSqrDgts[i];
For j := 0 to base1-1 do
Begin
SumSqrDgts[n] := sq+SumSqrDgts[j];
inc(n);
end;
end;
Base1 := Base1*base;
until Base1 >= cDigit2;
SumSqrDgts[n] := 1;
end;
function SumSqrdDgt(n: Uint64):NativeUint;inline;
var
r: Uint64;
begin
result := 0;
while n>cDigit2 do
Begin
r := n;
n := n div cDigit2;
r := r-n*cDigit2;
inc(result,SumSqrDgts[r]);
end;
inc(result,SumSqrDgts[n]);
end;
procedure CalcSqrdSumCache1;
var
Count : tSqrdSumCache;
i,sq,result : NativeInt;
begin
For i :=High(Count) downto 0 do
Count[i] := 0;
//count the manifold
For i := cDigit1-1 downto 0 do
inc(count[SumSqrDgts[i]]);
For i := High(Count) downto 0 do
if count[i] <> 0 then
Begin
Max1 := i;
BREAK;
end;
For sq := 0 to (20-3)*81 do
Begin
result := 0;
For i := Max1 downto 0 do
inc(result,Count[i]*Cache[sq+i]);
SqrdSumCache1[sq] := result;
end;
end;
procedure CalcSqrdSumCache2;
var
Count : tSqrdSumCache;
i,sq,result : NativeInt;
begin
For i :=High(Count) downto 0 do
Count[i] := 0;
For i := cDigit2-1 downto 0 do
inc(count[SumSqrDgts[i]]);
For i := High(Count) downto 0 do
if count[i] <> 0 then
Begin
Max2 := i;
BREAK;
end;
For sq := 0 to (20-6)*81 do
Begin
result := 0;
For i := Max2 downto 0 do
inc(result,Count[i]*Cache[sq+i]);
SqrdSumCache2[sq] := result;
end;
end;
procedure Inithappy;
var
n,s,p : NativeUint;
Begin
fillchar(SqrdSumCache1,SizeOf(SqrdSumCache1),#0);
fillchar(SqrdSumCache2,SizeOf(SqrdSumCache2),#0);
InitSumSqrDgts;
fillChar(Cache,SizeOf(Cache),#0);
Cache[1] := 1;
For n := 1 to High(Cache) do
Begin
If Cache[n] = 0 then
Begin
//start a linked list
Cache[n] := n;
p := n;
s := SumSqrdDgt(p);
while Cache[s] = 0 do
Begin
Cache[s] := p;
p := s;
s := SumSqrdDgt(p);
end;
//mark linked list backwards as happy number
IF Cache[s] = 1 then
Begin
repeat
s := Cache[p];
Cache[p] := 1;
p := s;
until s = n;
Cache[n] := 1;
end;
end;
end;
//mark all unhappy numbers with 0
For n := 1 to High(Cache) do
If Cache[n] <> 1 then
Cache[n] := 0;
CalcSqrdSumCache1;
CalcSqrdSumCache2;
end;
function is_happy(n: NativeUint): boolean;inline;
begin
is_happy := Boolean(Cache[SumSqrdDgt(n)])
end;
function nthHappy(Limit: Uint64):Uint64;
var
d,e,sE: NativeUint;
begin
result := 0;
d := 0;
e := 0;
sE := SumSqrDgts[e];
//big steps
while Limit >= cDigit2 do
begin
dec(Limit,SqrdSumCache2[SumSqrDgts[d]+sE]);
inc(result,cDigit2);
inc(d);
IF d >=cDigit2 then
Begin
inc(e);
sE := SumSqrdDgt(e);//SumSqrDgts[e];
d :=0;
end;
end;
//small steps
while Limit >= cDigit1 do
Begin
dec(Limit,SqrdSumCache1[SumSqrdDgt(result)]);
inc(result,cDigit1);
end;
//ONE BY ONE
while Limit > 0 do
begin
dec(Limit,Cache[SumSqrdDgt(result)]);
inc(result);
end;
result -= 1;
end;
var
n, count :Uint64;
Limit: NativeUint;
begin
write('cDigit1 = ',Numb2USA(IntToStr(cDigit1)));
writeln(' cDigit2 = ',Numb2USA(IntToStr(cDigit2)));
T0 := now;
Inithappy;
writeln('Init takes ',FormatDateTime(' HH:NN:SS.ZZZ',now-T0));
n := 1;
count := 0;
while count < 10 do
begin
if is_happy(n) then
begin
inc(count);
write(n, ' ');
end;
inc(n);
end;
writeln;
T0 := now;
T1 := T0;
n := 1;
Limit := 10;
repeat
writeln('1E',n:2,' n.th happy number ',Numb2USA(IntToStr(nthHappy(Limit))):26,
FormatDateTime(' HH:NN:SS.ZZZ',now-T1));
T1 := now;
inc(n);
Limit := limit*10;
until n> cMaxPot;
writeln('Total time counting ',FormatDateTime('HH:NN:SS.ZZZ',now-T0));
end.- output
cDigit1 = 1,000 cDigit2 = 1,000,000 Init takes 00:00:00.004 1 7 10 13 19 23 28 31 32 44 1E 1 n.th happy number 44 00:00:00.000 1E 2 n.th happy number 694 00:00:00.000 1E 3 n.th happy number 6,899 00:00:00.000 1E 4 n.th happy number 67,169 00:00:00.000 1E 5 n.th happy number 692,961 00:00:00.000 1E 6 n.th happy number 7,105,849 00:00:00.000 1E 7 n.th happy number 71,313,350 00:00:00.000 1E 8 n.th happy number 698,739,425 00:00:00.000 1E 9 n.th happy number 6,788,052,776 00:00:00.000 1E10 n.th happy number 66,305,148,869 00:00:00.000 1E11 n.th happy number 660,861,957,662 00:00:00.001 1E12 n.th happy number 6,745,877,698,967 00:00:00.008 1E13 n.th happy number 70,538,879,028,725 00:00:00.059 1E14 n.th happy number 744,083,563,164,178 00:00:00.612 Total time counting 00:00:00.680 real 0m0,685s cDigit1 = 10,000 cDigit2 = 1,000,000,000 Init takes 00:00:02.848 1 7 10 13 19 23 28 31 32 44 1E 1 n.th happy number 44 00:00:00.000 1E 2 n.th happy number 694 00:00:00.000 1E 3 n.th happy number 6,899 00:00:00.000 1E 4 n.th happy number 67,169 00:00:00.000 1E 5 n.th happy number 692,961 00:00:00.000 1E 6 n.th happy number 7,105,849 00:00:00.000 1E 7 n.th happy number 71,313,350 00:00:00.000 1E 8 n.th happy number 698,739,425 00:00:00.001 1E 9 n.th happy number 6,788,052,776 00:00:00.008 1E10 n.th happy number 66,305,148,869 00:00:00.010 1E11 n.th happy number 660,861,957,662 00:00:00.009 1E12 n.th happy number 6,745,877,698,967 00:00:00.008 1E13 n.th happy number 70,538,879,028,725 00:00:00.008 1E14 n.th happy number 744,083,563,164,178 00:00:00.011 1E15 n.th happy number 7,888,334,045,397,315 00:00:00.019 1E16 n.th happy number 82,440,929,809,838,249 00:00:00.079 1E17 n.th happy number 845,099,936,580,193,833 00:00:00.698 1E18 n.th happy number 8,489,964,903,498,345,213 00:00:06.920 Total time counting 00:00:07.771 real 0m10,627s
PascalABC.NET
uses School;
function IsHappy(n: integer): boolean;
begin
Result := False;
var cache := new HashSet<integer>;
while n <> 1 do
begin
if n in cache then
exit;
cache.Add(n);
n := n.Digits.Sum(d -> d*d);
end;
Result := True;
end;
begin
var n := 1;
var happyNums := new List<integer>;
while happyNums.Count < 8 do
begin
if IsHappy(n) then
happyNums.Add(n);
n += 1;
end;
happyNums.Print
end.- Output:
1 7 10 13 19 23 28 31
Perl
Since all recurrences end with 1 or repeat (37,58,89,145,42,20,4,16), we can do this test very quickly without having to make hashes of seen numbers.
use List::Util qw(sum);
sub ishappy {
my $s = shift;
while ($s > 6 && $s != 89) {
$s = sum(map { $_*$_ } split(//,$s));
}
$s == 1;
}
my $n = 0;
print join(" ", map { 1 until ishappy(++$n); $n; } 1..8), "\n";- Output:
1 7 10 13 19 23 28 31
Or we can solve using only the rudimentary task knowledge as below. Note the slightly different ways of doing the digit sum and finding the first 8 numbers where ishappy(n) is true -- this shows there's more than one way to do even these small sub-tasks.
use List::Util qw(sum);
sub is_happy {
my ($n) = @_;
my %seen;
while (1) {
$n = sum map { $_ ** 2 } split //, $n;
return 1 if $n == 1;
return 0 if $seen{$n}++;
}
}
my $n;
is_happy( ++$n ) and print "$n " or redo for 1..8;- Output:
1 7 10 13 19 23 28 31
Phix
Copy of Euphoria tweaked to give a one-line output
function is_happy(integer n) sequence seen = {} while n>1 do seen &= n integer k = 0 while n>0 do k += power(remainder(n,10),2) n = floor(n/10) end while n = k if find(n,seen) then return false end if end while return true end function integer n = 1 sequence s = {} while length(s)<8 do if is_happy(n) then s &= n end if n += 1 end while ?s
- Output:
{1,7,10,13,19,23,28,31}
PHP
function isHappy($n) {
while (1) {
$total = 0;
while ($n > 0) {
$total += pow(($n % 10), 2);
$n /= 10;
}
if ($total == 1)
return true;
if (array_key_exists($total, $past))
return false;
$n = $total;
$past[$total] = 0;
}
}
$i = $cnt = 0;
while ($cnt < 8) {
if (isHappy($i)) {
echo "$i ";
$cnt++;
}
$i++;
}1 7 10 13 19 23 28 31
Picat
go =>
println(happy_len(8)).
happy(N) =>
S = [N],
Happy = 1,
while (Happy == 1, N > 1)
N := sum([to_integer(I)**2 : I in N.to_string()]),
if member(N,S) then
Happy := 0
else
S := S ++ [N]
end
end,
Happy == 1.
happy_len(Limit) = S =>
S = [],
N = 1,
while (S.length < Limit)
if happy(N) then
S := S ++ [N]
end,
N := N + 1
end.- Output:
[1,7,10,13,19,23,28,31]
PicoLisp
(de happy? (N)
(let Seen NIL
(loop
(T (= N 1) T)
(T (member N Seen))
(setq N
(sum '((C) (** (format C) 2))
(chop (push 'Seen N)) ) ) ) ) )
(let H 0
(do 8
(until (happy? (inc 'H)))
(printsp H) ) )Output:
1 7 10 13 19 23 28 31
PILOT
C :max=8
:n=0
:i=0
*test
U :*happy
T (a=1):#n
C (a=1):i=i+1
C :n=n+1
J (i<max):*test
E :
*happy
C :a=n
:x=n
U :*sumsq
C :b=s
*loop
C :x=a
U :*sumsq
C :a=s
C :x=b
U :*sumsq
C :x=s
U :*sumsq
C :b=s
J (a<>b):*loop
E :
*sumsq
C :s=0
*digit
C :y=x/10
:z=x-y*10
:s=s+z*#z
:x=y
J (x):*digit
E :- Output:
1 7 10 13 19 23 28 31
PL/I
test: proc options (main); /* 19 November 2011 */
declare (i, j, n, m, nh initial (0) ) fixed binary (31);
main_loop:
do j = 1 to 100;
n = j;
do i = 1 to 100;
m = 0;
/* Form the sum of squares of the digits. */
do until (n = 0);
m = m + mod(n, 10)**2;
n = n/10;
end;
if m = 1 then
do;
put skip list (j || ' is a happy number');
nh = nh + 1;
if nh = 8 then return;
iterate main_loop;
end;
n = m; /* Replace n with the new number formed from digits. */
end;
end;
end test;OUTPUT:
1 is a happy number
7 is a happy number
10 is a happy number
13 is a happy number
19 is a happy number
23 is a happy number
28 is a happy number
31 is a happy number
PL/M
100H:
/* FIND SUM OF SQUARE OF DIGITS OF NUMBER */
DIGIT$SQUARE: PROCEDURE (N) BYTE;
DECLARE (N, T, D) BYTE;
T = 0;
DO WHILE N > 0;
D = N MOD 10;
T = T + D * D;
N = N / 10;
END;
RETURN T;
END DIGIT$SQUARE;
/* CHECK IF NUMBER IS HAPPY */
HAPPY: PROCEDURE (N) BYTE;
DECLARE (N, I) BYTE;
DECLARE FLAG (256) BYTE;
DO I=0 TO 255;
FLAG(I) = 0;
END;
DO WHILE NOT FLAG(N);
FLAG(N) = 1;
N = DIGIT$SQUARE(N);
END;
RETURN N = 1;
END HAPPY;
/* CP/M BDOS CALL */
BDOS: PROCEDURE (FN, ARG);
DECLARE FN BYTE, ARG ADDRESS;
GO TO 5;
END BDOS;
/* PRINT STRING */
PRINT: PROCEDURE (STR);
DECLARE STR ADDRESS;
CALL BDOS(9, STR);
END PRINT;
/* PRINT NUMBER */
PRINT$NUMBER: PROCEDURE (N);
DECLARE S (6) BYTE INITIAL ('...',13,10,'$');
DECLARE P ADDRESS;
DECLARE (N, C BASED P) BYTE;
P = .S(3);
DIGIT:
P = P - 1;
C = (N MOD 10) + '0';
N = N / 10;
IF N > 0 THEN GO TO DIGIT;
CALL PRINT(P);
END PRINT$NUMBER;
/* FIND FIRST 8 HAPPY NUMBERS */
DECLARE SEEN BYTE INITIAL (0);
DECLARE N BYTE INITIAL (1);
DO WHILE SEEN < 8;
IF HAPPY(N) THEN DO;
CALL PRINT$NUMBER(N);
SEEN = SEEN + 1;
END;
N = N + 1;
END;
CALL BDOS(0,0);
EOF- Output:
1 7 10 13 19 23 28 31
Potion
sqr = (n): n * n.
isHappy = (n) :
loop :
if (n == 1): return true.
if (n == 4): return false.
sum = 0
n = n string
n length times (i): sum = sum + sqr(n(i) number integer).
n = sum
.
.
firstEight = ()
i = 0
while (firstEight length < 8) :
i++
if (isHappy(i)): firstEight append(i).
.
firstEight string printPowerShell
function happy([int] $n) {
$a=@()
for($i=2;$a.count -lt $n;$i++) {
$sum=$i
$hist=@{}
while( $hist[$sum] -eq $null ) {
if($sum -eq 1) {
$a+=$i
}
$hist[$sum]=$sum
$sum2=0
foreach($j in $sum.ToString().ToCharArray()) {
$k=([int]$j)-0x30
$sum2+=$k*$k
}
$sum=$sum2
}
}
$a -join ','
}Output :
happy(8)
7,10,13,19,23,28,31,32Prolog
happy_numbers(L, Nb) :-
% creation of the list
length(L, Nb),
% Process of this list
get_happy_number(L, 1).
% the game is over
get_happy_number([], _).
% querying the newt happy_number
get_happy_number([H | T], N) :-
N1 is N+1,
(is_happy_number(N) ->
H = N,
get_happy_number(T, N1);
get_happy_number([H | T], N1)).
% we must memorized the numbers reached
is_happy_number(N) :-
is_happy_number(N, [N]).
% a number is happy when we get 1
is_happy_number(N, _L) :-
get_next_number(N, 1), !.
% or when this number is not already reached !
is_happy_number(N, L) :-
get_next_number(N, NN),
\+member(NN, L),
is_happy_number(NN, [NN | L]).
% Process of the next number from N
get_next_number(N, NewN) :-
get_list_digits(N, LD),
maplist(square, LD, L),
sumlist(L, NewN).
get_list_digits(N, LD) :-
number_chars(N, LCD),
maplist(number_chars_, LD, LCD).
number_chars_(D, CD) :-
number_chars(D, [CD]).
square(N, SN) :-
SN is N * N.Output :
?- happy_numbers(L, 8).
L = [1,7,10,13,19,23,28,31].Python
Procedural
>>> def happy(n):
past = set()
while n != 1:
n = sum(int(i)**2 for i in str(n))
if n in past:
return False
past.add(n)
return True
>>> [x for x in xrange(500) if happy(x)][:8]
[1, 7, 10, 13, 19, 23, 28, 31]Composition of pure functions
Drawing 8 terms from a non finite stream, rather than assuming prior knowledge of the finite sample size required:
'''Happy numbers'''
from itertools import islice
# main :: IO ()
def main():
'''Test'''
print(
take(8)(
happyNumbers()
)
)
# happyNumbers :: Gen [Int]
def happyNumbers():
'''Generator :: non-finite stream of happy numbers.'''
x = 1
while True:
x = until(isHappy)(succ)(x)
yield x
x = succ(x)
# isHappy :: Int -> Bool
def isHappy(n):
'''Happy number sequence starting at n reaches 1 ?'''
seen = set()
# p :: Int -> Bool
def p(x):
if 1 == x or x in seen:
return True
else:
seen.add(x)
return False
# f :: Int -> Int
def f(x):
return sum(int(d)**2 for d in str(x))
return 1 == until(p)(f)(n)
# GENERIC -------------------------------------------------
# succ :: Int -> Int
def succ(x):
'''The successor of an integer.'''
return 1 + x
# take :: Int -> [a] -> [a]
# take :: Int -> String -> String
def take(n):
'''The prefix of xs of length n,
or xs itself if n > length xs.'''
return lambda xs: (
xs[0:n]
if isinstance(xs, list)
else list(islice(xs, n))
)
# until :: (a -> Bool) -> (a -> a) -> a -> a
def until(p):
'''The result of repeatedly applying f until p holds.
The initial seed value is x.'''
def go(f, x):
v = x
while not p(v):
v = f(v)
return v
return lambda f: lambda x: go(f, x)
if __name__ == '__main__':
main()- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Quackery
[ 0 swap
[ 10 /mod 2 **
rot + swap
dup 0 = until ]
drop ] is digitsquare ( n --> n )
[ [ digitsquare
dup 1 != while
dup 42 != while
again ]
1 = ] is happy ( n --> b )
[ [] 1
[ dip
[ 2dup size > ]
swap while
dup happy if
[ tuck join swap ]
1+ again ]
drop nip ] is happies ( n --> [ )
8 happies echo- Output:
[ 1 7 10 13 19 23 28 31 ]
R
is.happy <- function(n)
{
stopifnot(is.numeric(n) && length(n)==1)
getdigits <- function(n)
{
as.integer(unlist(strsplit(as.character(n), "")))
}
digits <- getdigits(n)
previous <- c()
repeat
{
sumsq <- sum(digits^2, na.rm=TRUE)
if(sumsq==1L)
{
happy <- TRUE
break
} else if(sumsq %in% previous)
{
happy <- FALSE
attr(happy, "cycle") <- previous
break
} else
{
previous <- c(previous, sumsq)
digits <- getdigits(sumsq)
}
}
happy
}Example usage
is.happy(2)[1] FALSE attr(,"cycle") [1] 4 16 37 58 89 145 42 20
#Find happy numbers between 1 and 50
which(apply(rbind(1:50), 2, is.happy))1 7 10 13 19 23 28 31 32 44 49
#Find the first 8 happy numbers
happies <- c()
i <- 1L
while(length(happies) < 8L)
{
if(is.happy(i)) happies <- c(happies, i)
i <- i + 1L
}
happies1 7 10 13 19 23 28 31
Racket
#lang racket
(define (sum-of-squared-digits number (result 0))
(if (zero? number)
result
(sum-of-squared-digits (quotient number 10)
(+ result (expt (remainder number 10) 2)))))
(define (happy-number? number (seen null))
(define next (sum-of-squared-digits number))
(cond ((= 1 next)
#t)
((memq next seen)
#f)
(else
(happy-number? next (cons number seen)))))
(define (get-happys max)
(for/list ((x (in-range max))
#:when (happy-number? x))
x))
(display (take (get-happys 100) 8)) ;displays (1 7 10 13 19 23 28 31)Raku
(formerly Perl 6)
sub happy (Int $n is copy --> Bool) {
loop {
state %seen;
$n = [+] $n.comb.map: { $_ ** 2 }
return True if $n == 1;
return False if %seen{$n}++;
}
}
say join ' ', grep(&happy, 1 .. *)[^8];- Output:
1 7 10 13 19 23 28 31
Here's another approach that uses a different set of tricks including lazy lists, gather/take, repeat-until, and the cross metaoperator X.
my @happy = lazy gather for 1..* -> $number {
my %stopper = 1 => 1;
my $n = $number;
repeat until %stopper{$n}++ {
$n = [+] $n.comb X** 2;
}
take $number if $n == 1;
}
say ~@happy[^8];Output is the same as above.
Here is a version using a subset and an anonymous recursion (we cheat a little bit by using the knowledge that 7 is the second happy number):
subset Happy of Int where sub ($n) {
$n == 1 ?? True !!
$n < 7 ?? False !!
&?ROUTINE([+] $n.comb »**» 2);
}
say (grep Happy, 1 .. *)[^8];Again, output is the same as above. It is not clear whether this version returns in finite time for any integer, though.
There's more than one way to do it...
Refal
$ENTRY Go {
= <ShowFirst 8 Happy 1>;
};
ShowFirst {
0 s.F s.I = ;
s.N s.F s.I, <Mu s.F s.I>: T =
<Prout s.I>
<ShowFirst <- s.N 1> s.F <+ s.I 1>>;
s.N s.F s.I =
<ShowFirst s.N s.F <+ s.I 1>>;
};
Happy {
1 e.X = T;
s.N e.X s.N e.Y = F;
s.N e.X = <Happy <SqDigSum s.N> s.N e.X>;
};
SqDigSum {
0 = 0;
s.N, <Symb s.N>: s.Ds e.Rs,
<Numb s.Ds>: s.D,
<Numb e.Rs>: s.R =
<+ <* s.D s.D> <SqDigSum s.R>>;
};- Output:
1 7 10 13 19 23 28 31
Relation
function happy(x)
set y = x
set lasty = 0
set found = " "
while y != 1 and not (found regex "\s".y."\s")
set found = found . y . " "
set m = 0
while y > 0
set digit = y mod 10
set m = m + digit * digit
set y = (y - digit) / 10
end while
set y = format(m,"%1d")
end while
set found = found . y . " "
if y = 1
set result = 1
else
set result = 0
end if
end function
set c = 0
set i = 1
while c < 8 and i < 100
if happy(i)
echo i
set c = c + 1
end if
set i = i + 1
end while1 7 10 13 19 23 28 31
REXX
/*REXX program computes and displays a specified range of happy numbers. */
Call time 'R'
linesize=80
Parse Arg low high /* obtain range of happy numbers */
If low='?' Then Call help
If low='' Then low=10
If high='' Then
Parse Value 1 low With low high
Do i=0 To 9 /*build a squared decimal digit table. */
square.i=i*i
End
happy.=0 /* happy.m=1 - m is a happy number */
unhappy.=0 /* unhappy.n=1 - n is an unhappy number*/
hapn=0 /* count of the happy numbers */
ol=''
Do n=1 While hapn<high /* test integers starting with 1 */
If unhappy.n Then /* if n is unhappy, */
Iterate /* then try next number */
work=n
suml='' /* list of computed sums */
Do Forever
sum=0
Do length(work) /* compute sum of squared digits */
Parse Var work digit +1 work
sum=sum+square.digit
End
Select
When unhappy.sum |, /* sum is known to be unhappy */
wordpos(sum,suml)>0 Then Do /* or was already encountered */
-- If wordpos(sum,suml)>0 Then say 'Loop' n':' suml sum
-- If n<7 Then say n':' suml sum
unhappy.n=1 /* n is unhappy */
Call set suml /* amd so are all sums so far */
Iterate n
End
When sum=1 Then Do /* we reached sum=1 */
hapn+=1 /* increment number of happy numbers */
happy.n=1 /* n is happy */
If hapn>=low Then /* if it is in specified range */
Call out n /* output it */
If hapn=high Then /* end of range reached */
Leave n /* we are done */
Iterate n /* otherwise proceed */
End
Otherwise Do /* otherwise */
suml=suml sum /* add sum to list of sums */
work=sum /* proceed with the new sum */
End
End
End
End
If ol>'' Then /* more output data */
Say strip(ol) /* write to console */
-- Say time('E')
Exit
set: /* all intermediate sums are unhappy */
Parse Arg list
Do While list<>''
Parse Var list s list
unhappy.s=1
End
Return
out: /* output management */
Parse Arg hn /* the happy number */
If length(ol hn)>linesize Then Do /* if it does not fit */
Say strip(ol) /* output the line */
ol=hn /* and start a new line */
End
Else /* otherwise */
ol=ol hn /* append is to the output line */
Return
help:
Say 'rexx hno n compute and show the first n happy numbers'
Say 'rexx hno low high show happy numbers from index low to high'
Exit- Output:
K:\_B\HN>rexx hno ? rexx hno n compute and show the first n happy numbers rexx hno low high show happy numbers from index low to high K:\_B\HN>rexx hno 8 1 7 10 13 19 23 28 31 K:\_B\HN>rexx hno 1000 1003 6899 6904 6917 6923
Ring
n = 1
found = 0
While found < 8
If IsHappy(n)
found += 1
see string(found) + " : " + string(n) + nl
ok
n += 1
End
Func IsHappy n
cache = []
While n != 1
Add(cache,n)
t = 0
strn = string(n)
for e in strn
t += pow(number(e),2)
next
n = t
If find(cache,n) Return False ok
End
Return True- Output:
1 : 1 2 : 7 3 : 10 4 : 13 5 : 19 6 : 23 7 : 28 8 : 31
RPL
≪ { } SWAP DO
SWAP OVER + 0 ROT
DO
MANT RND DUP IP SQ ROT + SWAP FP
UNTIL DUP NOT END
DROP
UNTIL DUP2 POS END
SWAP DROP 1 ==
≫
'HAPY?' STO
≪ { } 0 DO
1 + IF DUP HAPY? THEN SWAP OVER + SWAP END
UNTIL OVER SIZE 8 == END
≫ EVAL
- Output:
1: { 1 7 10 13 19 23 28 31 }
Ruby
require 'set' # Set: Fast array lookup / Simple existence hash
@seen_numbers = Set.new
@happy_numbers = Set.new
def happy?(n)
return true if n == 1 # Base case
return @happy_numbers.include?(n) if @seen_numbers.include?(n) # Use performance cache, and stop unhappy cycles
@seen_numbers << n
digit_squared_sum = n.digits.sum{|n| n*n}
if happy?(digit_squared_sum)
@happy_numbers << n
true # Return true
else
false # Return false
end
endHelper method to produce output:
def print_happy
happy_numbers = []
1.step do |i|
break if happy_numbers.length >= 8
happy_numbers << i if happy?(i)
end
p happy_numbers
end
print_happy- Output:
[1, 7, 10, 13, 19, 23, 28, 31]Alternative version
@memo = [0,1]
def happy(n)
sum = n.digits.sum{|n| n*n}
return @memo[sum] if @memo[sum]==0 or @memo[sum]==1
@memo[sum] = 0 # for the cycle check
@memo[sum] = happy(sum) # return 1:Happy number, 0:other
end
i = count = 0
while count < 8
i += 1
puts i or count+=1 if happy(i)==1
end
puts
for i in 99999999999900..99999999999999
puts i if happy(i)==1
end- Output:
1 7 10 13 19 23 28 31 99999999999901 99999999999910 99999999999914 99999999999915 99999999999916 99999999999937 99999999999941 99999999999951 99999999999956 99999999999961 99999999999965 99999999999973
Simpler Alternative
def happy?(n)
past = []
until n == 1
n = n.digits.sum { |d| d * d }
return false if past.include? n
past << n
end
true
end
i = count = 0
until count == 8; puts i or count += 1 if happy?(i += 1) end
puts
(99999999999900..99999999999999).each { |i| puts i if happy?(i) }- Output:
1 7 10 13 19 23 28 31 99999999999901 99999999999910 99999999999914 99999999999915 99999999999916 99999999999937 99999999999941 99999999999951 99999999999956 99999999999961 99999999999965 99999999999973
Rust
In Rust, using a tortoise/hare cycle detection algorithm (generic for integer types)
#![feature(core)]
fn sumsqd(mut n: i32) -> i32 {
let mut sq = 0;
while n > 0 {
let d = n % 10;
sq += d*d;
n /= 10
}
sq
}
use std::num::Int;
fn cycle<T: Int>(a: T, f: fn(T) -> T) -> T {
let mut t = a;
let mut h = f(a);
while t != h {
t = f(t);
h = f(f(h))
}
t
}
fn ishappy(n: i32) -> bool {
cycle(n, sumsqd) == 1
}
fn main() {
let happy = std::iter::count(1, 1)
.filter(|&n| ishappy(n))
.take(8)
.collect::<Vec<i32>>();
println!("{:?}", happy)
}- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Salmon
variable happy_count := 0;
outer:
iterate(x; [1...+oo])
{
variable seen := <<(* --> false)>>;
variable now := x;
while (true)
{
if (seen[now])
{
if (now == 1)
{
++happy_count;
print(x, " is happy.\n");
if (happy_count == 8)
break from outer;;
};
break;
};
seen[now] := true;
variable new := 0;
while (now != 0)
{
new += (now % 10) * (now % 10);
now /::= 10;
};
now := new;
};
};This Salmon program produces the following output:
1 is happy. 7 is happy. 10 is happy. 13 is happy. 19 is happy. 23 is happy. 28 is happy. 31 is happy.
Scala
scala> def isHappy(n: Int) = {
| new Iterator[Int] {
| val seen = scala.collection.mutable.Set[Int]()
| var curr = n
| def next = {
| val res = curr
| curr = res.toString.map(_.asDigit).map(n => n * n).sum
| seen += res
| res
| }
| def hasNext = !seen.contains(curr)
| }.toList.last == 1
| }
isHappy: (n: Int)Boolean
scala> Iterator from 1 filter isHappy take 8 foreach println
1
7
10
13
19
23
28
31Scheme
(define (number->list num)
(do ((num num (quotient num 10))
(lst '() (cons (remainder num 10) lst)))
((zero? num) lst)))
(define (happy? num)
(let loop ((num num) (seen '()))
(cond ((= num 1) #t)
((memv num seen) #f)
(else (loop (apply + (map (lambda (x) (* x x)) (number->list num)))
(cons num seen))))))
(display "happy numbers:")
(let loop ((n 1) (more 8))
(cond ((= more 0) (newline))
((happy? n) (display " ") (display n) (loop (+ n 1) (- more 1)))
(else (loop (+ n 1) more))))The output is:
happy numbers: 1 7 10 13 19 23 28 31
Scratch
Scratch is a free visual programming language. Click the link, then "See inside" to view the code.
https://scratch.mit.edu/projects/78912620/
This code will allow you to check if a positive interger (<=9999) is a happy number. It will also output a list of the first 8 happy numbers. (1 7 10 13 19 23 28 31)
Seed7
$ include "seed7_05.s7i";
const type: cacheType is hash [integer] boolean;
var cacheType: cache is cacheType.value;
const func boolean: happy (in var integer: number) is func
result
var boolean: isHappy is FALSE;
local
var bitset: cycle is bitset.value;
var integer: newnumber is 0;
var integer: cycleNum is 0;
begin
while number > 1 and number not in cycle do
if number in cache then
number := ord(cache[number]);
else
incl(cycle, number);
newnumber := 0;
while number > 0 do
newnumber +:= (number rem 10) ** 2;
number := number div 10;
end while;
number := newnumber;
end if;
end while;
isHappy := number = 1;
for cycleNum range cycle do
cache @:= [cycleNum] isHappy;
end for;
end func;
const proc: main is func
local
var integer: number is 0;
begin
for number range 1 to 50 do
if happy(number) then
writeln(number);
end if;
end for;
end func;Output:
1 7 10 13 19 23 28 31 32 44 49
SequenceL
import <Utilities/Math.sl>;
import <Utilities/Conversion.sl>;
main(argv(2)) := findHappys(stringToInt(head(argv)));
findHappys(count) := findHappysHelper(count, 1, []);
findHappysHelper(count, n, happys(1)) :=
happys when size(happys) = count
else
findHappysHelper(count, n + 1, happys ++ [n]) when isHappy(n)
else
findHappysHelper(count, n + 1, happys);
isHappy(n) := isHappyHelper(n, []);
isHappyHelper(n, cache(1)) :=
let
digits[i] := (n / integerPower(10, i - 1)) mod 10
foreach i within 1 ... ceiling(log(10, n + 1));
newN := sum(integerPower(digits, 2));
in
false when some(n = cache)
else
true when n = 1
else
isHappyHelper(newN, cache ++ [n]);- Output:
$>happy.exe 8 [1,7,10,13,19,23,28,31]
SETL
proc is_happy(n);
s := [n];
while n > 1 loop
if (n := +/[val(i)**2: i in str(n)]) in s then
return false;
end if;
s with:= n;
end while;
return true;
end proc;happy := [];
n := 1;
until #happy = 8 loop
if is_happy(n) then happy with:= n; end if;
n +:= 1;
end loop;
print(happy);Output:
[1 7 10 13 19 23 28 31]
Alternative version:
print([n : n in [1..100] | is_happy(n)](1..8));Output:
[1 7 10 13 19 23 28 31]
Sidef
func happy(n) is cached {
static seen = Hash()
return true if n.is_one
return false if seen.exists(n)
seen{n} = 1
happy(n.digits.sum { _*_ })
}
say happy.first(8)- Output:
[1, 7, 10, 13, 19, 23, 28, 31]
Smalltalk
In addition to the "Python's cache mechanism", the use of a Bag assures that found e.g. the happy 190, we already have in cache also the happy 910 and 109, and so on.
Object subclass: HappyNumber [
|cache negativeCache|
HappyNumber class >> new [ |me|
me := super new.
^ me init
]
init [ cache := Set new. negativeCache := Set new. ]
hasSad: aNum [
^ (negativeCache includes: (self recycle: aNum))
]
hasHappy: aNum [
^ (cache includes: (self recycle: aNum))
]
addHappy: aNum [
cache add: (self recycle: aNum)
]
addSad: aNum [
negativeCache add: (self recycle: aNum)
]
recycle: aNum [ |r n| r := Bag new.
n := aNum.
[ n > 0 ]
whileTrue: [ |d|
d := n rem: 10.
r add: d.
n := n // 10.
].
^r
]
isHappy: aNumber [ |cycle number newnumber|
number := aNumber.
cycle := Set new.
[ (number ~= 1) & ( (cycle includes: number) not ) ]
whileTrue: [
(self hasHappy: number)
ifTrue: [ ^true ]
ifFalse: [
(self hasSad: number) ifTrue: [ ^false ].
cycle add: number.
newnumber := 0.
[ number > 0 ]
whileTrue: [ |digit|
digit := number rem: 10.
newnumber := newnumber + (digit * digit).
number := (number - digit) // 10.
].
number := newnumber.
]
].
(number = 1)
ifTrue: [
cycle do: [ :e | self addHappy: e ].
^true
]
ifFalse: [
cycle do: [ :e | self addSad: e ].
^false
]
]
].|happy|
happy := HappyNumber new.
1 to: 31 do: [ :i |
(happy isHappy: i)
ifTrue: [ i displayNl ]
].Output:
1 7 10 13 19 23 28 31
an alternative version is:
|next isHappy happyNumbers|
next :=
[:n |
(n printString collect:[:ch | ch digitValue squared] as:Array) sum
].
isHappy :=
[:n | | t already |
already := Set new.
t := n.
[ t == 1 or:[ (already includes:t)]] whileFalse:[
already add:t.
t := next value:t.
].
t == 1
].
happyNumbers := OrderedCollection new.
try := 1.
[happyNumbers size < 8] whileTrue:[
(isHappy value:try) ifTrue:[ happyNumbers add:try].
try := try + 1
].
happyNumbers printCROutput: OrderedCollection(1 7 10 13 19 23 28 31)
Swift
func isHappyNumber(var n:Int) -> Bool {
var cycle = [Int]()
while n != 1 && !cycle.contains(n) {
cycle.append(n)
var m = 0
while n > 0 {
let d = n % 10
m += d * d
n = (n - d) / 10
}
n = m
}
return n == 1
}
var found = 0
var count = 0
while found != 8 {
if isHappyNumber(count) {
print(count)
found++
}
count++
}- Output:
1 7 10 13 19 23 28 31
Tcl
using code from Sum of squares#Tcl
proc is_happy n {
set seen [list]
while {$n > 1 && [lsearch -exact $seen $n] == -1} {
lappend seen $n
set n [sum_of_squares [split $n ""]]
}
return [expr {$n == 1}]
}
set happy [list]
set n -1
while {[llength $happy] < 8} {
if {[is_happy $n]} {lappend happy $n}
incr n
}
puts "the first 8 happy numbers are: [list $happy]"the first 8 happy numbers are: {1 7 10 13 19 23 28 31}
TUSCRIPT
$$ MODE TUSCRIPT
SECTION check
IF (n!=1) THEN
n = STRINGS (n,":>/:")
LOOP/CLEAR nr=n
square=nr*nr
n=APPEND (n,square)
ENDLOOP
n=SUM(n)
r_table=QUOTES (n)
BUILD R_TABLE/word/EXACT chk=r_table
IF (seq.ma.chk) THEN
status="next"
ELSE
seq=APPEND (seq,n)
ENDIF
RELEASE r_table chk
ELSE
PRINT checkednr," is a happy number"
happynrs=APPEND (happynrs,checkednr)
status="next"
ENDIF
ENDSECTION
happynrs=""
LOOP n=1,100
sz_happynrs=SIZE(happynrs)
IF (sz_happynrs==8) EXIT
checkednr=VALUE(n)
status=seq=""
LOOP
IF (status=="next") EXIT
DO check
ENDLOOP
ENDLOOPOutput:
1 is a happy number 7 is a happy number 10 is a happy number 13 is a happy number 19 is a happy number 23 is a happy number 28 is a happy number 31 is a happy number
Uiua
HC ← /+ⁿ2≡⋕°⋕ # Happiness calc = sum of squares of digits
IH ← |2 memo⟨IH ⊙⊂.|=1⟩∊,, HC # Apply HC until seen value recurs
Happy ← ⟨0◌|∘⟩IH : [1] . # Pre-load `seen` with 1. Return start number or 0
# Brute force approach isn't too bad with memoisation even for high bounds.
↙8⊚>0≡Happy⇡10000
# But iterative approach is still much faster
NH ← |1 ⟨NH|∘⟩≠0Happy.+1 # Find next Happy number
⇌[⍥(NH.) 7 1]UNIX Shell
function sum_of_square_digits {
typeset -i n=$1 sum=0 d
while (( n )); do
(( d=n%10, sum+=d*d, n=n/10 ))
done
printf '%d\n' "$sum"
}
function is_happy {
typeset -i n=$1
typeset -a seen=()
while (( n != 1 )); do
if [[ -n ${seen[$n]} ]]; then
return 1
fi
seen[$n]=1
(( n=$(sum_of_square_digits "$n") ))
done
return 0
}
function first_n_happy {
typeset -i count=$1 n
for (( n=1; count; n+=1 )); do
if is_happy "$n"; then
printf '%d\n' "$n"
(( count -= 1 ))
fi
done
return 0
}
first_n_happy 8Ursala
The happy function is a predicate testing whether a given number is happy, and first(p) defines a function mapping a number n to the first n positive naturals having property p.
#import std
#import nat
happy = ==1+ ^== sum:-0+ product*iip+ %np*hiNCNCS+ %nP
first "p" = ~&i&& iota; ~&lrtPX/&; leql@lrPrX->lrx ^|\~& ^/successor@l ^|T\~& "p"&& ~&iNC
#cast %nL
main = (first happy) 8output:
<1,7,10,13,19,23,28,31>
Vala
using Gee;
/* function to sum the square of the digits */
int sum(int input){
// convert input int to string
string input_str = input.to_string();
int total = 0;
// read through each character in string, square them and add to total
for (int x = 0; x < input_str.length; x++){
// char.digit_value converts char to the decimal value the char it represents holds
int digit = input_str[x].digit_value();
total += (digit * digit);
}
return total;
} // end sum
/* function to decide if a number is a happy number */
bool is_happy(int total){
var past = new HashSet<int>();
while(true){
total = sum(total);
if (total == 1){
return true;}
if (total in past){
return false;}
past.add(total);
} // end while loop
} // end happy
public static void main(){
var happynums = new ArrayList<int>();
int x = 1;
while (happynums.size < 8){
if (is_happy(x) == true)
happynums.add(x);
x++;
}
foreach(int num in happynums)
stdout.printf("%d ", num);
stdout.printf("\n");
} // end mainThe output is:
1 7 10 13 19 23 28 31
V (Vlang)
fn happy(h int) bool {
mut m := map[int]bool{}
mut n := h
for n > 1 {
m[n] = true
mut x := 0
for x, n = n, 0; x > 0; x /= 10 {
d := x % 10
n += d * d
}
if m[n] {
return false
}
}
return true
}
fn main() {
for found, n := 0, 1; found < 8; n++ {
if happy(n) {
print("$n ")
found++
}
}
println('')
}- Output:
1 7 10 13 19 23 28 31
Wren
var happy = Fn.new { |n|
var m = {}
while (n > 1) {
m[n] = true
var x = n
n = 0
while (x > 0) {
var d = x % 10
n = n + d*d
x = (x/10).floor
}
if (m[n] == true) return false // m[n] will be null if 'n' is not a key
}
return true
}
var found = 0
var n = 1
while (found < 8) {
if (happy.call(n)) {
System.write("%(n) ")
found = found + 1
}
n = n + 1
}
System.print()- Output:
1 7 10 13 19 23 28 31
XPL0
The largest possible 32-bit integer is less than 9,999,999,999. The sum of the squares of these ten digits is 10*9^2 = 810. If a cycle consisted of all the values smaller than 810, an array size of 810 would still be sufficiently large to hold them. Actually, tests show that the array only needs to hold 16 numbers.
int List(810); \list of numbers in a cycle
int Inx; \index for List
include c:\cxpl\codes;
func HadNum(N); \Return 'true' if number N is in the List
int N;
int I;
[for I:= 0 to Inx-1 do
if N = List(I) then return true;
return false;
]; \HadNum
func SqDigits(N); \Return the sum of the squares of the digits of N
int N;
int S, D;
[S:= 0;
while N do
[N:= N/10;
D:= rem(0);
S:= S + D*D;
];
return S;
]; \SqDigits
int N0, N, C;
[N0:= 0; \starting number
C:= 0; \initialize happy (starting) number counter
repeat N:= N0;
Inx:= 0; \reset List index
loop [N:= SqDigits(N);
if N = 1 then \happy number
[IntOut(0, N0); CrLf(0);
C:= C+1;
quit;
];
if HadNum(N) then quit; \if unhappy number then quit
List(Inx):= N; \if neither, add it to the List
Inx:= Inx+1; \ and continue the cycle
];
N0:= N0+1; \next starting number
until C=8; \done when 8 happy numbers have been found
]Output:
1 7 10 13 19 23 28 31
Zig
const std = @import("std");
const stdout = std.io.getStdOut().outStream();
pub fn main() !void {
try stdout.print("The first 8 happy numbers are: ", .{});
var n: u32 = 1;
var c: u4 = 0;
while (c < 8) {
if (isHappy(n)) {
c += 1;
try stdout.print("{} ", .{n});
}
n += 1;
}
try stdout.print("\n", .{});
}
fn isHappy(n: u32) bool {
var t = n;
var h = sumsq(n);
while (t != h) {
t = sumsq(t);
h = sumsq(sumsq(h));
}
return t == 1;
}
fn sumsq(n0: u32) u32 {
var s: u32 = 0;
var n = n0;
while (n > 0) : (n /= 10) {
const m = n % 10;
s += m * m;
}
return s;
}- Output:
The first 8 happy numbers are: 1 7 10 13 19 23 28 31
zkl
Here is a function that generates a continuous stream of happy numbers. Given that there are lots of happy numbers, caching them doesn't seem like a good idea memory wise. Instead, a num of squared digits == 4 is used as a proxy for a cycle (see the Wikipedia article, there are several number that will work).
fcn happyNumbers{ // continously spew happy numbers
foreach N in ([1..]){
n:=N; while(1){
n=n.split().reduce(fcn(p,n){ p + n*n },0);
if(n==1) { vm.yield(N); break; }
if(n==4) break; // unhappy cycle
}
}
}h:=Utils.Generator(happyNumbers);
h.walk(8).println();- Output:
L(1,7,10,13,19,23,28,31)
Get the one million-th happy number. Nobody would call this quick.
Utils.Generator(happyNumbers).drop(0d1_000_000-1).next().println();- Output:
7105849
Categories:
- Programming Tasks
- Arithmetic operations
- 11l
- 8080 Assembly
- 8th
- ABC
- ACL2
- Action!
- ActionScript
- Ada
- ALGOL 68
- ALGOL-M
- ALGOL W
- APL
- AppleScript
- Arturo
- AutoHotkey
- AutoIt
- AWK
- BASIC
- Applesoft BASIC
- BASIC256
- BBC BASIC
- Commodore BASIC
- FreeBASIC
- Liberty BASIC
- Locomotive Basic
- PureBasic
- Run BASIC
- UBasic/4tH
- VBA
- VBScript
- Visual Basic .NET
- ZX Spectrum Basic
- Batch File
- BCPL
- Bori
- BQN
- Brat
- C
- C sharp
- C++
- Clojure
- CLU
- COBOL
- CoffeeScript
- Common Lisp
- Cowgol
- Crystal
- D
- Dart
- Dc
- DCL
- Delphi
- System.SysUtils
- Boost.Int
- Draco
- DWScript
- Dyalect
- Déjà Vu
- E
- E examples needing attention
- Examples needing attention
- EasyLang
- Eiffel
- Elena
- Elixir
- Erlang
- Euphoria
- F Sharp
- Factor
- FALSE
- Fantom
- FOCAL
- Forth
- Fortran
- Frege
- FutureBasic
- Fōrmulæ
- Go
- Groovy
- Harbour
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- K
- Kotlin
- Lambdatalk
- Lasso
- Logo
- LOLCODE
- Lua
- M2000 Interpreter
- MACRO-11
- MAD
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Maxima
- MAXScript
- Mercury
- MiniScript
- Miranda
- ML
- MLite
- Modula-2
- MUMPS
- NetRexx
- Nim
- Objeck
- OCaml
- Oforth
- Ol
- OoRexx
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- PHP
- Picat
- PicoLisp
- PILOT
- PL/I
- PL/M
- Potion
- PowerShell
- Prolog
- Python
- Quackery
- R
- Racket
- Raku
- Refal
- Relation
- REXX
- Ring
- RPL
- Ruby
- Rust
- Salmon
- Scala
- Scheme
- Scratch
- Seed7
- SequenceL
- SETL
- Sidef
- Smalltalk
- Swift
- Tcl
- TUSCRIPT
- Uiua
- UNIX Shell
- Ursala
- Vala
- Gee
- V (Vlang)
- Wren
- XPL0
- Zig
- Zkl
- Pages with too many expensive parser function calls