Strong and weak primes: Difference between revisions

 

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

V is_prime = [0B] * 2 [+] [1B] * (limit - 1)

L(n) 0 .< Int(limit ^ 0.5 + 1.5)

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

 

{{out}}

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

</pre>

=={{header|AWK}}==

# syntax: GAWK -f STRONG_AND_WEAK_PRIMES.AWK

BEGIN {

return(1)

}

{{out}}

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

#include <iterator>

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

return 0;

 

Contents of prime_sieve.hpp:

#define PRIME_SIEVE_HPP

 

}

 

 

{{out}}

 

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

 

=={{header|FreeBASIC}}==

#include "isprime.bas"

 

wend

print "There are ";c;" weak primes below ten million"

{{out}}<pre>

The first 36 strong primes are:

 

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

 

=={{header|Ksh}}==

#!/bin/ksh

 

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}

{{out}}<pre>

Total primes under 10000000 = 664579

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

 

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

p = Prime[Range[PrimePi[10^7] + 1]];

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}

 

=={{header|Nim}}==

 

const

echo " ", weakPrimes[0..36].join(" ")

echo "Count of weak primes below 1_000_000: ", weakPrimes.count(1_000_000)

 

{{out}}

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>

 

=={{header|PureBasic}}==

Global Dim P.b(#MAX) : FillMemory(@P(),#MAX,1,#PB_Byte)

Global NewList Primes.i()

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,".","'"))

{{out}}

<pre>First 36 strong primes:

 

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:

 

=={{header|Rust}}==

for i in 2..n {

if i * i > n {

}

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

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

 

=={{header|XPL0}}==

int Num, Dig, Cnt;

[Cnt:= [0];

NumOut(WeakCnt);

CrLf(0);

 

{{out}}

 

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