Happy numbers: Difference between revisions

{{trans|Python}}

 

Set[Int] past

L n != 1

R 1B

 

 

{{out}}

under 256, the cycle never goes above 163; this program could be trivially changed to print up to 39 happy numbers.

 

puts: equ 9 ; CP/M print string

bdos: equ 5 ; CP/M entry point

adi 10

ret ; 1s digit is left in A afterwards

 

{{out}}

 

=={{header|8th}}==

: until! "not while!" eval i;

 

;with

;with

{{out}}

<pre>

 

=={{header|ACL2}}==

 

(defun sum-of-digit-squares (n)

 

(defun first-happy-nums (n)

Output:

<pre>(1 7 10 13 19 23 28 31)</pre>

 

=={{header|Action!}}==

BYTE sum,d

 

x==+1

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Happy_numbers.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

{

var sum:uint = 0;

}

}

Sample output:

<pre>

 

=={{header|Ada}}==

with Ada.Containers.Ordered_Sets;

 

end if;

end loop;

Sample output:

<pre>

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

 

PROC next = (INT in n)INT: (

print((i, new line))

FI

Output:

<pre>

 

=={{header|ALGOL-M}}==

integer function mod(a,b);

integer a,b;

i := i + 1;

end;

{{out}}

<pre> 1

 

=={{header|ALGOL W}}==

% find some happy numbers %

% returns true if n is happy, false otherwise; n must be >= 0 %

end while_happyCount_lt_8

end

{{out}}

<pre>

 

===Tradfn===

[1] ⍝0: Happy number

[2] ⍝1: http://rosettacode.org/wiki/Happy_numbers

[17]

[18] ⎕←~∘0¨∆first↑bin/iroof ⍝ Show ∆first numbers, but not 0

<pre>

HappyNumbers 100 8

 

===Dfn===

HappyNumbers←{ ⍝ return the first ⍵ Happy Numbers

⍺←⍬ ⍝ initial list

HappyNumbers 8

1 7 10 13 19 23 28 31

 

=={{header|AppleScript}}==

 

===Iteration===

set howManyHappyNumbers to 8

set happyNumberList to {}

end repeat

return (numberToCheck = 1)

<pre>

Result: (*1, 7, 10, 13, 19, 23, 28, 31*)

{{Trans|JavaScript}}

{{Trans|Haskell}}

 

-- isHappy :: Int -> Bool

end tell

return v

{{Out}}

 

=={{header|Applesoft BASIC}}==

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

4 Q = 0: FOR I = 0 TO S - 1: IF N = S(I) THEN RETURN

5 NEXT I:Q = 1: RETURN

{{out}}

<pre>

{{trans|Nim}}

 

happy?: function [x][

n: x

loop 0..31 'x [

if happy? x -> print x

 

{{out}}

 

=={{header|AutoHotkey}}==

If isHappy(A_Index) {

out .= (out="" ? "" : ",") . A_Index

Return false

Else Return isHappy(sum, list)

<pre>

The first 8 happy numbers are: 1,7,10,13,19,23,28,31

</pre>

===Alternative version===

if (Happy(A_Index)) {

Out .= A_Index A_Space

n := t, t := 0

}

<pre>1 7 10 13 19 23 28 31</pre>

 

=={{header|AutoIt}}==

$c = 0

$k = 0

EndIf

WEnd

 

<pre>

 

===Alternative version===

$c = 0

$k = 0

$a.Clear

WEnd

<pre>

Saves all numbers in a list, duplicate entry indicates a loop.

 

=={{header|AWK}}==

{

if ( n in happy ) return 1;

}

}

Result:

<pre>1

Alternately, for legibility one might write:

 

for (i = 1; i < 50; ++i){

if (isHappy(i)) {

}

return tot

 

=={{header|BASIC256}}==

print "The first 8 isHappy numbers are:"

print

num = isHappy

end while

 

=={{header|Batch File}}==

happy.bat

setlocal enableDelayedExpansion

::Define a list with 10 terms as a convenience for defining a loop

)

set /a n=sum

Sample usage and output

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

total% = 0

REPEAT

num% = MOD(digit&())^2 + 0.5

UNTIL num% = 1 OR num% = 4

Output:

<pre> 1 is a happy number

 

=={{header|BCPL}}==

 

let sumdigitsq(n) =

$)

wrch('*N')

{{out}}

<pre>1 7 10 13 19 23 28 31</pre>

 

=={{header|Bori}}==

{

ints cache;

}

puts("First 8 happy numbers : " + str.newline + happynums);

Output:

<pre>First 8 happy numbers :

 

=={{header|BQN}}==

Happy ← ⟨⟩{𝕨((⊑∊˜ )◶⟨∾𝕊(SumSqDgt⊢),1=⊢⟩)𝕩}⊢

{{out}}

<pre>⟨ 1 7 10 13 19 23 28 31 ⟩</pre>

 

=={{header|Brat}}==

 

happiness = set.new 1

p "First eight happy numbers: #{happies}"

p "Happy numbers found: #{happiness.to_array.sort}"

Output:

<pre>First eight happy numbers: [1, 7, 10, 13, 19, 23, 28, 31]

=={{header|C}}==

Recursively look up if digit square sum is happy.

 

#define CACHE 256

 

return 0;

output<pre>1 7 10 13 19 23 28 31

The 1000000th happy number: 7105849</pre>

Without caching, using cycle detection:

 

int dsum(int n)

 

return 0;

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

}

}

<pre>

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.<br/>

using System.Collections.Generic;

class Program

Console.WriteLine("\nComputation time {0} seconds.", (DateTime.Now - st).TotalSeconds);

}

