Prime reciprocal sum: Difference between revisions
Added Sidef
(Added Sidef) |
|||
| (7 intermediate revisions by 6 users not shown) | |||
Line 39:
# previous primes and the sum remain below 1 #
PR precision
PR read "primes.incl.a68" PR # include prime utilities #
Line 87:
# each succeeding prime is the next prime > the denominator of the sum #
# divided by the difference of the denominator and the numerator #
FOR i FROM 2 TO
LONG LONG INT next := IF num OF sum + 1 = den OF sum
THEN den OF sum + 1
Line 129:
13: 12748246592672078196...20708715953110886963 592 digits
14: 46749025165138838243...65355869250350888941 1180 digits
15: 11390125639471674628...31060548964273180103 2358 digits
</pre>
Line 294 ⟶ 295:
16: 36961763505630520555..02467094377885929191 (4711 digits)
17: 21043364724798439508..14594683820359204509 (9418 digits)
</pre>
=={{header|Nim}}==
{{libheader|bignum}}
<syntaxhighlight lang="Nim">import std/strformat
import bignum
iterator a075442(): Int =
let One = newRat(1)
var sum = newRat(0)
var p = newInt(0)
while true:
let q = reciprocal(One - sum)
p = nextPrime(if q.isInt: q.num else: q.toInt + 1)
yield p
sum += newRat(1, p)
func compressed(str: string; size: int): string =
## Return a compressed value for long strings of digits.
if str.len <= 2 * size: str
else: &"{str[0..<size]}...{str[^size..^1]} ({str.len} digits)"
var count = 0
for p in a075442():
inc count
echo &"{count:2}: {compressed($p, 20)}"
if count == 15: break
</syntaxhighlight>
{{out}}
<pre> 1: 2
2: 3
3: 7
4: 43
5: 1811
6: 654149
7: 27082315109
8: 153694141992520880899
9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (76 digits)
11: 20300753813848234767...91313959045797597991 (150 digits)
12: 20323705381471272842...21649394434192763213 (297 digits)
13: 12748246592672078196...20708715953110886963 (592 digits)
14: 46749025165138838243...65355869250350888941 (1180 digits)
15: 11390125639471674628...31060548964273180103 (2358 digits)
</pre>
Line 510 ⟶ 556:
Real time: 21.024 s User time: 20.768 s Sys. time: 0.067 s CPU share: 99.10 %
@home (4.4Ghz 5600G ) modified with primes up to 1E6 ( Uint16-> Uint32 )
78498 999979 reducing factor 0.04059798
...
15 10015 ms ,delta 3510 // first guess than searching for next prime
1139012563947167462...31060548964273180103 ( 2358 digits)
1731172 999979
16 110030 ms ,delta 6493
3696176350563052055...02467094377885929191 ( 4711 digits)
17 5098268 ms ,delta 55552 // first guess than searching for next prime
2104336472479843950...14594683820359204509 ( 9418 digits)
</pre>
=={{header|Perl}}==
<syntaxhighlight lang="perl" line>
use strict; use warnings; use feature 'state';
use Math::AnyNum <next_prime ceil>;
sub abbr { my $d=shift; my $l = length $d; $l < 41 ? $d : substr($d,0,20) . '..' . substr($d,-20) . " ($l digits)" }
sub succ_prime {
state $sum = 0;
my $next = next_prime ceil( 1 / (1-$sum) );
$sum += 1/$next;
$next
}
printf "%2d: %s\n", $_, abbr succ_prime for 1..14;
</syntaxhighlight>
{{out}}
<pre>
1: 2
2: 3
3: 7
4: 43
5: 1811
6: 654149
7: 27082315109
8: 153694141992520880899
9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)
</pre>
=={{header|Phix}}==
The Julia entry took over 4 hours to get the 17th on this box, so I just went with "keep it all under 10s"...<br>
<small>(As others have alluded, it is all about getting the next prime. Even should you land on one straightaway, it still takes quite some time to prove an n-thousand digit number ''is'' prime.)</small>
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
Line 551 ⟶ 643:
13: 12748246592672078196...20708715953110886963 (592 digits)
14: 46749025165138838243...65355869250350888941 (1,180 digits)
</pre>
If you've really got nothing better to do, you can also get, in 10 mins on 64-bit, thrice that on 32-bit:
<pre>
15: 11390125639471674628...31060548964273180103 (digits: 2358)
16: 36961763505630520555...02467094377885929191 (digits: 4711)
</pre>
Line 622 ⟶ 719:
15: 11390125639471674628..31060548964273180103 (2358 digits)
16: 36961763505630520555..02467094377885929191 (4711 digits)</pre>
=={{header|RPL}}==
Limited floating-point precision prevents from finding the correct 7th term. Program starts with a non-empty sequence to avoid the <code>∑LIST</code> calculation bug that occurs when the input list has less than two items.
{{works with|HP|49g}}
≪ {2 3}
1 4 '''START''' 1 OVER INV ∑LIST - INV →NUM IP NEXTPRIME + '''NEXT'''
≫ '<span style="color:blue">∑INVPR</span>' STO
{{out}}
<pre>
1: {2 3 7 43 1811 654149}
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var A075442 = Enumerator({|callback|
var sum = 0
loop {
var p = next_prime(ceil(1/(1-sum)))
sum += 1/p
callback(p)
}
})
A075442.first(15).each_kv {|k,n|
var s = Str(n)
s = "#{s.first(20)}..#{s.last(20)} (#{s.len} digits)" if (s.len > 50)
say "#{'%2d' % k+1}: #{s}"
}</syntaxhighlight>
{{out}}
<pre>
1: 2
2: 3
3: 7
4: 43
5: 1811
6: 654149
7: 27082315109
8: 153694141992520880899
9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)
15: 11390125639471674628..31060548964273180103 (2358 digits)
</pre>
=={{header|Wren}}==
Line 627 ⟶ 769:
{{libheader|Wren-fmt}}
Even with GMP takes about 4½ minutes to find the first 16.
<syntaxhighlight lang="
import "./fmt" for Fmt
| |||