Distribution of 0 digits in factorial series: Difference between revisions

permanently falls below 0.16. This task took many hours in the Python example, though I wonder if there is a faster

algorithm out there.

=={{header|11l}}==

{{trans|Python}}

V proportions = [0.0] * n

V (fac, psum) = (BigInt(1), 0.0)

L(n) [100, 1000, 10000]

{{out}}

=== Base 1000 version ===

V zc = [0] * 999

L(x) 1..9

print(‘The mean proportion dips permanently below 0.16 at ’first‘.’)

{{out}}

The mean proportion dips permanently below 0.16 at 47332.

</pre>

=={{header|C++}}==

{{trans|Phix}}

#include <chrono>

#include <iomanip>

std::cout << "The mean proportion dips permanently below 0.16 at " << first

<< ". (" << elapsed(t0) << "ms)\n";

{{out}}

The mean proportion dips permanently below 0.16 at 47332. (4598ms)

</pre>

=={{header|Go}}==

===Brute force===

{{libheader|Go-rcu}}

Timings here are 2.8 seconds for the basic task and 182.5 seconds for the stretch goal.

import (

fmt.Println(" (stays below 0.16 after this)")

fmt.Printf("%6s = %12.10f\n", "50,000", sum / 50000)

{{out}}

{{trans|Phix}}

Much quicker than before with 10,000 now being reached in 0.35 seconds and the stretch goal in about 5.5 seconds.

import (

fmt.Println(" (stays below 0.16 after this)")

fmt.Printf("%6s = %12.10f\n", "50,000", total/50000)

{{out}}

Same as 'brute force' version.

</pre>

=={{header|jq}}==

'''Works with jq'''

'''From BigInt.jq'''

# multiply two decimal strings, which may be signed (+ or -)

def long_multiply(num1; num2):

else mult($a1[1]; $a2[1]) | adjustsign( $a1[0] * $a2[0] )

end;

'''The task'''

def count(s): reduce s as $x (0; .+1);

# The task:

{{out}}

<pre>

Mean proportion of zero digits in factorials to 10000 is 0.17300384824186707; goal (0.16) unmet.

</pre>

=={{header|Julia}}==

factoril, proportionsum = big"1", 0.0

for i in 1:N

@time meanfactorialdigits(50000, 0.16)

<pre>

Mean proportion of zero digits in factorials to 100 is 0.24675318616743216

=== Base 1000 version ===

{{trans|Pascal, Phix}}

zc = zeros(Int, 999)

for x in 1:9

meanfactorialzeros(100, false)

@time meanfactorialzeros()

<pre>

Mean proportion of zero digits in factorials to 100 is 0.24675318616743216

4.638323 seconds (50.08 k allocations: 7.352 MiB)

</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

ZeroDigitsFractionFactorial[n_Integer] := Module[{m},

m = IntegerDigits[n!];

means = Accumulate[N@fracs]/Range[Length[fracs]];

len = LengthWhile[Reverse@means, # < 0.16 &];

{{out}}

<pre>0.111111

0.173004

47332</pre>

=={{header|Nim}}==

===Task===

{{libheader|bignum}}

import bignum

lim *= 10

echo()

{{out}}

At each step, we eliminate the trailing zeroes to reduce the length of the number and save some time. But this is not much, about 8%.

import bignum

echo "Permanently below 0.16 at n = ", first

{{out}}

<pre>Permanently below 0.16 at n = 47332

Execution time: (seconds: 190, nanosecond: 215845101)</pre>

=={{header|Pascal}}==

Doing the calculation in Base 1,000,000,000 like in [[Primorial_numbers#alternative]].<BR>

The most time consuming is converting to string and search for zeros.<BR>

Therefor I do not convert to string.I divide the base in sections of 3 digits with counting zeros in a lookup table.

{$IFDEF FPC} {$MODE DELPHI} {$Optimization ON,ALL} {$ENDIF}

uses

inc(i);

writeln('First ratio < 0.16 ', i:8,SumOfRatio[i]/i:20:17);

{{out}}

<pre> 100 0.246753186167432

First ratio < 0.16 47332 0.15999999579985665

Real time: 4.898 s CPU share: 99.55 % // 2.67s on 2200G freepascal 3.2.2</pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory qw/factorial/;

$f = factorial $_ and $sum += ($f =~ tr/0//) / length $f for 1..$n;

printf "%5d: %.5f\n", $n, $sum/$n;

{{out}}

<pre> 100: 0.24675

1000: 0.20354

10000: 0.17300</pre>

=={{header|Phix}}==

Using "string math" to create reversed factorials, for slightly easier skipping of "trailing" zeroes,

but converted to base 1000 and with the zero counting idea from Pascal, which sped it up threefold.

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

<span style="color: #004080;">sequence</span> <span style="color: #000000;">rfs</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span> <span style="color: #000080;font-style:italic;">-- reverse factorial(1) in base 1000</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;">"The mean proportion dips permanently below 0.16 at %d. (%s)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">first</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>

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

{{out}}

<pre>

=== trailing zeroes only ===

Should you only be interested in the ratio of trailing zeroes, you can do that much faster:

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

<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">(),</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</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;">"The mean proportion dips permanently below 0.07 at %d. (%s)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">first</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

The mean proportion dips permanently below 0.07 at 31549. (0.1s)

</pre>

=={{header|Python}}==

proportions = [0.0] * N

fac, psum = 1, 0.0

print("The mean proportion dips permanently below 0.16 at {}.".format(n + 2))

<pre>

The mean proportion of 0 in factorials from 1 to 100 is 0.24675318616743216.

</pre>

The means can be plotted, showing a jump from 0 to over 0.25, followed by a slowly dropping curve:

plt.plot([i+1 for i in range(len(props))], props)

=== Base 1000 version ===

{{trans|Go via Phix via Pascal}}

zc = [0] * 999

for x in range(1, 10):

meanfactorialdigits()

print("\nTotal time:", time.perf_counter() - TIME0, "seconds.")

<pre>

The mean proportion of zero digits in factorials to 100 is 0.24675318616743216

Total time: 648.3583232999999 seconds.

</pre>

=={{header|Raku}}==

Works, but depressingly slow for 10000.

sink 10000!; # prime the iterator to allow multithreading

,1000

,10000

{{out}}

<pre>100: 0.24675318616743216

10000: 0.17300384824186605

</pre>

=={{header|REXX}}==

parse arg $ /*obtain optional arguments from the CL*/

if $='' | $="," then $= 100 1000 10000 /*not specified? Then use the default.*/

do k=1 for z; != ! * k; y= y + countstr(0, !) / length(!)

end /*k*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

───────────┴────────────────────────────────────────────────────────────────────────────────

</pre>

=={{header|Rust}}==

{{trans|Phix}}

let mut zc = vec![0; 1000];

zc[0] = 3;

duration.as_millis()

);

{{out}}

The mean proportion dips permanently below 0.16 at 47332. (4485ms)

</pre>

=={{header|Sidef}}==

var v = 1

say mean_factorial_digits(100)

say mean_factorial_digits(1000)

{{out}}

<pre>

0.173003848241866053180036642893070615681027880906

</pre>

=={{header|Wren}}==

===Brute force===

{{libheader|Wren-fmt}}

Very slow indeed, 10.75 minutes to reach N = 10,000.

import "/fmt" for Fmt

Fmt.print("$,6d = $12.10f", n, sum / n)

}

{{out}}

{{trans|Phix}}

Around 60 times faster than before with 10,000 now being reached in about 10.5 seconds. Even the stretch goal is now viable and comes in at 5 minutes 41 seconds.

var rfs = [1] // reverse factorial(1) in base 1000

Fmt.write("$,6d = $12.10f", first, firstRatio)

System.print(" (stays below 0.16 after this)")

{{out}}