View source for Successive prime differences

{{task|Prime Numbers}}
The series of increasing prime numbers begins: <code>2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...</code>

The task applies a filter to the series returning groups of ''successive'' primes, (s'primes),  that differ from the next by a given value or values.

'''Example 1:''' Specifying that the difference between s'primes be <code>2</code> leads to the groups: 
:<code>(3, 5), (5, 7), (11, 13), (17, 19), (29, 31), ...</code> <br>
(Known as [[wp:Twin prime|Twin primes]] or [https://oeis.org/A077800 Prime pairs])

'''Example 2:''' Specifying more than one difference ''between'' s'primes leads to groups of size one greater than the number of differences. Differences of <code>2, 4</code> leads to the groups: 
:<code>(5, 7, 11), (11, 13, 17), (17, 19, 23), (41, 43, 47), ...</code>. <br>
In the first group 7 is two more than 5 and 11 is four more than 7; as well as 5, 7, and 11 being ''successive'' primes. 
Differences are checked in the order of the values given, (differences of <code>4, 2</code> would give different groups entirely).

;Task:
* In each case use a list of primes less than 1_000_000
* For the following Differences show the first and last group, as well as the number of groups found:
:# Differences of <code>2</code>.
:# Differences of <code>1</code>.
:# Differences of <code>2, 2</code>.
:# Differences of <code>2, 4</code>.
:# Differences of <code>4, 2</code>.
:# Differences of <code>6, 4, 2</code>.
* Show output here.

<br>Note: Generation of a list of primes is a secondary aspect of the task. Use of a built in function, well known library, or importing/use of prime generators from other [[Sieve of Eratosthenes|Rosetta Code tasks]] is encouraged.

;references
:#https://pdfs.semanticscholar.org/78a1/7349819304863ae061df88dbcb26b4908f03.pdf
:#https://www.primepuzzles.net/puzzles/puzz_011.htm
:#https://matheplanet.de/matheplanet/nuke/html/viewtopic.php?topic=232720&start=0

=={{header|11l}}==
{{trans|D}}

<syntaxhighlight lang="11l">F primes_upto(limit)
   V is_prime = [0B] * 2 [+] [1B] * (limit - 1)
   L(n) 0 .< Int(limit ^ 0.5 + 1.5)
      I is_prime[n]
         L(i) (n * n .< limit + 1).step(n)
            is_prime[i] = 0B
   R enumerate(is_prime).filter((i, prime) -> prime).map((i, prime) -> i)

F successive_primes(primes, diffs)
   [[Int]] results
   V dl = diffs.len

   L(i) 0 .< primes.len - dl
      V group = [0] * (dl + 1)
      group[0] = primes[i]
      L(j) i .+ dl
         I primes[j + 1] - primes[j] != diffs[j - i]
            L.break
         group[j - i + 1] = primes[j + 1]
      L.was_no_break
         results [+]= group

   R results

V prime_list = primes_upto(1'000'000)

print(‘For primes less than 1,000,000:-’)
L(diffs) [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]]
   print(‘  For differences of #. ->’.format(diffs))
   V sp = successive_primes(prime_list, diffs)
   print(‘    First group   = ’sp[0])
   print(‘    Last group    = ’sp.last)
   print(‘    Number found  = ’sp.len)
   print()</syntaxhighlight>

{{out}}
<pre>
For primes less than 1,000,000:-
  For differences of [2] ->
    First group   = [3, 5]
    Last group    = [999959, 999961]
    Number found  = 8169

  For differences of [1] ->
    First group   = [2, 3]
    Last group    = [2, 3]
    Number found  = 1

  For differences of [2, 2] ->
    First group   = [3, 5, 7]
    Last group    = [3, 5, 7]
    Number found  = 1

  For differences of [2, 4] ->
    First group   = [5, 7, 11]
    Last group    = [999431, 999433, 999437]
    Number found  = 1393

  For differences of [4, 2] ->
    First group   = [7, 11, 13]
    Last group    = [997807, 997811, 997813]
    Number found  = 1444

  For differences of [6, 4, 2] ->
    First group   = [31, 37, 41, 43]
    Last group    = [997141, 997147, 997151, 997153]
    Number found  = 306

</pre>

=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN # find some sequences of primes where the gaps between the elements #
      # follow specific patterns                                          #
    # reurns a list of primes up to n #
    PROC prime list = ( INT n )[]INT:
         BEGIN
            # sieve the primes to n #
            INT no = 0, yes = 1;
            [ 1 : n ]INT p;
            p[ 1 ] := no; p[ 2 ] := yes;
            FOR i FROM 3 BY 2 TO n DO p[ i ] := yes OD;
            FOR i FROM 4 BY 2 TO n DO p[ i ] := no  OD;
            FOR i FROM 3 BY 2 TO ENTIER sqrt( n ) DO
                IF p[ i ] = yes THEN FOR s FROM i * i BY i + i TO n DO p[ s ] := no OD FI
            OD;
            # replace the sieve with a list #
            INT p pos := 0;
            FOR i TO n DO IF p[ i ] = yes THEN p[ p pos +:= 1 ] := i FI OD;
            p[ 1 : p pos ]
         END # prime list # ;
    # prints the elements of list #
    PROC print list = ( STRING name, []INT list )VOID:
         BEGIN
            print( ( name, "[" ) );
            FOR i FROM LWB list TO UPB list DO print( ( " ", whole( list[ i ], 0 ) ) ) OD;
            print( ( " ]" ) )
         END # print list # ;
    # attempts to find patterns in the differences of primes and prints the results #
    PROC try differences = ( []INT primes, []INT pattern )VOID:
         BEGIN
            INT    pattern length = ( UPB pattern - LWB pattern ) + 1;
            [ 1 :  pattern length + 1 ]INT first; FOR i TO UPB first DO first[ i ] := 0 OD;
            [ 1 :  pattern length + 1 ]INT last;  FOR i TO UPB last  DO last[  i ] := 0 OD;
            INT    count := 0;
            FOR p FROM LWB primes + pattern length TO UPB primes DO
                BOOL matched := TRUE;
                INT e pos    := LWB pattern;
                FOR e FROM p - pattern length TO p - 1
                WHILE matched := primes[ e + 1 ] - primes[ e ] = pattern[ e pos ]
                DO
                    e pos +:= 1
                OD;
                IF matched THEN
                    # found a matching sequence #
                    count +:= 1;
                    last   := primes[ p - pattern length : p @ 1 ];
                    IF count = 1 THEN first := last FI
                FI
            OD;
            print( ( "  Found ", whole( count, 0 ), " prime sequence(s) that differ by: " ) );
            print list( "", pattern );
            print( ( newline ) );
            IF count > 0 THEN
                # found at least one sequence #
                print list( "    first: ", first );
                print list( "    last: ",  last  );
                print( ( newline ) )
            FI;
            print( ( newline ) )
         END # try differences # ;
    INT max number = 1 000 000;
    []INT    p list = prime list( max number );
    print( ( "For primes up to ", whole( max number, 0 ), "...", newline ) );
    try differences( p list, ( 2 )               );try differences( p list, ( 1 )               );
    try differences( p list, ( 2, 2 )            );try differences( p list, ( 2, 4 )            );
    try differences( p list, ( 4, 2 )            );try differences( p list, ( 6, 4, 2 )         );
    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 ) )
END</syntaxhighlight>
{{out}}
<pre>
For primes up to 1000000...
  Found 8169 prime sequence(s) that differ by: [ 2 ]
    first: [ 3 5 ]    last: [ 999959 999961 ]

  Found 1 prime sequence(s) that differ by: [ 1 ]
    first: [ 2 3 ]    last: [ 2 3 ]

  Found 1 prime sequence(s) that differ by: [ 2 2 ]
    first: [ 3 5 7 ]    last: [ 3 5 7 ]

  Found 1393 prime sequence(s) that differ by: [ 2 4 ]
    first: [ 5 7 11 ]    last: [ 999431 999433 999437 ]

  Found 1444 prime sequence(s) that differ by: [ 4 2 ]
    first: [ 7 11 13 ]    last: [ 997807 997811 997813 ]

  Found 306 prime sequence(s) that differ by: [ 6 4 2 ]
    first: [ 31 37 41 43 ]    last: [ 997141 997147 997151 997153 ]

  Found 68 prime sequence(s) that differ by: [ 2 4 6 8 ]
    first: [ 347 349 353 359 367 ]    last: [ 984911 984913 984917 984923 984931 ]

  Found 11 prime sequence(s) that differ by: [ 2 4 6 8 10 ]
    first: [ 13901 13903 13907 13913 13921 13931 ]    last: [ 954257 954259 954263 954269 954277 954287 ]

  Found 1 prime sequence(s) that differ by: [ 32 16 8 4 2 ]
    first: [ 148091 148123 148139 148147 148151 148153 ]    last: [ 148091 148123 148139 148147 148151 148153 ]

</pre>


=={{header|Amazing Hopper}}==
<syntaxhighlight lang="c">

#proto buscarprimos(_X_,_Y_)

#include <basico.h>

algoritmo

     pila de trabajo 50
     decimales '0'
     
     números( dif 1, dif 2, dif 22, dif 24, dif 42, dif 642)
     cadenas( inicio1, inicio2, inicio22, inicio24, inicio42, inicio642,\
              final1, final2, final22, final24, final42, final642 )
     
     sw1=1, sw2=1, sw22=1, sw24=1, sw42=1, sw642=1
     
     i=2
     iterar
         i, es primo?, entonces {
             i2 = i, i4=i, i6=i
             
             ++i2; i2, es primo?, entonces{
                  ++dif 1
                  sw1, entonces{
                      #( string(i)),#(string(i2)), unir en 'inicio1'
                      sw1=0
                  }
                  #( string(i)),#(string(i2)), unir en 'final1'
             }
             ++i2; i2, es primo?, entonces{
                  ++dif 2
                  sw2, entonces{
                      #( string(i)),#(string(i2)), unir en 'inicio2'
                      sw2=0
                  }
                  #( string(i)),#(string(i2)), unir en 'final2'

                  i2+=2; i2, es primo?, entonces{
                       ++dif 22
                       sw22, entonces{
                           #( string(i)),#(string(i2-2)),#(string(i2))
                           unir en 'inicio22'
                           sw22=0
                       }
                       #( string(i)),#(string(i2-2)),#(string(i2))
                       unir en 'final22'
                  }
                  i2+=2; i2, es primo?, entonces{
                       ++dif 24
                       sw24, entonces{
                           #( string(i)),#(string(i2-4)),#(string(i2))
                           unir en 'inicio24'
                           sw24=0
                       }
                       #( string(i)),#(string(i2-4)),#(string(i2))
                       unir en 'final24'
                  }
             }
             i4+=4, i4, es primo?, entonces{
                  i4+=2, i4, es primo?, entonces{
                       ++dif 42
                       sw42, entonces{
                           #( string(i)),#(string(i4-2)),#(string(i4))
                           unir en 'inicio42'
                           sw42=0
                       }
                       #( string(i)),#(string(i4-2)),#(string(i4))
                       unir en 'final42'
                  }
             }
             /* aquí, debido al espaciamiento, pueden haber primos entre 'i'
                e 'i+12', y debo chequear eso */
             i6+=6, i6, es primo?, entonces{
                  i6+=4, i6, es primo?, entonces{
                      i6+=2, i6, es primo?, entonces{
                          si '#(buscar primos( (i+1),(i6-6) ) && buscar primos( (i6-5),i6-2))'
                              sw642, entonces{
                                  #( string(i)),#(string(i6-6)),#(string(i6-2)),#(string(i6))
                                  unir en 'inicio642'
                                  sw642=0
                              }
                              ++dif 642
                          fin si

                          #( string(i)),#(string(i6-6)),#(string(i6-2)),#(string(i6))
                          unir en 'final642'
                      }
                  }
             }
         }
         ++i
     hasta que '#(i == 1000000)'
     imprimir( "Diff Sequence\tCount\t\tFirst\tLast\n")
     imprimir( "[ 1 ]    \t", dif 1, "\t", #(lpad(" ",13,inicio1)),"   ",final1,\
             "\n[ 2 ]    \t", dif 2, "\t", #(lpad(" ",13,inicio2)),"   ",final2,\
             "\n[ 2-2 ]  \t", dif22, "\t", #(lpad(" ",13,inicio22)),"   ",final22,\
             "\n[ 2-4 ]  \t", dif 24,"\t", #(lpad(" ",13,inicio24)),"   ",final24,\
             "\n[ 4-2 ]  \t", dif 42,"\t", #(lpad(" ",13,inicio42)),"   ",final42,\
             "\n[ 6-4-2 ]\t", dif 642,"\t", #(lpad(" ",13,inicio642)),"   ",final642,"\n")

terminar

subrutinas

buscar primos(x,y)
    sw=1
    iterar para( i=x, #(sw && i<y), ++i )
         i, es primo?, entonces{
              sw=0
         }
    siguiente
retornar 'sw'
</syntaxhighlight>
{{out}}
<pre>
Diff Sequence	Count		First	Last
[ 1 ]    	    1	          2,3   2,3
[ 2 ]    	    8169          3,5   999959,999961
[ 2-2 ]  	    1           3,5,7   3,5,7
[ 2-4 ]  	    1393       5,7,11   999431,999433,999437
[ 4-2 ]  	    1444      7,11,13   997807,997811,997813
[ 6-4-2 ]	    306	  31,37,41,43   997141,997147,997151,997153

</pre>

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">LIM: 1000000

findDiffs: function [r][
    if r=[1] -> return [[2 3]]
    i: 3
    tupled: map 0..dec size r 'x -> fold slice r 0 x [a b][a+b]
    diffs: new []
    while [i < LIM][
        if prime? i [
            prset: map tupled 't -> i + t
            if every? prset 'elem -> prime? elem [
                'diffs ++ @[@[i] ++ prset]
            ]
        ]
        i: i + 2
    ]

    diffs: filter diffs 'dd [
        some? range (first dd)+1 (last dd)-1 'x -> and? [prime? x][not? contains? dd x]
    ]
    return diffs
]

loop [[2] [1] [2 2] [2 4] [4 2] [6 4 2]] 'rng [
    print ["Differences of" join.with:", " to [:string] rng]
    diffs: findDiffs rng
    print ["\tFirst: " join.with:" " to [:string] first diffs]
    print ["\tLast: " join.with:" " to [:string] last diffs]
    print ["\tCount: " size diffs]
]</syntaxhighlight>

