n! means n (n 1) ... 3 2 1

Find the sum of the digits in the number 100!

+-;nats
(defn nats [] 
  (iterate inc 1)
)

+-;factorial
(defn factorial [n]
  (apply * (take n (nats)))
)

+-;digit-split
(defn digit-split [n] 
  (map #(- (int %) 48) (str n))
)

(defn p20 []
  (println
    (apply + (digit-split (factorial 100)))
  )
)

+-%digit_split
digit_split(N)->
	lists:map(fun(X)->X-48 end,integer_to_list(N)).

+-%factorial
factorial(0)->1;
factorial(N)->
	lists:foldl(fun(A,B)->A*B end, 1, lists:seq(1,N)).

p20()->io:format("~w~n",[lists:sum(digit_split(factorial(100)))]).

+-#factorial
def factorial(n)
  return 1 if n<2
  (2..n).inject{|u,v|u*v}
end

+-#Enumerable
module Enumerable
  def sum
    self.inject{|u,v|u+v}
  end
  def product
    self.inject{|u,v|u*v}
  end
  def count(ob)
    self.select{|i|i==ob}.length
  end
  def take_while
    return [] unless yield(self.first)
    if(self.class==Range)
      evalPoint=self.first
      evalPoint=evalPoint.succ while yield(evalPoint.succ) and not evalPoint==self.last
      return self.first..evalPoint
    else
      s=self.to_a
      upTo=1
      upTo+=1 while yield(s[upTo]) and upTo<self.length
      return self[0...upTo]
    end
  end
end

+-#dig_split
def dig_split(n)
  s=n.to_s
  s.split("").map{|i|i.to_i}
end

def p20
  puts dig_split(factorial(100)).sum
end

+-//digitSplit
def digitSplit(n: BigInt)={
  n.toString.map(_.toInt - 48)
}

+-//factorial
def factorial(n: Int):BigInt=n match{
  case 0 => 1
  case 1 => 1
  case _ => (1 to n).map(m=>new BigInt(new java.math.BigInteger(m.toString))).foldLeft(1:BigInt)(_*_)
}

def p20{
  println(digitSplit(factorial(100)).foldLeft(0)(_+_))
}