Successive prime differences: Difference between revisions

{{trans|D}}

 

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

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

print(‘ Last group = ’sp.last)

print(‘ Number found = ’sp.len)

 

{{out}}

 

=={{header|ALGOL 68}}==

# follow specific patterns #

# reurns a list of primes up to n #

try differences( p list, ( 2, 4, 6, 8 ) );try differences( p list, ( 2, 4, 6, 8, 10 ) );

try differences( p list, ( 32, 16, 8, 4, 2 ) )

{{out}}

<pre>

 

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f SUCCESSIVE_PRIME_DIFFERENCES.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

 

=={{header|C}}==

#include <stdint.h>

#include <stdio.h>

 

return 0;

{{out}}

<pre>differences|count|first group|last group

 

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

using System.Collections.Generic;

using static System.Linq.Enumerable;

 

public static void Main() {

var primes = GeneratePrimes(1_000_000).ToList();

 

IEnumerable<IEnumerable<int>> FindDifferenceGroups(int[] diffs) {

yield return Range(pi - diffs.Length, diffs.Length + 1).Select(i => primes[i]);

}

}

}

{{out}}

<pre>

 

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

#include <cstdint>

#include <vector>

}

return 0;

 

Contents of prime_sieve.hpp:

#define PRIME_SIEVE_HPP

 

}

 

 

{{out}}

=={{header|D}}==

{{trans|Go}}

import std.array;

import std.range;

writeln();

}

{{out}}

<pre>For primes less than 1,000,000:-

{{libheader| System.SysUtils}}

{{libheader| System.Generics.Collections}}

program Successive_prime_differences;

 

end.

 

 

{{out}}

(6, 4, 2): first group = (31,37,41,43), last group = (997141,997147,997151,997153), count = 306

</pre>

 

=={{header|F_Sharp|F#}}==

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

// Successive primes. Nigel Galloway: May 6th., 2019

let sP n=let sP=pCache|>Seq.takeWhile(fun n->n<1000000)|>Seq.windowed(Array.length n+1)|>Seq.filter(fun g->g=(Array.scan(fun n g->n+g) g.[0] n))

printfn "sP %A\t-> Min element = %A Max element = %A of %d elements" n (Seq.head sP) (Seq.last sP) (Seq.length sP)

List.iter sP [[|2|];[|1|];[|2;2|];[|2;4|];[|4;2|];[|6;4;2|]]

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99}}

math.statistics sequences ;

IN: rosetta-code.successive-prime-differences

} [ show ] with each ;

{{out}}

<pre>

Last group: { 997141 997147 997151 997153 }

Count: 306

</pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Println()

}

 

{{out}}

Number found = 306

</pre>

=={{header|Haskell}}==

Uses primes library: http://hackage.haskell.org/package/primes-0.2.1.0/docs/Data-Numbers-Primes.html

===Fixed computed values===

import Data.Numbers.Primes (primes)

 

main :: IO ()

main = showGroup "2" >> showGroup "1" >> showGroup "(2 2)" >> showGroup "(2 4)" >> showGroup "(4 2)"

 

===Dynamic computed input===

import Data.Numbers.Primes (primes)

 

where

(diffs, result) = groups [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]]

{{out}}

<pre>

 

=={{header|J}}==

primes_less_than=: i.&.:(p:inv)

assert 2 3 5 -: primes_less_than 7

 

NB. Insert minus `-/' into the length two infixes `\'.