{{out}}

<pre>Differences of 2 
	First:  3 5 
	Last:  999959 999961 
	Count:  8169 
Differences of 1 
	First:  2 3 
	Last:  2 3 
	Count:  1 
Differences of 2, 2 
	First:  3 5 7 
	Last:  3 5 7 
	Count:  1 
Differences of 2, 4 
	First:  5 7 11 
	Last:  999431 999433 999437 
	Count:  1393 
Differences of 4, 2 
	First:  7 11 13 
	Last:  997807 997811 997813 
	Count:  1444 
Differences of 6, 4, 2 
	First:  31 37 41 43 
	Last:  997141 997147 997151 997153 
	Count:  306</pre>

=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f SUCCESSIVE_PRIME_DIFFERENCES.AWK
BEGIN {
    for (i=lo=0; i<=hi=1000000; i++) {
      if (is_prime(i)) {
        p_arr[++p] = i
      }
    }
    printf("there are %d primes between %d - %d\n",p,lo,hi)
    fmt = "%-11s %5s %-15s %s\n"
    printf(fmt,"differences","count","first group","last group")
    for (a=1; a<=split("2;1;2,2;2,4;4,2;6,4,2;2,4,6;100;112",diff_arr,";"); a++) {
      diff_leng = split(diff_arr[a],tmp_arr,",")
      first_set = last_set = ""
      count = 0
      for (b=1; b<=p; b++) {
        str = ""
        for (c=1; c<=diff_leng; c++) {
          if (p_arr[b+c-1] + tmp_arr[c] == p_arr[b+c]) {
            str = (str == "") ? (p_arr[b+c-1] "," p_arr[b+c]) : (str "," p_arr[b+c])
          }
        }
        if (gsub(/,/,"&",str) == diff_leng) {
          count++
          if (first_set == "") {
            first_set = str
          }
          last_set = str
        }
      }
      printf(fmt,diff_arr[a],count,first_set,last_set)
    }
    exit(0)
}
function is_prime(x,  i) {
    if (x <= 1) {
      return(0)
    }
    for (i=2; i<=int(sqrt(x)); i++) {
      if (x % i == 0) {
        return(0)
      }
    }
    return(1)
}
</syntaxhighlight>
{{out}}
<pre>
there are 78498 primes between 0 - 1000000
differences count first group     last group
2            8169 3,5             999959,999961
1               1 2,3             2,3
2,2             1 3,5,7           3,5,7
2,4          1393 5,7,11          999431,999433,999437
4,2          1444 7,11,13         997807,997811,997813
6,4,2         306 31,37,41,43     997141,997147,997151,997153
2,4,6         279 17,19,23,29     997097,997099,997103,997109
100             2 396733,396833   838249,838349
112             1 370261,370373   370261,370373
</pre>

=={{header|C}}==
<syntaxhighlight lang="c">#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

#define PRIME_COUNT 100000
int64_t PRIMES[PRIME_COUNT];
size_t primeSize = 0;

bool isPrime(int n) {
    size_t i = 0;

    for (i = 0; i < primeSize; i++) {
        int64_t p = PRIMES[i];
        if (n == p) {
            return true;
        }
        if (n % p == 0) {
            return false;
        }
        if (p * p > n) {
            break;
        }
    }

    return true;
}

void initialize() {
    int i;

    PRIMES[primeSize++] = 2;
    PRIMES[primeSize++] = 3;
    PRIMES[primeSize++] = 5;
    PRIMES[primeSize++] = 7;
    PRIMES[primeSize++] = 11;
    PRIMES[primeSize++] = 13;
    PRIMES[primeSize++] = 17;
    PRIMES[primeSize++] = 19;

    for (i = 21; primeSize < PRIME_COUNT;) {
        if (isPrime(i)) {
            PRIMES[primeSize++] = i;
        }
        i += 2;

        if (primeSize < PRIME_COUNT && isPrime(i)) {
            PRIMES[primeSize++] = i;
        }
        i += 2;
    }
}

void diff1(size_t diff) {
    int64_t pm0, pm1;
    int64_t fg1 = 0, fg2 = 0, lg1 = 0, lg2 = 0;
    size_t pos, count = 0;

    if (diff == 0) {
        return;
    }

    pm0 = PRIMES[0];
    for (pos = 1; pos < PRIME_COUNT; pos++) {
        pm1 = pm0;
        pm0 = PRIMES[pos];
        if (pm0 > 1000000) {
            break;
        }
        if (pm0 - pm1 == diff) {
            count++;
            if (fg1 == 0) {
                fg1 = pm1;
                fg2 = pm0;
            }
            lg1 = pm1;
            lg2 = pm0;
        }
    }

    printf("%ld|%d|%lld %lld|%lld %lld|\n", diff, count, fg1, fg2, lg1, lg2);
}

void diff2(size_t d0, size_t d1) {
    int64_t pm0, pm1, pm2;
    int64_t fg1 = 0, fg2, fg3, lg1, lg2, lg3;
    size_t pos, count = 0;

    if (d0 == 0 || d1 == 0) {
        return;
    }

    pm1 = PRIMES[0];
    pm0 = PRIMES[1];
    for (pos = 2; pos < PRIME_COUNT; pos++) {
        pm2 = pm1;
        pm1 = pm0;
        pm0 = PRIMES[pos];
        if (pm0 > 1000000) {
            break;
        }
        if (pm1 - pm2 == d0 && pm0 - pm1 == d1) {
            count++;
            if (fg1 == 0) {
                fg1 = pm2;
                fg2 = pm1;
                fg3 = pm0;
            }
            lg1 = pm2;
            lg2 = pm1;
            lg3 = pm0;
        }
    }

    printf("%d %d|%d|%lld %lld %lld|%lld %lld %lld|\n", d0, d1, count, fg1, fg2, fg3, lg1, lg2, lg3);
}

void diff3(size_t d0, size_t d1, size_t d2) {
    int64_t pm0, pm1, pm2, pm3;
    int64_t fg1 = 0, fg2, fg3, fg4, lg1, lg2, lg3, lg4;
    size_t pos, count = 0;

    if (d0 == 0 || d1 == 0 || d2 == 0) {
        return;
    }

    pm2 = PRIMES[0];
    pm1 = PRIMES[1];
    pm0 = PRIMES[2];
    for (pos = 3; pos < PRIME_COUNT; pos++) {
        pm3 = pm2;
        pm2 = pm1;
        pm1 = pm0;
        pm0 = PRIMES[pos];
        if (pm0 > 1000000) {
            break;
        }
        if (pm2 - pm3 == d0 && pm1 - pm2 == d1 && pm0 - pm1 == d2) {
            count++;
            if (fg1 == 0) {
                fg1 = pm3;
                fg2 = pm2;
                fg3 = pm1;
                fg4 = pm0;
            }
            lg1 = pm3;
            lg2 = pm2;
            lg3 = pm1;
            lg4 = pm0;
        }
    }

    printf("%d %d %d|%d|%lld %lld %lld %lld|%lld %lld %lld %lld|\n", d0, d1, d2, count, fg1, fg2, fg3, fg4, lg1, lg2, lg3, lg4);
}

int main() {
    initialize();

    printf("differences|count|first group|last group\n");

    diff1(2);
    diff1(1);

    diff2(2, 2);
    diff2(2, 4);
    diff2(4, 2);

    diff3(6, 4, 2);

    return 0;
}</syntaxhighlight>
{{out}}
<pre>differences|count|first group|last group
2|8169|3 5|999959 999961|
1|1|2 3|2 3|
2 2|1|3 5 7|3 5 7|
2 4|1393|5 7 11|999431 999433 999437|
4 2|1444|7 11 13|997807 997811 997813|
6 4 2|306|31 37 41 43|997141 997147 997151 997153|</pre>

=={{header|C sharp}}==
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using static System.Linq.Enumerable;

public static class SuccessivePrimeDifferences {

    public static void Main() {
        var primes = GeneratePrimes(1_000_000).ToList();
        foreach (var d in new[] {
            new [] { 2 },
            new [] { 1 },
            new [] { 2, 2 },
            new [] { 2, 4 },
            new [] { 4, 2 },
            new [] { 6, 4, 2 },
        }) {
            IEnumerable<int> first = null, last = null;
            int count = 0;
            foreach (var grp in FindDifferenceGroups(d)) {
                if (first == null) first = grp;
                last = grp;
                count++;
            }
            Console.WriteLine($"{$"({string.Join(", ", first)})"}, {$"({string.Join(", ", last)})"}, {count}");
        }

        IEnumerable<IEnumerable<int>> FindDifferenceGroups(int[] diffs) {
            for (int pi = diffs.Length; pi < primes.Count; pi++)
                if (Range(0, diffs.Length).All(di => primes[pi-diffs.Length+di+1] - primes[pi-diffs.Length+di] == diffs[di]))
                    yield return Range(pi - diffs.Length, diffs.Length + 1).Select(i => primes[i]);
        }

        IEnumerable<int> GeneratePrimes(int lmt) {
            bool[] comps = new bool[lmt + 1];
            comps[0] = comps[1] = true;
            yield return 2; yield return 3;
            for (int j = 4; j <= lmt; j += 2) comps[j] = true;
            for (int j = 9; j <= lmt; j += 6) comps[j] = true;
            int i = 5, d = 4, rt = (int)Math.Sqrt(lmt);
            for ( ; i <= rt; i += (d = 6 - d))
                if (!comps[i]) {
                    yield return i;
                    for (int j = i * i, k = i << 1; j <= lmt; j += k)
                        comps[j] = true;
                }
            for ( ; i <= lmt; i += (d = 6 - d)) if (!comps[i]) yield return i;
        }
    }
}</syntaxhighlight>
{{out}}
<pre>
(3, 5), (999959, 999961), 8169
(2, 3), (2, 3), 1
(3, 5, 7), (3, 5, 7), 1
(5, 7, 11), (999431, 999433, 999437), 1393
(7, 11, 13), (997807, 997811, 997813), 1444
(31, 37, 41, 43), (997141, 997147, 997151, 997153), 306
</pre>

=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iostream>
#include <cstdint>
#include <vector>
#include "prime_sieve.hpp"

using integer = uint32_t;
using vector = std::vector<integer>;

void print_vector(const vector& vec) {
    if (!vec.empty()) {
        auto i = vec.begin();
        std::cout << '(' << *i;
        for (++i; i != vec.end(); ++i)
            std::cout << ", " << *i;
        std::cout << ')';
    }
}

class diffs {
public:
    diffs(std::initializer_list<integer> list) : diffs_(list) {}
    diffs(const vector& vec) : diffs_(vec) {}
    void test_group(const vector&);
    size_t size() const {
        return diffs_.size();
    }
    void print(std::ostream&);
private:
    vector diffs_;
    vector first_;
    vector last_;
    integer count_ = 0;
};

void diffs::test_group(const vector& vec) {
    if (vec.size() < size() + 1)
        return;
    size_t start = vec.size() - size() - 1;
    for (size_t i = 0, j = start + 1; i < size(); ++i, ++j) {
        if (vec[j] - vec[j - 1] != diffs_[i])
            return;
    }
    vector group(vec.begin() + start, vec.end());
    if (count_ == 0)
        first_ = group;
    last_ = group;
    ++count_;
}

void diffs::print(std::ostream& out) {
    print_vector(diffs_);
    out << ": first group = ";
    print_vector(first_);
    out << ", last group = ";
    print_vector(last_);
    out << ", count = " << count_ << '\n';
}

int main() {
    const integer limit = 1000000;
    const size_t max_group_size = 4;
    prime_sieve sieve(limit);
    diffs d[] = { {2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2} };
    vector group;
    for (integer p = 0; p < limit; ++p) {
        if (!sieve.is_prime(p))
            continue;
        if (group.size() >= max_group_size)
            group.erase(group.begin());
        group.push_back(p);
        for (auto&& diff : d) {
            diff.test_group(group);
        }
    }
    for (auto&& diff : d) {
        diff.print(std::cout);
    }
    return 0;
}</syntaxhighlight>

