print happynumber(7, [7])
#True

def happynumber(n, lst):
    total = sumofsquareofdigits(n)
    if total == 1:
        return True
    elif lst.__contains__(total):
        return False

    lst.append(total)
    return happynumber(total, lst)


def sumofsquareofdigits(n):
    return sum([int(data) * int(data) for data in str(n)])

function is_happy(/*integer*/n, /*?object?*/unhappy) {
   
    var visited = {};
    unhappy = unhappy || {};
   
    var n0 = n;

    while (true) {
        n = iter( n );
        if (n === 1)
            return true;
        if (visited[n] || unhappy[n]) {
            unhappy[n0] = true;
            return false;
        }
        visited[n] = true;
    }

    function iter(n) {
        var ret = 0;
        while (n) {
            var p = n % 10;
            ret += p * p;
            n = (n / 10) >> 0;
        }
        return ret;
    }
}

function find_happy(n) {
    var ret = [], unhappy = {};
    for (var a = 1; a <= n; a++)
        if (is_happy(a, unhappy))
            ret.push(a);
    return ret;
}

console.log( find_happy(100).join(' '));
// 1 7 10 13 19 23 28 31 32 44 49 68 70 79 82 86 91 94 97 100

def happy?(n)
seen={}
begin
seen[n] = true
n = n.to_s.each_char.map { |x| x.to_i ** 2 }.reduce { |x,y| x + y }
end until seen[n]
return n == 1
end

def happy?(n, seen={})
sum = n.to_s.each_char.map { |x| x.to_i ** 2 }.reduce { |x,y| x + y }
return true if n == 1
return false if seen[sum]
seen[sum] = true
return happy?(sum, seen)
end

http://tapoueh.org/articles/blog/_Happy_Numbers.html

;;; happy-numbers.el — Dimitri Fontaine
;;
;; http://programmingpraxis.com/2010/07/23/happy-numbers/
;;
(require ‘cl) ; subseq

(defun happy? (&optional n seen)
“return true when n is a happy number”
(interactive)
(let* ((number (or n (read-from-minibuffer “Is this number happy: “)))
(digits (mapcar ‘string-to-int (subseq (split-string number “”) 1 -1)))
(squares (mapcar (lambda (x) (* x x)) digits))
(happiness (apply ‘+ squares)))
(cond ((eq 1 happiness) t)
((memq happiness seen) nil)
(t (happy? (number-to-string happiness)
(push happiness seen))))))

(defun find-happy-numbers (&optional limit)
“find all happy numbers from 1 to limit”
(interactive)
(let ((count (or limit (read-from-minibuffer “List of happy numbers from 1 to: “)))
happy)
(dotimes (n (string-to-int count))
(when (happy? (number-to-string (1+ n)))
(push (1+ n) happy)))
(nreverse happy)))

ELISP> (happy? “7″)
t
ELISP> (happy? “17″)
nil

ELISP> (find-happy-numbers “50″)
(1 7 10 13 19 23 28 31 32 44 49)

http://re-factor.blogspot.com/2010/08/happy-numbers.html

(defn char-to-int [c]
  (- (int c) (int \0)))

(defn to-num-seq [n]
  (map char-to-int (seq (str n))))

(defn happy?
  ([n] (happy? n {}))
  ([n hist]
     (let [sum (apply + (map #(* % %) (to-num-seq n)))]
       (cond (= 1 sum) true
	     (hist sum) false
	     :default (recur sum (assoc hist sum true))))))
  
(defn happies [n]
  (filter happy? (range 1 (inc n))))		 

#include <iostream>
#include <bitset>
using namespace std;

bool is_happy_number (int x) {
    bitset<100000> founds;
    int itr = x;
    do {
        founds.set(itr);
        int num = 0;
        while (itr) {
            int factor = itr % 10;
            num += factor * factor;
            itr /= 10;
        }
        itr = num;
    } while (itr != 1 && !founds.test(itr));

    if (itr == 1) return true;
    else return false;
}

int main(int argc, char *argv[])
{
    int input;
    while (cin >> input)
        cout << boolalpha << is_happy_number (input) << endl;

    return 0;
}