A googol (10¹⁰⁰) is a massive number: one followed by one-hundred zeros; 100¹⁰⁰ is almost unimaginably large: one followed by two-hundred zeros. Despite their size, the sum of the digits in each number is only 1.

Considering natural numbers of the form, a^b, where a, b 100, what is the maximum digital sum?

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

+-;pow
(defn pow [a b]
  (loop [res 1 mult a shift b]
    (if (= 0 shift)
      res
      (if (= 1 (rem shift 2))
        (recur (* res mult) (* mult mult) (bit-shift-right shift 1))
        (recur res (* mult mult) (bit-shift-right shift 1))
      )
    )
  )
)

+-;cartesian-product
(defn cartesian-product [& lists]
  (if (= 1 (count lists))
    (map list (first lists))
    (let [recurs (apply cartesian-product (rest lists))]
      (apply concat (map (fn [el] (map #(cons el %) recurs)) (first lists)))
    )
  )
)

(defn p56 []
  (println
    (apply max (map (fn [[a b]] (apply + (digit-split (pow a b)))) (cartesian-product (range 1 100) (range 1 100))))
  )
)

+-%run_procs
run_procs(wait,0,_,Val)->Val;
run_procs(wait,Running,AccFun,Val)->
	NextVal=receive Anything->Anything end,
	run_procs(wait,Running-1,AccFun,AccFun(Val,NextVal));
run_procs(HowMany,ArgFun,AccumulatorFun,InitialAccVal)->
	run_procs(1,HowMany+1,ArgFun,AccumulatorFun,InitialAccVal).
run_procs(Limit,Limit,_,AccFun,Val)->run_procs(wait,Limit-1,AccFun,Val);
run_procs(I,Limit,ArgFun,AccFun,Val)->
	[Mod,Fun,Args]=ArgFun(I),
	spawn(Mod,Fun,Args),
	run_procs(I+1,Limit,ArgFun,AccFun,Val).

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

+-%pow
pow(_,0)->1;
pow(1,_)->1;
pow(A,B)->pow(A,B,1).
pow(_,0,Res)->Res;
pow(Mult,B,Res) when B band 1 == 1 ->
	pow(Mult*Mult,B bsr 1, Res*Mult);
pow(Mult,B,Res)->pow(Mult*Mult,B bsr 1, Res).

p56()->
	Ans=run_procs(98,fun(I)->[euler,p56,[I+1,2,self(),0]] end,
		     fun(A,{done,B})->lists:max([A,B]) end,0),
	io:format("~w~n",[Ans]).
p56(_,100,Parent,Max)->Parent ! {done,Max};
p56(A,B,Parent,Max)->
	S=lists:sum(digit_split(pow(A,B))),
	p56(A,B+1,Parent,lists:max([S,Max])).

+-#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 p56
  large=0
  (1...100).each do |a|
    (1...100).each do |b|
      c=dig_split(a**b).sum
      large=c if c>large
    end
  end
  puts large
end