Strong and weak primes: Difference between revisions

::*   The OEIS article [[oeis:A051635|A051635: weak primes]].

<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 1,000,000: 37,780

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

</pre>

 

=={{header|C}}==

{{trans|D}}

#include <stdint.h>

#include <stdio.h>

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

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

{{works with|C sharp|7}}

using static System.Linq.Enumerable;

using System;

}

{{out}}

<pre>

 

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

#include <locale>

#include "prime_sieve.hpp"

 

public:

explicit prime_info(int max) : max_print(max) {}

private:

int max_print;

int count1 = 0;

int count2 = 0;

};

 

int main() {

weak_primes.print(std::cout, "weak");

return 0;

 

Contents of prime_sieve.hpp:

#define PRIME_SIEVE_HPP

 

}

 

 

{{out}}

<pre>

Number of strong primes below 1,000,000: 37,723

Number of strong primes below 10,000,000: 320,991

Number of weak primes below 1,000,000: 37,780

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

 

=={{header|D}}==

import std.array;

import std.range;

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]

There are 37780 weak primes below 1,000,000

There are 321750 weak primes below 10,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|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 }]

println["Weak primes below 1,000,000: " + length[weakPrimes[1_000_000]]]

println["Weak primes below 10,000,000: " + length[weakPrimes[10_000_000]]]

 

{{out}}

 

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

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

 

printf "Weak primes below 10,000,000: %d\n\n" . length . takeWhile (<10000000) $ weakPrimes

where strongPrimes = xPrimes (>) primes

{{out}}

<pre>

 

=={{header|Java}}==

public class StrongAndWeakPrimes {

 

 

}

{{out}}

<pre>

Number of weak primes below 1,000,000 = 37,780

Number of weak primes below 10,000,000 = 321,750

</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.

=={{header|Kotlin}}==

{{trans|Java}}

private val primes = BooleanArray(MAX)

 

}

}

{{out}}

<pre>First 36 strong primes:

Number of weak primes below 1,000,000 = 37,780

Number of weak primes below 10,000,000 = 321,750</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:

 

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

{{trans|Raku}}

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

 

=={{header|Phix}}==

{{out}}

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

{{works with|Rakudo|2018.11}}

 

 

use Math::Primesieve;

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:

 

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

 

=={{header|Ring}}==

load "stdlib.ring"

 

see "weak primes below 1,000,000: " + primes2 + nl

see "weak primes below 10,000,000: " + primes3 + nl

Output:

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

{{trans|Raku}}

 

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>

 

=={{header|Swift}}==

 

class PrimeSieve {

 

strongPrimes.printInfo(name: "strong")

 

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

var primes = Int.primeSieve(1e7 + 19) // next prime above 10 million

Fmt.print("$d", weak.take(37))

Fmt.print("\nThe count of the weak primes below $,d is $,d.", 1e6, weak.count{ |n| n < 1e6 })

 

{{out}}

 

The count of the weak primes below 10,000,000 is 321,750.

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