NB. Passive `~' swaps the arguments producing the positive differences.

 

 

 

 

┌─────┬─────┬───────────────────────────┐

├─────┼─────┼───────────────────────────┤

│2 │8169 │ 3 5 │

│6 4 2│306 │ 31 37 41 43│

│ │ │997141 997147 997151 997153│

 

=={{header|Java}}==

{{trans|Go}}

import java.util.Arrays;

import java.util.List;

}

}

{{out}}

<pre>For primes less than 1,000,000:-

Number found = 306</pre>

 

=={{header|Julia}}==

 

function filterdifferences(deltas, N)

 

filterdifferences([[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]], 1000000)

<pre>

Diff Sequence Count First Last

[6, 4, 2] 306 [31, 37, 41, 43]...[997141, 997147, 997151, 997153]

</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

val primes = mutableListOf<Int>()

primes.add(2)

println()

}

{{out}}

<pre>For primes less than 1,000,000:-

Last group = [997141, 997147, 997151, 997153]

Number found = 306</pre>

 

=={{header|Nim}}==

 

const N = 1_000_000

primes.findGroups(2, 4)

primes.findGroups(4, 2)

 

{{out}}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use List::EachCons;

join(' ', @primes[$offsets[ 0]..($offsets[ 0]+@$diffs)]),

join(' ', @primes[$offsets[-1]..($offsets[-1]+@$diffs)]);

{{out}}

<pre> (2) has 8169 sets: 3 5 … 999959 999961

 

=={{header|Phix}}==

{{out}}

<pre>

{4,2} : 1444 {7,11,13}...{997807,997811,997813}

{6,4,2} : 306 {31,37,41,43}...{997141,997147,997151,997153}

</pre>

 

Uses the [https://www.sympy.org/en/index.html Sympy] library.

 

from sympy import Sieve

 

print(" First group:", str(first)[1:-1])

print(" Last group:", str(last)[1:-1])

 

{{out}}

Essentially the code from the [[Sexy_primes#Raku|Sexy primes]] task with minor tweaks.

 

my $sieve = Math::Primesieve.new;

 

}

say ' Count: ', +$primes{$i}, "\n";

{{out}}

<pre>## Sets of 2 successive primes <= 1,000,000 with successive differences of 2

===Precomputed Differences===

{{works with|Rakudo|2019.03}}

 

constant $max = 1_000_000;

say sprintf '%10s has %5d sets: %15s … %s',

@succ.gist, @group_start_offsets.elems, $first, $last;

{{Out}}

<pre>Given all ordered primes <= 1000000, sets with successive differences of:

 

=={{header|REXX}}==

parse arg H . 1 . difs /*allow the highest number be specified*/

if H=='' | H=="," then H= 1000000 /*Not specified? Then use the default.*/

do m=jj to N by j+j; @.m=; end /*odd multiples.*/

end /* [↑] strike odd multiples ¬ prime. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

count: 306

</pre>

 

=={{header|Ruby}}==

PRIMES = Prime.each(1_000_000).to_a

difs = [[2], [1], [2,2], [2,4], [4,2], [6,4,2]]

puts "#{ar} has #{res.size} sets. #{res.first}...#{res.last}"

end

{{output}}

<pre>[2] has 8169 sets. [3, 5]...[999959, 999961]

[4, 2] has 1444 sets. [7, 11, 13]...[997807, 997811, 997813]

[6, 4, 2] has 306 sets. [31, 37, 41, 43]...[997141, 997147, 997151, 997153]

</pre>

 

=={{header|Scala}}==

def main(args: Array[String]): Unit = {

val d2 = primesByDiffs(2)(1000000)

def primesSliding(len: Int): Iterator[Vector[Int]] = primes.sliding(len).map(_.toVector)

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 primes = limit.primes

 

say ("...for differences #{diffs}, there are #{groups.len} groups, where ",

"the first group = #{groups.first} and the last group = #{groups.last}")

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|Java}}

 

Module Module1

End Sub

 

{{out}}

<pre>For primes less than 1,000,000:-

{{trans|Go}}

{{libheader|Wren-math}}

 

var successivePrimes = Fn.new { |primes, diffs|

System.print(" Number found = %(sp.count)\n")

}

 

{{out}}

Last group = [997141, 997147, 997151, 997153]

Number found = 306

</pre>

 

 

Treat this as a string search problem.

var [const] BI=Import("zklBigNum"); // libGMP

var [const] primeBitMap=Data(PRIME_LIMIT).fill(0x30); // one big string

while(n=primeBitMap.find(sp,n+1)){ r.append(n) } // (31, 61, 271,...)

r.apply('wrap(n){ T(n).extend(ds.apply('+(n))) }) //( (31,37,41,43), (61,67,71,73), (271,277,281,283) ...)

r:=primeWindows(PRIME_LIMIT,w);

println("Successive primes (<=%,d) with deltas of %s (%,d groups):"

println(" First group: %s; Last group: %s\n"

.fmt(r[0].concat(", "),r[-1].concat(", ")));

{{out}}

<pre>