Contents of prime_sieve.hpp:
<syntaxhighlight lang="cpp">#ifndef PRIME_SIEVE_HPP
#define PRIME_SIEVE_HPP

#include <algorithm>
#include <vector>

/**
 * A simple implementation of the Sieve of Eratosthenes.
 * See https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes.
 */
class prime_sieve {
public:
    explicit prime_sieve(size_t);
    bool is_prime(size_t) const;
private:
    std::vector<bool> is_prime_;
};

/**
 * Constructs a sieve with the given limit.
 *
 * @param limit the maximum integer that can be tested for primality
 */
inline prime_sieve::prime_sieve(size_t limit) {
    limit = std::max(size_t(3), limit);
    is_prime_.resize(limit/2, true);
    for (size_t p = 3; p * p <= limit; p += 2) {
        if (is_prime_[p/2 - 1]) {
            size_t inc = 2 * p;
            for (size_t q = p * p; q <= limit; q += inc)
                is_prime_[q/2 - 1] = false;
        }
    }
}

/**
 * Returns true if the given integer is a prime number. The integer
 * must be less than or equal to the limit passed to the constructor.
 *
 * @param n an integer less than or equal to the limit passed to the
 * constructor
 * @return true if the integer is prime
 */
inline bool prime_sieve::is_prime(size_t n) const {
    if (n == 2)
        return true;
    if (n < 2 || n % 2 == 0)
        return false;
    return is_prime_.at(n/2 - 1);
}

#endif</syntaxhighlight>

{{out}}
<pre>
(2): first group = (3, 5), last group = (999959, 999961), count = 8169
(1): first group = (2, 3), last group = (2, 3), count = 1
(2, 2): first group = (3, 5, 7), last group = (3, 5, 7), count = 1
(2, 4): first group = (5, 7, 11), last group = (999431, 999433, 999437), count = 1393
(4, 2): first group = (7, 11, 13), last group = (997807, 997811, 997813), count = 1444
(6, 4, 2): first group = (31, 37, 41, 43), last group = (997141, 997147, 997151, 997153), count = 306
</pre>

=={{header|D}}==
{{trans|Go}}
<syntaxhighlight lang="d">import std.algorithm;
import std.array;
import std.range;
import std.stdio;

immutable PRIMES = [
    2, 3, 5, 7,
    11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
    101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
    307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523,
    541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769,
    773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997,
    1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217,
    1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
    1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663,
    1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907,
    1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141,
    2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383,
    2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659,
    2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861,
    2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163,
    3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391,
    3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637,
    3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907,
    3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153,
    4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423,
    4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679,
    4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967,
    4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231,
    5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501,
    5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749,
    5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043,
    6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299,
    6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571,
    6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841,
    6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121,
    7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451,
    7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681,
    7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951,
    7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263,
    8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563,
    8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819,
    8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103,
    9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377,
    9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643,
    9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907,
    9923, 9929, 9931, 9941, 9949, 9967, 9973,
];

bool isPrime(int n) {
    if (n < 2) {
        return false;
    }

    foreach (prime; PRIMES) {
        if (n == prime) {
            return true;
        }
        if (n % prime == 0) {
            return false;
        }
        if (n < prime * prime) {
            if (n > PRIMES[$-1] * PRIMES[$-1]) {
                assert(false, "Out of pre-computed primes.");
            }
            break;
        }
    }

    return true;
}

int[][] successivePrimes(int[] primes, int[] diffs) {
    int[][] results;
    auto dl = diffs.length;

    outer:
    for (int i = 0; i < primes.length - dl; i++) {
        auto group = uninitializedArray!(int[])(dl + 1);
        group[0] = primes[i];
        for (int j = i; j < i + dl; j++) {
            if (primes[j + 1] - primes[j] != diffs[j - i]) {
                continue outer;
            }
            group[j - i + 1] = primes[j + 1];
        }
        results ~= group;
    }

    return results;
}

void main() {
    auto primeList = iota(2, 1_000_000).filter!isPrime.array;
    auto diffsList = [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]];
    writeln("For primes less than 1,000,000:-");
    foreach (diffs; diffsList) {
        writefln("  For differences of %s ->", diffs);
        auto sp = successivePrimes(primeList, diffs);
        if (sp.length == 0) {
            writeln("    No groups found");
            continue;
        }
        writeln("    First group   = ", sp[0]);
        writeln("    Last group    = ", sp[$ - 1]);
        writeln("    Number found  = ", sp.length);
        writeln();
    }
}</syntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-
  For differences of [2] ->
    First group   = [3, 5]
    Last group    = [999959, 999961]
    Number found  = 8169

  For differences of [1] ->
    First group   = [2, 3]
    Last group    = [2, 3]
    Number found  = 1

  For differences of [2, 2] ->
    First group   = [3, 5, 7]
    Last group    = [3, 5, 7]
    Number found  = 1

  For differences of [2, 4] ->
    First group   = [5, 7, 11]
    Last group    = [999431, 999433, 999437]
    Number found  = 1393

  For differences of [4, 2] ->
    First group   = [7, 11, 13]
    Last group    = [997807, 997811, 997813]
    Number found  = 1444

  For differences of [6, 4, 2] ->
    First group   = [31, 37, 41, 43]
    Last group    = [997141, 997147, 997151, 997153]
    Number found  = 306</pre>

=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Generics.Collections}}
<syntaxhighlight lang="delphi">
program Successive_prime_differences;


{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Generics.Collections;

function IsPrime(a: UInt64): Boolean;
var
  d: UInt64;
begin
  if (a < 2) then
    exit(False);

  if (a mod 2) = 0 then
    exit(a = 2);

  if (a mod 3) = 0 then
    exit(a = 3);

  d := 5;

  while (d * d <= a) do
  begin
    if (a mod d = 0) then
      Exit(false);
    inc(d, 2);

    if (a mod d = 0) then
      Exit(false);
    inc(d, 4);
  end;

  Result := True;
end;

function Primes(const limit: UInt64): TArray<UInt64>;
var
  i: UInt64;

  procedure Add(const value: UInt64);
  begin
    SetLength(result, Length(result) + 1);
    Result[Length(result) - 1] := value;
  end;

begin
  if limit < 2 then
    exit;

  // 2 is the only even prime
  Add(2);

  i := 3;
  while i <= limit do
  begin
    if IsPrime(i) then
      Add(i);
    inc(i, 2);
  end;
end;

function Commatize(const n: UInt64): string;
var
  str: string;
  digits: Integer;
  i: Integer;
begin
  Result := '';
  str := n.ToString;
  digits := str.Length;

  for i := 1 to digits do
  begin
    if ((i > 1) and (((i - 1) mod 3) = (digits mod 3))) then
      Result := Result + ',';
    Result := Result + str[i];
  end;
end;

function CheckScan(index: Integer; p: TArray<UInt64>; pattern: array of Integer): Boolean;
var
  i, last: Integer;
begin
  last := Length(pattern) - 1;
  for i := 0 to last do
    if p[index - last + i - 1] + pattern[i] <> p[index - last + i] then
      exit(False);
  Result := True;
end;

const
  GroupLabel: array[1..6] of string = ('(2)', '(1)', '(2, 2)', '(2, 4)',
    '(4, 2)', '(6, 4, 2)');

var
  limit, start: UInt64;
  c: TArray<UInt64>;
  i, j: UInt64;
  Group: array[1..6] of Tlist<string>;

begin
  for i := 1 to 6 do
    Group[i] := Tlist<string>.Create;

  limit := Trunc(1e6 - 1);
  c := Primes(limit);

  for j := 1 to High(c) do
  begin
    if CheckScan(j, c, [2]) then
      Group[1].Add(format('(%d,%d)', [c[j - 1], c[j]]));

    if CheckScan(j, c, [1]) then
      Group[2].Add(format('(%d,%d)', [c[j - 1], c[j]]));

    if j > 1 then
    begin
      if CheckScan(j, c, [2, 2]) then
        Group[3].Add(format('(%d,%d,%d)', [c[j - 2], c[j - 1], c[j]]));

      if CheckScan(j, c, [2, 4]) then
        Group[4].Add(format('(%d,%d,%d)', [c[j - 2], c[j - 1], c[j]]));

      if CheckScan(j, c, [4, 2]) then
        Group[5].Add(format('(%d,%d,%d)', [c[j - 2], c[j - 1], c[j]]));
    end;

    if j > 2 then
      if CheckScan(j, c, [6, 4, 2]) then
        Group[6].Add(format('(%d,%d,%d,%d)', [c[j - 3], c[j - 2], c[j - 1], c[j]]));

  end;

  for i := 1 to 6 do
  begin
    Write(GroupLabel[i], ': first group = ', Group[i].First);
    Writeln(', last group = ', Group[i].last, ', count = ', Group[i].Count);
    Group[i].free;
  end;

  readln;
end.

</syntaxhighlight>

{{out}}
<pre>
(2): first group = (3,5), last group = (999959,999961), count = 8169
(1): first group = (2,3), last group = (2,3), count = 1
(2, 2): first group = (3,5,7), last group = (3,5,7), count = 1
(2, 4): first group = (5,7,11), last group = (999431,999433,999437), count = 1393
(4, 2): first group = (7,11,13), last group = (997807,997811,997813), count = 1444
(6, 4, 2): first group = (31,37,41,43), last group = (997141,997147,997151,997153), count = 306
</pre>

=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight>
fastfunc isprim num .
   i = 2
   while i <= sqrt num
      if num mod i = 0
         return 0
      .
      i += 1
   .
   return 1
.
func nextprime n .
   n += 1
   while isprim n = 0
      n += 1
   .
   return n
.
func spd n d[] .
   if isprim n = 0
      return 0
   .
   for i = 1 to len d[]
      if nextprime n <> n + d[i]
         return 0
      .
      n += d[i]
   .
   return 1
.
proc print_set n d[] . .
   write "( " & n & " "
   for i = 1 to len d[]
      write n + d[i] & " "
      n += d[i]
   .
   print ")"
.
proc show max d[] . .
   write "Differences of "
   for d in d[]
      write d & " "
   .
   print ""
   for n = 2 to max - d[len d[]]
      if spd n d[] = 1
         c += 1
         if c = 1
            print_set n d[]
         .
         last = n
      .
   .
   print_set last d[]
   print "Number of occurrences: " & c
   print ""
.
show 1000000 [ 2 ]
show 1000000 [ 1 ]
show 1000000 [ 2 2 ]
show 1000000 [ 2 4 ]
show 1000000 [ 4 2 ]
show 1000000 [ 6 4 2 ]
</syntaxhighlight>

=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]
<syntaxhighlight lang="fsharp">
// 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|]]
</syntaxhighlight>
{{out}}
<pre>
sP [|2|]        -> Min element = [|3; 5|] Max element = [|999959; 999961|] of 8169 elements
sP [|1|]        -> Min element = [|2; 3|] Max element = [|2; 3|] of 1 elements
sP [|2; 2|]     -> Min element = [|3; 5; 7|] Max element = [|3; 5; 7|] of 1 elements
sP [|2; 4|]     -> Min element = [|5; 7; 11|] Max element = [|999431; 999433; 999437|] of 1393 elements
sP [|4; 2|]     -> Min element = [|7; 11; 13|] Max element = [|997807; 997811; 997813|] of 1444 elements
sP [|6; 4; 2|]  -> Min element = [|31; 37; 41; 43|] Max element = [|997141; 997147; 997151; 997153|] of 306 elements
</pre>

=={{header|Factor}}==
{{works with|Factor|0.99}}
<syntaxhighlight lang="factor">USING: formatting fry grouping kernel math math.primes
math.statistics sequences ;
IN: rosetta-code.successive-prime-differences

