Consider all integer combinations of a^b for 2 a 5 and 2 b 5:

2²=4, 2³=8, 2⁴=16, 2⁵=32
3²=9, 3³=27, 3⁴=81, 3⁵=243
4²=16, 4³=64, 4⁴=256, 4⁵=1024
5²=25, 5³=125, 5⁴=625, 5⁵=3125

If they are then placed in numerical order, with any repeats removed, we get the following sequence of 15 distinct terms:

4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125

How many distinct terms are in the sequence generated by a^b for 2 a 100 and 2 b 100?

+-;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 p29 []
  (println
    (count (set (map (fn [[a b]] (pow a b)) (cartesian-product (range 2 101) (range 2 101)))))
  )
)

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

+-%cartesian_product
cartesian_product([])->[];
cartesian_product([OneList])->lists:map(fun(X)->[X] end,OneList);
cartesian_product([FirstList|RestLists])->
	Others=cartesian_product(RestLists),
	lists:append(lists:map(fun(Item)-> lists:map(fun(Rest)->[Item|Rest] end, Others) end,FirstList)).

p29()->
	Ans=sets:size(sets:from_list(lists:map(fun([A,B])->pow(A,B) end,cartesian_product([lists:seq(2,100),lists:seq(2,100)])))),
	io:format("~w~n",[Ans]).

+-#cartesian_product
def cartesian_product(*a)
	return [] if a.length==0
	return a[0].map{|h|[h]} if a.length==1
	a.map!{|b| b.to_a}
	b=cartesian_product(*(a[1..-1]))
	a=a[0]
	res=[]
	if block_given?
		a.each do |aitem|
			res=res+b.select{|i|yield(aitem,*i)}.map{|i|[aitem]+i}
		end
	else
		a.each do |aitem|
			b.each{|bitem| res.push([aitem]+bitem)}
		end
	end
	res
end

def p29
  puts cartesian_product((2..100),(2..100)).map{|a,b|a**b}.uniq.length
end