Kürzlich habe ich den Roman "Die Einsamkeit der Primzahlen" gelesen, in dem die Hauptfiguren in gewisser Weise mit Doppelprimzahlen verglichen werden (" immer zusammen, aber nie berührend ").

Eine Doppelprimzahl ist eine Primzahl, die entweder 2 weniger oder 2 mehr als eine andere Primzahl ist - zum Beispiel das Doppelprimpaar (41, 43). Mit anderen Worten, eine Doppelprimzahl ist eine Primzahl mit einer Primzahllücke von zwei. Manchmal wird der Begriff Doppelprimus für ein Paar Doppelprimus verwendet; Ein alternativer Name hierfür ist Prime Twin oder Prime Pair. Wikipedia

Obwohl ich den deprimierenden Roman nicht besonders mochte und seitdem ich in letzter Zeit in PPCG verfallen bin, stellte sich mir eine Frage ...

Aufgabe:

Bei einer positiven Ganzzahl N> 4 finden Sie die einsamen Primzahlen (AKA- isolierte Primzahlen ) zwischen den engsten Paaren von Doppelprimen .

Bitte beachten Sie, dass in diesem Fall mit dem Begriff einsame Primzahlen alle Primzahlen gemeint sind, die keine Doppelprimzahlen sind, und zwischen Paaren von Doppelprimzahlen . Deshalb ist N> 4, weil die ersten beiden Primzahlenpaare (3, 5) und (5, 7) sind.

Beispiel:

1. N = 90.
2. Finden Sie die ersten beiden Paare der Doppelprimzahlen <N und> N. Sie sind: (71, 73) und (101, 103).
3. Finde die einsamen Primzahlen im Bereich> 73 und <101.
4. Sie sind: 79, 83, 89, 97.

Spezialfälle:

• Wenn N zwischen zwei Doppelprimzahlen liegt, finden Sie die nächsten Paare der Doppelprimzahlen> N + 1 und <N-1. Beispiel: N = 72, finde die engsten Paare der Doppelprimzahlen> 73 und <71 und schließe sie dann aus der Liste 71 und 73 aus, weil sie keine einsamen Primzahlen sind . Für N = 72 ist das erwartete Ergebnis: 67, 71 , 73 , 79, 83, 89, 97
• Wenn N zu einem Paar von Zwillingsprimen gehört, zum Beispiel N = 73, sind die nächsten Paare von Zwillingsprimen (71, 73) und (101, 103). Wenn N = 71 ist, sind die engsten Paare der Doppelprimzahlen (59, 61) und (71, 73).

Testfälle:

N = 70   >  Lonely primes are:  67
N = 71   >  Lonely primes are:  67
N = 72   >  Lonely primes are:  67, 79, 83, 89, 97 (not the twins 71 and 73)
N = 73   >  Lonely primes are:  79, 83, 89, 97 
N = 90   >  Lonely primes are:  79, 83, 89, 97
N = 201  >  Lonely primes are:  211, 223
N = 499  >  Lonely primes are:  467, 479, 487, 491, 499, 503, 509

Regeln:

• Schreiben Sie ein vollständiges Programm oder eine Funktion, die die Nummer N von der Standardeingabe übernimmt.
• Die Liste der einsamen Primzahlen in einem lesbaren Format als CSV, Liste, Array usw. ausgeben.
• Kürzester Code gewinnt.
• Bitte fügen Sie (wenn möglich) eine testbare Online-Geige bei.

Eigentlich 47 Bytes

Diese Lösung befasst sich mit dem Fall nzwischen zwei Doppelprimzahlen, indem überprüft wird, ob die untere Grenze die größere eines Paares von Doppelprimzahlen ist (wobei die Doppelprimzahl links von uns nicht mehr unsere untere Grenze ist) und ob die obere Grenze ist die kleinere von zwei Doppelprimzahlen (wobei die Doppelprimzahl rechts von uns nicht mehr unsere obere Schranke ist). Um zu verhindern, dass die Doppelprimzahlen in unser Sortiment aufgenommen werden, sobald wir die Unter- und Obergrenze haben, müssen wir Primzahlen entfernen, bei pdenen p-2OR p+2Primzahlen sind, daher das logische OR und die Negation im Code.

Dies ist ein wenig lang und kann wahrscheinlich weiter golfen werden. Golfvorschläge sind willkommen. Probieren Sie es online!

╗1`╜+;⌐p@p&`╓F╜+1`╜-;¬p@p&`╓F╜-x`;;¬p@⌐p|Y@p&`░

Ungolfing

╗         Store implicit input n in register 0.

