Strong and weak primes: Difference between revisions

:::::*   '''prime(4)'''   is   '''7'''

::* &nbsp; A &nbsp; ''' strong &nbsp; prime''' &nbsp; is when &nbsp; &nbsp; <big>'''prime(''p'')'''</big> &nbsp; is &nbsp; <big>'''>''' &nbsp; '''[prime(''p''-1) + prime(''p''+1)] ÷ 2</big>'''

 

 

 

;Related Task:

 

 

;Also see:

<br><br>

 

=={{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 #

print( ( newline ) );

print( ( " weak primes below 1,000,000: ", commatise( weak1 ), newline ) );

{{out}}

<pre>

weak primes below 10,000,000: 321,750

</pre>

 

=={{header|C sharp}}==

{{works with|C sharp|7}}

using static System.Linq.Enumerable;

using System;

}

{{out}}

<pre>

There are 37,780 weak primes below 1,000,000

There are 321,750 weak primes below 1,000,000</pre>

 

=={{header|Factor}}==

tools.memory.private ;

IN: rosetta-code.strong-primes

First 37 weak primes:\n%[%d, %]

%s weak primes below 1,000,000

{{out}}

<pre>

37,780 weak primes below 1,000,000

321,750 weak primes below 10,000,000

</pre>

 

=={{header|Go}}==

 

import "fmt"

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}}

 

The number of weak primes below 10,000,000 is 321,750

</pre>

 

+/ weaklings </ 1e6 * 1 10

37780 321750

</pre>

 

=={{header|Julia}}==

 

function parseprimelist()

 

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.

There are 21,837 balanced primes less than 10 million.

</pre>

 

=={{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)

for i = 1, 37 do io.write(weak[i] .. " ") end

print("\n\nThere are " .. wCount .. " weak primes below one million.")

{{out}}

<pre>The first 36 strong primes are:

There are 321750 weak primes below ten million.

</pre>

=={{header|Maple}}==

holder := false;

if isprime(n) and 1/2*prevprime(n) + 1/2*nextprime(n) < n then

countStrong(10000000)

countWeak(1000000)

{{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]

37780

321750</pre>

 

=={{header|Pascal}}==

If deltaAfter < deltaBefore than a strong prime is found.

{$IFNDEF FPC}

{$AppType CONSOLE}

WeakOut(37);

CntWeakStrong10(CntWs);

{{Out}}

<pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

 

sub comma {

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>

</pre>

 

 

 

 

 

{{out}}

<pre>First 36 strong primes:

First 37 weak primes:

</pre>

 

 

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):

print('\nTOTAL primes below 1,000,000:',

sum(1 for pr in p if pr < 1_000_000))

 

{{out}}

TOTAL primes below 1,000,000: 78498

TOTAL primes below 10,000,000: 664579</pre>

 

=={{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.*/

else return 0 /*not " " " */

else if y>s then return add() /*is an strong prime.*/

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or

BIF) which is used to determine the screen width (or linesize) of the

37,780 WEAK primes found below or equal to 1,000,000.

</pre>

<pre>

321,750 WEAK primes found below or equal to 10,000,000.

</pre>

 

=={{header|Ruby}}==

 

strong_gen = Enumerator.new{|y| Prime.each_cons(3){|a,b,c|y << b if a+c-b<b} }

puts "#{strongs} strong primes and #{weaks} weak primes below #{limit}."

end

{{out}}

<pre>First 36 strong primes:

37723 strong primes and 37780 weak primes below 1000000.

320991 strong primes and 321750 weak primes below 10000000.

</pre>

 

=={{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

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}}

 

=={{header|Sidef}}==

 

var (*strong, *weak, *balanced)

say ("Count of #{type} primes <= #{c1.commify}: ", pr.first_index { _ > 1e6 }.commify)

say ("Count of #{type} primes <= #{c2.commify}: " , pr.len.commify)

{{out}}

<pre>

Count of balanced primes <= 1,000,000: 2,994

Count of balanced primes <= 10,000,000: 21,837

</pre>

 

 

[[Extensible prime generator#zkl]] could be used instead.

const N=1e7;

 

}

ps.pop(0); ps.append(pw.nextPrime().toInt());

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>