def is_happy(nr):
	for i in range(200):
		nr = sum(int(ch)**2 for ch in str(nr)) 
		if nr == 1: return ""
	return "not "
print "\n".join("%i is %shappy" % (i, is_happy(i)) for i in range(1000))

#!/usr/bin/perl -w
#
use strict;
my $iNumber = 4398;
bHappy($iNumber);
sub bHappy
{
        $iNumber = shift;
        my $sResult = ( therapist($iNumber) eq 1) ? "Happy" : "Not Happy";
        print "$sResult\n";
}
sub therapist
{
        my $iCalc = shift;
        for( my $j = 0; $j < 100; $j++ )
        {
                $iCalc = medic( $iCalc );
                return 1 if( $iCalc ) eq 1;
        }
        return 0;
}
sub medic
{
        my $iInt = shift;
        my @aNumbers = split(//, $iInt);
        return sqrCalc($iInt) if( $#aNumbers eq 0 );
        my $iReturn;
        for( my $k = 0; $k < $#aNumbers + 1; $k++ )
        {
                my $iResult = sqrCalc($aNumbers[$k]);
                $iReturn += $iResult;
        }
        return $iReturn;
}
sub sqrCalc
{
        my $i = shift;
        return $i*$i;
}

#include <iostream>
#include <sstream>
using namespace std;
int isHappy(string s)
{
	for (int j = 0; j < 100; j++)
	{
		int sum = 0;
		for (int i = 0; i < s.size(); i++)
		{
			int n = s[i] - '0';
			sum += n * n;
		}
		if (sum == 1) return true;
		stringstream st;
		st << sum;
		s = st.str();
	}
	return false;
}
int main(void)
{
	while (true)
	{
		string s;
		cin >> s;
		if (isHappy(s))
			cout << "happy" << endl;
		else
			cout << "not happy" << endl;
	}
}

(define (number->list n)
  (map 
   (lambda (x) (- x (char->integer #\0))) 
   (map
    char->integer 
    (string->list (number->string n)))))
(define (happy? n iterations)
  (cond
   ((= n 1) #t)
   ((zero? iterations) #f)
   (else (happy?
	  (apply + 
		 (map 
		  (lambda (x) (* x x))
		  (number->list n))) 
	  (- iterations 1)))))
(define input-loop
  (lambda ()
    (let ((input (read)))
      (if (happy? input 100)
	  (display "happy")
	  (display "not happy"))
      (newline)
      (input-loop))))
(newline)
(input-loop)

#!/usr/bin/ruby -w
def isHappy(num)
	(0..100).each do
		num = num.to_s.split("").map { |x| x.to_i * x.to_i }.inject(0) { |sum,n| sum + n }
		return true if num == 1
	end
	return false
end
while true
	number = gets.chomp.to_i
	if isHappy(number)
		puts "happy"
	else
		puts "not happy"
	end
end

#include <stdio.h>
#define MAX_NUMBER 10000;
#define ARRAY_SIZE 810;
int iaNumbers[ARRAY_SIZE];
int isHappy(int iNum);
int main() {
  int i, iNumber;
  for( i = 1; i < ARRAY_SIZE; i++ )
    iaNumbers[i] = -1;
  iaNumbers[0] = 1;
  for( iNumber=2; iNumber <= MAX_NUMBER; iNumber++ )
    if( isHappy(iNumber) )
      printf("%d, ", iNumber);
      
  return 0;
}
int isHappy(int iNum) {
  int n, iResult;
  
  iResult = iNum;
  
  while( iResult > 1 ) {
    n       = iResult;
    iResult = 0;
    
    while( n > 0 ) {
      i        = n % 10;
      iResult += i * i;
      n       /=  10;
    }
    if( iaNumbers[iResult - 1] >= 0 )
      iResult = iaNumbers[iResult - 1]
    else
      if( iaNumbers[iResult - 1] == -iNum )
        iResult = 0
      else {
        iaNumbers[iResult - 1] = -iNum;
        iNum                   = iResult;
      }
  }
  return iResult;
}

#ishappy.s
.section .data
tala:
	.int 0
thnmbr:
	.ascii "The number "
erglod:
	.ascii " is happy\n"
erekkiglod:
	.ascii " is not happy\n"
.section .bss
	.lcomm buffer 4
	.lcomm geymsla 12
.section .text
.globl _start
_start: 
	nop
	nop
	nop
	movl $0, %eax			# lata vera fyrsta run
	pushl %eax
	movl $3, %eax			# system call 3 , read
	movl $0, %ebx			# lesa fra stdin (keyboard)
	movl $buffer, %ecx		# skrifa i buffer
	movl $4, %edx			# lesa 4 byte
	int $0x80			# kallid sjalft
	xor %edx,%edx 			
	xor %ebx,%ebx			# nulla alla registera
	xor %eax,%eax
	xor %ecx,%ecx
	movl $buffer, %edi		# bua til pointer a buffer i edi
	movl $geymsla, %edx		# gera pointer a geymslu i edx
 loop1:
	movb (%edi), %al		# lesa byte ur buffer og setja i al
	cmp $10, %al			# skoda hvort ad seinasti stafur var line feed (ascii 10)
	je out				# ef thad var 10 hoppa ur loop
	subb $48, %al			# breyta ascii gildi i tolu gildi
	movb %al, (%edx)		# skrifa toluna i geymsla
	inc %edi			# benda a naesta byte i buffer
	inc %edx			# benda a naesta byte i geymsla
	inc %ebx			# thetta er talning a hverso oft loopinn er tekinn
	jmp loop1			# hoppa a loop1
 out:
	movb $0, (%edi)			# skrifa 0 i seinasta staf sem var lesinn, er alltaf line feed
	movl %ebx, tala			# flytja talninguna i tala
	movl $1, %eax			# setja 1 i eax, verdur margfaldad med 10 i veldi tala
	movl tala, %ecx			# set tala i ecx. ecx er counter fyrir loop
	xor %ebx, %ebx			# nulla ebx
	cmp $1, %ecx			# skoda hvort ad loop1 var tekinn einusini
	je over				# ef tekid tha er thetta eins stafs tala
	subl $1, %ecx			# ecx er ad minnsta kosti 2 her og breytt i 1
	xor %ebx, %ebx			# nulla ebx
	movw $10, %bx			# setja 10 i bx, verdur margfaldad vid eax
	xor %edx, %edx			# nulla edx
loop2:
	mulw %bx			# margfalda that sem er i ax vid bx
	loop loop2			# gera tad ecx sinnum, (veldi)
	sal $16, %edx			# shift left 16 sinnum, svarid ur bx*ax er sett i dx:ax
	addl %edx, %eax			# breyta svarinu ur dx:ax i eax
	movl %eax, %ecx			# setja svarid i ecx
	movl $geymsla, %edx		# gera pointer a geymslu
	movb (%edx), %al		# flytja fyrsta byte ur geymslu i al
	mull %ecx			# margfalda med rettum tug, ef ad slegid var inn 123, tha er her 100
	movl $0, tala			# setja 0 i tala
	movl %eax, tala			# flytja fyrsta tug i tala
	movl $1, %ebx			# setja 1 i ebx, counter
	cmp $10, %ecx			# ef skoda hvort slegin var inn 3 stafa tala
	je over				# ef ekki tha afgreida seinasta stafinn
	movb $10, %bl			# her verdur margfaldad med tug, buid ad afgreida 100
	movl %ecx, %eax			# setja 100 i eax
	divb %bl			# deila svo med 10
	movl %eax, %ecx			# setja svarid (10) i ecx
	movl $geymsla, %edx		# tharf aftur ad gera pointer tvi ad deiling skemmir edx
	addl $1, %edx			# leggja einn vid pointerinn, lesa naesta byte
	movb (%edx), %al		# lesa byte numer 2 og setja i al
	mull %ecx			# margfalda med 10
	addl %eax, tala			# leggja vid tad sem fyrir var, ef ad slegid var inn 123
	movl $2, %ebx			# tha er tala 120, setja 2 i ebx, counter
over:	 
	movl $geymsla, %edx		# gera nyjan pointer, til vonar og vara
	xor %eax, %eax			# nulla eax, lika til vara
	addl %ebx, %edx			# leggja counterinn vid pointer, segjir fjolda lesina byta
	movb (%edx), %al		# setja seinasta bytid i al
	addl %eax, tala			# leggja vid tala, tharf ekki ad margf thetta er eining
	movl $1, %ecx			# minnsta kosti einn
	addl %ebx, %ecx			# flytja counterinn i ecx
	xor %edx, %edx			# nulla edx
	movl $geymsla, %ebx		# gera pointer i ebx
loop3:					#**********ALLT HER A UNDAN LES ASCII OG BREYTIR I ALLVORU TOLUR**
	movb (%ebx), %al		# flytja fyrstu toluna aftur i al
	mulb %al			# setja hana i annad veldi
	movb %al, (%ebx)		# skilar tolunni i 2 veldi til baka
	inc %ebx			# haekka pointer, taka naestu tolu
	inc %edx			# haekka counter
	loop loop3			
	xor %eax, %eax			# nulla eax
	movl $geymsla, %ebx		# gera pointer
loop4:
	addb (%ebx), %al		# leggja tolu i 2 veldi vid thad sem er i al, fyrst er thad 0
	inc %ebx			# haekka pointer, al dugar, thversumma ekki haerri en 3*81
	cmp $1, %edx			# skoda hvort thad er ein tala
	je over2			# ef svo er hoppa
	dec %edx			# laekka counter
	jmp loop4			# verdur haesta lagi tekin 2 1/2 sinnum
over2:
	cmp $1,%al			# skoda hvort ad thver summan se 1 
	je happy			# tha fara i happy
	cmp $10, %al			# athuga hvort ad thversumma se laegri en 10
	jb breyta1			# ef svo hoppa
	cmp $100, %al			# skoda hvort ad se laegra en 100
	jb breyta2			# ef svo hoppa
	popl %edx			# fa her 2 til baka
	jmp breyta3			# ef ad thversumman er haerri en 100 tha er thetta tekid
label1:			# ******HER ER KOMID THEGAR BUID ER AD SKIPTA SUMMUNI I EINSTAKAR TOLUR******** 
	popl %eax			# her er fjoldi ferda sem teknar hafa verid sottar
	addl $1, %eax			# einum baett vid
	pushl %eax			# sett aftur i stackin
	movl $geymsla, %ebx		# her er pointer buin til
	cmp $500,%eax			# sed hvort ad teknar hafa verid 50 eda fleirri ferdir
	jb loop3			# ef faerri tha er tekid atur
	
nhappy:
	movl $4, %eax			# her er system call 4 (write)
	movl $1, %ebx			# write to standard out (skjarinn)
	movl $thnmbr, %ecx		# pointer a hvad skal skrifa (thnmbr)
	movl $11, %edx			# hversu morg byte verda skrifud
	int $0x80			# kallid sjalft
	movl $4, %eax
	movl $1, %ebx			# tetta er tad sama nema annad sem verdur skrifad
	movl $buffer, %ecx		# thad sem upphaflega var lesid verdur skrifad ut (an line feed)
	movl $3, %edx			
	int $0x80
	movl $4, %eax			# og tetta er aftur system call 4 (write)
	movl $1, %ebx			
	movl $erekkiglod, %ecx		# bara annar texti
	movl $14, %edx
	int $0x80
	jmp loka			# loka svo forritinu
happy:
	movl $4, %eax			# allt med felldu her
	movl $1, %ebx	
	movl $thnmbr, %ecx	
	movl $11, %edx
	int $0x80
	movl $4, %eax			# her er enn verid ad skrifa
	movl $1, %ebx
	movl $buffer, %ecx		# bara verid ad lata etta litta nice ut
	movl $3, %edx
	int $0x80
	movl $4, %eax			# her er enn verid ad skrifa, system call 4
	movl $1, %ebx			
	movl $erglod, %ecx		# bara texti sem segir ad talan se glod
	movl $10, %edx
	int $0x80
loka:
	movl $0, %ebx			# setja 0 i ebx, etta er exir code
	movl $1, %eax			# system call 1 (exit)
	int $0x80			# kallid sjalft, forritid buid
breyta1:			# ***********skipta thversummu i 1 tolu*****************
	movl $0, geymsla		# nulla geymslu
	movb %al, geymsla		# setja thversummu i geymslu
	movl $geymsla, %ebx		# gera pointer
	movl $1, %ecx			# setja 1 i ecx,etta er counter
	jmp label1			# hoppa i endan a algorithmanum
breyta2:			# ***********skipta thversummu i 2 tolur****************
	pushl %eax			# setja thversummu i stackin
	movl $geymsla, %edi		# gera pointer
	movl $0, %ebx			# setja 0 i ebx
	movl %ebx, (%edi)		# nulla ut geymsla
	movl $10, %ebx			# setja 10 i ebx
	divb %bl			# deila med tug, fa ad vita fyrstu toluna
	movb %al, (%edi)		# svarid keumur i al, setja tad i geymslu
	mulb %bl			# margfalda fjolda af tugum med 10, ef 34, tha 30 her
	popl %ecx			# fa herna thversummuna til baka
	subb %al, %cl			# draga tugina fra toluni
	movb %cl, 1(%edi)		# eftir stendur eining sem er sett i holf 2 i geymslu
	movl $geymsla, %ebx		# gera pointer i geymslu
	movl $2, %ecx			# setja 2 i ecx, thetta er counter
	jmp label1			# hoppa i endan
breyta3:			# ***********skipta thversummu i 3 tolur****************
	pushl %eax			# setja tvesummu i stackin
	movl $geymsla, %edi		# gera pointer
	movl $0, (%edi)			# nulla ut geymslu
	movl $100, %ebx			# setja her 100 i ebx
	divb %bl			# deila thversummuni med 100
	movb %al, (%edi)		# setja svarid i geymsla
	mulb %bl			# margfalda svo toluna med 100
	popl %ecx			# fa her tversummuna
	subb %al, %cl			# draga svo fra hundrudin
	movb %cl, %al			# setja thau i al
	pushl %ecx			# setja afganginn i stackin
	movl $10, %ebx			# setja her 10 i ebx
	divb %bl			# deila afgangnum med 10
	movb %al, 1(%edi)		# setja svarid i geymsla+1
	mulb %bl			# margf med 10
	popl %ecx			# fa herna afganginn
	subb %al, %cl			# draga enn fra
	movb %cl, 2(%edi)		# eftir stendur eining setja hana i geymsla+2
	movl $geymsla, %ebx		# gera pointer
	movl $3, %ecx                   #setja 3 i ecx segir hversu margar tolur eru
	jmp label1                      #klara algorithman

import java.math.BigInteger;
public class BigHappyNumbers {
	
		public static BigInteger happySqr(BigInteger x, BigInteger rdx)
		{
			BigInteger s = BigInteger.ZERO;
			do
			{
				BigInteger xm = x.mod(rdx);
				s = s.add(xm.multiply(xm));
				x = x.divide(rdx);
			}
			while(!x.equals(BigInteger.ZERO));
			return s;
		}
		public static boolean isHappy(BigInteger x, BigInteger rdx)
		{
			BigInteger m_step = new BigInteger("10");
			for (BigInteger m = BigInteger.ZERO;  !x.equals(BigInteger.ONE); m = m.add(m_step))
				for (BigInteger i = BigInteger.ZERO, y = x; i.compareTo(m) == -1; i = i.add(BigInteger.ONE))
					if((x = happySqr(x, rdx)).equals(y))
						return false;
				return true;
		}
		public static void main(String[] args)
		{
			BigInteger rdx_10 = new BigInteger("10");			
			//BigInteger m = BigInteger.ONE;
			BigInteger m = BigInteger.probablePrime(256, new java.security.SecureRandom());
			for (int i = 0; i < 100; i++)
			{
				if(isHappy(m, rdx_10)) 
					System.out.println(m.toString() + " is happy");
				m = m.add(BigInteger.ONE);				
			}
		}
	
}

#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
int square_digits(int n)
{
	int i = 0, digit, sum = 0;
	
	while(n > 0) {
		digit = (n % 10);
		sum += digit*digit;
		n /= 10;
	}
	
	return sum;
}
int is_happy(int n)
{
	while(n != 1) {
		n = square_digits(n);
		if(n == 4) {
			return FALSE;
		}
	}
	return TRUE;
}
int main(int argc, char *argv[])
{
	int n = 0, i, digit, count = 0;
	
	if(argc < 2)
		return 0;
	//first iteration
	for(i = 0; argv[1][i] != '\0'; i++) {
		digit = argv[1][i] - '0';
		if(0 <= digit && digit <= 9)
			n += digit*digit;
		else {
			printf("not a number, bailing out\n");
			return -1;
		}
	}
	printf("%s is%shappy\n", argv[1], (is_happy(n)) ? " " : " not ");
	return 0;
}

(in-package :cl-user)
(defpackage :happy
  (:use :cl))
(in-package :happy)
(defun number-to-list (number)
  "Convert a number to a list of it's digits"
  (remove nil
          (loop for num across (write-to-string number)
             collect (digit-char-p num))))
(defun is-happy? (num)
  "See if num is a happy number, using a max of 1000 iterations"
  (labels ((rec (num times)
             (if (= num 1)
                 'happy
                 (if (not (> times 1000))
                     (rec (apply #'+ (mapcar #'(lambda (x)
                                                 (expt x 2))
                                             (number-to-list num)))
                          (1+ times))))))
    (rec num 0)))

        static void Main()
        {
            1.To(100).ForEach(i => Console.WriteLine(i + "\t" + IsHappyNumber(i)));
            Console.ReadLine();
        }
        static bool IsHappyNumber(int n)
        {
            for (int i = 0; i < 500; i++)
            {
                if (n == 1) return true;
                n = n.Digits().Sum(d => d * d);
            }
            return false;
        }