1`...`╓   Get the first value x for which the following function f returns a truthy value.
  ╜         Push n from register 0.
  +         Add x to n.
  ;⌐        Duplicate n+x and add 2 to a copy of n+x.
  p         Check if n+x+2 is prime.
  @p        Swap n+x to TOS and check if n+x is prime.
  &         Logical AND the two results.
F         Push the first (and only) result of previous filtering
╜+        Add that result to n to get the upper bound for our solitude.

1`...`╓   Get the first value x for which the following function f returns a truthy value.
  ╜         Push n from register 0.
  -         Subtract x from n.
  ;¬        Duplicate n-x and subtract 2 from a copy of n-x.
  p         Check if n-x-2 is prime.
  @p        Swap n-x to TOS and check if n-x is prime.
  &         Logical AND the two results.
F         Push the first (and only) result of previous filtering.
╜-        Subtract that result from n to get the lower bound for our solitude.

x`...`░   Push values of the range [a...b] where f returns a truthy value. Variable m.
  ;;        Duplicate m twice.
  ¬p        Check if m-2 is prime.
  @⌐p       Check if m+2 is prime. 
  |Y        Logical OR the results and negate.
             This eliminates any numbers with neighboring primes.
  @p        Check if m is prime.
  &         Logical AND primality_check(m) and the previous negation.
             This keeps every other prime number in the range.

PowerShell v2 +, 237 149 147 231 216 181 174 169 166 Byte

param($n)filter f($a){'1'*$a-match'^(?!(..+)\1+$)..'}for($i=$n;!((f $i)-and(f($i+2)))){$i++}for(){if(f(--$i)){if((f($i-2))-or(f($i+2))){if($i-lt$n-1){exit}}else{$i}}}

Übernimmt die Eingabe $n. Definiert eine neue Funktion fals Regex-Prim-Funktion (hier wird ein Boolescher Wert zurückgegeben, wenn die Eingabe eine Primzahl ist oder nicht).

Der nächste Teil $iist gleich und $ngeht dann in einer Schleife nach oben, bis wir die untere Hälfte unserer oberen Grenze für das Twin-Prim-Paar finden. ZB für die Eingabe endet 90dies bei $i=101.

Dann schleifen wir von der oberen Grenze nach unten. Ich weiß, es sieht aus wie eine Endlosschleife, aber es wird irgendwann enden.

Wenn die aktuelle Zahl eine Primzahl (ist f(--$i)), aber seine +/- 2 nicht prim, fügen wir $ian die Pipeline. Wenn +/- 2es sich jedoch um eine Primzahl handelt, prüfen wir, ob wir niedriger sind als $n-1(dh um die Situation zu berücksichtigen, in der es sich um ein Twin-Prim-Paar handelt) exit. Nach Abschluss des Programms wird die Pipeline implizit auf dem Bildschirm ausgegeben Write-Output.

Hinweis: Aufgrund der Schleifenstruktur werden die Primzahlen in absteigender Reihenfolge gedruckt. OP hat klargestellt, dass das in Ordnung ist.

Beispiele

Die Ausgabe ist hier durch Leerzeichen getrennt, da dies die Standard-Stringifizierungsmethode für ein Array ist.

PS C:\Tools\Scripts\golfing> 70,71,72,73,90,201,499,982|%{"$_ --> "+(.\the-solitude-of-prime-numbers.ps1 $_)}
70 --> 67
71 --> 67
72 --> 97 89 83 79 67
73 --> 97 89 83 79
90 --> 97 89 83 79
201 --> 223 211
499 --> 509 503 499 491 487 479 467
982 --> 1013 1009 997 991 983 977 971 967 953 947 941 937 929 919 911 907 887

Haskell, 105 Bytes

p x=all((>0).mod x)[2..x-1]
a%x=until(\z->p z&&p(z+2*a))(+a)x
f n=[x|x<-[(-1)%n+1..1%n-1],p x,1%x>x,(-1)%x<x]

Probieren Sie es online

JavaScript, 186 183 168 158 Bytes

// solution:
function d(d){function p(n){for(i=n;n%--i;);return!--i}u=d;for(;!p(d--)||!p(--d););for(;!p(u++)||!p(++u););for(;++d<u;)if(p(d)&&!p(d-2)&&!p(d+2))console.log(d)}

// runnable test cases:
console.info('Test ' + 70);
d(70);
console.info('Test ' + 71);
d(71);
console.info('Test ' + 72);
d(72);
console.info('Test ' + 73);
d(73);
console.info('Test ' + 90);
d(90);
console.info('Test ' + 201);
d(201);
console.info('Test ' + 499);
d(499);

PHP, 207 Bytes

47 54 Bytes für die is_primeFunktion, die PHP nicht hat. Ohne das hätte ich Mathematica geschlagen. :-D

