Combinations with repetitions/Square digit chain: Difference between revisions

=={{header|D}}==

{{improve|D|See talk page}}

// Count how many number chains for Natural Numbers < 10**K end with a value of 1.

//

writefln ("\n(k=%d) In the range 1 to %d\n%d translate to 1 and %d translate to 89\n", K, (cast (ulong) (10))^^K-1,z,(cast (ulong) (10))^^K-1-z);

}

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Println(count1, "numbers produce 1 and", limit-count1, "numbers produce 89\n")

}

 

{{out}}

of gojq would be required. The output shown below is taken from a gojq run.

 

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

 

| ((10|power($k)) - 1) as $limit

| "For k = \($k) in the range 1 to \($limit)",

{{out}}

<pre>

 

=={{header|Julia}}==

 

function iterate(m::Integer)

testitersquares(i)

end

<pre>

For k = 2, in the range 1 to 99,

 

So the following generalizes that code to deal with values of k up to 17 (which requires 64 bit integers) and to count numbers where the squared digits sum sequence eventually ends in 1 rather than 89, albeit the sum of both must of course be 10 ^ k - 1.

 

fun endsWithOne(n: Int): Boolean {

println("$count1 numbers produce 1 and ${limit - count1} numbers produce 89\n")

}

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

func endsWithOne(n: Natural): bool =

let limit = 10^k - 1

echo &"For k = {k} in the range 1 to {limit}"

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

say "For k = $k in the range 1 to " . comma $limit;

say comma($count1) . ' numbers produce 1 and ' . comma($limit-$count1) . " numbers produce 89\n";

{{out}}

<pre>For k = 7 in the range 1 to 9,999,999

=={{header|Phix}}==

{{trans|Wren}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s numbers produce 1 and %s numbers produce 89\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

12,024,696,404,768,024 numbers produce 1 and 87,975,303,595,231,975 numbers produce 89

</pre>

 

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Kotlin}}

 

sub endsWithOne($n --> Bool) {

say "For k = $k in the range 1 to $limit";

say "$count1 numbers produce 1 and ",$limit-$count1," numbers produce 89";

 

{{out}}

 

=={{header|Ruby}}==

# Count how many number chains for Natural Numbers < 10**K end with a value of 1.

#

}

puts "\nk=(#{K}) in the range 1 to #{10**K-1}\n#{z} numbers produce 1 and #{10**K-1-z} numbers produce 89"

{{out}}

<pre>

{{libheader|Wren-big}}

As Wren doesn't have 64 bit integers, it is necessary to use BigInt here to process k = 17.

 

var endsWithOne = Fn.new { |n|

System.print("For k = %(k) in the range 1 to %(limit)")

System.print("%(count1) numbers produce 1 and %(limit - count1) numbers produce 89\n")

 

{{out}}

=={{header|zkl}}==

{{trans|Ruby}}

F:=(K+1).pump(List,fcn(n){ (1).reduce(n,'*,1) }); #Some small factorials

g:=fcn(n){

println("%,d numbers produce 1 and %,d numbers produce 89".fmt(z,(10).pow(K)-1-z));

z

combosKW(k,sequence) is lazy, which, in this case, is quite a bit faster than the non-lazy version.

{{out}}

<pre>