A Hamming number is a positive number which has no prime factor larger than 5.
So the first few Hamming numbers are 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15.
There are 1105 Hamming numbers not exceeding 10⁸.

We will call a positive number a generalised Hamming number of type n, if it has no prime factor larger than n.
Hence the Hamming numbers are the generalised Hamming numbers of type 5.

How many generalised Hamming numbers of type 100 are there which don't exceed 10⁹?

+-%echo
echo(Message,Sender)->Sender ! Message.

+-%prime_list
prime_list()->
	case whereis(primeList) of
		undefined->
			Pid=spawn(euler,prime_list,[initialize]),
			register(primeList, Pid),
			Pid;
		Exists->
			Exists
	end.
prime_list(initialize)->
	put(primes,array:from_list([2,3,5,7,11,13,17,19])),
	put(total,8),
	prime_list(idle);
prime_list(idle)->
	Size=get(total),
	receive
		{get,FromZero,Reply} when FromZero < Size ->
			Reply ! {prime,FromZero,array:get(FromZero,get(primes))};
		{get,FromZero,Reply} ->
			echo({get,FromZero,Reply},self()),
			prime_list(gen);
		{all_below,What,Reply} ->
			case array:get(Size-1,get(primes)) < What of 
				true->
					prime_list(gen),
					echo({all_below,What,Reply},self());
				false->
					Reply ! {primes_below,What,prime_list(below,What,0,[])}
			end;
		{is_prime,What,Reply}->
			Skirt=math:sqrt(What),
			Largest=array:get(Size-1,get(primes)),
			case Largest < What of
				true->
					case Largest < Skirt of 
						true->
							prime_list(gen),
							echo({is_prime,What,Reply},self());
						false->
							Reply ! {is_prime,What,prime_list(check_factors,0,What,Skirt)}
					end;
				false->
					Reply ! {is_prime,What,prime_list(binary_search,What,0,Size-1)}
				end
		end,
		prime_list(idle);
prime_list(gen)->
	Size=get(total),
	Start=array:get(Size-1,get(primes))+2,
	End=Start*10+1,
	Sqrt=math:sqrt(End),
	AsList=array:to_list(get(primes)),
	[2|Odds]=AsList,
	RelevantOdds=lists:takewhile(fun(N)->N =< Sqrt end,Odds),
	Newbs=prime_list(gen,Size,Start,End,RelevantOdds,ordsets:from_list(lists:seq(Start,End,2))),
	put(primes,array:from_list(lists:append(AsList,ordsets:to_list(Newbs)))),
	put(total,get(total)+ordsets:size(Newbs)).
prime_list(check_factors,NextIndex,N,Sqrt)->
	NextPrime=array:get(NextIndex,get(primes)),
	case NextPrime > Sqrt of
		true->true;
		false->
			case N rem NextPrime ==0 of
				true->false;
				false->
					prime_list(check_factors,NextIndex+1,N,Sqrt)
			end
		end;
prime_list(binary_search,What,Low,High) when High-Low < 2 ->
	H=array:get(High,get(primes)),
	L=array:get(Low,get(primes)),
	if
		H == What; L == What ->
			true;
		true->false
	end;
prime_list(binary_search,What,Low,High)->
	Mid=Low+((High-Low) div 2),
	Got=array:get(Mid,get(primes)),
	if
		What > Got->prime_list(binary_search,What,Mid+1,High);
		What < Got->prime_list(binary_search,What,Low,Mid-1);
		true->true
	end;

	
prime_list(below,What,Index,SoFar)->
	Next=array:get(Index,get(primes)),
	if
		Next >= What->
			lists:reverse(SoFar);
		true->
			prime_list(below,What,Index+1,[Next|SoFar])
	end.
prime_list(gen,_,_,_,[],Survivors)->Survivors;
prime_list(gen,Total,Lowest,Highest,[MyPrime|RestPrimes],Survivors)->
	prime_list(gen,Total,Lowest,Highest,RestPrimes,
		ordsets:subtract(Survivors,
			ordsets:from_list(
				lists:seq(Lowest-(Lowest rem MyPrime),Highest,MyPrime)))).

+-%prime_iterator
prime_iterator(Pid)->spawn(euler,prime_iterator,[idle,0,2,Pid,prime_list()]).
prime_iterator(idle,Index,Next,Parent,List)->
	receive
		next->
			Parent ! {prime, Next},
			List ! {get, Index+1,self()},
			prime_iterator(wait,Index+1,nothing,Parent,List)
	end;
prime_iterator(wait,Index,_,Parent,List)->
	receive
		{prime,Index,Next}->
			prime_iterator(idle,Index,Next,Parent,List)
	end.

%
% The idea here is to simply walk through the entire prime factorization tree,
% counting each number one by one.
%

p204()->
	Iter=prime_iterator(self()),
	Primes=p204(get_primes,Iter,[]),
	io:format("~w~n",[p204(compute,1,Primes)]).

p204(help_compute,_,[],Sum)->Sum;
p204(help_compute,Base,List,Sum)->
	[Next|Rest]=List,
	p204(help_compute,Base,Rest,Sum+p204(compute,Base*Next,List)).
p204(compute,_,[])->0;
p204(compute,Base,Using) when Base > 1000000000->0;
p204(compute,Base,Using)->
	1+p204(help_compute,Base,Using,0);

p204(get_primes,Iter,L)->
	Iter ! next,
	receive
		{prime,N}->
			if
				N>100->L;
				true->p204(get_primes,Iter,[N|L])
			end
	end.