: seq-diff ( seq diffs -- seq' quot )
    dup [ length 1 + <clumps> ] dip '[ differences _ sequence= ]
    ; inline

: show ( seq diffs -- )
    [ "...for differences %u:\n" printf ] keep seq-diff
    [ find nip { } like ]
    [ find-last nip { } like ]
    [ count ] 2tri
    "First group: %u\nLast group: %u\nCount: %d\n\n" printf ;

: successive-prime-differences ( -- )
    "Groups of successive primes up to one million...\n" printf
    1,000,000 primes-upto {
        { 2 }
        { 1 }
        { 2 2 }
        { 2 4 }
        { 4 2 }
        { 6 4 2 }
    } [ show ] with each ;
    
MAIN: successive-prime-differences</syntaxhighlight>
{{out}}
<pre>
Groups of successive primes up to one million...
...for differences { 2 }:
First group: { 3 5 }
Last group: { 999959 999961 }
Count: 8169

...for differences { 1 }:
First group: { 2 3 }
Last group: { 2 3 }
Count: 1

...for differences { 2 2 }:
First group: { 3 5 7 }
Last group: { 3 5 7 }
Count: 1

...for differences { 2 4 }:
First group: { 5 7 11 }
Last group: { 999431 999433 999437 }
Count: 1393

...for differences { 4 2 }:
First group: { 7 11 13 }
Last group: { 997807 997811 997813 }
Count: 1444

...for differences { 6 4 2 }:
First group: { 31 37 41 43 }
Last group: { 997141 997147 997151 997153 }
Count: 306
</pre>

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#include "isprime.bas"

function nextprime( n as uinteger ) as uinteger
    'finds the next prime after n
    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 spd( byval n as integer, d() as integer ) as boolean
    if not isprime(n) then return false
    for i as integer = lbound(d) to ubound(d)
        if not nextprime(n) = n + d(i) then return false
        n+=d(i)
    next i
    return true
end function

sub print_set( byval n as uinteger, d() as uinteger )
    print "( ";n;" ";
    for i as integer = lbound(d) to ubound(d)
        print n+d(i);" ";
        n+=d(i)
    next i 
    print ")"
end sub

function count_below( max as uinteger, d() as uinteger ) as uinteger
    dim as uinteger c = 0, last = 0
    for n as uinteger = 2 to max-d(ubound(d))
        if spd(n, d()) then
            c+=1
            if c=1 then print_set( n, d() )
            last = n
        end if
    next n
    print_set(last, d())
    return c
end function

dim as integer n, c

'example 1, differences of 2
redim as uinteger d(0)
d(0) = 2
print "Differences of 2 (the twin primes)"
c = count_below(1000000, d())
print "Number of occurrences: ", c

'example 2, difference of 1
d(0) = 1
print
print "Differences of 1"
c = count_below(1000000, d())
print "Number of occurrences: ", c

'example 3, differences of 2,2
redim as uinteger d(1)
d(0) = 2 : d(1) = 2
print
print "Differences of 2, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c

'example 4, differences of 2,4
d(1) = 4
print
print "Differences of 2, 4"
c = count_below(1000000, d())
print "Number of occurrences: ", c

'example 5, differences of 2,2
d(0) = 4 : d(1) = 2
print
print "Differences of 4, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c

'example 6, differences of 6,4,2
redim as uinteger d(2)
d(0) = 6 : d(1) = 4 : d(2) = 2
print
print "Differences of 6, 4, 2"
c = count_below(1000000, d())
print "Number of occurrences: ", c</syntaxhighlight>
{{out}}<pre>
Differences of 2 (the twin primes)
( 3 5 )
( 999959 999961 )
Number of occurrences:       8169

Differences of 1
( 2 3 )
( 2 3 )
Number of occurrences:       1

Differences of 2, 2
( 3 5 7 )
( 3 5 7 )
Number of occurrences:       1

Differences of 2, 4
( 5 7 11 )
( 999431 999433 999437 )
Number of occurrences:       1393

Differences of 4, 2
( 7 11 13 )
( 997807 997811 997813 )
Number of occurrences:       1444

Differences of 6, 4, 2
( 31 37 41 43 )
( 997141 997147 997151 997153 )
Number of occurrences:       306
</pre>

=={{header|Go}}==
<syntaxhighlight lang="go">package main

import "fmt"

func sieve(limit int) []int {
    primes := []int{2}
    c := make([]bool, limit+1) // composite = true
    // no need to process even numbers > 2
    p := 3
    for {
        p2 := p * p
        if p2 > limit {
            break
        }
        for i := p2; i <= limit; i += 2 * p {
            c[i] = true
        }
        for {
            p += 2
            if !c[p] {
                break
            }
        }
    }
    for i := 3; i <= limit; i += 2 {
        if !c[i] {
            primes = append(primes, i)
        }
    }
    return primes
}

func successivePrimes(primes, diffs []int) [][]int {
    var results [][]int
    dl := len(diffs)
outer:
    for i := 0; i < len(primes)-dl; i++ {
        group := make([]int, dl+1)
        group[0] = primes[i]
        for j := i; j < i+dl; j++ {
            if primes[j+1]-primes[j] != diffs[j-i] {
                group = nil
                continue outer
            }
            group[j-i+1] = primes[j+1]
        }
        results = append(results, group)
        group = nil
    }
    return results
}

func main() {
    primes := sieve(999999)
    diffsList := [][]int{{2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2}}
    fmt.Println("For primes less than 1,000,000:-\n")
    for _, diffs := range diffsList {
        fmt.Println("  For differences of", diffs, "->")
        sp := successivePrimes(primes, diffs)
        if len(sp) == 0 {
            fmt.Println("    No groups found")
            continue
        }
        fmt.Println("    First group   = ", sp[0])
        fmt.Println("    Last group    = ", sp[len(sp)-1])
        fmt.Println("    Number found  = ", len(sp))
        fmt.Println()
    }
}</syntaxhighlight>

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

  For differences of [2] ->
    First group   =  [3 5]
    Last group    =  [999959 999961]
    Number found  =  8169

  For differences of [1] ->
    First group   =  [2 3]
    Last group    =  [2 3]
    Number found  =  1

  For differences of [2 2] ->
    First group   =  [3 5 7]
    Last group    =  [3 5 7]
    Number found  =  1

  For differences of [2 4] ->
    First group   =  [5 7 11]
    Last group    =  [999431 999433 999437]
    Number found  =  1393

  For differences of [4 2] ->
    First group   =  [7 11 13]
    Last group    =  [997807 997811 997813]
    Number found  =  1444

  For differences of [6 4 2] ->
    First group   =  [31 37 41 43]
    Last group    =  [997141 997147 997151 997153]
    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===
<syntaxhighlight lang="haskell">{-# LANGUAGE NumericUnderscores #-}
import Data.Numbers.Primes (primes)

type Result = [(String, [Int])]

oneMillionPrimes :: Integral p => [p]
oneMillionPrimes = takeWhile (<1_000_000) primes

getGroups :: [Int] -> Result
getGroups [] = []
getGroups ps@(n:x:y:z:xs) 
  | x-n == 6 && y-x == 4 && z-y == 2 = ("(6 4 2)", [n, x, y, z])            : getGroups (tail ps)
  | x-n == 4 && y-x == 2             = ("(4 2)", [n, x, y])                 : getGroups (tail ps)
  | x-n == 2 && y-x == 4             = ("(2 4)", [n, x, y]) : ("2", [n, x]) : getGroups (tail ps)
  | x-n == 2 && y-x == 2             = ("(2 2)", [n, x, y]) : ("2", [n, x]) : getGroups (tail ps)
  | x-n == 2                         = ("2", [n, x])                        : getGroups (tail ps)
  | x-n == 1                         = ("1", [n, x])                        : getGroups (tail ps)
  | otherwise                        = getGroups (tail ps)
getGroups (x:xs) = getGroups xs

groups :: Result
groups = getGroups oneMillionPrimes

showGroup :: String -> IO ()
showGroup group = do 
  putStrLn $ "Differences of " ++ group ++ ": " ++ show (length r)
  putStrLn $ "First: " ++ show (head r) ++ "\nLast:  " ++ show (last r) ++ "\n"
  where r = foldr (\(a, b) c -> if a == group then b : c else c) [] groups

main :: IO ()
main = showGroup "2" >> showGroup "1" >> showGroup "(2 2)" >> showGroup "(2 4)" >> showGroup "(4 2)" 
  >> showGroup "(6 4 2)"</syntaxhighlight>

===Dynamic computed input===
<syntaxhighlight lang="haskell">{-# LANGUAGE NumericUnderscores #-}
import Data.Numbers.Primes (primes)

-- Type alias dictionary. Key is the difference group and value is a successive prime group.
type Result = [(String, [Int])]

findPrimes :: [Int] -> [[Int]] -> Result
findPrimes []     _     = []
findPrimes primes diffs = loopDiffs diffs <> findPrimes (tail primes) diffs
 where
  loopDiffs ds = [(show d, successive)
                  | d <- ds,
                    let successive = take (length d + 1) primes,
                    subs successive == d]
  subs = map (uncurry (-)) . init . tail . (\xs -> zip (xs <> [0]) (0 : xs))

showGroup :: Result -> String -> IO ()
showGroup result diffs = do
  putStrLn $ "Differences of " ++ diffs ++ ": " ++ show (length groups)
  putStrLn
    $  "First: "
    ++ firstGroup groups
    ++ "\nLast:  "
    ++ lastGroup groups
    ++ "\n"
 where
  groups     = [b | (a, b) <- result, a == diffs]
  firstGroup = show . head
  lastGroup  = show . last

main :: IO ()
main = mapM_ (showGroup result . show) diffs
 where
  (diffs, result) = groups [[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]]
  groups diffs = (diffs, findPrimes (takeWhile (< 1_000_000) primes) diffs)</syntaxhighlight>
{{out}}
<pre>
Differences of [2]: 8169
First: [3,5]
Last:  [999959,999961]

Differences of [1]: 1
First: [2,3]
Last:  [2,3]

Differences of [2,2]: 1
First: [3,5,7]
Last:  [3,5,7]

Differences of [2,4]: 1393
First: [5,7,11]
Last:  [999431,999433,999437]

Differences of [4,2]: 1444
First: [7,11,13]
Last:  [997807,997811,997813]

Differences of [6,4,2]: 306
First: [31,37,41,43]
Last:  [997141,997147,997151,997153]
</pre>

=={{header|J}}==
<syntaxhighlight lang="j">
   primes_less_than=: i.&.:(p:inv)
   assert 2 3 5 -: primes_less_than 7
   Primes=: primes_less_than 1e6

   NB. Insert minus `-/' into the length two infixes `\'.
   NB. Passive `~' swaps the arguments producing the positive differences.
   Successive_Differences=: 2 -~/\ Primes
   assert 8169 -: +/ 2 = Successive_Differences   NB. twin prime tally

   Groups=: 2 ; 1 ; 2 2 ; 2 4 ; 4 2 ; 6 4 2

   group_index=: [: I. E.
   end_groups=: Primes {~  ({. , {:)@] +/ 0,#\@[

   Header=: <;._2 'Group;Count;First/Last groups;'

   Header ,> Groups ([ ([ ; #@] ; end_groups) group_index)&.> <Successive_Differences
┌─────┬─────┬───────────────────────────┐
│Group│Count│First/Last groups          │
├─────┼─────┼───────────────────────────┤
│2    │8169 │     3      5              │
│     │     │999959 999961              │
├─────┼─────┼───────────────────────────┤
│1    │1    │2 3                        │
│     │     │2 3                        │
├─────┼─────┼───────────────────────────┤
│2 2  │1    │3 5 7                      │
│     │     │3 5 7                      │
├─────┼─────┼───────────────────────────┤
│2 4  │1393 │     5      7     11       │
│     │     │999431 999433 999437       │
├─────┼─────┼───────────────────────────┤
│4 2  │1444 │     7     11     13       │
│     │     │997807 997811 997813       │
├─────┼─────┼───────────────────────────┤
│6 4 2│306  │    31     37     41     43│
│     │     │997141 997147 997151 997153│
└─────┴─────┴───────────────────────────┘</syntaxhighlight>

=={{header|Java}}==
{{trans|Go}}
<syntaxhighlight lang="java">import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SuccessivePrimeDifferences {
    private static Integer[] sieve(int limit) {
        List<Integer> primes = new ArrayList<>();
        primes.add(2);
        boolean[] c = new boolean[limit + 1];// composite = true
        // no need to process even numbers > 2
        int p = 3;
        while (true) {
            int p2 = p * p;
            if (p2 > limit) {
                break;
            }
            for (int i = p2; i <= limit; i += 2 * p) {
                c[i] = true;
            }
            do {
                p += 2;
            } while (c[p]);
        }
        for (int i = 3; i <= limit; i += 2) {
            if (!c[i]) {
                primes.add(i);
            }
        }

        return primes.toArray(new Integer[0]);
    }

    private static List<List<Integer>> successivePrimes(Integer[] primes, Integer[] diffs) {
        List<List<Integer>> results = new ArrayList<>();
        int dl = diffs.length;
        outer:
        for (int i = 0; i < primes.length - dl; i++) {
            Integer[] group = new Integer[dl + 1];
            group[0] = primes[i];
            for (int j = i; j < i + dl; ++j) {
                if (primes[j + 1] - primes[j] != diffs[j - i]) {
                    continue outer;
                }
                group[j - i + 1] = primes[j + 1];
            }
            results.add(Arrays.asList(group));
        }
        return results;
    }

    public static void main(String[] args) {
        Integer[] primes = sieve(999999);
        Integer[][] diffsList = {{2}, {1}, {2, 2}, {2, 4}, {4, 2}, {6, 4, 2}};
        System.out.println("For primes less than 1,000,000:-\n");
        for (Integer[] diffs : diffsList) {
            System.out.printf("  For differences of %s ->\n", Arrays.toString(diffs));
            List<List<Integer>> sp = successivePrimes(primes, diffs);
            if (sp.isEmpty()) {
                System.out.println("    No groups found");
                continue;
            }
            System.out.printf("    First group   = %s\n", Arrays.toString(sp.get(0).toArray(new Integer[0])));
            System.out.printf("    Last group    = %s\n", Arrays.toString(sp.get(sp.size() - 1).toArray(new Integer[0])));
            System.out.printf("    Number found  = %d\n", sp.size());
            System.out.println();
        }
    }
}</syntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-

  For differences of [2] ->
    First group   = [3, 5]
    Last group    = [999959, 999961]
    Number found  = 8169

  For differences of [1] ->
    First group   = [2, 3]
    Last group    = [2, 3]
    Number found  = 1

  For differences of [2, 2] ->
    First group   = [3, 5, 7]
    Last group    = [3, 5, 7]
    Number found  = 1

  For differences of [2, 4] ->
    First group   = [5, 7, 11]
    Last group    = [999431, 999433, 999437]
    Number found  = 1393

  For differences of [4, 2] ->
    First group   = [7, 11, 13]
    Last group    = [997807, 997811, 997813]
    Number found  = 1444

  For differences of [6, 4, 2] ->
    First group   = [31, 37, 41, 43]
    Last group    = [997141, 997147, 997151, 997153]
    Number found  = 306</pre>

=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''

For a suitable implementation of `is_prime` as used here, see e.g. # [[Erd%C5%91s-primes#jq]].
<syntaxhighlight lang="jq"># Emit a stream of consecutive primes.
# The stream is unbounded if . is null or infinite,
# otherwise it continues up to but excluding `.`.
def primes:
  (if . == null then infinite else . end) as $n
  | 2, (range(3; $n; 2) | select(is_prime));

# s is a stream
# $deltas is an array
# Output: a stream of arrays, each corresponding to a selection of consecutive
# items from s satisfying the differences requirement.
def filter_differences(s; $deltas):

  def diffs_equal: # i.e. equal to $deltas
    . as $in
    | all( range(1;length);
           ($in[.] - $in[.-1]) == $deltas[. - 1]);

  ($deltas|length + 1) as $n
  | foreach s as $x ( {};
      .emit = null
      | .tuple += [$x]
      | .tuple |= .[-$n:]
      | if (.tuple|length) == $n
        then if (.tuple|diffs_equal) then .emit = .tuple
             else .
	     end
	else .
	end;
      select(.emit).emit );

def report_first_last_count(s):
  null | {first,last,count}
  | reduce s as $x (.;
      if .first == null then .first = $x else . end
      | .count = .count + 1
      | .last = $x ) ;
</syntaxhighlight>
'''The Tasks'''
<syntaxhighlight lang="jq">[pow(10;6) | primes] as $p1e6
| ([2], [1], [2,2], [2,4], [4,2], [6,4,2]) as $d
| ("\nFor deltas = \($d):", report_first_last_count(filter_differences($p1e6[]; $d ) ) )</syntaxhighlight>
{{out}}
<pre>
For deltas = [2]:
{"first":[3,5],"last":[999959,999961],"count":8169}

For deltas = [1]:
{"first":[2,3],"last":[2,3],"count":1}

For deltas = [2,2]:
{"first":[3,5,7],"last":[3,5,7],"count":1}

For deltas = [2,4]:
{"first":[5,7,11],"last":[999431,999433,999437],"count":1393}

For deltas = [4,2]:
{"first":[7,11,13],"last":[997807,997811,997813],"count":1444}

For deltas = [6,4,2]:
{"first":[31,37,41,43],"last":[997141,997147,997151,997153],"count":306}
</pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes

function filterdifferences(deltas, N)
    allprimes = primes(N)
    differences = map(i -> allprimes[i + 1] - allprimes[i], 1:length(allprimes) - 1)
    println("Diff Sequence   Count         First           Last")
    for delt in deltas
        ret = trues(length(allprimes) - length(delt))
        for j in 1:length(ret)
            for (i, d) in enumerate(delt)
                if differences[j - 1 + i] != d
                    ret[j] = false
                    break
                end
            end
        end
        count, p1, pn, n = sum(ret), findfirst(ret), findlast(ret), length(delt)
        println(rpad(string(delt), 16), lpad(count, 4),
            lpad(string(allprimes[p1:p1 + n]), 18), "...", rpad(allprimes[pn:pn+n], 15))
    end
end

filterdifferences([[2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2]], 1000000)
</syntaxhighlight>{{out}}
<pre>
Diff Sequence   Count         First           Last
[2]             8169            [3, 5]...[999959, 999961]
[1]                1            [2, 3]...[2, 3]
[2, 2]             1         [3, 5, 7]...[3, 5, 7]
[2, 4]          1393        [5, 7, 11]...[999431, 999433, 999437]
[4, 2]          1444       [7, 11, 13]...[997807, 997811, 997813]
[6, 4, 2]        306  [31, 37, 41, 43]...[997141, 997147, 997151, 997153]
</pre>

=={{header|Lua}}==
This task uses <code>primegen</code> from:  [[Extensible_prime_generator#Lua]]
<syntaxhighlight lang="lua">function findspds(primelist, diffs)
  local results = {}
  for i = 1, #primelist-#diffs do
    result = {primelist[i]}
    for j = 1, #diffs do
      if primelist[i+j] - primelist[i+j-1] == diffs[j] then
        result[j+1] = primelist[i+j]
      else
        result = nil
        break
      end
    end
    results[#results+1] = result
  end
  return results
end

primegen:generate(nil, 1000000)
for _,diffs in ipairs{{2}, {1}, {2,2}, {2,4}, {4,2}, {6,4,2}} do
  spdlist = findspds(primegen.primelist, diffs)
  print("DIFFS: ["..table.concat(diffs," ").."]")
  print("COUNT: "..#spdlist)
  print("FIRST: ["..table.concat(spdlist[1]," ").."]")
  print("LAST : ["..table.concat(spdlist[#spdlist]," ").."]")
  print()
end</syntaxhighlight>
{{out}}
<pre>DIFFS: [2]
COUNT: 8169
FIRST: [3 5]
LAST : [999959 999961]

DIFFS: [1]
COUNT: 1
FIRST: [2 3]
LAST : [2 3]

DIFFS: [2 2]
COUNT: 1
FIRST: [3 5 7]
LAST : [3 5 7]

DIFFS: [2 4]
COUNT: 1393
FIRST: [5 7 11]
LAST : [999431 999433 999437]

DIFFS: [4 2]
COUNT: 1444
FIRST: [7 11 13]
LAST : [997807 997811 997813]

DIFFS: [6 4 2]
COUNT: 306
FIRST: [31 37 41 43]
LAST : [997141 997147 997151 997153]</pre>

=={{header|Kotlin}}==
{{trans|Java}}
<syntaxhighlight lang="scala">private fun sieve(limit: Int): Array<Int> {
    val primes = mutableListOf<Int>()
    primes.add(2)
    val c = BooleanArray(limit + 1) // composite = true
    // no need to process even numbers > 2
    var p = 3
    while (true) {
        val p2 = p * p
        if (p2 > limit) {
            break
        }
        var i = p2
        while (i <= limit) {
            c[i] = true
            i += 2 * p
        }
        do {
            p += 2
        } while (c[p])
    }
    var i = 3
    while (i <= limit) {
        if (!c[i]) {
            primes.add(i)
        }
        i += 2
    }
    return primes.toTypedArray()
}

private fun successivePrimes(primes: Array<Int>, diffs: Array<Int>): List<List<Int>> {
    val results = mutableListOf<List<Int>>()
    val dl = diffs.size
    outer@ for (i in 0 until primes.size - dl) {
        val group = IntArray(dl + 1)
        group[0] = primes[i]
        for (j in i until i + dl) {
            if (primes[j + 1] - primes[j] != diffs[j - i]) {
                continue@outer
            }
            group[j - i + 1] = primes[j + 1]
        }
        results.add(group.toList())
    }
    return results
}

fun main() {
    val primes = sieve(999999)
    val diffsList = arrayOf(
        arrayOf(2),
        arrayOf(1),
        arrayOf(2, 2),
        arrayOf(2, 4),
        arrayOf(4, 2),
        arrayOf(6, 4, 2)
    )
    println("For primes less than 1,000,000:-\n")
    for (diffs in diffsList) {
        println("  For differences of ${diffs.contentToString()} ->")
        val sp = successivePrimes(primes, diffs)
        if (sp.isEmpty()) {
            println("    No groups found")
            continue
        }
        println("    First group   = ${sp[0].toTypedArray().contentToString()}")
        println("    Last group    = ${sp[sp.size - 1].toTypedArray().contentToString()}")
        println("    Number found  = ${sp.size}")
        println()
    }
}</syntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-

  For differences of [2] ->
    First group   = [3, 5]
    Last group    = [999959, 999961]
    Number found  = 8169

  For differences of [1] ->
    First group   = [2, 3]
    Last group    = [2, 3]
    Number found  = 1

  For differences of [2, 2] ->
    First group   = [3, 5, 7]
    Last group    = [3, 5, 7]
    Number found  = 1

  For differences of [2, 4] ->
    First group   = [5, 7, 11]
    Last group    = [999431, 999433, 999437]
    Number found  = 1393

  For differences of [4, 2] ->
    First group   = [7, 11, 13]
    Last group    = [997807, 997811, 997813]
    Number found  = 1444

  For differences of [6, 4, 2] ->
    First group   = [31, 37, 41, 43]
    Last group    = [997141, 997147, 997151, 997153]
    Number found  = 306</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[Primediffs]
p = Prime[Range[PrimePi[10^6]]];
Primediffs[seq_] := {First[#], Last[#], Length[#]} &[p[[#1 ;; #2 + 1]] & @@@ SequencePosition[Differences[p], seq]]
Primediffs[{2}]
Primediffs[{1}]
Primediffs[{2, 2}]
Primediffs[{2, 4}]
Primediffs[{4, 2}]
Primediffs[{6, 4, 2}]</syntaxhighlight>
{{out}}
<pre>{{3,5},{999959,999961},8169}
{{2,3},{2,3},1}
{{3,5,7},{3,5,7},1}
{{5,7,11},{999431,999433,999437},1393}
{{7,11,13},{997807,997811,997813},1444}
{{31,37,41,43},{997141,997147,997151,997153},306}</pre>

=={{header|Nim}}==
<syntaxhighlight lang="nim">import math, strutils

const N = 1_000_000

var comp: array[2..(N - 1), bool]   # True is composite, so default is prime.
for n in 2..<N:
  if not comp[n]:
    for k in countup(n * n, N - 1, n):
      comp[k] = true

var primes = @[2]
for n in countup(3, N - 1, 2):
  if not comp[n]:
    primes.add n

iterator groups(primes: seq[int]; diffs: varargs[int]): seq[int] =
  ## Yield groups of successive primes with given differences.
  var cumdiffs = cumsummed(diffs)   # Compute differences from first prime of group.
  let groupSize = diffs.len + 1
  for i in 0..(primes.len - groupSize):
    let p = primes[i]
    var group = @[p]
    for k, diff in cumdiffs:
      if primes[i + k + 1] != p + diff: break
      group.add p + diff
    if group.len == groupSize:
      yield group

proc findGroups(primes: seq[int]; diffs: varargs[int]) =
  ## In the given list of primes and for the given differences,
  ## find the first group, the last group and the count of groups.
  var
    first, last: seq[int]
    count = 0
  for group in primes.groups(diffs):
    if first.len == 0: first = group
    last = group
    inc count
  echo "Differences: ", diffs.join(", ")
  echo "– first: ($#)" % first.join(", ")
  echo "– last:  ($#)" % last.join(", ")
  echo "– count: ", count
  echo()

primes.findGroups(2)
primes.findGroups(1)
primes.findGroups(2, 2)
primes.findGroups(2, 4)
primes.findGroups(4, 2)
primes.findGroups(6, 4, 2)</syntaxhighlight>

{{out}}
<pre>Differences: 2
– first: (3, 5)
– last:  (999959, 999961)
– count: 8169

Differences: 1
– first: (2, 3)
– last:  (2, 3)
– count: 1

Differences: 2, 2
– first: (3, 5, 7)
– last:  (3, 5, 7)
– count: 1

Differences: 2, 4
– first: (5, 7, 11)
– last:  (999431, 999433, 999437)
– count: 1393

Differences: 4, 2
– first: (7, 11, 13)
– last:  (997807, 997811, 997813)
– count: 1444

Differences: 6, 4, 2
– first: (31, 37, 41, 43)
– last:  (997141, 997147, 997151, 997153)
– count: 306</pre>

=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl">use strict;
use warnings;
use List::EachCons;
use Array::Compare;
use ntheory 'primes';

my $limit = 1E6;
my @primes = (2, @{ primes($limit) });
my @intervals = map { $primes[$_] - $primes[$_-1] } 1..$#primes;

print "Groups of successive primes <= $limit\n";

my $c = Array::Compare->new;
for my $diffs ([2], [1], [2,2], [2,4], [4,2], [6,4,2]) {
    my $n = -1;
    my @offsets = grep {$_} each_cons @$diffs, @intervals, sub { $n++; $n if $c->compare(\@_, \@$diffs) };
    printf "%10s has %5d sets: %15s … %s\n", 
       '(' . join(' ',@$diffs) . ')',
        scalar @offsets,
        join(' ', @primes[$offsets[ 0]..($offsets[ 0]+@$diffs)]),
        join(' ', @primes[$offsets[-1]..($offsets[-1]+@$diffs)]);
}</syntaxhighlight>
{{out}}
<pre>       (2) has  8169 sets:             3 5 … 999959 999961
       (1) has     1 sets:             2 3 … 2 3
     (2 2) has     1 sets:           3 5 7 … 3 5 7
     (2 4) has  1393 sets:          5 7 11 … 999431 999433 999437
     (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|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #008080;">constant</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1_000_000</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">differences</span><span style="color: #0000FF;">)</span>
     <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
     <span style="color: #004080;">integer</span> <span style="color: #000000;">ld</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">differences</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;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">ld</span> <span style="color: #008080;">do</span>
         <span style="color: #004080;">integer</span> <span style="color: #000000;">pi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
         <span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">ld</span> <span style="color: #008080;">do</span>
             <span style="color: #000000;">pi</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">differences</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
             <span style="color: #008080;">if</span> <span style="color: #000000;">pi</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
                 <span style="color: #000000;">pi</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
                 <span style="color: #008080;">exit</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: #008080;">if</span> <span style="color: #000000;">pi</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
             <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">ld</span><span style="color: #0000FF;">])</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: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">differences</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span><span style="color: #000000;">res</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;">"%8V : %8d %14V...%V\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</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;">"Differences   Count          First   Last\n"</span><span style="color: #0000FF;">)</span>
 <span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">2</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: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}},</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Differences   Count          First   Last
     {2} :     8169          {3,5}...{999959,999961}
     {1} :        1          {2,3}...{2,3}
   {2,2} :        1        {3,5,7}...{3,5,7}
   {2,4} :     1393       {5,7,11}...{999431,999433,999437}
   {4,2} :     1444      {7,11,13}...{997807,997811,997813}
 {6,4,2} :      306  {31,37,41,43}...{997141,997147,997151,997153}
</pre>
=={{header|Picat}}==
{{trans|Prolog}}
<syntaxhighlight lang="picat">main =>
  Num is 1_000_000,
  statistics(runtime,[Start|_]),
  PrimeList = primes(Num),
  NumPrimes = PrimeList.len,
  statistics(runtime,[Stop|_]),
  RunTime = Stop - Start,
  printf("There are %w primes until %w [time(ms) %w]%n",NumPrimes, Num, RunTime),
  DiffList = [[1], [2], [2,2], [2,4], [4,2], [2,4,6],
              [2,6,4], [4,2,6], [4,6,2], [6,2,4], [6,4,2],[6,4,2,4]],
  run(DiffList, PrimeList).

primesByDiffs([],_,[]).
primesByDiffs([Prime|Primes], Diff, [Slide|Slides]):-
  Slide = new_list(Diff.len+1),
  append(Slide, _, [Prime|Primes]),
  select(Diff, Slide),!,
  primesByDiffs(Primes, Diff, Slides).
primesByDiffs([_|Primes], Diff, Slides):-
  primesByDiffs(Primes, Diff, Slides).

select([],_).
select([Diff|Diffs],[S1, S2|Stail]):-
  S2 = S1 + Diff,
  select(Diffs, [S2|Stail]).
 
run([],_).
run([Diff|Dtail], PrimeList):-
  statistics(runtime,[Start|_]),
  primesByDiffs(PrimeList, Diff, SlideList),	
  Num = SlideList.len,
  statistics(runtime,[Stop|_]),
  Runtime = Stop - Start,
  printf("%-10w number: %5w (%2wms) first: %-22w last: %-22w\n", Diff, Num, Runtime, SlideList.first, SlideList.last),
  !,
  run(Dtail, PrimeList).</syntaxhighlight>

{{out}}
<pre>There are 78498 primes until 1000000 [time(ms) 130]
[1]        number:     1 ( 9ms) first: [2,3]                  last: [2,3]                 
[2]        number:  8169 (10ms) first: [3,5]                  last: [999959,999961]       
[2,2]      number:     1 (10ms) first: [3,5,7]                last: [3,5,7]               
[2,4]      number:  1393 (11ms) first: [5,7,11]               last: [999431,999433,999437]
[4,2]      number:  1444 (10ms) first: [7,11,13]              last: [997807,997811,997813]
[2,4,6]    number:   279 (12ms) first: [17,19,23,29]          last: [997097,997099,997103,997109]
[2,6,4]    number:   297 (12ms) first: [29,31,37,41]          last: [979541,979543,979549,979553]
[4,2,6]    number:   162 (12ms) first: [67,71,73,79]          last: [980587,980591,980593,980599]
[4,6,2]    number:   300 (12ms) first: [19,23,29,31]          last: [997099,997103,997109,997111]
[6,2,4]    number:   159 (12ms) first: [1601,1607,1609,1613]  last: [997091,997097,997099,997103]
[6,4,2]    number:   306 (13ms) first: [31,37,41,43]          last: [997141,997147,997151,997153]
[6,4,2,4]  number:    62 (13ms) first: [31,37,41,43,47]       last: [959461,959467,959471,959473,959477]

</pre>

=={{header|Prolog}}==
<syntaxhighlight lang="prolog">prime(2).     % use swi prolog
prime(N):-
	N /\ 1 > 0,              % odd
	M is floor(sqrt(N)) - 1, % reverse 2*I+1
	Max is M // 2,           % integer division
	forall(between(1, Max, I), N mod (2*I+1) > 0).

primesByDiffs([],_,[]).
primesByDiffs([Prime|Primes], Diff, [Slide|Slides]):-
	length(Diff, Len0),
	Len is Len0 + 1,
	length(Slide, Len),
	append(Slide, _, [Prime|Primes]),
	select(Diff, Slide),!,
	primesByDiffs(Primes, Diff, Slides).
primesByDiffs([_|Primes], Diff, Slides):-
	primesByDiffs(Primes, Diff, Slides).

select([],_).
select([Diff|Diffs],[S1, S2|Stail]):-
	S2 is S1 + Diff,
	select(Diffs, [S2|Stail]).

run([],_).
run([Diff|Dtail], PrimeList):-
	statistics(runtime,[Start|_]),
	primesByDiffs(PrimeList, Diff, SlideList),	
	length(SlideList, Num),
	statistics(runtime,[Stop|_]),
	Runtime is Stop - Start,
	SlideList = [First|SlideTail],
	format('~|~w~t~7+ number: ~|~t~d~4+ [time(ms) ~|~t~d~3+] first: ~|~w~t~22+',[Diff, Num, Runtime, First]),
	writeLast(SlideTail),!, nl,
	run(Dtail, PrimeList).

writeLast([]).
writeLast(SlideTail):-
	last(SlideTail, Last),
	format('last: ~w',[Last]).

do:-	Num is 1000000,
	statistics(runtime,[Start|_]),
	numlist(2, Num, List),
	include(prime, List, PrimeList),
	length(PrimeList, NumPrimes),
	statistics(runtime,[Stop|_]),
	RunTime is Stop - Start,
	format('there are ~w primes until ~w [time(ms) ~w]~n',[NumPrimes, Num, RunTime]),
	DiffList = [[1], [2], [2,2], [2,4], [4,2], [2,4,6],
		    [2,6,4], [4,2,6], [4,6,2], [6,2,4], [6,4,2]],
	run(DiffList, PrimeList).</syntaxhighlight>
{{out}}
<pre>?- do.
there are 78498 primes until 1000000 [time(ms) 14614]
[1]     number:    1 [time(ms) 123] first: [2,3]                 
[2]     number: 8169 [time(ms) 124] first: [3,5]                 last: [999959,999961]
[2,2]   number:    1 [time(ms) 131] first: [3,5,7]               
[2,4]   number: 1393 [time(ms) 133] first: [5,7,11]              last: [999431,999433,999437]
[4,2]   number: 1444 [time(ms) 133] first: [7,11,13]             last: [997807,997811,997813]
[2,4,6] number:  279 [time(ms) 141] first: [17,19,23,29]         last: [997097,997099,997103,997109]
[2,6,4] number:  297 [time(ms) 141] first: [29,31,37,41]         last: [979541,979543,979549,979553]
[4,2,6] number:  162 [time(ms) 142] first: [67,71,73,79]         last: [980587,980591,980593,980599]
[4,6,2] number:  300 [time(ms) 141] first: [19,23,29,31]         last: [997099,997103,997109,997111]
[6,2,4] number:  159 [time(ms) 142] first: [1601,1607,1609,1613] last: [997091,997097,997099,997103]
[6,4,2] number:  306 [time(ms) 142] first: [31,37,41,43]         last: [997141,997147,997151,997153]
true.
</pre>

=={{header|Python}}==
Uses the [https://www.sympy.org/en/index.html Sympy] library.

<syntaxhighlight lang="python"># https://docs.sympy.org/latest/index.html
from sympy import Sieve

def nsuccprimes(count, mx):
    "return tuple of <count> successive primes <= mx (generator)"
    sieve = Sieve()
    sieve.extend(mx)
    primes = sieve._list
    return zip(*(primes[n:] for n in range(count)))

def check_value_diffs(diffs, values):
    "Differences between successive values given by successive items in diffs?"
    return all(v[1] - v[0] == d 
               for d, v in zip(diffs, zip(values, values[1:])))

def successive_primes(offsets=(2, ), primes_max=1_000_000):
    return (sp for sp in nsuccprimes(len(offsets) + 1, primes_max) 
            if check_value_diffs(offsets, sp))

if __name__ == '__main__':
    for offsets, mx in [((2,),      1_000_000), 
                        ((1,),      1_000_000),
                        ((2, 2),    1_000_000),
                        ((2, 4),    1_000_000),
                        ((4, 2),    1_000_000),
                        ((6, 4, 2), 1_000_000),
                       ]:
        print(f"## SETS OF {len(offsets)+1} SUCCESSIVE PRIMES <={mx:_} WITH "
              f"SUCCESSIVE DIFFERENCES OF {str(list(offsets))[1:-1]}")
        for count, last in enumerate(successive_primes(offsets, mx), 1):
            if count == 1:
                first = last
        print("  First group:", str(first)[1:-1])
        print("   Last group:", str(last)[1:-1])
        print("        Count:", count)</syntaxhighlight>

{{out}}
<pre>## SETS OF 2 SUCCESSIVE PRIMES <=1_000_000 WITH SUCCESSIVE DIFFERENCES OF 2
  First group: 3, 5
   Last group: 999959, 999961
        Count: 8169
## SETS OF 2 SUCCESSIVE PRIMES <=1_000_000 WITH SUCCESSIVE DIFFERENCES OF 1
  First group: 2, 3
   Last group: 2, 3
        Count: 1
## SETS OF 3 SUCCESSIVE PRIMES <=1_000_000 WITH SUCCESSIVE DIFFERENCES OF 2, 2
  First group: 3, 5, 7
   Last group: 3, 5, 7
        Count: 1
## SETS OF 3 SUCCESSIVE PRIMES <=1_000_000 WITH SUCCESSIVE DIFFERENCES OF 2, 4
  First group: 5, 7, 11
   Last group: 999431, 999433, 999437
        Count: 1393
## SETS OF 3 SUCCESSIVE PRIMES <=1_000_000 WITH SUCCESSIVE DIFFERENCES OF 4, 2
  First group: 7, 11, 13
   Last group: 997807, 997811, 997813
        Count: 1444
## SETS OF 4 SUCCESSIVE PRIMES <=1_000_000 WITH SUCCESSIVE DIFFERENCES OF 6, 4, 2
  First group: 31, 37, 41, 43
   Last group: 997141, 997147, 997151, 997153
        Count: 306</pre>

=={{header|Raku}}==
(formerly Perl 6)
===Categorized by Successive===
{{works with|Rakudo|2019.03}}
Essentially the code from the [[Sexy_primes#Raku|Sexy primes]] task with minor tweaks.

<syntaxhighlight lang="raku" line>use Math::Primesieve;
my $sieve = Math::Primesieve.new;

my $max = 1_000_000;
my @primes = $sieve.primes($max);
my $filter = @primes.Set;
my $primes = @primes.categorize: &successive;

sub successive ($i) {
    gather {
        take '2' if $filter{$i + 2};
        take '1' if $filter{$i + 1};
        take '2_2' if all($filter{$i «+« (2,4)});
        take '2_4' if all($filter{$i «+« (2,6)});
        take '4_2' if all($filter{$i «+« (4,6)});
        take '6_4_2' if all($filter{$i «+« (6,10,12)}) and
            none($filter{$i «+« (2,4,8)});
    }
}

sub comma { $^i.flip.comb(3).join(',').flip }

for (2,), (1,), (2,2), (2,4), (4,2), (6,4,2) -> $succ {
    say "## Sets of {1+$succ} successive primes <= { comma $max } with " ~
        "successive differences of { $succ.join: ', ' }";
    my $i = $succ.join: '_';
    for 'First', 0, ' Last', * - 1 -> $where, $ind {
        say "$where group: ", join ', ', [\+] flat $primes{$i}[$ind], |$succ
    }
    say '      Count: ', +$primes{$i}, "\n";
}</syntaxhighlight>
{{out}}
<pre>## Sets of 2 successive primes <= 1,000,000 with successive differences of 2
First group: 3, 5
 Last group: 999959, 999961
      Count: 8169

## Sets of 2 successive primes <= 1,000,000 with successive differences of 1
First group: 2, 3
 Last group: 2, 3
      Count: 1

## Sets of 3 successive primes <= 1,000,000 with successive differences of 2, 2
First group: 3, 5, 7
 Last group: 3, 5, 7
      Count: 1

## Sets of 3 successive primes <= 1,000,000 with successive differences of 2, 4
First group: 5, 7, 11
 Last group: 999431, 999433, 999437
      Count: 1393

## Sets of 3 successive primes <= 1,000,000 with successive differences of 4, 2
First group: 7, 11, 13
 Last group: 997807, 997811, 997813
      Count: 1444

## Sets of 4 successive primes <= 1,000,000 with successive differences of 6, 4, 2
First group: 31, 37, 41, 43
 Last group: 997141, 997147, 997151, 997153
      Count: 306
</pre>
===Precomputed Differences===
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku" line>use Math::Primesieve;

constant $max    = 1_000_000;
constant @primes = Math::Primesieve.primes($max);
constant @diffs  = @primes.skip Z- @primes;

say "Given all ordered primes <= $max, sets with successive differences of:";
for (2,), (1,), (2,2), (2,4), (4,2), (6,4,2) -> @succ {
    my $size = @succ.elems;

    my @group_start_offsets = @diffs.rotor( $size => 1-$size )
                                    .grep(:k, { $_ eqv @succ });

    my ($first, $last) = @group_start_offsets[0, *-1]
                         .map: { @primes.skip($_).head($size + 1) };

    say sprintf '%10s has %5d sets: %15s … %s',
        @succ.gist, @group_start_offsets.elems, $first, $last;
}</syntaxhighlight>
{{Out}}
<pre>Given all ordered primes <= 1000000, sets with successive differences of:
       (2) has  8169 sets:             3 5 … 999959 999961
       (1) has     1 sets:             2 3 … 2 3
     (2 2) has     1 sets:           3 5 7 … 3 5 7
     (2 4) has  1393 sets:          5 7 11 … 999431 999433 999437
     (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|REXX}}==
<syntaxhighlight lang="rexx">/*REXX program finds and displays  primes  with successive differences  (up to a limit).*/
parse arg H . 1 . difs                           /*allow the highest number be specified*/
if H=='' | H==","  then  H= 1000000              /*Not specified?  Then use the default.*/
if difs=''   then  difs= 2 1 2.2 2.4 4.2 6.4.2   /* "      "         "   "   "     "    */
call genP H

        do j=1  for words(difs)                             /*traipse through the lists.*/
        dif= translate( word(difs, j),,.);  dw= words(dif)  /*obtain true differences.  */
            do i=1  for dw;  dif.i= word(dif, i)            /*build an array of diffs.  */
            end   /*i*/                                     /* [↑]  for optimization.   */
        say center('primes with differences of:'  dif,  50, '─')        /*display title.*/
        p= 1;                        c= 0;        grp=      /*init. prime#,  count, grp.*/
             do a=1;  p= nextP(p+1);  if p==0  then leave   /*find the next  DIF  primes*/
             aa= p;   !.=                                   /*AA: nextP;  the group #'s.*/
             !.1= p                                         /*assign 1st prime in group.*/
                    do g=2  for dw                          /*get the rest of the group.*/
                    aa= nextP(aa+1); if aa==0  then leave a /*obtain the next prime.    */
                    !.g= aa;         _= g-1                 /*prepare to add difference.*/
                    if !._ + dif._\==!.g  then iterate a    /*determine if fits criteria*/
                    end   /*g*/
             c= c+1                                         /*bump count of # of groups.*/
             grp= !.1;       do b=2  for dw;  grp= grp !.b  /*build a list of primes.   */
                             end   /*b*/
             if c==1  then say '     first group: '   grp   /*display the first group.  */
             end   /*a*/
                                                            /* [↓]  test if group found.*/
        if grp==''   then say "         (none)"             /*display the  last group.  */
                     else say '      last group: '   grp    /*   "     "     "    "     */
                          say '           count: '   c      /*   "     "  group count.  */
        say
        end   /*j*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
nextP:    do nxt=arg(1)  to H;  if @.nxt==.  then return nxt;  end /*nxt*/;     return 0
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: procedure expose @.; parse arg N;  != 0;  @.=.;  @.1=      /*initialize the array.*/
          do e=4  by 2  for (N-1)%2;  @.e=;  end /*treat the even integers > 2  special.*/
                                                 /*all primes are indicated with a  "." */
        do j=1  by 2  for (N-1)%2                /*use odd integers up to  N  inclusive.*/
        if @.j==.  then do;  if !  then iterate  /*Prime?   Should skip the top part ?  */
                             jj= j * j           /*compute the square of  J.        ___ */
                             if jj>N  then != 1  /*indicate skip top part  if  j > √ N  */
                               do m=jj  to N  by j+j;  @.m=;  end       /*odd multiples.*/
                        end                      /* [↑]  strike odd multiples  ¬ prime. */
        end   /*j*/;               return</syntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
──────────primes with differences of: 2───────────
     first group:  3 5
      last group:  999959 999961
           count:  8169

──────────primes with differences of: 1───────────
     first group:  2 3
      last group:  2 3
           count:  1

─────────primes with differences of: 2 2──────────
     first group:  3 5 7
      last group:  3 5 7
           count:  1

─────────primes with differences of: 2 4──────────
     first group:  5 7 11
      last group:  999431 999433 999437
           count:  1393

─────────primes with differences of: 4 2──────────
     first group:  7 11 13
      last group:  997807 997811 997813
           count:  1444

────────primes with differences of: 6 4 2─────────
     first group:  31 37 41 43
      last group:  997141 997147 997151 997153
           count:  306
</pre>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl + nl
see "For primes less than 1,000,000:" + nl + nl
num = 0
limit = 1000000
Primes = []
SuccPrimes = []
Sp = [[2],[1],[2,2],[2,4],[4,2],[6,4,2]]

for n = 1 to limit
    if isprime(n)
       add(Primes,n)
    ok
next

for n = 1 to len(Sp)
    num = 0
    for m = 1 to len(Primes)-len(Sp[n])
        flag = 0
        SuccPrimes = []
        for p = 1 to len(Sp[n])
            if (Primes[m+p]-Primes[m+p-1] = Sp[n][p]) 
               flag++
               add(SuccPrimes,Primes[m+p])
               add(SuccPrimes,Primes[m+p-1])
            else
               exit
            ok
        next

        SuccPrimes = sort(SuccPrimes)
        for x = len(SuccPrimes) to 2 step -1
            if SuccPrimes[x] = SuccPrimes[x-1]
               del(SuccPrimes,x)
            ok
        next

        if len(SuccPrimes) = len(Sp[n])+1
           num++
           LastSuccPrimes = SuccPrimes
           if num = 1
              see "For differences of " 
              showArray(Sp[n])
              see " ->" + nl
              see " First group = "
              showArray(SuccPrimes)
              see nl
           ok
        ok
    next
    see " Last group = "
    showArray(LastSuccPrimes)
    see nl
    see " Number found = " + num + nl + nl
 next

see "done..." + nl

func showArray(array)
     txt = ""
     see "["
     for n = 1 to len(array)
         txt = txt + array[n] + ","
     next
     txt = left(txt,len(txt)-1)
     txt = txt + "]"
     see txt 
</syntaxhighlight>
{{out}}
<pre>
working...

For primes less than 1,000,000:

For differences of [2] ->
 First group = [3,5]
 Last group = [999959,999961]
 Number found = 8169

For differences of [1] ->
 First group = [2,3]
 Last group = [2,3]
 Number found = 1

For differences of [2,2] ->
 First group = [3,5,7]
 Last group = [3,5,7]
 Number found = 1

For differences of [2,4] ->
 First group = [5,7,11]
 Last group = [999431,999433,999437]
 Number found = 1393

For differences of [4,2] ->
 First group = [7,11,13]
 Last group = [997807,997811,997813]
 Number found = 1444

For differences of [6,4,2] ->
 First group = [31,37,41,43]
 Last group = [997141,997147,997151,997153]
 Number found = 306

done...
</pre>

=={{header|RPL}}==
{{works with|HP|49}}
 « DUP SIZE 1 + { } DUP 0 → diff n first last count
   « 1
     2 n '''START''' DUP NEXTPRIME '''NEXT'''
     '''WHILE''' DUP 1000000 < '''REPEAT''' 
       n ROLL DROP DUP NEXTPRIME 
       n DUPN n →LIST
       '''IF''' DUP ΔLIST diff == '''THEN''' 
         1 →LIST
         '''IF''' first SIZE THEN 'last' '''ELSE''' 'first' '''END''' STO 
         1 'count' STO+
       '''ELSE''' DROP '''END'''
    '''END''' 
    n DROPN first last + count
 » » '<span style="color:blue">SUCCP</span>' STO

 { 2 4 } <span style="color:blue">SUCCP</span>
{{out}}
<pre>
2: { { 5 7 11 } { 999431 999433 999437 } }
1: 1393
</pre> 

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
PRIMES = Prime.each(1_000_000).to_a
difs = [[2], [1], [2,2], [2,4], [4,2], [6,4,2]]

difs.each do |ar|
  res = PRIMES.each_cons(ar.size+1).select do |slice|
    slice.each_cons(2).zip(ar).all? {|(a,b), c| a+c == b}
  end
  puts "#{ar} has #{res.size} sets. #{res.first}...#{res.last}"
end
</syntaxhighlight>
{{output}}
<pre>[2] has 8169 sets. [3, 5]...[999959, 999961]
[1] has 1 sets. [2, 3]...[2, 3]
[2, 2] has 1 sets. [3, 5, 7]...[3, 5, 7]
[2, 4] has 1393 sets. [5, 7, 11]...[999431, 999433, 999437]
[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|Rust}}==
<syntaxhighlight lang="rust">
fn is_prime(num: u32) -> bool {
  match num {
      x if x < 4 => x > 1,
      x if x % 2 == 0 => false,
      x => { let limit = (x as f32).sqrt().ceil() as u32;
              (3..=limit).step_by(2).all(|a| x % a != 0)
            }
  } 
}

fn primes_by_diffs(primes: &[u32], diffs: &[u32]) -> Vec<Vec<u32>> {

  fn select(diffs: &[u32], prime_win: &[u32], acc: bool) -> bool {
    if diffs.is_empty() || !acc {
      acc
    }
    else {
      let acc1 = prime_win[0] + diffs[0] == prime_win[1];
      select(&diffs[1..], &prime_win[1..], acc1)
    }
  }
  
  primes.windows(diffs.len() + 1)
        .filter(|&win| select(diffs, win, true))
        .map(|win| win.to_vec())
        .collect()
}

fn main() {
  let limit = 1_000_000u32;
  let start = std::time::Instant::now();
  let primes = (2..).filter(|&i| is_prime(i));
  let prime_list: Vec<u32> = primes.take_while(|&p| p <= limit).collect();
  let duration = start.elapsed();
  println!("primes time: {:?}", duration);
  for diffs in vec!(vec!(1), vec!(2), vec!(2,2), vec!(2,4), vec!(4,2), vec!(6,4,2), vec!(2,4,6)) {
    let result_list = primes_by_diffs(&prime_list, &diffs);
    let len = result_list.len();
    println!("{:?} number: {}\n\tfirst: {:?}", diffs, len, result_list[0]);
    if len == 1 {
      println!()
    }
    if len > 1 {
      println!("\tlast: {:?}\n", result_list.last().unwrap())
    }
  }
}
</syntaxhighlight>
{{out}}
<pre>
primes time: 422.406627ms
[1] number: 1
	first: [2, 3]

[2] number: 8169
	first: [3, 5]
	last: [999959, 999961]

[2, 2] number: 1
	first: [3, 5, 7]

[2, 4] number: 1393
	first: [5, 7, 11]
	last: [999431, 999433, 999437]

[4, 2] number: 1444
	first: [7, 11, 13]
	last: [997807, 997811, 997813]

[6, 4, 2] number: 306
	first: [31, 37, 41, 43]
	last: [997141, 997147, 997151, 997153]

[2, 4, 6] number: 279
	first: [17, 19, 23, 29]
	last: [997097, 997099, 997103, 997109]
</pre>

=={{header|Scala}}==
<syntaxhighlight lang="scala">object SuccessivePrimeDiffs {
  def main(args: Array[String]): Unit = {
    val d2 = primesByDiffs(2)(1000000)
    val d1 = primesByDiffs(1)(1000000)
    val d22 = primesByDiffs(2, 2)(1000000)
    val d24 = primesByDiffs(2, 4)(1000000)
    val d42 = primesByDiffs(4, 2)(1000000)
    val d642 = primesByDiffs(6, 4, 2)(1000000)
    
    if(true) println(
      s"""|Diffs: (First), (Last), Count
          |2:     (${d2.head.mkString(", ")}), (${d2.last.mkString(", ")}), ${d2.size}
          |1:     (${d1.head.mkString(", ")}), (${d1.last.mkString(", ")}), ${d1.size}
          |2-2:   (${d22.head.mkString(", ")}), (${d22.last.mkString(", ")}), ${d22.size}
          |2-4:   (${d24.head.mkString(", ")}), (${d24.last.mkString(", ")}), ${d24.size}
          |4-2:   (${d42.head.mkString(", ")}), (${d42.last.mkString(", ")}), ${d42.size}
          |6-4-2: (${d642.head.mkString(", ")}), (${d642.last.mkString(", ")}), ${d642.size}
          |""".stripMargin)
  }
  
  def primesByDiffs(diffs: Int*)(max: Int): LazyList[Vector[Int]] = {
    primesSliding(diffs.size + 1)
      .takeWhile(_.last <= max)
      .filter{vec => diffs.zip(vec.init).map{case (a, b) => a + b} == vec.tail}
      .to(LazyList)
  }
  
  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))
}</syntaxhighlight>

{{out}}
<pre>Diffs: (First), (Last), Count
2:     (3, 5), (999959, 999961), 8169
1:     (2, 3), (2, 3), 1
2-2:   (3, 5, 7), (3, 5, 7), 1
2-4:   (5, 7, 11), (999431, 999433, 999437), 1393
4-2:   (7, 11, 13), (997807, 997811, 997813), 1444
6-4-2: (31, 37, 41, 43), (997141, 997147, 997151, 997153), 306</pre>

=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var limit  = 1e6
var primes = limit.primes

say "Groups of successive primes <= #{limit.commify}:"

for diffs in [[2], [1], [2,2], [2,4], [4,2], [6,4,2]] {

    var groups = []
    primes.each_cons(diffs.len+1, {|*group|
        if (group.map_cons(2, {|a,b| b-a}) == diffs) {
            groups << group
        }
    })

    say ("...for differences #{diffs}, there are #{groups.len} groups, where ",
         "the first group = #{groups.first} and the last group = #{groups.last}")
}</syntaxhighlight>
{{out}}
<pre>
Groups of successive primes <= 1,000,000:
...for differences [2], there are 8169 groups, where the first group = [3, 5] and the last group = [999959, 999961]
...for differences [1], there are 1 groups, where the first group = [2, 3] and the last group = [2, 3]
...for differences [2, 2], there are 1 groups, where the first group = [3, 5, 7] and the last group = [3, 5, 7]
...for differences [2, 4], there are 1393 groups, where the first group = [5, 7, 11] and the last group = [999431, 999433, 999437]
...for differences [4, 2], there are 1444 groups, where the first group = [7, 11, 13] and the last group = [997807, 997811, 997813]
...for differences [6, 4, 2], there are 306 groups, where the first group = [31, 37, 41, 43] and the last group = [997141, 997147, 997151, 997153]
</pre>

=={{header|Visual Basic .NET}}==
{{trans|Java}}
<syntaxhighlight lang="vbnet">Imports System.Text

Module Module1

    Function Sieve(limit As Integer) As Integer()
        Dim primes As New List(Of Integer) From {2}
        Dim c(limit + 1) As Boolean REM composite = true
        REM no need to process even numbers > 2
        Dim p = 3
        While True
            Dim p2 = p * p
            If p2 > limit Then
                Exit While
            End If
            For i = p2 To limit Step 2 * p
                c(i) = True
            Next
            Do
                p += 2
            Loop While c(p)
        End While
        For i = 3 To limit Step 2
            If Not c(i) Then
                primes.Add(i)
            End If
        Next
        Return primes.ToArray
    End Function

    Function SuccessivePrimes(primes() As Integer, diffs() As Integer) As List(Of List(Of Integer))
        Dim results As New List(Of List(Of Integer))
        Dim dl = diffs.Length
        Dim i = 0
        While i < primes.Length - dl
            Dim group(dl) As Integer
            group(0) = primes(i)

            Dim j = i
            While j < i + dl
                If primes(j + 1) - primes(j) <> diffs(j - i) Then
                    GoTo outer REM continue the outermost loop
                End If
                group(j - i + 1) = primes(j + 1)

                j += 1
            End While
            results.Add(group.ToList)
outer:
            i += 1
        End While
        Return results
    End Function

    Function CollectionToString(Of T)(c As IEnumerable(Of T)) As String
        Dim builder As New StringBuilder
        builder.Append("[")

        Dim it = c.GetEnumerator()
        If it.MoveNext() Then
            builder.Append(it.Current)
        End If
        While it.MoveNext()
            builder.Append(", ")
            builder.Append(it.Current)
        End While

        builder.Append("]")
        Return builder.ToString
    End Function

    Sub Main()
        Dim primes = Sieve(999999)
        Dim diffsList = {({2}), ({1}), ({2, 2}), ({2, 4}), ({4, 2}), ({6, 4, 2})}
        Console.WriteLine("For primes less than 1,000,000:-")
        Console.WriteLine()
        For Each diffs In diffsList
            Console.WriteLine("  For differences of {0} ->", CollectionToString(diffs))
            Dim sp = SuccessivePrimes(primes, diffs)
            If sp.Count = 0 Then
                Console.WriteLine("    No groups found")
                Continue For
            End If
            Console.WriteLine("    First group   = {0}", CollectionToString(sp(0)))
            Console.WriteLine("    Last group    = {0}", CollectionToString(sp(sp.Count - 1)))
            Console.WriteLine("    Number found  = {0}", sp.Count)
            Console.WriteLine()
        Next
    End Sub

End Module</syntaxhighlight>
{{out}}
<pre>For primes less than 1,000,000:-

  For differences of [2] ->
    First group   = [3, 5]
    Last group    = [999959, 999961]
    Number found  = 8169

  For differences of [1] ->
    First group   = [2, 3]
    Last group    = [2, 3]
    Number found  = 1

  For differences of [2, 2] ->
    First group   = [3, 5, 7]
    Last group    = [3, 5, 7]
    Number found  = 1

  For differences of [2, 4] ->
    First group   = [5, 7, 11]
    Last group    = [999431, 999433, 999437]
    Number found  = 1393

  For differences of [4, 2] ->
    First group   = [7, 11, 13]
    Last group    = [997807, 997811, 997813]
    Number found  = 1444

  For differences of [6, 4, 2] ->
    First group   = [31, 37, 41, 43]
    Last group    = [997141, 997147, 997151, 997153]
    Number found  = 306</pre>

=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-math}}
<syntaxhighlight lang="wren">import "./math" for Int

var successivePrimes = Fn.new { |primes, diffs|
    var results = []
    var dl = diffs.count
    for (i in 0...primes.count-dl) {
        var group = List.filled(dl+1, 0)
        group[0] = primes[i]
        var outer = false
        for (j in i...i+dl) {
            var cont = false
            if (primes[j+1] - primes[j] != diffs[j-i]) {
                outer = true
                break             
            }
            group[j-i+1] = primes[j+1]
        }
        if (!outer) results.add(group)
    }
    return results
}

var primes = Int.primeSieve(999999)
var diffsList = [ [2], [1], [2, 2], [2, 4], [4, 2], [6, 4, 2] ]
System.print("For primes less than 1,000,000:-\n")
for (diffs in diffsList) {
    System.print("  For differences of %(diffs) ->")
    var sp = successivePrimes.call(primes, diffs)
    var cont = false
    if (sp.count == 0) {
        System.print("    No groups found")
        cont = true
    }
    if (!cont) {
        System.print("    First group   =  %(sp[0])")
        System.print("    Last group    =  %(sp[-1])")
        System.print("    Number found  =  %(sp.count)\n")
    }
}</syntaxhighlight>

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

  For differences of [2] ->
    First group   =  [3, 5]
    Last group    =  [999959, 999961]
    Number found  =  8169

  For differences of [1] ->
    First group   =  [2, 3]
    Last group    =  [2, 3]
    Number found  =  1

  For differences of [2, 2] ->
    First group   =  [3, 5, 7]
    Last group    =  [3, 5, 7]
    Number found  =  1

  For differences of [2, 4] ->
    First group   =  [5, 7, 11]
    Last group    =  [999431, 999433, 999437]
    Number found  =  1393

  For differences of [4, 2] ->
    First group   =  [7, 11, 13]
    Last group    =  [997807, 997811, 997813]
    Number found  =  1444

  For differences of [6, 4, 2] ->
    First group   =  [31, 37, 41, 43]
    Last group    =  [997141, 997147, 997151, 997153]
    Number found  =  306
</pre>

=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N);        \Return 'true' if N is prime
int  N, D;
[if N < 2 then return false;
if (N&1) = 0 then return N = 2;
if rem(N/3) = 0 then return N = 3;
D:= 5;
while D*D <= N do
        [if rem(N/D) = 0 then return false;
        D:= D+2;
        if rem(N/D) = 0 then return false;
        D:= D+4;
        ];
return true;
];

char Prime(1_000_000), S;
int  Diff, Diffs, Count, N, I, First, Last;
int  Str, Len;
[for N:= 0 to 1_000_000-1 do
    Prime(N):= if IsPrime(N) then ^1 else ^0;
Diffs:= [[2, 0, 0], [1, 0, 0], [2, 2+2, 0], [2, 4+2, 0], [4, 2+4, 0], [6, 4+6, 2+4+6]];
Str:= [ "101 ", "11 ", "10101 ", "1010001 ", "1000101 ", "1000001000101 "];
Len:= [      3,     2,        5,          7,          7,               13];
for Diff:= 0 to 6-1 do
    [Count:= 0;
    for N:= 0 to 1_000_000-1 -13 do
        [S:= Str(Diff);
        for I:= 0 to Len(Diff)-1 do
            if S(I) # Prime(N+I) then I:= 100;
        if I < 100 then         \have match
            [Count:= Count+1;
            if Count = 1 then First:= N;
            Last:= N;
            ];
        ];
    Text(0, "First: ");  IntOut(0, First);
    for I:= 0 to 2 do
        if Diffs(Diff,I) # 0 then
            [ChOut(0, ^ );  IntOut(0, First+Diffs(Diff,I))];
    Text(0, "  Last: ");  IntOut(0, Last);
    for I:= 0 to 2 do
        if Diffs(Diff,I) # 0 then
            [ChOut(0, ^ );  IntOut(0, Last+Diffs(Diff,I))];
    Text(0, " Groups: ");  IntOut(0, Count);  CrLf(0);
    ];
]</syntaxhighlight>
{{out}}
<pre>
First: 3 5  Last: 999959 999961 Groups: 8169
First: 2 3  Last: 2 3 Groups: 1
First: 3 5 7  Last: 3 5 7 Groups: 1
First: 5 7 11  Last: 999431 999433 999437 Groups: 1393
First: 7 11 13  Last: 997807 997811 997813 Groups: 1444
First: 31 37 41 43  Last: 997141 997147 997151 997153 Groups: 306
</pre>

=={{header|zkl}}==
{{libheader|GMP}} GNU Multiple Precision Arithmetic Library
Using GMP ( probabilistic primes), 
because it is easy and fast to generate primes.

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

Treat this as a string search problem.
<syntaxhighlight lang="zkl">const PRIME_LIMIT=1_000_000;
var [const] BI=Import("zklBigNum");  // libGMP
var [const] primeBitMap=Data(PRIME_LIMIT).fill(0x30);   // one big string
p:= BI(1);
while(p.nextPrime()<=PRIME_LIMIT){ primeBitMap[p]="1" } // bitmap of primes

fcn primeWindows(m,deltas){ // eg (6,4,2)
   n,r := 0,List();
   ds:=deltas.len().pump(List,'wrap(n){ deltas[0,n+1].sum(0) });  // (6,10,12)
   sp:=Data(Void,"1" + "0"*deltas.sum(0));
   foreach n in (ds){ sp[n]="1" } // "1000001000101" 
   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) ...)
}</syntaxhighlight>
<syntaxhighlight lang="zkl">foreach w in (T( T(2), T(1), T(2,2), T(2,4), T(4,2), T(6,4,2) )){
   r:=primeWindows(PRIME_LIMIT,w);
   println("Successive primes (<=%,d) with deltas of %s (%,d groups):"
      .fmt(PRIME_LIMIT,w.concat(","),r.len()));
   println("   First group: %s;  Last group: %s\n"
      .fmt(r[0].concat(", "),r[-1].concat(", ")));
}</syntaxhighlight>
{{out}}
<pre>
Successive primes (<=1,000,000) with deltas of 2 (8,169 groups):
   First group: 3, 5;  Last group: 999959, 999961

Successive primes (<=1,000,000) with deltas of 1 (1 groups):
   First group: 2, 3;  Last group: 2, 3

Successive primes (<=1,000,000) with deltas of 2,2 (1 groups):
   First group: 3, 5, 7;  Last group: 3, 5, 7

Successive primes (<=1,000,000) with deltas of 2,4 (1,393 groups):
   First group: 5, 7, 11;  Last group: 999431, 999433, 999437

Successive primes (<=1,000,000) with deltas of 4,2 (1,444 groups):
   First group: 7, 11, 13;  Last group: 997807, 997811, 997813

Successive primes (<=1,000,000) with deltas of 6,4,2 (306 groups):
   First group: 31, 37, 41, 43;  Last group: 997141, 997147, 997151, 997153
</pre>