Ich weiß, ich weiß, noch eine Herausforderung für Primzahlen ...

verbunden

Ein einsames (oder getrennt) prime eine Primzahl ist, pso dass p-2, p+2, p-4, p+4... p-2k, p+2kfür einen Teil kaller Verbund sind. Wir nennen eine solche Primzahl eine kth-mal isolierte Primzahl.

Zum Beispiel ist eine fünffach isolierte Primzahl 211, da alle zusammengesetzt 201, 203, 205, 207, 209, 213, 215, 217, 219, 221sind. ( p-2*5=201, p-2*4=203, Etc.)

Herausforderung

Geben Sie bei zwei Eingabe-Ganzzahlen und n > 3und k > 0die kleinste kth-mal isolierte Primzahl aus, die streng größer als ist n.

Zum Beispiel sollte für k = 5und in jedem nBereich 4 ... 210der Ausgang sein 211, da dies die kleinste fünffach isolierte Primzahl ist, die streng größer als der Eingang ist n.

Beispiele

n=55 k=1
67

n=500 k=1
503

n=2100 k=3
2153

n=2153 k=3
2161

n=14000 k=7
14107

n=14000 k=8
14107

Regeln

• Falls zutreffend, können Sie davon ausgehen, dass die Eingabe / Ausgabe in den nativen Integer-Typ Ihrer Sprache passt.
• Die Eingabe und Ausgabe kann durch jede bequeme Methode erfolgen .
• Entweder ein vollständiges Programm oder eine Funktion sind akzeptabel. Wenn es sich um eine Funktion handelt, können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Code-Golf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Bytes) gewinnt.

Gelee , 17 13 Bytes

_æR+⁼ḟ
‘ç1#Ḥ}

Probieren Sie es online aus!

Wie es funktioniert

‘ç1#Ḥ}  Main link. Left argument: n. Right argument: k

‘       Increment; yield n+1.
    Ḥ}  Unhalve right; yield 2k.
 ç1#    Call the helper link with arguments m = n+1, n+2, ... and k until 1 one
        them returns a truthy value. Return the matching [m].


_æR+⁼ḟ  Helper link. Left argument: m. Right argument: k

_       Subtract; yield m-2k.
   +    Add; yield m+2k.
 æR     Prime range; yield the array of primes in [m-2k, ..., m+2k].
     ḟ  Filterfalse; yield the elements of [m] that do not occur in [k], i.e., [m]
        if m ≠ 2k and [] otherwise.
        The result to the left will be non-empty when m = 2k, as there always is
        a prime in [0, ..., 2m], since m > n > 3.
    ⁼   Test the results to both sides for equality.
        This yields 1 iff m is the only prime in [m-2k, ..., m+2k].

Schale , 13 Bytes

ḟ§=;ofṗM+ṡD⁰→

Probieren Sie es online aus!

Erläuterung

Ziemlich einfach.

ḟ§=;ofṗM+ṡD⁰→  Inputs are k and n.
            →  Increment n
ḟ              and find the first number m >= n+1 such that:
         ṡD⁰    Take symmetric range [-2k,..,2k].
       M+       Add m to each.
    ofṗ         Keep those that are prime.
 §=             Check equality with
   ;            the singleton [m].

Java 8, 144 143 Bytes

(n,k)->{for(k*=2;;)if(p(++n)>1){int i=-k;for(;i<=k&p(n+i)<2|i==0;i+=2);if(i>k)return n;}}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Erläuterung:

Probieren Sie es online aus.

(n,k)->{                      // Method with two integer parameters and integer return-type
  for(k*=2;                   //  Multiply `k` by 2
      ;)                      //  Loop indefinitely
    if(p(++n)>1){             //   Increase `n` by 1 before every iteration with `++n`
                              //   And if it's a prime:
      int i=-k;for(;i<=k      //    Loop `i` from `-k` to `k` (inclusive)
        &p(n+i)<2|i==0;       //    As long as `n+i` is not a prime (skipping `n` itself)
        i+=2);                //    And iterate in steps of 2 instead of 1
      if(i>k)                 //    If we've reached the end of the loop:
        return n;}}           //     We've found our result, so return it

// Separated method to check if `n` is a prime
// `n` is a prime if it remained unchanged, and not when it became 0 or 1
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Python 2 , 105 104 Bytes

^{-1 Byte dank Ovs}

