Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:

1634 = 1⁴ + 6⁴ + 3⁴ + 4⁴
8208 = 8⁴ + 2⁴ + 0⁴ + 8⁴
9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴

As 1 = 1⁴ is not a sum it is not included.

The sum of these numbers is 1634 + 8208 + 9474 = 19316.

Find the sum of all the numbers that can be written as the sum of fifth powers of their digits.

+-%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).

p30()->
	Pows=list_to_tuple(lists:map(fun(X)->pow(X,5) end,lists:seq(0,9))),
	Limit=6*pow(9,5),
	Ans=run_procs(Limit div 1000,fun(I)->[euler,p30,[check,1000*I,1000*(I+1),0,Pows,self()]] end,
				     fun(A,{done,B})->A+B end,0),
	io:format("~w~n",[Ans]).
p30(check,On,On,Total,_,Parent)->Parent!{done,Total};
p30(check,On,Upto,Total,Pows,Parent)->
	Test=lists:sum(lists:map(fun(X)->element(X+1,Pows) end, digit_split(On))),
	if
		Test==On->
			p30(check,On+1,Upto,Total+On,Pows,Parent);
		true->
			p30(check,On+1,Upto,Total,Pows,Parent)
	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

def p30test(n)
  n==n.to_s.split("").map{|i|$fifths[i]}.sum
end

def p30
  $fifths={}
  (0..9).each{|i|$fifths[i.to_s]=i**5}
  puts (2..(6*(9**5))).select{|i|p30test i}.sum
end