Su desafío, si elige aceptarlo, es codificar golf una función que devuelve verdadero o falso (o alguna representación significativa similar de sí y no) si un número cumple con los siguientes criterios:

1. El entero en sí es un número primo O
2. Cualquiera de sus números enteros vecinos son primos

Por ejemplo:
una entrada de 7devolvería True.
Una entrada de 8también devolvería True.
Una entrada de 15devolvería False. (Ni 14, 15 o 16 son primos)

La entrada debe poder regresar correctamente para números entre 2 ^ 0 y 2 ^ 20 inclusive, por lo que no hay necesidad de preocuparse por problemas de signos o desbordamientos de enteros.

J, 17

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

Devuelve booleanos codificados como códigos de retorno de proceso: cero para verdadero, distinto de cero para falso. Uso de la muestra:

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

Haskell, 47 personajes

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)

Primera vez en Code Golf, así que probablemente faltan algunos trucos.

No es un contendiente real en la falta de código de ninguna manera, pero aún se somete desde la determinación de la prima por expresión regular está torcido de muchas maneras!

Python (2.x), 85 caracteres

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

Rubí (55 o 50 como lambda)

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

o como lambda (solía g[23]llamarlo)

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

Coffeescript (53)

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

¡La aburrida solución de Mathematica, 35 !

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

C, 112 82 72 caracteres

Siguiendo el comentario de Ilmari Karonen, ahorró 30 caracteres al eliminar main, ahora Pdevuelve verdadero / falso. También reemplazado bucle con recursión, y algunos ajustes más.

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

Versión original:

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

No sé por qué esta vieja publicación apareció en mi lista hoy, pero me di cuenta de que Mathematica es competitiva aquí.

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

Función sin nombre que toma un argumento entero y devuelve Trueo False. Implementación directa.

Stax , 6 bytes

Ç▀<╝ºΩ

Ejecutar y depurarlo

Explicación (sin embalaje):

;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)

Demostración: http://jsfiddle.net/ydsxJ/3/

Edición 1: Cambiar for(i=2;i<j;i++)a for(i=1;++i<j;)(gracias @minitech). Convierta la ifdeclaración a ternario. Movido r|=py p=1hacia afuera forpara eliminar los frenos internos. Guardado 7 caracteres.

Edición 2: combina p=1y j++<=npara p=j++<=n, guarda 2 caracteres (gracias @ugoren).

Regex (ECMAScript), 20 bytes

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

Pruébalo en línea!

La versión anterior no maneja correctamente el cero, pero eso solo toma 1 byte adicional:

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

Como una ventaja adicional, aquí hay una versión que ofrece una coincidencia de retorno de 1uno menos que un primo, 2por primo y 3por uno más que un primo:

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

Pruébalo en línea!

C #, 96

Devuelve -1,0,1 para verdadero, cualquier otra cosa es falsa.

¡Cualquier sugerencia para hacerlo más corto sería maravilloso!

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;}

Forma expandida:

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*;

Explicación: el bloque más interno {.:i,{i\%!},,2=@|\(} determina si la parte superior de la pila es primo al verificar si hay exactamente 2 factores menos que la parte superior de la pila. Luego disjunta esto con el segundo elemento en la pila, que contiene el estado de si ya se ha visto una prima. Finalmente, disminuye el número en la parte superior de la pila.

Comience incrementando la entrada, inicializando el estado de vista principal, y repita el bloque 3 veces. Como esto disminuirá dos veces, pero comenzamos incrementando, esto cubrirá n+1y n-1.

C #, 87 97 caracteres

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 es mucho más joven que este desafío, por lo que esta respuesta no es elegible para la marca de verificación verde (que debe actualizarse a la respuesta de randomra de todos modos). Sin embargo, jugar al golf en realidad fue bastante divertido: comencé con 17 bytes y luego cambié mi enfoque por completo tres veces, ahorrando uno o dos bytes cada vez.

{(3,f+:mp:|}

Este es un bloque, el equivalente más cercano a una función en CJam, que espera la entrada en la pila y deja un 1 (verdadero) o 0 (falso) en la pila.

Pruébalo aquí.

Así es como funciona:

(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 (no competitivos)

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

Pruébalo en línea!

Por eso me encanta el golf de código. Todavía soy muy verde con F #, pero aprendo mucho sobre cómo funciona el lenguaje y qué puede hacer con este tipo de desafíos.

APL (Dyalog Classic) , 20 bytes

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

Pruébalo en línea!

Retina , 22 bytes

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

Pruébalo en línea!

Toma unario como entrada

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;}

Devoluciones true/false como verdad / valores de falsey.

Pruébalo en línea.

Explicación: "

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

Entonces int p(int n)dará como resultado -1for n=0y non-primes, y dará como resultado n-1for n=1o primes. Dado que p(0)+p(1)+p(2)se convertirá -1+0+1 = 0y devolvería falso (aunque 2sea ​​un primo), este n=1es un caso límite con este enfoque.

Un solo bucle sin método separado sería de 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;}

Devuelve 1/0 como verdad / valores de falsey.

Pruébalo en línea.

Explicación:

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.

Pruébalo en línea!

R, 68 caracteres

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

Uso (1 para VERDADERO, 0 para FALSO):

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 caracteres 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 caracteres

   (_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 caracteres

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

8**7 > 2**20 siendo un poco más corto para escribir

Ruby, 47 caracteres pero muy legible

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

C ++ 97

Ugoren parece haberme ganado en la solución inteligente. Entonces es una versión corta en el enfoque de tres veces:

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);}

Adelante (gforth) , 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< ;

Pruébalo en línea!

Explicación

Comprobación principal (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

Función principal (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)

Pruébalo en línea!

Jalea , 5 bytes

‘r’ẒẸ

Pruébalo en línea!

Cómo funciona

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