Ihre Herausforderung besteht darin, eine Funktion mit Code-Golf zu akzeptieren, die true oder false (oder eine ähnliche aussagekräftige Darstellung von yes und no) zurückgibt, wenn eine Zahl die folgenden Kriterien erfüllt:

1. Die ganze Zahl selbst ist eine Primzahl ODER
2. Jede seiner Nachbar-Ganzzahlen ist eine Primzahl

Zum Beispiel:
Eine Eingabe von 7würde True zurückgeben.
Eine Eingabe von 8würde auch True zurückgeben.
Eine Eingabe von 15würde False zurückgeben. (Weder 14, 15 noch 16 sind Primzahlen)

Die Eingabe muss für Zahlen zwischen 2 ^ 0 und 2 ^ 20 korrekt zurückgegeben werden können, damit Sie sich keine Gedanken über Vorzeichenprobleme oder Ganzzahlüberläufe machen müssen.

J, 17

*/<:$&q:(<:,],>:)

Gibt Boolesche Werte zurück, die als Prozessrückgabecodes codiert sind: null für wahr, ungleich null für falsch. Beispielgebrauch:

   */<:$&q:(<:,],>:) 7
0
   */<:$&q:(<:,],>:) 8
0
   */<:$&q:(<:,],>:) 15
3

Haskell, 47 Zeichen

f n=any(\k->all((>0).mod k)[2..k-1])[n-1..n+1]

Python 85 80

def f(n):g=lambda n:all(n%i!=0for i in range(2,n));return g(n)or g(n-1)or g(n+1)

Zum ersten Mal bei Code Golf, daher fehlen mir wahrscheinlich einige Tricks.

Kein wirklicher Konkurrent in Sachen Code-Kürze, aber dennoch unterwerfend, da die Bestimmung der Primzahl durch regulären Ausdruck in vielerlei Hinsicht verdreht ist!

Python (2.x), 85 Zeichen

import re
f=lambda n:any(not re.match(r"^1?$|^(11+?)\1+$","1"*x)for x in[n,n-1,n+1])

Ruby (55 oder 50 als Lambda)

def f q;(q-1..q+1).any?{|n|(2..n-1).all?{|d|n%d>0}};end

oder als lambda (benutze g[23]es um es zu nennen)

g=->q{(q-1..q+1).any?{|n|(2..n-1).all?{|d|n%d>0}}}

Kaffeeskript (53)

p=(q)->[q-1..q+1].some (n)->[2..n-1].every (d)->n%d>0

Die langweilige Mathematica, 35- Lösung!

PrimeQ[n-1]||PrimeQ[n]||PrimeQ[n+1]

C 112 82 72 Zeichen

Nach dem Kommentar von Ilmari Karonen, der durch das Entfernen 30 Zeichen gespart hat main, wird nun Ptrue / false zurückgegeben. Außerdem wurde die Schleife durch Rekursion und einige weitere Verbesserungen ersetzt.

p(n,q){return++q==n||n%q&&p(n,q);}P(n){return p(-~n,1)|p(n,1)|p(~-n,1);}

Originalfassung:

p(n,q,r){for(r=0,q=2;q<n;)r|=!(n%q++);return!r;}
main(int n,int**m){putchar(48|p(n=atoi(*++m))|p(n-1)|p(n+1));}

Mathematica, 24 Bytes

Ich weiß nicht, warum dieser alte Beitrag heute in meiner Liste auftauchte, aber ich erkannte, dass Mathematica hier wettbewerbsfähig ist.