n,k=input()
n+=1
while sum(all(x%i for i in range(2,x))^(x==n)for x in range(n-k*2,2*k-~n)):n+=1
print n

Probieren Sie es online aus!

Stax , 14 Bytes

åΣ▀ë F▬&■º↔╔^∞

Führen Sie es aus und debuggen Sie es

Dies ist die entsprechende ASCII-Darstellung.

w^x:r{Hn+|p_!=m0#

w                   while; run the rest of the program until a falsy value remains
 ^                  increment candidate value.
  x:r               [-x, ..., -1, 0, 1, ... x] where x is the first input
     {        m     map using block, using k from -x to x
      Hn+           double and add to candidate value - this is "p+2k"
         |p         is it prime? produces 0 or 1
           _!       k is zero?
             =      two values are equal; always true for a passing candidate
               0#   any falses left after mapping? if so, continue running

JavaScript (Node.js) , 94 92 89 Byte

f=(n,k)=>(Q=y=>y<-k||(P=(a,b=2)=>a>b?a%b&&P(a,b+1):1)(n+2*y)^!!y&&Q(--y))(k,++n)?n:f(n,k)

Probieren Sie es online aus!

Auf mysteriöse Weise führen weitere Golfplätze zu einem Stapelüberlauf. Nur das funktioniert bei der Größe von 14000.

Endlich ein Golf, der bei 14000 nicht zu einem Stapelüberlauf führt.

Erläuterung

f=(n,k)=>            // Two inputs
 (Q=y=>              // Function checking whether all numbers in 
                     // [n-2*k, n+2*k] except n are all composite
  y<-k               // The counter runs from k to -k
                     // If none breaks the rule, return true
  ||(P=(a,b=2)=>     // Function checking primality
   a>b?              // Check if a>b
   a%b&&P(a,b+1)     // If a>b and a%b==0 return false, else proceed
   :1                // If a<=b return 1 (prime)
  )(n+2*y)^!!y       // If n+2*y is prime, then y must be 0
                     // If n+2*y is not prime, then y must be non-zero
                     // If none of the conditions are met, return false
  &&Q(--y)           // Else proceed to the next counter
 )
 (k,++n)?            // Add 1 to n first, then start the check
 n                   // If conditions are met, return n
 :f(n,k)             // Else proceed to the next n.

C (gcc) , 113 Bytes

P(n,d,b){for(b=d=n>1;++d<n;)b=b&&n%d;n=b;}f(n,k,i,f){for(f=n;f;)for(f=i=!P(++n);i++<k;f|=P(n+i+i)|P(n-i-i));f=n;}

Probieren Sie es online aus!

Ruby + -rprime, 73 71 61 57 Bytes

->n,k{n+=1;(-k..k).all?{|i|(i*2+n).prime?^(i!=0)}?n:redo}

Probieren Sie es online aus!

Es fühlt sich gut an zu lernen! Ich verwende die Integer#[]und redoTechniken, die ich hier auf PPCG gelernt habe. Sich im Unkraut der lustigen Techniken verlieren ...

-1 Byte: Verwenden Sie n%2anstelle von n[0], um das niedrigstwertige Bit zu erhalten. Danke, Asone Tuhid !

-1 Byte: Verwenden Sie einen ternären Operator anstelle eines booleschen Ausdrucks. Danke, Asone Tuhid !

-10 Bytes: Verwenden Sie den XOR-Operator, um ein .prime?zweimaliges Tippen zu vermeiden ... Dies ist genau die Antwort von Asone Tuhid wie meine jetzt :)

-4 Bytes: Es schadet nicht, gerade Werte von zu überprüfen n. Asone Tuhid ist nonstop.

Ungolfed:

->n,k{
  n += 1;                   # Increment n
  (-k..k).all?{|i|          # In the set [n-2*k, n+2*k], is every number
    (i*2+n).prime? ^ (i!=0) #    EITHER prime XOR different from n itself?
  } ? n                     # If yes, return the current value of n
  : redo                    # Otherwise, restart the block
}

Pari / GP , 55 Bytes

f(n,k)=until(isprime(n++)&&#primes([n-2*k,n+2*k])<2,);n

Probieren Sie es online aus!

Perl 6 , 63 Bytes

{$^k;first {[grep *.is-prime,$_-2*$k..$_+2*$k]eqv[$_]},$^a^..*}

Probieren Sie es online aus!