langs a-z

Task/Happy-numbers/NetRexx/happy-numbers.netrexx

@@ -0,0 +1,28 @@
+/*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

Task/Happy-numbers/OCaml/happy-numbers.ocaml

@@ -0,0 +1,25 @@
+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)) ;;

Task/Happy-numbers/Objeck/happy-numbers.objeck

@@ -0,0 +1,47 @@
+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("");
+    }
+  }
+}

Task/Happy-numbers/Oz/happy-numbers.oz

@@ -0,0 +1,40 @@
+declare
+  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
+  {Show {List.take HappyNumbers 8}}

Task/Happy-numbers/PARI-GP/happy-numbers.pari

@@ -0,0 +1,10 @@
+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))

Task/Happy-numbers/PL-I/happy-numbers.pli

@@ -0,0 +1,24 @@
+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;

Task/Happy-numbers/Pascal/happy-numbers.pascal

@@ -0,0 +1,61 @@
+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.

Task/Happy-numbers/Perl-6/happy-numbers-1.pl6

@@ -0,0 +1,10 @@
+sub happy (Int $n is copy --> Bool) {
+  my %seen;
+  loop {
+      $n = [+] $n.comb.map: { $_ ** 2 }
+      return True  if $n == 1;
+      return False if %seen{$n}++;
+  }
+}
+
+say join ' ', grep(&happy, 1 .. *)[^8];

Task/Happy-numbers/Perl-6/happy-numbers-2.pl6

@@ -0,0 +1,10 @@
+my @happy := 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];

Task/Happy-numbers/PowerShell/happy-numbers-1.psh

@@ -0,0 +1,20 @@
+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
+                $i
+            }
+            $hist[$sum]=$sum
+            $sum2=0
+            foreach($j in $sum.ToString().ToCharArray()) {
+                $k=([int]$j)-0x30
+                $sum2+=$k*$k
+            }
+            $sum=$sum2
+        }
+    }
+}

Task/Happy-numbers/PowerShell/happy-numbers-2.psh

@@ -0,0 +1,18 @@
+function happy([int] $n) {
+    1..$n | ForEach-Object {
+        $sum=$_
+        $hist=@{}
+        while( $hist[$sum] -eq $null ) {
+            if($sum -eq 1) {
+                $_
+            }
+            $hist[$sum]=$sum
+            $sum2=0
+            foreach($j in $sum.ToString().ToCharArray()) {
+                $k=([int]$j)-0x30
+                $sum2+=$k*$k
+            }
+            $sum=$sum2
+        }
+    }
+}

Task/Happy-numbers/PureBasic/happy-numbers.purebasic

@@ -0,0 +1,34 @@
+#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

Task/Happy-numbers/Run-BASIC/happy-numbers.run

@@ -0,0 +1,19 @@
+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 function

Task/Happy-numbers/SETL/happy-numbers-1.setl

@@ -0,0 +1,10 @@
+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;

Task/Happy-numbers/SETL/happy-numbers-2.setl

@@ -0,0 +1,8 @@
+happy := [];
+n := 1;
+until #happy = 8 loop
+  if is_happy(n) then happy with:= n; end if;
+  n +:= 1;
+end loop;
+
+print(happy);

Task/Happy-numbers/SETL/happy-numbers-3.setl

@@ -0,0 +1 @@
+print([n : n in [1..100] | is_happy(n)](1..8));

Task/Happy-numbers/Salmon/happy-numbers.salmon

@@ -0,0 +1,29 @@
+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;
+      };
+  };

Task/Happy-numbers/TUSCRIPT/happy-numbers.tuscript

@@ -0,0 +1,36 @@
+$$ 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
+ENDLOOP

Task/Happy-numbers/UNIX-Shell/happy-numbers.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+function sum_of_square_digits
+{
+  local -i n="$1" sum=0
+  while (( n )); do
+    local -i d=n%10
+    let sum+=d*d
+    let n=n/10
+  done
+  echo "$sum"
+}
+
+function is_happy?
+{
+   local -i n="$1"
+   local seen=()
+   while (( n != 1 )); do
+     if [ -n "${seen[$n]}" ]; then
+        return 1
+     fi
+     seen[n]=1
+     let n="$(sum_of_square_digits "$n")"
+   done
+   return 0
+}
+
+function first_n_happy
+{
+  local -i count="$1"
+  local -i n
+  for (( n=0; count; n+=1 )); do
+  if is_happy? "$n"; then
+    echo "$n"
+    let count-=1
+  fi
+  done
+  return 0
+}
+
+first_n_happy 8

Task/Happy-numbers/Ursala/happy-numbers.ursala

@@ -0,0 +1,10 @@
+#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) 8

Task/Happy-numbers/Vala/happy-numbers.vala

@@ -0,0 +1,46 @@
+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 main

Task/Happy-numbers/Visual-Basic-.NET/happy-numbers.visual

@@ -0,0 +1,29 @@
+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

Task/Happy-numbers/XPL0/happy-numbers.xpl0

@@ -0,0 +1,45 @@
+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
+]