Count in factors
Write a program which counts up from 1, displaying each number as the multiplication of its prime factors. For the purpose of this task, may be shown as itself.
For examle, is prime, so it would be shown as itself. is not prime; it would be shown as . Likewise, 2144 is not prime; it would be shown as .
c.f. Prime decomposition
D
<lang d>import std.stdio, std.math, std.conv, std.algorithm, std.array, std.string ; import xt.uiprimes ;
pragma(lib, "uiprimes.lib") ;
// function _factorize_ included in uiprimes.lib ulong[] factorize(ulong n) {
if(n == 0) return [] ;
if(n == 1) return [1] ;
ulong[] res ;
uint limit = cast(uint) (1 + sqrt(n)) ;
foreach(p; Primes(limit)) {
if(n == 1) break ;
if(0UL == (n % p ))
while((n > 1) && (0UL == (n % p ))) {
res ~= p ;
n = n / p ;
}
}
if(n > 1)
res ~= [n] ;
return res ;
}
string productStr(T)(T[] nums) {
return array(map!q{to!string(a)}(nums)).join(" x ") ;
}
void main() {
foreach(i;1..21)
writefln("%2d = %s", i, productStr(factorize(i))) ;
}</lang>
Library uiprimes is a homebrew library to generate prime numbers upto the maximum 32bit unsigned integer range 2^32-1, by using a pre-generated bit array of Sieve of Eratosthenes (a dll in size of ~256M bytes :p ).
J
Solution:Use J's factoring primitive, <lang j>q:</lang> Example (including formatting):<lang j> ('1 : 1',":&> ,"1 ': ',"1 ":@q:) 2+i.10 1 : 1 2 : 2 3 : 3 4 : 2 2 5 : 5 6 : 2 3 7 : 7 8 : 2 2 2 9 : 3 3 10: 2 5 11: 11</lang>
Perl 6
The first two multi prime lines are adapted from Perl 6's entry at Primality by Trial Division. <lang perl6># Multi function to test a number for primality.
- Which function body is called depends on which one's
- criteria most-specifically matches the given argument
- values.
multi prime(Int $n where ( $n <= 1)) { False } multi prime(Int $n --> Bool) {
$n %% none 2, 3, *+2 ...^ * > sqrt $n;
}
- Returns the next prime greater than the value given.
multi next_prime(2) { 3 } multi next_prime(Int $check is copy --> Int) {
repeat until prime($check) { $check += 2 }
return $check;
}
- binding to an array memoizes primes list
my @primes := 2, { next_prime($^a) } ... *;
- Finds the factors of the given argument.
multi factors(1) { 1 } multi factors(Int $remainder is copy) {
gather for @primes -> $factor {
# How many times can we divide by this prime?
while $remainder %% $factor {
take $factor;
last if ($remainder /= $factor) == 1;
}
last if $remainder == 1;
}
}
- An infinite loop, from 1 incrementing upward.
- calls factor() with each of 1, 2, 3, etc., receives an
- array containing that number's factors, and then
- formats and displays them.
say "$_: ", factors($_).join(" x ") for 1..*;</lang>
The first twenty numbers:
1: 1 2: 2 3: 3 4: 2 x 2 5: 5 6: 2 x 3 7: 7 8: 2 x 2 x 2 9: 3 x 3 10: 2 x 5 11: 11 12: 2 x 2 x 3 13: 13 14: 2 x 7 15: 3 x 5 16: 2 x 2 x 2 x 2 17: 17 18: 2 x 3 x 3 19: 19 20: 2 x 2 x 5
Here we use a multi declaration with a constant parameter to match the degenerate case. We use copy parameters when we wish to reuse the formal parameter as a mutable variable within the function. (Parameters default to readonly in Perl 6.) Note the use of gather/take as the final statement in the function, which is a common Perl 6 idiom to set up a coroutine within a function to return a lazy list on demand.
The second last is a workaround since rakudo does not yet support loop exit via loop labels.
PicoLisp
This is the 'factor' function from Prime decomposition#PicoLisp. <lang PicoLisp>(de factor (N)
(make
(let (D 2 L (1 2 2 . (4 2 4 2 4 6 2 6 .)) M (sqrt N))
(while (>= M D)
(ifn (=0 (% N D))
(inc 'D (pop 'L))
(link D)
(setq M (sqrt (setq N (/ N D)))) ) )
(or (= 1 N) (link N)) ) ) )
(for N 20
(prinl N ": " (or (glue " * " (factor N)) 1)) )</lang>
Output:
1: 1 2: 2 3: 3 4: 2 * 2 5: 5 6: 2 * 3 7: 7 8: 2 * 2 * 2 9: 3 * 3 10: 2 * 5 11: 11 12: 2 * 2 * 3 13: 13 14: 2 * 7 15: 3 * 5 16: 2 * 2 * 2 * 2 17: 17 18: 2 * 3 * 3 19: 19 20: 2 * 2 * 5