Jump to content

Next special primes

From Rosetta Code
Next special primes is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

n   is smallest prime such that the difference of successive terms is strictly increasing, where     n   <   1050.

11l

Translation of: FreeBASIC
F is_prime(a)
   I a == 2
      R 1B
   I a < 2 | a % 2 == 0
      R 0B
   L(i) (3 .. Int(sqrt(a))).step(2)
      I a % i == 0
         R 0B
   R 1B

V p = 3
V i = 2
print(‘2 3’, end' ‘ ’)

L p + i < 1050
   I is_prime(p + i)
      p += i
      print(p, end' ‘ ’)
   i += 2
Output:
2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049

Action!

Library: Action! Sieve of Eratosthenes
INCLUDE "H6:SIEVE.ACT"

PROC Main()
  DEFINE MAX="1049"
  BYTE ARRAY primes(MAX+1)
  INT i,count=[1],lastprime=[3],lastgap=[1]

  Put(125) PutE() ;clear the screen
  Sieve(primes,MAX+1)
  PrintI(lastprime)
  FOR i=1 TO MAX
  DO
    IF primes(i)=1 AND i-lastprime>lastgap THEN
      lastgap=i-lastprime
      lastprime=i
      Put(32) PrintI(i)
      count==+1
    FI
  OD
  PrintF("%E%EThere are %I next special primes",count)
RETURN
Output:

Screenshot from Atari 8-bit computer 

3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049

There are 26 next special primes

ALGOL 68

Translation of: ALGOL W
BEGIN # find some primes where the gap between the current prime and the     #
      # next is greater than the gap between previus primes and the current  #
    PR read "primes.incl.a68" PR                   # include prime utilities #
    INT max number = 1050;                 # largest number we will consider #
    []BOOL prime = PRIMESIEVE max number;
    print( ( "         this  next",      newline ) );
    print( ( "element prime prime  gap", newline ) );
    INT p count := 1, this prime := 2, next prime := 3;
    PROC show prime = ( INT gap )VOID:
    BEGIN
        print( ( "  ", whole( p count, - 5), ":", whole( this prime, - 5 ) ) );
        print( ( " ", whole( next prime, - 5 ), whole( gap, - 5 ) ) );
        print( ( newline ) )
    END # show prime # ;
    # the first gap is 1 (between 2 and 3) the gap between all other primes  #
    # is even so we treat 2-3 as a special case                              #
    show prime( 1 );
    INT p gap := 0;
    WHILE this prime < max number DO
        this prime := next prime;
        WHILE   p gap      +:= 2;
                next prime  := this prime + p gap;
                IF next prime > max number
                THEN FALSE
                ELSE NOT prime[ next prime ]
                FI
        DO SKIP OD;
        IF next prime < max number THEN
                p count +:= 1;
                show prime( p gap )
        FI
    OD
END
Output:
         this  next
element prime prime  gap
      1:    2     3    1
      2:    3     5    2
      3:    5    11    6
      4:   11    19    8
      5:   19    29   10
      6:   29    41   12
      7:   41    59   18
      8:   59    79   20
      9:   79   101   22
     10:  101   127   26
     11:  127   157   30
     12:  157   191   34
     13:  191   227   36
     14:  227   269   42
     15:  269   313   44
     16:  313   359   46
     17:  359   409   50
     18:  409   461   52
     19:  461   521   60
     20:  521   587   66
     21:  587   659   72
     22:  659   733   74
     23:  733   809   76
     24:  809   887   78
     25:  887   967   80
     26:  967  1049   82

ALGOL W 

begin % find some primes where the gap between the current prime and the next is greater than  %
      % the gap between previus primes and the current                                         %
    % sets p( 1 :: n ) to a sieve of primes up to n %
    procedure Eratosthenes ( logical array p( * ) ; integer value n ) ;
    begin
        p( 1 ) := false; p( 2 ) := true;
        for i := 3 step 2 until n do p( i ) := true;
        for i := 4 step 2 until n do p( i ) := false;
        for i := 3 step 2 until truncate( sqrt( n ) ) do begin
            integer ii; ii := i + i;
            if p( i ) then for pr := i * i step ii until n do p( pr ) := false
        end for_i ;
    end Eratosthenes ;
    integer MAX_NUMBER;
    MAX_NUMBER := 1050;
    begin
        logical array prime( 1 :: MAX_NUMBER );
        integer       pCount, pGap, thisPrime, nextPrime;
        % sieve the primes to MAX_NUMBER %
        Eratosthenes( prime, MAX_NUMBER );
        % the first gap is 1 (between 2 and 3) the gap between all other primes is even       %
        % so we treat 2-3 as a special case                                                   %
        write( "         this  next" );
        write( "element prime prime  gap" );
        pCount := pGap := 1; thisPrime := 2; nextPrime := 3;
        write( i_w := 5, s_w := 0, "  ", pCount, ":", thisPrime, " ", nextPrime, pGap );
        pGap := 0;
        while thisPrime < MAX_NUMBER do begin
            thisPrime := nextPrime;
            while begin
                pGap      := pGap + 2;
                nextPrime := thisPrime + pGap;
                nextPrime < MAX_NUMBER and not prime( nextPrime )
            end do begin end;
            if nextPrime < MAX_NUMBER then begin
                pCount := pCount + 1;
                write( i_w := 5, s_w := 0, "  ", pCount, ":", thisPrime, " ", nextPrime, pGap )
            end if_nextPrime_lt_MAX_NUMBER
        end while_thisPrime_lt_MAX_NUMBER
    end
end.
Output:
         this  next
element prime prime  gap
      1:    2     3    1
      2:    3     5    2
      3:    5    11    6
      4:   11    19    8
      5:   19    29   10
      6:   29    41   12
      7:   41    59   18
      8:   59    79   20
      9:   79   101   22
     10:  101   127   26
     11:  127   157   30
     12:  157   191   34
     13:  191   227   36
     14:  227   269   42
     15:  269   313   44
     16:  313   359   46
     17:  359   409   50
     18:  409   461   52
     19:  461   521   60
     20:  521   587   66
     21:  587   659   72
     22:  659   733   74
     23:  733   809   76
     24:  809   887   78
     25:  887   967   80
     26:  967  1049   82

Arturo 

specials: new [2 3]
lim: 1050
lastP: 3
lastGap: 1

loop 5.. .step:2 lim 'n [
    if not? prime? n -> continue
    if lastGap < n - lastP [
        lastGap: n - lastP
        lastP: n
        'specials ++ n
    ]
]

print "List of next special primes less than 1050:"
print specials
Output:
List of next special primes less than 1050:
2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049

AWK 

# syntax: GAWK -f NEXT_SPECIAL_PRIMES.AWK
BEGIN {
    start = 1
    stop = 1050
    print("Prime1 Prime2 Gap")
    last_special = 3
    last_gap = 1
    printf("%6d %6d %3d\n",2,3,last_gap)
    count = 1
    for (i=start; i<=stop; i++) {
      if (is_prime(i) && i-last_special > last_gap) {
        last_gap = i - last_special
        printf("%6d %6d %3d\n",last_special,i,last_gap)
        last_special = i
        count++
      }
    }
    printf("Next special primes %d-%d: %d\n",start,stop,count)
    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)
}
Output:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82
Next special primes 1-1050: 26