{{out}}

<pre>---Happy Numbers---

=={{header|C++}}==

{{trans|Python}}

#include <set>

 

std::cout << i << std::endl;

return 0;

Output:

<pre>1

49</pre>

Alternative version without caching:

{

unsigned int result = 0;

}

std::cout << std::endl;

Output:

<pre>1 7 10 13 19 23 28 31 </pre>

 

=={{header|Clojure}}==

(loop [n n, seen #{}]

(cond

(def happy-numbers (filter happy? (iterate inc 1)))

 

Output:<pre>(1 7 10 13 19 23 28 31)</pre>

===Alternate Version (with caching)===

 

(def ^{:private true} cache {:happy (atom #{}) :sad (atom #{})})

(filter #(= :happy (happy-algo %)))))

 

Same output.

 

=={{header|CLU}}==

sum_sq: int := 0

while n > 0 do

stream$putl(po, int$unparse(i))

end

{{out}}

<pre>1

 

=={{header|CoffeeScript}}==

seen = {}

while true

console.log i

cnt += 1

output

<pre>

 

=={{header|Common Lisp}}==

(* n n))

 

(print (happys))

 

Output:<pre>(1 7 10 13 19 23 28 31)</pre>

 

=={{header|Cowgol}}==

 

sub sumDigitSquare(n: uint8): (s: uint8) is

end if;

n := n + 1;

 

{{out}}

=={{header|Crystal}}==

{{trans|Ruby}}

past = [] of Int32 | Int64

until n == 1

until count == 8; (puts i; count += 1) if happy?(i += 1) end

puts

{{out}}

<pre>

 

=={{header|D}}==

int[int] past;

 

 

int.max.iota.filter!isHappy.take(8).writeln;

{{out}}

<pre>[1, 7, 10, 13, 19, 23, 28, 31]</pre>

===Alternative Version===

 

bool isHappy(int n) pure nothrow {

void main() {

int.max.iota.filter!isHappy.take(8).writeln;

Same output.

 

=={{header|Dart}}==

HashMap<int,bool> happy=new HashMap<int,bool>();

happy[1]=true;

i++;

}

 

=={{header|dc}}==

[0rsclHxd4<h]sh

[lIp]s_

Output:

<pre>1

 

=={{header|DCL}}==

$ found = 0

$ i = 1

$ goto loop1

$ done:

{{out}}

<pre> FOUND = 8 Hex = 00000008 Octal = 00000000010

{{libheader| Boost.Int}}

Adaptation of [[#Pascal]]. The lib '''Boost.Int''' can be found here [https://github.com/MaiconSoft/DelphiBoostLib]

program Happy_numbers;

 

writeln;

readln;

{{out}}

<pre>1 7 10 13 19 23 28 31</pre>

=={{header|Draco}}==

byte r, d;

r := 0;

n := n + 1

od

{{out}}

<pre> 1

 

=={{header|DWScript}}==

var

cache : array of Integer;

Dec(n);

end;

Output:

<pre>1

=={{header|Dyalect}}==

 

var m = []

while n > 1 {

n += 1

}

 

{{out}}

 

=={{header|Déjà Vu}}==

0

while over:

++

drop

{{output}}

<pre>A happy number: 1

=={{header|E}}==

{{output?|E}}

var seen := [].asSet()

while (!seen.contains(x)) {

println(x)

if ((count += 1) >= 8) { break }

 

=={{header|Eiffel}}==

class

APPLICATION

end

 

 

=={{header|Elena}}==

{{trans|C#}}

ELENA 4.x :

import system'collections;

import system'routines;

};

console.printLine("First 8 happy numbers: ", happynums.asEnumerable())

{{out}}

<pre>

 

=={{header|Elixir}}==

def task(num) do

Process.put({:happy, 1}, true)

end

 

 

{{out}}

 

=={{header|Erlang}}==

-export([main/0]).

-import(lists, [map/2, member/2, sort/1, sum/1]).

main() ->

main(0, []).

 

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):

 

-export([main/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));

Output:

<pre>[1,7,10,13,19,23,28,31]</pre>

 

=={{header|Euphoria}}==

sequence seen

integer k

end if

n += 1

Output:

<pre>1

=={{header|F_Sharp|F#}}==

This requires the F# power pack to be referenced and the 2010 beta of F#

open Microsoft.FSharp.Collections

 

|> Seq.truncate 8 // Stop when we've found 8

|> Seq.iter (Printf.printf "%d\n") // Print results

Output:

<pre>

 

=={{header|Factor}}==

 

: squares ( n -- s )

dup happy? [ dup , [ 1 - ] dip ] when 1 +

] while 2drop

{{out}}

 

=={{header|FALSE}}==

[$m;![$9>][m;!@@+\]#$*+]s: {sum of squares}

[$0[1ø1>][1ø3+ø3ø=|\1-\]#\%]f: {look for duplicates}

"Happy numbers:"

[1ø8=~][h;![" "$.\1+\]?1+]#

 

{{out}}

 

=={{header|Fantom}}==

{

static Bool isHappy (Int n)

}

}

Output:

<pre>

 

=={{header|FOCAL}}==

01.20 D 3;I (K-2)1.5

01.30 S N=N+1

03.30 S S(K)=0

03.40 D 2;S K=R

 

{{out}}

 

=={{header|Forth}}==

0 swap begin 10 /mod >r dup * + r> ?dup 0= until ;

 

loop drop ;

 

 

===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.

: next ( n -- n')

0 swap BEGIN dup WHILE 10 /mod >r dup * + r> REPEAT drop ;

BEGIN 1+ dup happy? UNTIL dup . r> 1- >r

REPEAT r> drop drop ;

{{out}}

<pre>1 7 10 13 19 23 28 31</pre>

Produces the 1 millionth happy number with:

>r 0 BEGIN r@ WHILE

BEGIN 1+ dup happy? UNTIL r> 1- >r

REPEAT r> drop ;

in about 9 seconds.

 

=={{header|Fortran}}==

 

implicit none

end function is_happy

 

Output:

<pre>1

 

=={{header|FreeBASIC}}==

 

Function isHappy(n As Integer) As Boolean

Print

Print "Press any key to quit"

 

{{out}}

{{Works with|Frege|3.21.586-g026e8d7}}

 

 

import Prelude.Math

f = sum . map (sqr . digitToInteger) . unpacked . show

 

 

{{out}}

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println()

{{out}}

<pre>

 

=={{header|Groovy}}==

def number = delegate as Long

def cycle = new HashSet<Long>()

if (i.happy) { matches << i }

}

{{out}}

<pre>[1, 7, 10, 13, 19, 23, 28, 31]</pre>

 

=={{header|Harbour}}==

LOCAL i := 8, nH := 0

 

AAdd( aUnhappy, nSum )

 

Output:

 

 

=={{header|Haskell}}==

import Data.Set (member, insert, empty)

 

 

main :: IO ()

{{Out}}

<pre>1

 

We can create a cache for small numbers to greatly speed up the process:

 

happy :: Int -> Bool

 

main :: IO ()

{{Out}}

<pre>327604323</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

local n

n := arglist[1] | 8 # limiting number of happy numbers to generate, default=8

if happy(n) then return i

}

Usage and Output:

<pre>

 

=={{header|J}}==

This is a repeat while construction

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.

So for easier reading the solution could be expressed as:

sumSqrDigits=: +/@(*:@(,.&.":))

 

14

8{. (#~ 1 = sumSqrDigits ^: cond ^:_ "0) 1 + i.100

 

=={{header|Java}}==

{{works with|Java|1.5+}}

{{trans|JavaScript}}

public class Happy{

public static boolean happy(long number){

}

}

Output:

<pre>1

{{works with|Java|1.8}}

{{trans|Java}}

 

import java.util.Arrays;

return number == 1;

}

Output:

<pre>1

===ES5===

====Iteration====

var m, digit ;

var cycle = [] ;

document.write(number + " ") ;

number++ ;

Output:

<pre>1 7 10 13 19 23 28 31 </pre>

====Functional composition====

{{Trans|Haskell}}

 

// isHappy :: Int -> Bool

take(8, filter(isHappy, enumFromTo(1, 50)))

);

{{Out}}

 

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

.xs

);

{{Out}}

 

=={{header|jq}}==

{{works with|jq|1.4}}

def next: tostring | explode | map( (. - 48) | .*.) | add;

def last(g): reduce g as $i (null; $i);

end

end );

'''Emit a stream of the first n happy numbers''':

def happy(n):

def subtask: # state: [i, found]

[0,0] | subtask;

 

{{out}}

1

7

28

31

 

=={{header|Julia}}==

function happy(x)

happy_ints = ref(Int)

end

return happy_ints

Output

<pre> julia> happy(8)

31</pre>

A recursive version:

 

function ishappy(x, mem = [])

 

happy(n) = [z = 1 ; [z = nexthappy(z) for i = 1:n-1]]

{{Out}}

<pre>julia> show(happy(8))

Faster with use of cache

{{trans|C}}

buf = zeros(Int,CACHE)

buf[1] = 1

end

return i-1

 

=={{header|K}}==

 

hpy 1+!100

 

8#hpy 1+!100

 

Another implementation which is easy to follow is given below:

/ happynum.k

 

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:

=={{header|Kotlin}}==

{{trans|C#}}

 

fun isHappy(n: Int): Boolean {

}

println("First 8 happy numbers : " + happyNums.joinToString(", "))

 

{{out}}

 

=={{header|Lasso}}==

define isHappy(n::integer) => {

where isHappy(#x)

take 8

Output:

 

=={{header|Liberty BASIC}}==

n = 0

DO

sqrInts$ = sqrInts$ + Str$(sqrInts) + ":"

HappyN = HappyN(sqrInts, sqrInts$)

Output:-

<pre>1 1

=={{header|Locomotive Basic}}==

 

20 for i=1 to 100

30 i2=i

140 ' check if we have reached 8 numbers yet

150 if n=8 then end

 

[[File:Happy Numbers, Locomotive BASIC.png]]

=={{header|Logo}}==

 

output (apply "sum (map [[d] d*d] ` :number))

end

 

print n_happy 8

 

Output:

{{works with|lci 0.10.3}}

 

Happy Numbers Rosetta Code task in LOLCODE

Requires 1.3 for BUKKIT availability

OIC

IM OUTTA YR LOOP

 

Output:<pre>1

 

=={{header|Lua}}==

if n > 0 then return n % 10, digits(math.floor(n/10)) end

end

repeat

i, j = happy[j] and (print(j) or i+1) or i, j + 1

Output:

<pre>1

 

 

Function FactoryHappy {

sumOfSquares= lambda (n) ->{

PrintHappy=factoryHappy()

Call PrintHappy()

{{out}}

<pre>

=={{header|MAD}}==

 

BOOLEAN CYCLE

DIMENSION CYCLE(200)

END OF PROGRAM

 

{{out}}

=={{header|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.)

local s := 0;

local m := n;

end do;

s

(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 );

570

We can check this by computing it another way (more directly).

> n := 1234567890987654321:

> `+`( op( map( parse, StringTools:-Explode( convert( n, 'string' ) ) )^~2) );

570

The most straight-forward way to check whether a number is happy or sad seems also to be the fastest (that I could think of).

if n = 1 then

true

evalb( s = 1 )

end if

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, 856929

Finally, to solve the stated problem, here is a completely straight-forward routine to locate the first N happy numbers, returning them in a set.

local count := 0;

local T := table();

end do;

{seq}( T[ i ], i = 1 .. count )

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.

local a, b;

a, b := n, SumSqDigits( n );

end do;

evalb( a = 1 )

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Custom function HappyQ:

NestUntilRepeat[a_,f_]:=NestWhile[f,{a},!MemberQ[Most[Last[{##}]],Last[Last[{##}]]]&,All]

Examples for a specific number:

gives back:

Example finding the first 8:

n = 1;

i = 0;

]

]

gives back:

 

=={{header|MATLAB}}==

Recursive version:

nHappy = 0;

k = 1;

hap = isHappyNumber(sum((sprintf('%d', k)-'0').^2), [prev k]);

end

{{out}}

<pre>1 7 10 13 19 23 28 31 </pre>

 

=={{header|MAXScript}}==

fn isHappyNumber n =

(

)

Output:

1

7

28

31

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

:- func sqr(int) = int.

 

{{out}}

<pre>[1, 7, 10, 13, 19, 23, 28, 31]</pre>

=={{header|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.

while true

if x == 89 then return false

i = i + 1

end while

{{out}}

<pre>First 8 happy numbers: [1, 7, 10, 13, 19, 23, 28, 31]</pre>

=={{header|ML}}==

==={{header|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

 

foreach (fn n = (print n; print " is "; println ` happy n)) ` iota 10;

Output:

<pre>1 is happy

 

=={{header|Modula-2}}==

FROM InOut IMPORT WriteCard, WriteLn;

 

INC(num);

END;

{{out}}

<pre> 1

 

=={{header|MUMPS}}==

;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

FOR I=1:1 QUIT:C<1 SET Q=+$$ISHAPPY(I) WRITE:Q !,I SET:Q C=C-1

KILL I

Output:<pre>

USER>D HAPPY^ROSETTA(8)

=={{header|NetRexx}}==

{{trans|REXX}}

limit = arg[0] /*get argument for LIMIT. */

say limit

q=sum /*now, lets try the Q sum. */

end

;Output

<pre>

=={{header|Nim}}==

{{trans|Python}}

 

proc happy(n: int): bool =

for x in 0..31:

if happy(x):

Output:

<pre>1

 

=={{header|Objeck}}==

use Structure;

 

}

}

output:

<pre>First 8 happy numbers: 1,7,10,13,19,23,28,31,</pre>

=={{header|OCaml}}==

Using [[wp:Cycle detection|Floyd's cycle-finding algorithm]].

 

let step =

 

List.iter print_endline (

Output:

<pre>$ ocaml nums.cma happy_numbers.ml

=={{header|Oforth}}==

 

| cycle |

ListBuffer new ->cycle

ListBuffer new ->numbers

1 while(numbers size N <>) [ dup isHappy ifTrue: [ dup numbers add ] 1+ ]

 

Output:

 

=={{header|ooRexx}}==

count = 0

say "First 8 happy numbers are:"

number = next

end

<pre>

First 8 happy numbers are:

 

=={{header|Oz}}==

import

System

in

{System.show {List.take HappyNumbers 8}}

Output:

<pre>[1 7 10 13 19 23 28 31]</pre>

{{PARI/GP select}}

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.

isHappy(n)={

if(n<262,

)

};

Output:

<pre>%1 = [1, 7, 10, 13, 19, 23, 28, 31]</pre>

 

=={{header|Pascal}}==

 

uses

end;

writeln;

Output:

<pre>:> ./HappyNumbers

Extended to 10e18

Tested with Free Pascal 3.0.4

{$IFDEF FPC}

{$MODE DELPHI}

writeln('Total time counting ',FormatDateTime('HH:NN:SS.ZZZ',now-T0));

end.

;output:

<pre>

=={{header|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.

 

sub ishappy {

 

my $n = 0;

{{out}}

<pre>1 7 10 13 19 23 28 31</pre>

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.

{{trans|Raku}}

sub is_happy {

my ($n) = @_;

 

my $n;

{{out}}

<pre>1 7 10 13 19 23 28 31</pre>

=={{header|Phix}}==

Copy of [[Happy_numbers#Euphoria|Euphoria]] tweaked to give a one-line output

<span style="color: #008080;">function</span> <span style="color: #000000;">is_happy</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">seen</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>

{{out}}

<pre>

=={{header|PHP}}==

{{trans|D}}

while (1) {

$total = 0;

}

$i++;

<pre>1 7 10 13 19 23 28 31 </pre>

 

=={{header|Picat}}==

println(happy_len(8)).

 

end,

N := N + 1

 

{{out}}

 

=={{header|PicoLisp}}==

(let Seen NIL

(loop

(do 8

(until (happy? (inc 'H)))

Output:

<pre>1 7 10 13 19 23 28 31</pre>

 

=={{header|PILOT}}==

:n=0

:i=0

:x=y

J (x):*digit

{{out}}

<pre>1

 

=={{header|PL/I}}==

declare (i, j, n, m, nh initial (0) ) fixed binary (31);

 

end;

end test;

OUTPUT:

<pre>

 

=={{header|PL/M}}==

 

/* FIND SUM OF SQUARE OF DIGITS OF NUMBER */

 

CALL BDOS(0,0);

{{out}}

<pre>1

 

=={{header|Potion}}==

 

isHappy = (n) :

if (isHappy(i)): firstEight append(i).

.

 

=={{header|PowerShell}}==

$a=@()

for($i=2;$a.count -lt $n;$i++) {

}

$a -join ','

Output :

 

=={{header|Prolog}}==

{{Works with|SWI-Prolog}}

% creation of the list

length(L, Nb),

 

square(N, SN) :-

Output :

 

=={{header|PureBasic}}==

#MaxTests=100

#True = 1: #False = 0

Until i>#MaxTests

ProcedureReturn #False

Sample output:

<pre>#1 1

=={{header|Python}}==

===Procedural===

past = set()

while n != 1:

 

>>> [x for x in xrange(500) if happy(x)][:8]

 

===Composition of pure functions===

 

Drawing 8 terms from a non finite stream, rather than assuming prior knowledge of the finite sample size required:

 

from itertools import islice

 

if __name__ == '__main__':

{{Out}}

<pre>[1, 7, 10, 13, 19, 23, 28, 31]</pre>

=={{header|Quackery}}==

 

[ 0 swap

[ 10 /mod 2 **

drop nip ] is happies ( n --> [ )

 

 

{{Out}}

 

=={{header|R}}==

{

stopifnot(is.numeric(n) && length(n)==1)

}

happy

Example usage

[1] FALSE

attr(,"cycle")

[1] 4 16 37 58 89 145 42 20

1 7 10 13 19 23 28 31 32 44 49

happies <- c()

i <- 1L

i <- i + 1L

}

1 7 10 13 19 23 28 31

 

=={{header|Racket}}==

(define (sum-of-squared-digits number (result 0))

(if (zero? number)

x))

 

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|rakudo|2015-09-13}}

loop {

state %seen;

}

 

{{out}}

<pre>1 7 10 13 19 23 28 31</pre>

Here's another approach that uses a different set of tricks including lazy lists, gather/take, repeat-until, and the cross metaoperator X.

my %stopper = 1 => 1;

my $n = $number;

}

 

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):

$n == 1 ?? True !!

$n < 7 ?? False !!

}

Again, output is the same as above. It is not clear whether this version returns in finite time for any integer, though.

 

 

=={{header|Relation}}==

function happy(x)

set y = x

set i = i + 1

end while

 

<pre>

=={{header|REXX}}==

===unoptimized===

parse arg limit . /*obtain optional argument from the CL.*/

if limit=='' | limit=="," then limit=8 /*Not specified? Then use the default.*/

haps=haps+1 /*bump the count of happy numbers. */

end /*n*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 8 </tt>}}

<pre>

<br><br>This REXX version also accepts a &nbsp; ''range'' &nbsp; of happy numbers to be shown, &nbsp; that is,

<br>it can show the 2000^th through the 2032^nd (inclusive) happy numbers &nbsp; (as shown below).

parse arg L H . /*obtain optional arguments from the CL*/

if L=='' | L=="," then L=8 /*Not specified? Then use the default.*/

say right(n, 30) /*display right justified happy number.*/

end /*n*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 2000 &nbsp; 2032 </tt>}}

<pre>

===optimized, horizontal list===

This REXX version is identical to the optimized version, &nbsp; but displays the numbers in a horizontal list.

sw=linesize() - 1 /*obtain the screen width (less one). */

parse arg limit . /*obtain optional argument from the CL.*/

end /*n*/

if $\='' then say strip($) /*display any residual happy numbers. */

This REXX program makes use of &nbsp; '''linesize''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

 

 

=={{header|Ring}}==

found = 0

End

Return True

{{out}}

<pre>

{{works with|Ruby|2.1}}

 

 

@seen_numbers = Set.new

false # Return false

end

 

Helper method to produce output:

happy_numbers = []

 

end

 

 

{{out}}

 

===Alternative version===

def happy(n)

sum = n.to_s.chars.map{|c| c.to_i**2}.inject(:+)

for i in 99999999999900..99999999999999

puts i if happy(i)==1

 

{{out}}

===Simpler Alternative===

{{trans|Python}}

past = []

until n == 1

until count == 8; puts i or count += 1 if happy?(i += 1) end

puts

{{out}}

<pre>

 

=={{header|Run BASIC}}==

if happy(i) = 1 then

cnt = cnt + 1

num = happy

wend

<pre>1. 1 is a happy number

2. 7 is a happy number

=={{header|Rust}}==

In Rust, using a tortoise/hare cycle detection algorithm (generic for integer types)

 

fn sumsqd(mut n: i32) -> i32 {

 

println!("{:?}", happy)

{{out}}

<pre>

 

=={{header|Salmon}}==

outer:

iterate(x; [1...+oo])

now := new;

};

This Salmon program produces the following output:

<pre>1 is happy.

 

=={{header|Scala}}==

| new Iterator[Int] {

| val seen = scala.collection.mutable.Set[Int]()

28

31

 

=={{header|Scheme}}==

(do ((num num (quotient num 10))

(lst '() (cons (remainder num 10) lst)))

(cond ((= more 0) (newline))

((happy? n) (display " ") (display n) (loop (+ n 1) (- more 1)))

The output is:

<pre>happy numbers: 1 7 10 13 19 23 28 31</pre>

 

=={{header|Seed7}}==

 

const type: cacheType is hash [integer] boolean;

end if;

end for;

 

Output:

 

=={{header|SequenceL}}==

import <Utilities/Conversion.sl>;

 

true when n = 1

else

 

{{out}}

 

=={{header|SETL}}==

s := [n];

while n > 1 loop

end while;

return true;

n := 1;

until #happy = 8 loop

end loop;

 

Output:

<pre>[1 7 10 13 19 23 28 31]</pre>

Alternative version:

Output:

<pre>[1 7 10 13 19 23 28 31]</pre>

 

=={{header|Sidef}}==

static seen = Hash()

 

}

 

 

{{out}}

{{trans|Python}}

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.

|cache negativeCache|

HappyNumber class >> new [ |me|

]

]

happy := HappyNumber new.

 

(happy isHappy: i)

ifTrue: [ i displayNl ]

Output:

1

an alternative version is:

{{works with|Smalltalk/X}}

 

next :=

try := try + 1

].

Output:

OrderedCollection(1 7 10 13 19 23 28 31)

 

=={{header|Swift}}==

var cycle = [Int]()

}

count++

{{out}}

<pre>

=={{header|Tcl}}==

using code from [[Sum of squares#Tcl]]

set seen [list]

while {$n > 1 && [lsearch -exact $seen $n] == -1} {

incr n

}

<pre>the first 8 happy numbers are: {1 7 10 13 19 23 28 31}</pre>

 

=={{header|TUSCRIPT}}==

SECTION check

IF (n!=1) THEN

DO check

ENDLOOP

Output:

<pre>

 

=={{header|uBasic/4tH}}==

' ************************

' MAIN

' END SUBS & FUNCTIONS

' ************************

 

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

function sum_of_square_digits

{

}

 

Output:<pre>1

7

and first(p) defines a function mapping a number n to the first n

positive naturals having property p.

#import nat

 

#cast %nL

 

output:

<pre><1,7,10,13,19,23,28,31></pre>

=={{header|Vala}}==

{{libheader|Gee}}

 

/* function to sum the square of the digits */

stdout.printf("%d ", num);

stdout.printf("\n");

The output is:

<pre>

=={{header|VBA}}==

 

Option Explicit

 

Is_Happy_Number = True

End Function

{{Out}}

<pre>Is Happy : 1

 

=={{header|VBScript}}==

count = 0

firsteigth=""

Loop

End Function

 

{{Out}}

=={{header|Visual Basic .NET}}==

This version uses Linq to carry out the calculations.

Sub Main()

Dim n As Integer = 1

Return True

End Function

The output is:

<pre>1: 1

{{trans|C#}}

Curiously, this runs in about two thirds of the time of the cacheless C# version on Tio.run.

 

Dim sq As Integer() = {1, 4, 9, 16, 25, 36, 49, 64, 81}

Console.WriteLine(vbLf & "Computation time {0} seconds.", (DateTime.Now - st).TotalSeconds)

End Sub

{{out}}

<pre>---Happy Numbers---

=={{header|Vlang}}==

{{trans|go}}

mut m := map[int]bool{}

mut n := h

}

println('')

{{out}}

<pre>

=={{header|Wren}}==

{{trans|Go}}

var m = {}

while (n > 1) {

n = n + 1

}

 

{{out}}

numbers.

 

int Inx; \index for List

include c:\cxpl\codes;

N0:= N0+1; \next starting number

until C=8; \done when 8 happy numbers have been found

 

Output:

 

=={{header|Zig}}==

const std = @import("std");

const stdout = std.io.getStdOut().outStream();

return s;

}

{{Out}}

<pre>

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).

{{trans|Icon and Unicon}}

foreach N in ([1..]){

n:=N; while(1){

}

}

{{out}}

<pre>L(1,7,10,13,19,23,28,31)</pre>

Get the one million-th happy number. Nobody would call this quick.

{{out}}<pre>7105849</pre>

 

=={{header|ZX Spectrum Basic}}==

{{trans|Run_BASIC}}

20 GO SUB 1000

30 IF isHappy=1 THEN PRINT i;" is a happy number"

1080 NEXT j

1090 LET num=isHappy