Or@@PrimeQ/@{#-1,#,#+1}&

Unbenannte Funktion, die ein ganzzahliges Argument verwendet und Trueoder zurückgibt False. Direkte Umsetzung.

Stax , 6 Bytes

Ç▀<╝ºΩ

Führen Sie es aus und debuggen Sie es

Erklärung (ausgepackt):

;v:Pv<! Full program, implicit input  Example: 7
;v      Copy input and decrement               7 6
  :P    Next prime                             7 7
    v   Decrement                              7 6
     <! Check if input is >= result            1

JavaScript (71 73 80 )

n=prompt(r=0);for(j=n-2;p=j++<=n;r|=p)for(i=1;++i<j;)p=j%i?p:0;alert(r)

Demo: http://jsfiddle.net/ydsxJ/3/

Edit 1: Wechsle for(i=2;i<j;i++)zu for(i=1;++i<j;)(danke @minitech). ifAnweisung in ternär umwandeln . Verschoben r|=pund p=1in äußere for, um innere Zahnspangen zu beseitigen. 7 Zeichen gespeichert.

Edit 2: Kombiniere p=1und j++<=num p=j++<=n, speichere 2 Zeichen (danke @ugoren).

Regex (ECMAScript), 20 Bytes

^x?x?(?!(x+)(x\1)+$)

Probieren Sie es online!

Die obige Version behandelt Null nicht richtig, aber das benötigt nur 1 zusätzliches Byte:

^x?x?(?!(x+)(x\1)+$)x

Als zusätzlichen Bonus gibt es hier eine Version, die eine Rendite von 1eins weniger als einer Primzahl, 2für eine Primzahl und 3für eine mehr als eine Primzahl ergibt :

^x?x??(?!(x+)(x\1)+$)x

Probieren Sie es online!

C # 96

Es gibt -1,0,1 für wahr zurück, alles andere ist falsch.

Vorschläge, um es kürzer zu machen, wären wunderbar!

int p(int q){var r=q-1;for(var i=2;i<r&r<q+2;i++){if(i==r-1)break;if(r%i==0)r+=i=1;}return r-q;}

Erweiterte Form:

int p(int q){
    var r=q-1;
    for(var i=2;i<r&r<q+2;i++){
        if(i==r-1)break;
        if(r%i==0)r+=i=1;
    }
    return r-q;     
}

GolfScript: 26

)0\{.:i,{i\%!},,2=@|\(}3*;

Erläuterung: Der innerste Block {.:i,{i\%!},,2=@|\(}bestimmt, ob die Oberseite des Stapels prim ist, indem überprüft wird, ob genau zwei Faktoren kleiner als die Oberseite des Stapels sind. Dies wird dann mit dem zweiten Gegenstand auf dem Stapel getrennt, der den Zustand enthält, ob ein Prime noch gesehen wurde. Schließlich wird die Zahl oben auf dem Stapel dekrementiert.

Beginnen Sie, indem Sie den Eingang inkrementieren, den primären Status initialisieren und den Block dreimal wiederholen. Da diese zweimal verringern, aber wir begannen durch Erhöhen, wird diese Abdeckung n+1und n-1.

C #, 87 97 Zeichen

bool p(int q){return new[]{q-1,q,q+1}.Any(x=>Enumerable.Range(2,Math.Abs(x-2)).All(y=>x%y!=0));}

CJam, 12 Bytes

CJam ist viel jünger als diese Herausforderung, daher ist diese Antwort nicht für das grüne Häkchen geeignet (das ohnehin auf die zufällige Antwort aktualisiert werden sollte). Das Golfen hat Spaß gemacht - ich habe mit 17 Bytes angefangen und dann meine Herangehensweise dreimal komplett geändert, wobei ich jeweils ein oder zwei Bytes gespart habe.

{(3,f+:mp:|}

Dies ist ein Block, der einer Funktion in CJam am nächsten kommt, die die Eingabe auf dem Stapel erwartet und eine 1 (wahr) oder 0 (falsch) auf dem Stapel hinterlässt.

Teste es hier.

So funktioniert es:

(3,f+:mp:|
(          "Decrement the input N.";
 3,        "Push an array [0 1 2].";
   f+      "Add each of those to N-1, to get [N-1 N N+1].";
     :mp   "Test each each element for primality, yielding 0 or 1.";
        :| "Fold bitwise OR onto the list, which gives 1 if any of them was 1.";

F #, 68 Bytes (nicht konkurrierend)

let p n=Seq.forall(fun x->n%x>0){2..n-1}
let m n=p(n-1)||p n||p(n+1)

Probieren Sie es online!

Deshalb liebe ich Codegolf. Ich bin immer noch sehr grün mit F #, aber ich lerne so viel darüber, wie die Sprache funktioniert und was sie aus solchen Herausforderungen machen kann.

APL (Dyalog Classic) , 20 Byte

0∊¯1 0 1∘+∊(∘.×⍨1↓⍳)

Probieren Sie es online!

Netzhaut , 22 Bytes

$
1
^1?1?(?!(11+)\1+$)

Probieren Sie es online!

Nimmt unär als Eingabe

Java 8, 83 Bytes

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

Gibt true/ falseals wahrheitsgemäße / falsche Werte zurück.

Probieren Sie es online aus.

Erläuterung: "

n->                    // Method with integer parameter and boolean return-type
  n==1                 //  Return whether the input is 1 (edge-case)
  |p(n-1)+p(n)+p(n+1)>0//  Or if the sum of `n-1`, `n`, and `n+1` in method `p(n)` is not 0

int p(int n){          // Separated method with integer as both parameter and return-type
  for(int i=2;i<n;     //  Loop `i` in the range [2, `n`)
    n=n%i++<1?         //   If `n` is divisible by `i`
       0               //    Change `n` to 0
      :                //   Else:
       n);             //    Leave `n` as is
                       //  (After the loop `n` is either 0, 1, or unchanged,
                       //   if it's unchanged it's a prime, otherwise not)
  return--n;}          //  Return `n` minus 1

So int p(int n)führt in -1für n=0und nicht-Primzahlen und wird in Folge n-1für n=1oder Primzahlen. Da p(0)+p(1)+p(2)wird -1+0+1 = 0und würde falsch (auch wenn 2es sich um eine Primzahl handelt), n=1ist das ein Randfall mit diesem Ansatz.

Eine einzelne Schleife ohne getrennte Methode wäre 85 Bytes :

n->{int f=0,j=2,i,t;for(;j-->-1;f=t>1?1:f)for(t=n+j,i=2;i<t;t=t%i++<1?0:t);return f;}

Gibt 1/ 0als wahrheitsgemäße / falsche Werte zurück.

Probieren Sie es online aus.

Erläuterung:

n->{              // Method with integer as both parameter and return-type
  int f=0,        //  Result-integer, starting at 0 (false)
      j=2,i,      //  Index integers
      t;          //  Temp integer
  for(;j-->-1;    //  Loop `j` downwards in range (2, -1]
      f=          //    After every iteration: Change `f` to:
        t>1?      //     If `t` is larger than 1 (`t` is a prime):
         1        //      Change `f` to 1 (true)
        :         //     Else:
         f)       //      Leave `f` the same
    for(t=n+j,    //   Set `t` to `n+j`
        i=2;i<t;  //   Inner loop `i` in the range [2, t)
      t=t%i++<1?  //    If `t` is divisible by `i`:
         0        //     Change `t` to 0
        :         //    Else:
         t);      //     Leave `t` the same
                  //   (If `t` is still the same after this inner loop, it's a prime;
                  //   if it's 0 or 1 instead, it's not a prime)
  return f;}      //  Return the result-integer (either 1/0 for true/false respectively)

Japt , 7 Bytes

´Uô2 dj
´Uô2    // Given the range [U-1..U+1],
     dj // sing "Daddy DJ", uh, I mean, check if any are a prime.

Probieren Sie es online!

R 68 Zeichen

f=function(n){library(gmp);i=isprime;ifelse(i(n-1)|i(n)|i(n+1),1,0)}

Verwendung (1 für WAHR, 0 für FALSCH):

f(7)
[1] 1
f(8)
[1] 1
f(15)
[1] 0

C ++

k=3;cin>>i;i--;
while(k)
{l[k]=0;
  for(j=2;j<i;j++)
   if(!(i%j))
     l[k]++;
  k--;
  i++;
}
if(!l[1]|!l[2]|!l[3])
     cout<<"1";
else cout<<"0";

Q, 43 Zeichen 36

{any min each a mod 2_'til each a:x+-1 0 1}

{any(min')a mod 2_'(til')a:x+-1 0 1}

J, 16 Zeichen

   (_2&<@-4 p:]-2:)

   (_2&<@-4 p:]-2:) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1

Python, 69 67 Zeichen

any(all(i%j for j in range(2,i))for i in range(input()-1,8**7)[:3])

8**7 > 2**20 während etwas kürzer zu schreiben

Ruby, 47 Zeichen, aber sehr gut lesbar

require'Prime'
f=->x{[x-1,x,x+1].any? &:prime?}

C ++ 97

ugoren scheint mich auf die clevere lösung geschlagen zu haben. Er ist also eine kürzere Version des dreifachen Ansatzes:

P(int k){int j=1;for(int i=2;i<k;){j=k%i++&&j;}return j;}
a(int b){return P(b)|P(b+1)|P(b-1);}

Viertens (gviertens) , 104 Bytes

: p dup 1 > if 1 over 2 ?do over i mod 0> * loop else 0 then nip ;
: f dup 1- p over 1+ p rot p + + 0< ;

Probieren Sie es online!

Erläuterung

Prime Check (p)

dup 1 > if          \ if number to check if greater than 1
   1 over 2 ?do     \ place a 1 on the stack to act as a boolean and loop from 2 to n
      over i  mod   \ take the modulo of n and i
      0> *          \ check if greater than 0 (not a divisor) and multiply result by boolean
   loop             \ end the loop, result will be -1 if no divisor was found (prime)
else                \ if n is less than 2
   0                \ put 0 on the stack (not prime)
then                \ end the loop
nip                 \ drop n from the stack

Hauptfunktion (f)

dup 1- p             \ get n-1 and check if prime
over 1+ p            \ get n+1 and check if prime
rot p                \ rotate stack to put n on top and check if prime
+ + 0<               \ add the three results and check if less than 0 (at least 1 was prime)

Julia 0,4 , 23 Bytes

n->any(isprime,n-1:n+1)

Probieren Sie es online!

Gelee , 5 Bytes

‘r’ẒẸ

Probieren Sie es online!

Wie es funktioniert

‘r’ẒẸ    Monadic main link. Input: integer n
‘r’      Generate range n-1..n+1
   ẒẸ    Is any of them a prime?