BASIC

BASIC256 

function isPrime(v)
	if v < 2 then return False
	if v mod 2 = 0 then return v = 2
	if v mod 3 = 0 then return v = 3
	d = 5
	while d * d <= v
		if v mod d = 0 then return False else d += 2
	end while
	return True
end function

p = 3
i = 2

print "2 3 ";    #special case
do
	if isPrime(p + i) then
		p += i
		print p; " ";
	end if
	i += 2
until p + i >= 1050
end

PureBasic 

Procedure isPrime(v.i)
  If     v <= 1    : ProcedureReturn #False
  ElseIf v < 4     : ProcedureReturn #True
  ElseIf v % 2 = 0 : ProcedureReturn #False
  ElseIf v < 9     : ProcedureReturn #True
  ElseIf v % 3 = 0 : ProcedureReturn #False
  Else
    Protected r = Round(Sqr(v), #PB_Round_Down)
    Protected f = 5
    While f <= r
      If v % f = 0 Or v % (f + 2) = 0
        ProcedureReturn #False
      EndIf
      f + 6
    Wend
  EndIf
  ProcedureReturn #True
EndProcedure

OpenConsole()
p.i = 3
i.i = 2

Print("2 3 ")    ;special Case
Repeat
  If isPrime(p + i)
    p + i
    Print(Str(p) + " ")
  EndIf
  i + 2
Until p + i >= 1050
Input()
CloseConsole()

Yabasic 

sub isPrime(v)
    if v < 2 then return False : fi
    if mod(v, 2) = 0 then return v = 2 : fi
    if mod(v, 3) = 0 then return v = 3 : fi
    d = 5
    while d * d <= v
        if mod(v, d) = 0 then return False else d = d + 2 : fi
    wend
    return True
end sub

p = 3
i = 2

print "2 3 ";    //special case
repeat
    if isPrime(p + i) = 1 then
        p = p + i
        print p;
    endif
    i = i + 2
until p + i >= 1050
end


C 

#include <stdio.h>
#include <stdbool.h>

bool isPrime(int n) {
    int d;
    if (n < 2)  return false;
    if (!(n%2)) return n == 2;
    if (!(n%3)) return n == 3;
    d = 5;
    while (d*d <= n) {
        if (!(n%d)) return false;
        d += 2;
        if (!(n%d)) return false;
        d += 4;
    }
    return true;
}

int main() {
    int i, lastSpecial = 3, lastGap = 1;
    printf("Special primes under 1,050:\n");
    printf("Prime1 Prime2 Gap\n");
    printf("%6d %6d %3d\n", 2, 3, lastGap);
    for (i = 5; i < 1050; i += 2) {
        if (isPrime(i) && (i-lastSpecial) > lastGap) {
            lastGap = i - lastSpecial;
            printf("%6d %6d %3d\n", lastSpecial, i, lastGap);
            lastSpecial = i;
        }
    }
}
Output:
Special primes under 1,050:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82

EasyLang

Translation of: 11l
fastfunc isprim num .
   i = 2
   while i <= sqrt num
      if num mod i = 0
         return 0
      .
      i += 1
   .
   return 1
.
p = 3
i = 2
write "2 3 "
while p + i < 1050
   if isprim (p + i) = 1
      p += i
      write p & " "
   .
   i += 2
.
Output:
2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049

F#

This task uses Extensible Prime Generator (F#) 

// Next special primes. Nigel Galloway: March 26th., 2021
let mP=let mutable n,g=2,0 in primes32()|>Seq.choose(fun y->match y-n>g,n with (true,i)->g<-y-n; n<-y; Some(i,g,y) |_->None)
mP|>Seq.takeWhile(fun(_,_,n)->n<1050)|>Seq.iteri(fun i (n,g,l)->printfn "n%d=%d n%d=%d n%d-n%d=%d" i n (i+1) l (i+1) i g)
Output:
n0=2 n1=3 n1-n0=1
n1=3 n2=5 n2-n1=2
n2=5 n3=11 n3-n2=6
n3=11 n4=19 n4-n3=8
n4=19 n5=29 n5-n4=10
n5=29 n6=41 n6-n5=12
n6=41 n7=59 n7-n6=18
n7=59 n8=79 n8-n7=20
n8=79 n9=101 n9-n8=22
n9=101 n10=127 n10-n9=26
n10=127 n11=157 n11-n10=30
n11=157 n12=191 n12-n11=34
n12=191 n13=227 n13-n12=36
n13=227 n14=269 n14-n13=42
n14=269 n15=313 n15-n14=44
n15=313 n16=359 n16-n15=46
n16=359 n17=409 n17-n16=50
n17=409 n18=461 n18-n17=52
n18=461 n19=521 n19-n18=60
n19=521 n20=587 n20-n19=66
n20=587 n21=659 n21-n20=72
n21=659 n22=733 n22-n21=74
n22=733 n23=809 n23-n22=76
n23=809 n24=887 n24-n23=78
n24=887 n25=967 n25-n24=80
n25=967 n26=1049 n26-n25=82

Here's another way of writing the mP sequence above which is (hopefully) a little clearer: 

let mP = seq {
    let mutable prevp, maxdiff = 2, 0
    for p in primes32() do
        let diff = p - prevp
        if diff > maxdiff then
            yield (prevp, diff, p)
            maxdiff <- diff
            prevp <- p
}

Factor

Works with: Factor version 0.98
USING: formatting io kernel math math.primes ;

"2 " write 1 3
[ dup 1050 < ] [
    2dup "(%d) %d " printf [ + next-prime ] keep 2dup - nip swap
] while 2drop nl
Output:
2 (1) 3 (2) 5 (6) 11 (8) 19 (10) 29 (12) 41 (18) 59 (20) 79 (22) 101 (26) 127 (30) 157 (34) 191 (36) 227 (42) 269 (44) 313 (46) 359 (50) 409 (52) 461 (60) 521 (66) 587 (72) 659 (74) 733 (76) 809 (78) 887 (80) 967 (82) 1049

FreeBASIC 

#include "isprime.bas"

dim as integer p = 3, i = 2

print "2 3 ";    'special case
do
    if isprime( p + i ) then
        p += i
        print p;" ";
    end if
    i += 2
loop until p+i >=1050 : print
Output:
2 3  5  11  19  29  41  59  79  101  127  157  191  227  269  313  359  409  461  521  587  659  733  809  887  967  1049

Go 

package main

import "fmt"

func sieve(limit int) []bool {
    limit++
    // True denotes composite, false denotes prime.
    c := make([]bool, limit) // all false by default
    c[0] = true
    c[1] = true
    // no need to bother with even numbers over 2 for this task
    p := 3 // Start from 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
            }
        }
    }
    return c
}

