Strong and weak primes: Difference between revisions
m
→{{header|EasyLang}}
Catskill549 (talk | contribs) (added AWK) |
|||
(8 intermediate revisions by 8 users not shown) | |||
Line 36:
=={{header|11l}}==
<
V is_prime = [0B] * 2 [+] [1B] * (limit - 1)
L(n) 0 .< Int(limit ^ 0.5 + 1.5)
Line 64:
print(‘The count of balanced primes below 10,000,000: ’b.len)
print("\nTOTAL primes below 1,000,000: "sum(p.filter(pr -> pr < 1'000'000).map(pr -> 1)))
print(‘TOTAL primes below 10,000,000: ’p.len)</
{{out}}
Line 87:
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
<
PR heap=128M PR # set heap memory size for Algol 68G #
# returns a string representation of n with commas #
Line 178:
print( ( newline ) );
print( ( " weak primes below 1,000,000: ", commatise( weak1 ), newline ) );
print( ( " weak primes below 10,000,000: ", commatise( weak10 ), newline ) )</
{{out}}
<pre>
Line 191:
</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f STRONG_AND_WEAK_PRIMES.AWK
BEGIN {
Line 256:
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
Line 269:
=={{header|C}}==
{{trans|D}}
<
#include <stdint.h>
#include <stdio.h>
Line 390:
free(primePtr);
return EXIT_SUCCESS;
}</
{{out}}
<pre>First 36 strong primes: 11 17 29 37 41 59 67 71 79 97 101 107 127 137 149 163 179 191 197 223 227 239 251 269 277 281 307 311 331 347 367 379 397 419 431 439
Line 402:
=={{header|C sharp}}==
{{works with|C sharp|7}}
<
using static System.Linq.Enumerable;
using System;
Line 420:
}
}</
{{out}}
<pre>
Line 431:
=={{header|C++}}==
<
#include <iostream>
#include <iterator>
Line 493:
weak_primes.print(std::cout, "weak");
return 0;
}</
Contents of prime_sieve.hpp:
<
#define PRIME_SIEVE_HPP
Line 547:
}
#endif</
{{out}}
Line 560:
=={{header|D}}==
<
import std.array;
import std.range;
Line 653:
writefln("There are %d weak primes below 1,000,000", weakPrimes.filter!"a<1_000_000".count);
writefln("There are %d weak primes below 10,000,000", weakPrimes.filter!"a<10_000_000".count);
}</
{{out}}
<pre>First 36 strong primes: [11, 17, 29, 37, 41, 59, 67, 71, 79, 97, 101, 107, 127, 137, 149, 163, 179, 191, 197, 223, 227, 239, 251, 269, 277, 281, 307, 311, 331, 347, 367, 379, 397, 419, 431, 439]
Line 661:
There are 37780 weak primes below 1,000,000
There are 321750 weak primes below 10,000,000</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
procedure StrongWeakPrimes(Memo: TMemo);
{Display Strong/Weak prime information}
var I,P: integer;
var Sieve: TPrimeSieve;
var S: string;
var Cnt,Cnt1,Cnt2: integer;
type TPrimeTypes = (ptStrong,ptWeak,ptBalanced);
function GetTypeStr(PrimeType: TPrimeTypes): string;
{Get string describing PrimeType}
begin
case PrimeType of
ptStrong: Result:='Strong';
ptWeak: Result:='Weak';
ptBalanced: Result:='Balanced';
end;
end;
function GetPrimeType(N: integer): TPrimeTypes;
{Return flag indicating type of prime Primes[N] is}
{Strong = Primes(N) > [Primes(N-1) + Primes(N+1)] / 2}
{Weak = Primes(N) < [Primes(N-1) + Primes(N+1)] / 2}
{Balanced = Primes(N) = [Primes(N-1) + Primes(N+1)] / 2}
var P,P1: double;
begin
P:=Sieve.Primes[N];
P1:=(Sieve.Primes[N-1] + Sieve.Primes[N+1]) / 2;
if P>P1 then Result:=ptStrong
else if P<P1 then Result:=ptWeak
else Result:=ptBalanced;
end;
procedure GetPrimeCounts(PT: TPrimeTypes; var Cnt1,Cnt2: integer);
{Get number of primes of type "PT" below 1 million and 10 million}
var I: integer;
begin
Cnt1:=0; Cnt2:=0;
for I:=1 to 1000000-1 do
begin
if GetPrimeType(I)=PT then
begin
if Sieve.Primes[I]>10000000 then break;
Inc(Cnt2);
if Sieve.Primes[I]<1000000 then Inc(Cnt1);
end;
end;
end;
function GetPrimeList(PT: TPrimeTypes; Limit: integer): string;
{Get a list of primes of type PT up to Limit}
var I,Cnt: integer;
begin
Result:='';
Cnt:=0;
for I:=1 to Sieve.PrimeCount-1 do
if GetPrimeType(I)=PT then
begin
Inc(Cnt);
P:=Sieve.Primes[I];
Result:=Result+Format('%5d',[P]);
if Cnt>=Limit then break;
if (Cnt mod 10)=0 then Result:=Result+CRLF;
end;
end;
procedure ShowPrimeTypeData(PT: TPrimeTypes; Limit: Integer);
{Display information about specified PrimeType, listing items up to Limit}
var S,TS: string;
begin
S:=GetPrimeList(PT,Limit);
TS:=GetTypeStr(PT);
Memo.Lines.Add(Format('First %d %s primes are:',[Limit,TS]));
Memo.Lines.Add(S);
GetPrimeCounts(PT,Cnt1,Cnt2);
Memo.Lines.Add(Format('Number %s primes <1,000,000: %8.0n', [TS,Cnt1+0.0]));
Memo.Lines.Add(Format('Number %s primes <10,000,000: %8.0n', [TS,Cnt2+0.0]));
Memo.Lines.Add('');
end;
begin
Sieve:=TPrimeSieve.Create;
try
Sieve.Intialize(200000000);
Memo.Lines.Add('Primes in Sieve : '+IntToStr(Sieve.PrimeCount));
ShowPrimeTypeData(ptStrong,36);
ShowPrimeTypeData(ptWeak,37);
ShowPrimeTypeData(ptBalanced,28);
finally Sieve.Free; end;
end;
</syntaxhighlight>
{{out}}
<pre>
Primes in Sieve : 11078937
First 36 Strong primes are:
11 17 29 37 41 59 67 71 79 97
101 107 127 137 149 163 179 191 197 223
227 239 251 269 277 281 307 311 331 347
367 379 397 419 431 439
Number Strong primes <1,000,000: 37,723
Number Strong primes <10,000,000: 320,991
First 37 Weak primes are:
3 7 13 19 23 31 43 47 61 73
83 89 103 109 113 131 139 151 167 181
193 199 229 233 241 271 283 293 313 317
337 349 353 359 383 389 401
Number Weak primes <1,000,000: 37,780
Number Weak primes <10,000,000: 321,750
First 28 Balanced primes are:
5 53 157 173 211 257 263 373 563 593
607 653 733 947 977 1103 1123 1187 1223 1367
1511 1747 1753 1907 2287 2417 2677 2903
Number Balanced primes <1,000,000: 2,994
Number Balanced primes <10,000,000: 21,837
Elapsed Time: 2.947 Sec.
</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
fastfunc isprim num .
i = 3
while i <= sqrt num
if num mod i = 0
return 0
.
i += 2
.
return 1
.
func nextprim n .
repeat
n += 2
until isprim n = 1
.
return n
.
proc strwkprimes ncnt sgn . .
write "First " & ncnt & ": "
pr2 = 2
pr3 = 3
repeat
pr1 = pr2
pr2 = pr3
until pr2 >= 10000000
pr3 = nextprim pr3
if pr1 < 1000000 and pr2 > 1000000
print ""
print "Count lower 10e6: " & cnt
.
if sgn * pr2 > sgn * (pr1 + pr3) / 2
cnt += 1
if cnt <= ncnt
write pr2 & " "
.
.
.
print "Count lower 10e7: " & cnt
print ""
.
print "Strong primes:"
strwkprimes 36 1
print "Weak primes:"
strwkprimes 37 -1
</syntaxhighlight>
{{out}}
<pre>
Strong primes:
First 36: 11 17 29 37 41 59 67 71 79 97 101 107 127 137 149 163 179 191 197 223 227 239 251 269 277 281 307 311 331 347 367 379 397 419 431 439
Count lower 10e6: 37723
Count lower 10e7: 320991
Weak primes:
First 37: 3 7 13 19 23 31 43 47 61 73 83 89 103 109 113 131 139 151 167 181 193 199 229 233 241 271 283 293 313 317 337 349 353 359 383 389 401
Count lower 10e6: 37780
Count lower 10e7: 321750
</pre>
=={{header|Factor}}==
<
tools.memory.private ;
IN: rosetta-code.strong-primes
Line 687 ⟶ 883:
First 37 weak primes:\n%[%d, %]
%s weak primes below 1,000,000
%s weak primes below 10,000,000\n" printf</
{{out}}
<pre>
Line 699 ⟶ 895:
37,780 weak primes below 1,000,000
321,750 weak primes below 10,000,000
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
#include "isprime.bas"
function nextprime( n as uinteger ) as uinteger
'finds the next prime after n, excluding n if it happens to be prime itself
if n = 0 then return 2
if n < 3 then return n + 1
dim as integer q = n + 2
while not isprime(q)
q+=2
wend
return q
end function
function lastprime( n as uinteger ) as uinteger
'finds the last prime before n, excluding n if it happens to be prime itself
if n = 2 then return 0 'zero isn't prime, but it is a good sentinel value :)
if n = 3 then return 2
dim as integer q = n - 2
while not isprime(q)
q-=2
wend
return q
end function
function isstrong( p as integer ) as boolean
if nextprime(p) + lastprime(p) >= 2*p then return false else return true
end function
function isweak( p as integer ) as boolean
if nextprime(p) + lastprime(p) <= 2*p then return false else return true
end function
print "The first 36 strong primes are: "
dim as uinteger c, p=3
while p < 10000000
if isprime(p) andalso isstrong(p) then
c += 1
if c <= 36 then print p;" ";
if c=37 then print
end if
if p = 1000001 then print "There are ";c;" strong primes below one million"
p+=2
wend
print "There are ";c;" strong primes below ten million"
print
print "The first 37 weak primes are: "
p=3 : c=0
while p < 10000000
if isprime(p) andalso isweak(p) then
c += 1
if c <= 37 then print p;" ";
if c=38 then print
end if
if p = 1000001 then print "There are ";c;" weak primes below one million"
p+=2
wend
print "There are ";c;" weak primes below ten million"
print</syntaxhighlight>
{{out}}<pre>
The first 36 strong primes are:
11 17 29 37 41 59 67 71 79 97 101 107 127 137 149 163 179 191 197 223 227 239 251 269 277 281 307 311 331 347 367 379 397 419 431 439
There are 37723 strong primes below one million
There are 320991 strong primes below ten million
The first 37 weak primes are:
3 7 13 19 23 31 43 47 61 73 83 89 103 109 113 131 139 151 167 181 193 199 229 233 241 271 283 293 313 317 337 349 353 359 383 389 401
There are 37780 weak primes below one million
There are 321750 weak primes below ten million
</pre>
=={{header|Frink}}==
<
strongPrimes[end=undef] := select[primes[3,end], {|p| p > (previousPrime[p] + nextPrime[p])/2 }]
weakPrimes[end=undef] := select[primes[3,end], {|p| p < (previousPrime[p] + nextPrime[p])/2 }]
Line 713 ⟶ 983:
println["Weak primes below 1,000,000: " + length[weakPrimes[1_000_000]]]
println["Weak primes below 10,000,000: " + length[weakPrimes[10_000_000]]]
</syntaxhighlight>
{{out}}
Line 726 ⟶ 996:
=={{header|Go}}==
<
import "fmt"
Line 811 ⟶ 1,081:
fmt.Println("\nThe number of weak primes below 1,000,000 is", commatize(count))
fmt.Println("\nThe number of weak primes below 10,000,000 is", commatize(len(weak)))
}</
{{out}}
Line 831 ⟶ 1,101:
=={{header|Haskell}}==
Uses primes library: http://hackage.haskell.org/package/primes-0.2.1.0/docs/Data-Numbers-Primes.html
<
import Data.Numbers.Primes (primes)
Line 849 ⟶ 1,119:
printf "Weak primes below 10,000,000: %d\n\n" . length . takeWhile (<10000000) $ weakPrimes
where strongPrimes = xPrimes (>) primes
weakPrimes = xPrimes (<) primes</
{{out}}
<pre>
Line 892 ⟶ 1,162:
=={{header|Java}}==
<
public class StrongAndWeakPrimes {
Line 997 ⟶ 1,267:
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,008 ⟶ 1,278:
Number of weak primes below 1,000,000 = 37,780
Number of weak primes below 10,000,000 = 321,750
</pre>
=={{header|jq}}==
{{Works with|jq}}
'''Also works with gojq, the Go implementation of jq'''
The following assumes that `primes` generates a stream of primes less
than or equal to `.`
as defined, for example, at [[Sieve_of_Eratosthenes#jq|Sieve of Eratosthenes]]]].
<syntaxhighlight lang=jq>
def count(s): reduce s as $_ (0; .+1);
# Emit {strong, weak} primes up to and including $n
def strong_weak_primes:
. as $n
| primes as $primes
| ("\nCheck: last prime generated: \($primes[-1])" | debug) as $debug
| reduce range(1; $primes|length-1) as $p ({};
(($primes[$p-1] + $primes[$p+1]) / 2) as $x
| if $primes[$p] > $x
then .strong += [$primes[$p]]
elif $primes[$p] < $x
then .weak += [$primes[$p]]
else .
end );
(1e7 + 19)
| strong_weak_primes as {$strong, $weak}
| "The first 36 strong primes are:",
$strong[:36],
"\nThe count of the strong primes below 1e6: \(count($strong[]|select(. < 1e6 )))",
"\nThe count of the strong primes below 1e7: \(count($strong[]|select(. < 1e7 )))",
"\nThe first 37 weak primes are:",
$weak[:37],
"\nThe count of the weak primes below 1e6: \(count($weak[]|select(. < 1e6 )))",
"\nThe count of the weak primes below 1e7: \(count($weak[]|select(. < 1e7 )))"
</syntaxhighlight>
{{output}}
<pre>
The first 36 strong primes are:
[11,17,29,37,41,59,67,71,79,97,101,107,127,137,149,163,179,191,197,223,227,239,251,269,277,281,307,311,331,347,367,379,397,419,431,439]
The count of the strong primes below 1e6: 37723
The count of the strong primes below 1e7: 320991
The first 37 weak primes are:
[3,7,13,19,23,31,43,47,61,73,83,89,103,109,113,131,139,151,167,181,193,199,229,233,241,271,283,293,313,317,337,349,353,359,383,389,401]
The count of the weak primes below 1e6: 37780
The count of the weak primes below 1e7: 321750
</pre>
=={{header|Julia}}==
<
function parseprimelist()
Line 1,043 ⟶ 1,367:
parseprimelist()
</
The first 36 strong primes are: [11, 17, 29, 37, 41, 59, 67, 71, 79, 97, 101, 107, 127, 137, 149, 163, 179, 191, 197, 223, 227, 239, 251, 269, 277, 281, 307, 311, 331, 347, 367, 379, 397, 419, 431, 439]
There are 37,723 stromg primes less than 1 million.
Line 1,057 ⟶ 1,381:
=={{header|Kotlin}}==
{{trans|Java}}
<
private val primes = BooleanArray(MAX)
Line 1,159 ⟶ 1,483:
}
}
}</
{{out}}
<pre>First 36 strong primes:
Line 1,171 ⟶ 1,495:
=={{header|Ksh}}==
<
#!/bin/ksh
Line 1,260 ⟶ 1,584:
printf "Number of Weak Primes under %d is: %d\n" $GOAL1 ${goal1_weak}
printf "Number of Weak Primes under %d is: %d\n\n\n" $MAX_INT ${wpcnt}
printf "Number of Balanced Primes under %d is: %d\n\n\n" $MAX_INT ${bpcnt}</
{{out}}<pre>
Total primes under 10000000 = 664579
Line 1,279 ⟶ 1,603:
=={{header|Lua}}==
This could be made faster but favours readability. It runs in about 3.3 seconds in LuaJIT on a 2.8 GHz core.
<
function primeList (n)
local function isPrime (x)
Line 1,331 ⟶ 1,655:
for i = 1, 37 do io.write(weak[i] .. " ") end
print("\n\nThere are " .. wCount .. " weak primes below one million.")
print("\nThere are " .. #weak .. " weak primes below ten million.")</
{{out}}
<pre>The first 36 strong primes are:
Line 1,349 ⟶ 1,673:
=={{header|Maple}}==
<
holder := false;
if isprime(n) and 1/2*prevprime(n) + 1/2*nextprime(n) < n then
Line 1,392 ⟶ 1,716:
countStrong(10000000)
countWeak(1000000)
countWeak(10000000)</
{{Out}}
<pre>[11, 17, 29, 37, 41, 59, 67, 71, 79, 97, 101, 107, 127, 137, 149, 163, 179, 191, 197, 223, 227, 239, 251, 269, 277, 281, 307, 311, 331, 347, 367, 379, 397, 419, 431, 439]
Line 1,402 ⟶ 1,726:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
SequenceCases[p, ({a_, b_, c_}) /; (a + c < 2 b) :> b, 36, Overlaps -> True]
SequenceCases[p, ({a_, b_, c_}) /; (a + c > 2 b) :> b, 37, Overlaps -> True]
Line 1,410 ⟶ 1,734:
p = Prime[Range[PrimePi[10^7] + 1]];
Length[Select[Partition[p, 3, 1], #[[3]] + #[[1]] < 2 #[[2]] &]]
Length[Select[Partition[p, 3, 1], #[[3]] + #[[1]] > 2 #[[2]] &]]</
{{out}}
<pre>{11,17,29,37,41,59,67,71,79,97,101,107,127,137,149,163,179,191,197,223,227,239,251,269,277,281,307,311,331,347,367,379,397,419,431,439}
Line 1,421 ⟶ 1,745:
=={{header|Nim}}==
<
const
Line 1,468 ⟶ 1,792:
echo " ", weakPrimes[0..36].join(" ")
echo "Count of weak primes below 1_000_000: ", weakPrimes.count(1_000_000)
echo "Count of weak primes below 10_000_000: ", weakPrimes.count(10_000_000)</
{{out}}
Line 1,487 ⟶ 1,811:
If deltaAfter < deltaBefore than a strong prime is found.
<
{$IFNDEF FPC}
{$AppType CONSOLE}
Line 1,655 ⟶ 1,979:
WeakOut(37);
CntWeakStrong10(CntWs);
end.</
{{Out}}
<pre>
Line 1,678 ⟶ 2,002:
{{trans|Raku}}
{{libheader|ntheory}}
<
sub comma {
Line 1,705 ⟶ 2,029:
print "Count of $type primes <= @{[comma $c1]}: " . comma below($c1,@$pr) . "\n";
print "Count of $type primes <= @{[comma $c2]}: " . comma scalar @$pr . "\n";
}</
{{out}}
<pre>
Line 1,725 ⟶ 2,049:
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">strong</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">weak</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">get_maxprime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1e14</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> <span style="color: #000080;font-style:italic;">-- (ie idx of primes < (sqrt(1e14)==1e7), bar 1st)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">compare</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,(</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)+</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=+</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #000000;">strong</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">p</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #000000;">weak</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">p</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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 first thirty six strong primes: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">strong</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">36</span><span style="color: #0000FF;">],</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">", "</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 first thirty seven weak primes: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">weak</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">37</span><span style="color: #0000FF;">],</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">", "</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;">"There are %,d strong primes below %,d and %,d below %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">binary_search</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">strong</span><span style="color: #0000FF;">))-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">strong</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1e7</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;">"There are %,d weak primes below %,d and %,d below %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">binary_search</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">weak</span><span style="color: #0000FF;">))-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">weak</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1e7</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
The first
The first
</pre>
=={{header|PureBasic}}==
<
Global Dim P.b(#MAX) : FillMemory(@P(),#MAX,1,#PB_Byte)
Global NewList Primes.i()
Line 1,789 ⟶ 2,109:
PrintN("Number of weak primes below 1'000'000 = "+FormatNumber(c2,0,".","'"))
PrintN("Number of weak primes below 10'000'000 = "+FormatNumber(ListSize(Weak()),0,".","'"))
Input()</
{{out}}
<pre>First 36 strong primes:
Line 1,805 ⟶ 2,125:
COmputes and shows the requested output then adds similar output for the "balanced" case where <code>prime(p) == [prime(p-1) + prime(p+1)] ÷ 2</code>.
<
def primesfrom2to(n):
Line 1,841 ⟶ 2,161:
print('\nTOTAL primes below 1,000,000:',
sum(1 for pr in p if pr < 1_000_000))
print('TOTAL primes below 10,000,000:', len(p))</
{{out}}
Line 1,864 ⟶ 2,184:
{{works with|Rakudo|2018.11}}
<syntaxhighlight lang="raku"
use Math::Primesieve;
Line 1,889 ⟶ 2,209:
say "Count of $type primes <= {comma 1e6}: ", comma +@pr[^(@pr.first: * > 1e6,:k)];
say "Count of $type primes <= {comma 1e7}: ", comma +@pr;
}</
{{out}}
<pre>First 36 strong primes:
Line 1,907 ⟶ 2,227:
=={{header|REXX}}==
<
parse arg N kind _ . 1 . okind; upper kind /*obtain optional arguments from the CL*/
if N=='' | N=="," then N= 36 /*Not specified? Then assume default.*/
Line 1,956 ⟶ 2,276:
else return 0 /*not " " " */
else if y>s then return add() /*is an strong prime.*/
return 0 /*not " " " */</
This REXX program makes use of '''LINESIZE''' REXX program (or
BIF) which is used to determine the screen width (or linesize) of the
Line 1,995 ⟶ 2,315:
=={{header|Ring}}==
<
load "stdlib.ring"
Line 2,100 ⟶ 2,420:
see "weak primes below 1,000,000: " + primes2 + nl
see "weak primes below 10,000,000: " + primes3 + nl
</syntaxhighlight>
Output:
<pre>
Line 2,114 ⟶ 2,434:
=={{header|Ruby}}==
<
strong_gen = Enumerator.new{|y| Prime.each_cons(3){|a,b,c|y << b if a+c-b<b} }
Line 2,133 ⟶ 2,453:
puts "#{strongs} strong primes and #{weaks} weak primes below #{limit}."
end
</syntaxhighlight>
{{out}}
<pre>First 36 strong primes:
Line 2,146 ⟶ 2,466:
=={{header|Rust}}==
<
for i in 2..n {
if i * i > n {
Line 2,241 ⟶ 2,561:
}
println!("weak primes below 10,000,000: {}", n);
}</
<pre>
First 36 strong primes: 11 17 29 37 41 59 67 71 79 97 101 107 127 137 149 163 179 191 197 223 227 239 251 269 277 281 307 311 331 347 367 379 397 419 431 439
Line 2,253 ⟶ 2,573:
=={{header|Scala}}==
This example works entirely with lazily evaluated lists. It starts with a list of primes, and generates a sliding iterator that looks at each triplet of primes. Lists of strong and weak primes are built by applying the given filters then selecting the middle term from each triplet.
<
def main(args: Array[String]): Unit = {
val bnd = 1000000
Line 2,270 ⟶ 2,590:
def primeTrips: Iterator[LazyList[Int]] = primes.sliding(3)
def primes: LazyList[Int] = 2 #:: LazyList.from(3, 2).filter(n => !Iterator.range(3, math.sqrt(n).toInt + 1, 2).exists(n%_ == 0))
}</
{{out}}
Line 2,283 ⟶ 2,603:
=={{header|Sidef}}==
{{trans|Raku}}
<
var (*strong, *weak, *balanced)
Line 2,305 ⟶ 2,625:
say ("Count of #{type} primes <= #{c1.commify}: ", pr.first_index { _ > 1e6 }.commify)
say ("Count of #{type} primes <= #{c2.commify}: " , pr.len.commify)
}</
{{out}}
<pre>
Line 2,325 ⟶ 2,645:
=={{header|Swift}}==
<
class PrimeSieve {
Line 2,416 ⟶ 2,736:
strongPrimes.printInfo(name: "strong")
weakPrimes.printInfo(name: "weak")</
{{out}}
Line 2,431 ⟶ 2,751:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
var primes = Int.primeSieve(1e7 + 19) // next prime above 10 million
Line 2,453 ⟶ 2,773:
Fmt.print("$d", weak.take(37))
Fmt.print("\nThe count of the weak primes below $,d is $,d.", 1e6, weak.count{ |n| n < 1e6 })
Fmt.print("\nThe count of the weak primes below $,d is $,d.", 1e7, weak.count{ |n| n < 1e7 })</
{{out}}
Line 2,470 ⟶ 2,790:
The count of the weak primes below 10,000,000 is 321,750.
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">proc NumOut(Num); \Output positive integer with commas
int Num, Dig, Cnt;
[Cnt:= [0];
Num:= Num/10;
Dig:= rem(0);
Cnt(0):= Cnt(0)+1;
if Num then NumOut(Num);
Cnt(0):= Cnt(0)-1;
ChOut(0, Dig+^0);
if rem(Cnt(0)/3)=0 & Cnt(0) then ChOut(0, ^,);
];
func IsPrime(N); \Return 'true' if odd N > 2 is prime
int N, I;
[for I:= 3 to sqrt(N) do
[if rem(N/I) = 0 then return false;
I:= I+1;
];
return true;
];
int StrongCnt, WeakCnt, StrongCnt0, WeakCnt0, Strongs(36), Weaks(37);
int N, P0, P1, P2, T;
[StrongCnt:= 0; WeakCnt:= 1;
Weaks(0):= 3;
N:= 7; P1:= 3; P2:= 5; \handles unique case where (2+5)/2 = 3.5
repeat if IsPrime(N) then
[P0:= P1; P1:= P2; P2:= N;
T:= (P0+P2)/2;
if P1 > T then
[if StrongCnt < 36 then Strongs(StrongCnt):= P1;
StrongCnt:= StrongCnt+1;
];
if P1 < T then
[if WeakCnt < 37 then Weaks(WeakCnt):= P1;
WeakCnt:= WeakCnt+1;
];
];
if P1 < 1_000_000 then
[StrongCnt0:= StrongCnt; WeakCnt0:= WeakCnt];
N:= N+2;
until P1 >= 10_000_000;
Text(0, "First 36 strong primes:^M^J");
for N:= 0 to 36-1 do
[NumOut(Strongs(N)); ChOut(0, ^ )];
Text(0, "^M^JStrong primes below 1,000,000: ");
NumOut(StrongCnt0);
Text(0, "^M^JStrong primes below 10,000,000: ");
NumOut(StrongCnt);
Text(0, "^M^JFirst 37 weak primes:^M^J");
for N:= 0 to 37-1 do
[NumOut(Weaks(N)); ChOut(0, ^ )];
Text(0, "^M^JWeak primes below 1,000,000: ");
NumOut(WeakCnt0);
Text(0, "^M^JWeak primes below 10,000,000: ");
NumOut(WeakCnt);
CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
First 36 strong primes:
11 17 29 37 41 59 67 71 79 97 101 107 127 137 149 163 179 191 197 223 227 239 251 269 277 281 307 311 331 347 367 379 397 419 431 439
Strong primes below 1,000,000: 37,723
Strong primes below 10,000,000: 320,991
First 37 weak primes:
3 7 13 19 23 31 43 47 61 73 83 89 103 109 113 131 139 151 167 181 193 199 229 233 241 271 283 293 313 317 337 349 353 359 383 389 401
Weak primes below 1,000,000: 37,780
Weak primes below 10,000,000: 321,751
</pre>
Line 2,477 ⟶ 2,870:
[[Extensible prime generator#zkl]] could be used instead.
<
const N=1e7;
Line 2,489 ⟶ 2,882:
}
ps.pop(0); ps.append(pw.nextPrime().toInt());
}while(pn<=N);</
<
println("First %d %s primes:\n%s".fmt(psz,nm,list[0,psz].concat(" ")));
println("Count of %s primes <= %,10d: %,8d"
.fmt(nm,1e6,list.reduce('wrap(s,p){ s + (p<=1e6) },0)));
println("Count of %s primes <= %,10d: %,8d\n".fmt(nm,1e7,list.len()));
}</
{{out}}
<pre>
|