function p($n){for($i=$n>1?$n:4;$n%--$i;);return$i<2;}if(p($n=$argv[1])&p($n+2)|$z=p($n-1)&p($n+1))$n-=2;for($n|=1;!p($n)|!p($n-2);$n--);for($z++;$z--;$n+=2)for(;$n+=2;)if(p($n)){if(p($n+2))break;echo"$n,";}

renn mit -r. druckt ein nachstehendes Komma.

Nervenzusammenbruch

// is_prime function:
// loops from $n-1 down to 1, breaks if it finds a divisor.
// returns true if divisor is <2 (==1)
// special case $n==1: initialize $i=4 to prevent warnings
function p($n){for($i=$n>1?$n:4;$n%--$i;);return$i<2;}

// is $n between primes?
if($z=p(1+$n=$argv[1])&p($n-1)) // set $z to go to the _second_ twin pair above
    $n-=2;
// no:
else
    if(p($n)&p($n+2))$n-=2;     // $n is part of the upper pair
    // p($n)&p($n-2):           // $n is part of the lower pair
    // else:                    // this is a lonely (isolated) prime

// 1. find closest twins <=$n
for($n|=1;!p($n)|!p($n-2);$n--);

// 2. list primes until the next twin primes
L:
for(;$n+=2;)if(p($n))
    if(p($n+2))break;       // next twin primes found: break loop
    else echo"$n,";         // isolated prime: print

// 3. if ($z) repeat (once)
$n+=2;  // skip twin pair
if($z--)goto L;

Hinweis :

Die is_primeFunktion gibt tatsächlich truefür zurück $n<2; aber immerhin gibt es keine warnung. Legen Sie $n=vor $n>1zu beheben.

Mathematica, 169 157 Bytes

Select[PrimeQ]@Sort@Flatten@{If[q@#,0,#],Most@NestWhileList[i-=2;#+i&,#,!q@#&]&/@(i=3;q=PrimeQ@#&&Or@@PrimeQ[{2,-2}+#]&;#+{1,-1}(1+Boole@PrimeQ[{1,-1}+#]))}&

Schläger 228 Bytes

(λ(n)(let*((t 0)(lr(λ(l i)(list-ref l i)))(pl(drop(reverse(for/list((i(in-naturals))#:when(prime? i)#:final(and(> i n)
(= 2(- i t))))(set! t i)i))2)))(for/list((i(length pl))#:break(= 2(-(lr pl i)(lr pl(add1 i)))))(lr pl i))))

Nachteil dieser Version ist, dass sie alle Primzahlen bis N findet und nicht nur die um N.

Ungolfed-Version:

(define (f n)
  (let* ((t 0)
         (lr (λ(l i) (list-ref l i)))
         (pl (drop(reverse  
                   (for/list ((i (in-naturals))
                              #:when (prime? i)
                              #:final (and
                                       (> i n)
                                       (= 2 (- i t))))
                     (set! t i)
                     i)) 2)))
    (for/list ((i (length pl))
               #:break (= 2 (- (lr pl i) (lr pl (add1 i)))) )
      (lr pl i)))
)

Testen:

(f 90)

Ausgabe:

'(97 89 83 79)

Schläger 245 Bytes

(λ(n)(let((pl(reverse(let lp((n n)(t 0)(ol '()))(set! t(prev-prime n))(if(and(>(length ol)0)
(= 2(-(car ol)t)))(cdr ol)(lp t 0(cons t ol)))))))(let lq((n n)(t 0)(ol pl))(set! t(next-prime n))
(if(= 2(- t(car ol)))(cdr ol)(lq t 0(cons t ol))))))

Ungolfed-Version:

(require math)
(define f
  (lambda(n)
    (let ((pl 
           (reverse
            (let loop ((n n) (t 0) (ol '()))
              (set! t (prev-prime n))
              (if (and
                   (> (length ol) 0)
                   (= 2 (- (car ol) t)))
                  (cdr ol)
                  (loop t 0 (cons t ol)))))))
      (let loop2 ((n n) (t 0) (ol pl))
        (set! t (next-prime n))
        (if (= 2 (- t (car ol)))
            (cdr ol)
            (loop2 t 0 (cons t ol))))))
  )

(f 90)

Ausgabe:

'(97 89 83 79)

Python 2.7: 160 Bytes

t=lambda n:all(n%d for d in range(2,n))
def l(n):
 i=n
 while t(i)*t(i+2)-1:i+=1
 while t(n)*t(n-2)-1:n-=1
 print[x for x in range(n,i)if t(x)&~(t(x-2)|t(x+2))]

Vorschläge sind willkommen :)