func main() {
    c := sieve(1049)
    fmt.Println("Special primes under 1,050:")
    fmt.Println("Prime1 Prime2 Gap")
    lastSpecial := 3
    lastGap := 1
    fmt.Printf("%6d %6d %3d\n", 2, 3, lastGap)
    for i := 5; i < 1050; i += 2 {
        if !c[i] && (i-lastSpecial) > lastGap {
            lastGap = i - lastSpecial
            fmt.Printf("%6d %6d %3d\n", lastSpecial, i, lastGap)
            lastSpecial = i
        }
    }
}
Output:
Special primes under 1,050:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82

J 

   (, 4 p: (-~ +:)/@(_2&{.))^:(1049 > {:)^:_ (2 3)
2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049

Java

Translation of: C
class SpecialPrimes {
    private static boolean isPrime(int n) {
        if (n < 2)  return false;
        if (n%2 == 0) return n == 2;
        if (n%3 == 0) return n == 3;
        int d = 5;
        while (d*d <= n) {
            if (n%d == 0) return false;
            d += 2;
            if (n%d == 0) return false;
            d += 4;
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println("Special primes under 1,050:");
        System.out.println("Prime1 Prime2 Gap");
        int lastSpecial = 3;
        int lastGap = 1;
        System.out.printf("%6d %6d %3d\n", 2, 3, lastGap);
        for (int i = 5; i < 1050; i += 2) {
            if (isPrime(i) && (i-lastSpecial) > lastGap) {
                lastGap = i - lastSpecial;
                System.out.printf("%6d %6d %3d\n", lastSpecial, i, lastGap);
                lastSpecial = i;
            }
        }
    }
}
Output:
Special primes under 1,050:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82

jq

Works with: jq

Works with gojq, the Go implementation of jq

This entry uses `is_primes` as can be defined as in Erdős-primes#jq. 

def primes:
  2, (range(3;infinite;2) | select(is_prime));

def emit_until(cond; stream): label $out | stream | if cond then break $out else . end;

def special_primes:
  foreach primes as $p ({};
    .emit = null
    | if .p == null then .p = $p | .emit = .p
      else ($p - .p) as $g
      | if $g > .gap then .p = $p | .gap=$g | .emit = .p
        else .
        end
      end;
    select(.emit).emit);

# The task
# The following assumesg invocation with the -n option:
emit_until(. >= 1050; special_primes)
Output:

Invocation example: jq -n -f program.jq 

2
3
5
11
19
29
41
59
79
101
127
157
191
227
269
313
359
409
461
521
587
659
733
809
887
967
1049


Julia 

using Primes

let
    println("Special primes under 1050:\nPrime1 Prime2 Gap")
    println("     2     3   1")
    pmask = primesmask(1, 1050)
    n, gap = 3, 2
    while n + gap < 1050
        if pmask[n + gap]
            println(lpad(n, 6), lpad(n + gap, 6), lpad(gap, 4))
            n += gap
        end
        gap += 2
    end
end
Output:
Special primes under 1050:
Prime1 Prime2 Gap
     2     3   1
     3     5   2
     5    11   6
    11    19   8
    19    29  10
    29    41  12
    41    59  18
    59    79  20
    79   101  22
   101   127  26
   127   157  30
   157   191  34
   191   227  36
   227   269  42
   269   313  44
   313   359  46
   359   409  50
   409   461  52
   461   521  60
   521   587  66
   587   659  72
   659   733  74
   733   809  76
   809   887  78
   887   967  80
   967  1049  82

Mathematica /Wolfram Language 

max = 1050;
n = {2, 3};
Do[
 If[PrimeQ[i],
  lastdiff = n[[-1]] - n[[-2]];
  If[i - n[[-1]] > lastdiff,
   AppendTo[n, i]
   ]
  ]
 ,
 {i, Max[n] + 1, max}
 ]
n
Output:
{2, 3, 5, 11, 19, 29, 41, 59, 79, 101, 127, 157, 191, 227, 269, 313, 359, 409, 461, 521, 587, 659, 733, 809, 887, 967, 1049}

Nim 

import strutils, sugar

func isPrime(n: Positive): bool =
  if (n and 1) == 0: return n == 2
  var m = 3
  while m * m <= n:
    if n mod m == 0: return false
    inc m, 2
  result = true

iterator nextSpecialPrimes(lim: Positive): int =
  assert lim >= 3
  yield 2
  yield 3
  var last = 3
  var lastGap = 1
  for n in countup(5, lim, 2):
    if not n.isPrime: continue
    if n - last > lastGap:
      lastGap = n - last
      last = n
      yield n

let list = collect(newSeq, for p in nextSpecialPrimes(1050): p)
echo "List of next special primes less than 1050:"
echo list.join(" ")
Output:
List of next special primes less than 1050:
2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049

Pascal

Library: primTrial

just showing the small difference to increasing prime gaps.
LastPrime is updated outside or inside If 

program NextSpecialprimes;
//increasing prime gaps see
//https://oeis.org/A002386  https://en.wikipedia.org/wiki/Prime_gap
uses
  sysutils,
  primTrial;

procedure GetIncreasingGaps;
var
  Gap,LastPrime,p : NativeUInt;
Begin
  InitPrime;
  Writeln('next increasing prime gap');
  writeln('Prime1':8,'Prime2':8,'Gap':4);
  Gap := 0;
  LastPrime := actPrime;
  repeat
    p := NextPrime;
    if p-LastPrime > Gap then
    Begin
      Gap := p-LastPrime;
      writeln(LastPrime:8,P:8,Gap:4);

    end;
    LastPrime := p;
  until LastPrime > 1000;
end;

procedure NextSpecial;
var
  Gap,LastPrime,p : NativeUInt;
Begin
  InitPrime;
  Writeln('next special prime');
  writeln('Prime1':8,'Prime2':8,'Gap':4);
  Gap := 0;
  LastPrime := actPrime;
  repeat
    p := NextPrime;
    if p-LastPrime > Gap then
    Begin
      Gap := p-LastPrime;
      writeln(LastPrime:8,P:8,Gap:4);
      LastPrime := p;
    end;

  until LastPrime > 1000;
end;

begin
  GetIncreasingGaps;
  writeln;
  NextSpecial;
end.
Output:
next increasing prime gap
  Prime1  Prime2 Gap
       2       3   1
       3       5   2
       7      11   4
      23      29   6
      89      97   8
     113     127  14
     523     541  18
     887     907  20

next special prime
  Prime1  Prime2 Gap
       2       3   1
       3       5   2
       5      11   6
      11      19   8
      19      29  10
      29      41  12
      41      59  18
      59      79  20
      79     101  22
     101     127  26
     127     157  30
     157     191  34
     191     227  36
     227     269  42
     269     313  44
     313     359  46
     359     409  50
     409     461  52
     461     521  60
     521     587  66
     587     659  72
     659     733  74
     733     809  76
     809     887  78
     887     967  80
     967    1049  82

Perl

Library: ntheory
use strict;
use warnings;
use feature <state say>;
use ntheory 'primes';

my $limit = 1050;

sub is_special {
    state $previous = 2;
    state $gap      = 0;
    state @primes = @{primes( 2*$limit )};

    shift @primes while $primes[0] <= $previous + $gap;
    $gap = $primes[0] - $previous;
    $previous = $primes[0];
    [$previous, $gap];
}

my @specials = [2, 0];
do { push @specials, is_special() } until $specials[-1][0] >= $limit;

pop @specials;
printf "%4d %4d\n", @$_ for @specials;
Output:
   2    0
   3    1
   5    2
  11    6
  19    8
  29   10
  41   12
  59   18
  79   20
 101   22
 127   26
 157   30
 191   34
 227   36
 269   42
 313   44
 359   46
 409   50
 461   52
 521   60
 587   66
 659   72
 733   74
 809   76
 887   78
 967   80
1049   82

Phix 

integer lastSpecial = 3, lastGap = 1
printf(1,"Special primes under 1,050:\n")
printf(1,"Prime1 Prime2 Gap\n")
printf(1,"%6d %6d %3d\n", {2, 3, lastGap})
for i=5 to 1050 by 2 do
    if is_prime(i) and (i-lastSpecial) > lastGap then
        lastGap = i - lastSpecial
        printf(1,"%6d %6d %3d\n", {lastSpecial, i, lastGap})
        lastSpecial = i
    end if
end for
Output:
Special primes under 1,050:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82


Python 

#!/usr/bin/python

def isPrime(n):
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False        
    return True


if __name__ == '__main__':
    p = 3
    i = 2

    print("2 3", end = " ");
    while True:
        if isPrime(p + i) == 1:
            p += i
            print(p, end = " ");
        i += 2
        if p + i >= 1050:
            break

Quackery

isprime is defined at Primality by trial division#Quackery. 

  ' [ 2 ] 1
  [ over -1 peek +
    [ dup isprime
      not while
      1+ again ]
    dup 1050 < while
    join
    dup -2 split nip
    do swap - 1+ again ]
  drop
  echo
Output:
[ 2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049 ]

Raku 

sub is-special ( ($previous, $gap) ) {
    state @primes = grep *.is-prime, 2..*;
    shift @primes while @primes[0] <= $previous + $gap;
    return ( @primes[0], @primes[0] - $previous );
}

my @specials = (2, 0), &is-special … *;

my $limit = @specials.first: :k, *.[0] > 1050;

say .fmt('%4d') for @specials.head($limit);
Output:
   2    0
   3    1
   5    2
  11    6
  19    8
  29   10
  41   12
  59   18
  79   20
 101   22
 127   26
 157   30
 191   34
 227   36
 269   42
 313   44
 359   46
 409   50
 461   52
 521   60
 587   66
 659   72
 733   74
 809   76
 887   78
 967   80
1049   82

REXX

Translation of: RING
/*REXX program finds next special primes:  difference of successive terms is increasing.*/
parse arg hi cols .                              /*obtain optional argument from the CL.*/
if   hi=='' |   hi==","  then   hi= 1050         /* "      "         "   "   "     "    */
if cols=='' | cols==","  then cols=   10         /* "      "         "   "   "     "    */
call genP                                        /*build array of semaphores for primes.*/
w= 10                                            /*width of a number in any column.     */
                        @nsp= ' next special primes  < '      commas(hi)   ,
                              " such that the different of successive terms is increasing"
if cols>0 then say ' index │'center(@nsp                 ,   1 + cols*(w+1)     )
if cols>0 then say '───────┼'center(""                   ,   1 + cols*(w+1), '─')
op= @.1                                          /*assign  oldPrime  to the first prime.*/
nsp= 0;            idx= 1                        /*initialize number of  nsp  and index.*/
$=                                               /*a list of  nice  primes  (so far).   */
     do j=0;       np= op + j                    /*assign newPrime to oldPrime  +  j    */
     if np>=hi         then leave                /*Is  newPrimeN ≥ hi?  Then leave loop.*/
     if \!.np          then iterate              /*Is  np  a prime?   Then skip this  J.*/
     nsp= nsp + 1                                /*bump the number of   nsp's.          */
     op= np                                      /*set oldPrime to the value of newPrime*/
     if cols==0        then iterate              /*Build the list  (to be shown later)? */
     c= commas(np)                               /*maybe add commas to the number.      */
     $= $ right(c, max(w, length(c) ) )          /*add a nice prime ──► list, allow big#*/
     if nsp//cols\==0  then iterate              /*have we populated a line of output?  */
     say center(idx, 7)'│'  substr($, 2);   $=   /*display what we have so far  (cols). */
     idx= idx + cols                             /*bump the  index  count for the output*/
     end   /*j*/

if $\==''  then say center(idx, 7)"│"  substr($, 2)  /*possible display residual output.*/
say
say 'Found '       commas(nsp)         @nsp
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
genP: !.= 0                                      /*placeholders for primes (semaphores).*/
      @.1=2;  @.2=3;  @.3=5;  @.4=7;  @.5=11     /*define some low primes.              */
      !.2=1;  !.3=1;  !.5=1;  !.7=1;  !.11=1     /*   "     "   "    "     flags.       */
                        #=5;     sq.#= @.# **2   /*number of primes so far;     prime². */
                                                 /* [↓]  generate more  primes  ≤  high.*/
        do j=@.#+2  by 2  to hi                  /*find odd primes from here on.        */
        parse var j '' -1 _;       if    _==5  then iterate  /*J ÷ by 5?  (right digit).*/
        if j//3==0  then iterate;  if j//7==0  then iterate  /*" "  " 3?     J ÷ by 7?  */
               do k=5  while sq.k<=j             /* [↓]  divide by the known odd primes.*/
               if j // @.k == 0  then iterate j  /*Is  J ÷ X?  Then not prime.     ___  */
               end   /*k*/                       /* [↑]  only process numbers  ≤  √ J   */
        #= #+1;    @.#= j;   sq.#= j*j;   !.j= 1 /*bump # of Ps; assign next P;  P²; P# */
        end          /*j*/;               return
output   when using the default inputs:
 index │            next special primes  <  1,050  such that the different of successive terms is increasing
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │          2          3          5         11         19         29         41         59         79        101
  11   │        127        157        191        227        269        313        359        409        461        521
  21   │        587        659        733        809        887        967      1,049

Found  27  next special primes  <  1,050  such that the different of successive terms is increasing

Ring 

load "stdlib.ring"

see "working..." + nl

Primes = []
limit1 = 100
oldPrime = 2

for n = 1 to limit1
    nextPrime = oldPrime + n
    if isprime(nextPrime)
       add(Primes,nextPrime)
       oldPrime = nextPrime
    ok
next 

see "prime1 prime2 Gap" + nl
for n = 1 to Len(Primes)-1
    diff = Primes[n+1] - Primes[n]
    see ""+ Primes[n] + "      " + Primes[n+1] + "    " + diff + nl
next     

see nl + "done..." + nl
Output:
working...
prime1 prime2 Gap
3      5    2
5      11    6
11      19    8
19      29    10
29      41    12
41      59    18
59      79    20
79      101    22
101      127    26
127      157    30
157      191    34
191      227    36
227      269    42
269      313    44
313      359    46
359      409    50
409      461    52
461      521    60
521      587    66
587      659    72
659      733    74
733      809    76
809      887    78
887      967    80
967      1049    82
done...

RPL 

≪ 0 → gap
  ≪ {2} 2 1 CF
      WHILE 1 FC? REPEAT
         DUP
         DO NEXTPRIME UNTIL DUP2 - gap < END
         IF DUP 1050 < THEN 
            DUP2 - 'gap' STO
            NIP SWAP OVER + SWAP
         ELSE 1 SF END
      END DROP2
≫ ≫ 'TASK' STO
Output:
1: {2 3 5 11 19 29 41 59 79 101 127 157 191 227 269 313 359 409 461 521 587 659 733 809 887 967 1049}

Sidef 

func special_primes(upto) {

    var gap  = 0
    var prev = 2
    var list = [[prev, gap]]

    loop {
        var n = prev+gap
        n = n.next_prime
        break if (n > upto)
        gap = n-prev
        list << [n, gap]
        prev = n
    }

    return list
}

special_primes(1050).each_2d {|p,gap|
    say "#{'%4s' % p} #{'%4s' % gap}"
}
Output:
   2    0
   3    1
   5    2
  11    6
  19    8
  29   10
  41   12
  59   18
  79   20
 101   22
 127   26
 157   30
 191   34
 227   36
 269   42
 313   44
 359   46
 409   50
 461   52
 521   60
 587   66
 659   72
 733   74
 809   76
 887   78
 967   80
1049   82

Wren

Library: Wren-math
Library: Wren-fmt
import "./math" for Int
import "./fmt" for Fmt

var primes = Int.primeSieve(1049)
System.print("Special primes under 1,050:")
System.print("Prime1 Prime2 Gap")
var lastSpecial = primes[1]
var lastGap = primes[1] - primes[0]
Fmt.print("$6d $6d $3d", primes[0], primes[1], lastGap)
for (p in primes.skip(2)) {
    if ((p - lastSpecial) > lastGap) {
        lastGap = p - lastSpecial
        Fmt.print("$6d $6d $3d", lastSpecial, p, lastGap)
        lastSpecial = p
    }
}
Output:
Special primes under 1,050:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82

XPL0

Translation of: C
include xpllib; \for IsPrime and Print

int I, LastSpecial, LastGap;
[LastSpecial:= 3;  LastGap:= 1;
Print("Special primes under 1,050:\n");
Print("Prime1 Prime2 Gap\n");
Print("%6d %6d %3d\n", 2, 3, LastGap);
for I:= 5 to 1050-1 do
    [if IsPrime(I) and I-LastSpecial > LastGap then
        [LastGap:= I - LastSpecial;
        Print("%6d %6d %3d\n", LastSpecial, I, LastGap);
        LastSpecial:= I;
        ];
    I:= I+1;
    ];
]
Output:
Special primes under 1,050:
Prime1 Prime2 Gap
     2      3   1
     3      5   2
     5     11   6
    11     19   8
    19     29  10
    29     41  12
    41     59  18
    59     79  20
    79    101  22
   101    127  26
   127    157  30
   157    191  34
   191    227  36
   227    269  42
   269    313  44
   313    359  46
   359    409  50
   409    461  52
   461    521  60
   521    587  66
   587    659  72
   659    733  74
   733    809  76
   809    887  78
   887    967  80
   967   1049  82
Retrieved from "https://rosettacode.org/wiki/Next_special_primes?oldid=367214"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information