Powerful numbers: Difference between revisions

 

<br><br>

 

=={{header|Go}}==

{{trans|Perl}}

Curiously, the 'powerful' function is producing duplicates which the other existing solutions don't seem to suffer from. It's easily dealt with by using a set (rather than a slice) but means that we're unable to take advantage of the counting shortcut - not that it matters as the whole thing still runs in less than 0.4 seconds!

 

import (

fmt.Printf("Count of %2d-powerful numbers <= 10^j, j in [0, %d): %v\n", k, j, counts)

}

 

{{out}}

 

=={{header|Java}}==

import java.math.BigInteger;

import java.util.ArrayList;

}

 

{{out}}

=={{header|Julia}}==

{{trans|Perl}}

 

is_kpowerful(n, k) = all(x -> x[2] >= k, factor(n)) # not used here

[kpowerfulcount(Int128(10)^j, k) for j in 0:(k+9)], "\n")

end

<pre>

The set of 2-powerful numbers between 1 and 10^2 has 14 members:

The count of 10-powerful numbers from 1 to 10^j for j in 0:19 is: [1, 1, 1, 1, 5, 9, 14, 21, 28, 43, 68, 104, 155, 227, 322, 447, 621, 858, 1192, 1651]

</pre>

 

=={{header|Perl}}==

===Generation===

use ntheory qw(is_square_free);

use experimental qw(signatures);

my $t = join(', ', @a[$#a-4..$#a]);

printf("For k=%-2d there are %d k-powerful numbers <= 10^k: [%s, ..., %s]\n", $k, scalar(@a), $h, $t);

{{out}}

<pre>

 

===Counting===

use ntheory qw(is_square_free);

use experimental qw(signatures);

printf("Number of %2d-powerful <= 10^j for 0 <= j < %d: {%s}\n", $k, $k+10,

join(', ', map { powerful_count(ipow(10, $_), $k) } 0..($k+10-1)));

{{out}}

<pre>

{{libheader|Phix/mpfr}}

===priority queue===

{{out}}

<pre>

Counts of 10-powerful numbers <= 10^(0..19) : {1,1,1,1,5,9,14,21,28,43,68,104,155,227,322,447,621,858,1192,1651}

</pre>

===translation===

{{trans|Go}} {{trans|Sidef}}

Significantly faster. The last few counts were wrong when using native ints/atoms, so I went gmp, which means it also works on 32-bit.

{{out}}

<pre>

"0.8s"

</pre>

 

=={{header|Raku}}==

Raku has no handy pre-made nth integer root routine so has the same problem as Go with needing a slight "fudge factor" in the nth root calculation.

 

 

sub is-square-free (Int \n) {

printf "%2s-powerful numbers <= 10ⁿ (where 0 <= n <= %d): ", k, $top+k;

quietly say join ', ', [\+] powerfuls(10**($top + k), k);

{{out}}

<pre>Count and first and last five enumerated n-powerful numbers in 10ⁿ:

=={{header|Sidef}}==

===Generation===

 

var list = []

var t = a.tail(5).join(', ')

printf("For k=%-2d there are %d k-powerful numbers <= 10^k: [%s, ..., %s]\n", k, a.len, h, t)

{{out}}

<pre>

</pre>

===Counting===

 

var count = 0

var a = (k+10).of {|j| powerful_count(10**j, k) }

printf("Number of %2d-powerful numbers <= 10^j, for 0 <= j < #{k+10}: %s\n", k, a)

{{out}}

<pre>

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var potentialPowerful = Fn.new { |max, k|

}

Fmt.print("Count of $2d-powerful numbers <= 10^j, j in [0, $d]: $n", k, k + 9, powCount)

 

{{out}}

=={{header|zkl}}==

{{trans|Go}}

var [const] primes2=T(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,) // seems to be enough

.apply("pow",2);

}(1,(2).pow(k)-1, n,k, powerful:=Dictionary());

powerful.keys.apply("toInt").sort();

foreach k in ([2..10]){

ps:=powerfuls((10).pow(k),k);

println("%2d: %s ... %s".fmt(ps.len(),ps[0,5].concat(" "),ps.tail(5).concat(" ")));

{{out}}

<pre>

{{trans|Perl}}

Overflows a 64 bit int at the very end, which results in a count of zero.

fcn(m,r, n,k,count){ // recursive closure

if(r<=k){ count.incN(iroot(n/m, r)); return() }

}(1,2*k - 1, n,k, count:=Ref(0));

count.value

foreach k in ([2..10]){

print("%2s-powerful numbers <= 10\u207f (n in [0..%d)): ".fmt(k, 10+k));

ps:=[0 .. k+10 -1].apply('wrap(n){ powerfulsN((10).pow(n), k) });

println(ps.concat(" "));

{{out}}

<pre>