Thách thức của bạn, nếu bạn chọn chấp nhận nó, là mã hóa hàm golf trả về giá trị đúng hoặc sai (hoặc một số đại diện có ý nghĩa tương tự có và không) nếu một số đáp ứng các tiêu chí sau:

1. Số nguyên tự nó là số nguyên tố HOẶC
2. Một trong các số nguyên lân cận của nó là số nguyên tố

Ví dụ:
Một đầu vào 7sẽ trả về True.
Một đầu vào 8cũng sẽ trả về True.
Một đầu vào 15sẽ trả về Sai. (Cả 14, 15 hoặc 16 đều là số nguyên tố)

Đầu vào phải có thể trả về chính xác cho các số trong khoảng từ 2 ^ 0 đến 2 ^ 20, do đó không cần phải lo lắng về các vấn đề về dấu hiệu hoặc tràn số nguyên.

J, 17

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

Trả về booleans được mã hóa dưới dạng mã trả về quy trình: zero cho true, nonzero cho false. Sử dụng mẫu:

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

Haskell, 47 ký tự

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

Con trăn 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)

Lần đầu tiên chơi Code Golf nên có lẽ tôi còn thiếu một số mẹo.

Không phải là một ứng cử viên thực sự về độ ngắn mã bằng bất kỳ phương tiện nào, nhưng vẫn gửi vì xác định tính nguyên thủy bằng biểu thức chính quy bị xoắn theo nhiều cách!

Python (2.x), 85 ký tự

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 hoặc 50 là lambda)

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

hoặc như lambda (sử dụng g[23]để gọi nó)

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

Bản thảo (53)

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

Các Mathicala nhàm chán , 35 giải pháp!

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

C, 112 82 72 ký tự

Theo nhận xét của Ilmari Karonen, đã lưu 30 ký tự bằng cách xóa main, giờ Ptrả về đúng / sai. Cũng thay thế vòng lặp với đệ quy, và một số điều chỉnh thêm.

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

Phiên bản gốc:

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

Toán học, 24 byte

Không biết tại sao bài viết cũ này xuất hiện trong danh sách của tôi ngày hôm nay, nhưng tôi nhận ra Mathematica có tính cạnh tranh ở đây.

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

Hàm không tên lấy một đối số nguyên và trả về Truehoặc False. Trực tiếp thực hiện.

Stax , 6 byte

Ç▀<╝ºΩ

Chạy và gỡ lỗi nó

Giải thích (giải nén):

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

Bản trình diễn: http://jsfiddle.net/ydsxJ/3/

Chỉnh sửa 1: Thay đổi for(i=2;i<j;i++)thành for(i=1;++i<j;)(cảm ơn @minitech). Chuyển đổi iftuyên bố sang ternary. Di chuyển r|=pvà p=1vào bên ngoài forđể loại bỏ niềng răng bên trong. Đã lưu 7 ký tự.

Chỉnh sửa 2: Kết hợp p=1và j++<=nđể p=j++<=n, lưu 2 ký tự (cảm ơn @ugoren).

Regex (ECMAScript), 20 byte

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

Hãy thử trực tuyến!

Phiên bản trên không xử lý chính xác số 0, nhưng chỉ mất thêm 1 byte:

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

Là một phần thưởng bổ sung, đây là một phiên bản mang lại kết quả trả về 1ít hơn một số nguyên tố, 2cho số nguyên tố và 3cho một số nhiều hơn số nguyên tố:

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

Hãy thử trực tuyến!

C #, 96

Nó trả về -1,0,1 cho đúng, bất cứ điều gì khác là sai.

Bất kỳ đề xuất để làm cho nó ngắn hơn sẽ là tuyệt vời!

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

Hình thức mở rộng:

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

Giải thích: Khối trong cùng {.:i,{i\%!},,2=@|\(}xác định xem đỉnh của ngăn xếp có phải là số nguyên tố hay không bằng cách kiểm tra xem có chính xác 2 yếu tố so với đỉnh của ngăn xếp hay không. Sau đó, nó loại bỏ điều này với mục thứ hai trên ngăn xếp, trong đó giữ trạng thái xem một số nguyên tố đã được nhìn thấy chưa. Cuối cùng, nó giảm số trên đỉnh ngăn xếp.

Bắt đầu bằng cách tăng đầu vào, khởi tạo trạng thái nhìn thấy chính và lặp lại khối 3 lần. Vì điều này sẽ giảm hai lần, nhưng chúng tôi đã bắt đầu bằng cách tăng dần, điều này sẽ bao gồm n+1và n-1.

C #, 87 97 ký tự

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 byte

CJam trẻ hơn nhiều so với thử thách này, vì vậy câu trả lời này không đủ điều kiện cho dấu kiểm màu xanh lá cây (cần được cập nhật thành câu trả lời của Randomra). Tuy nhiên, chơi golf này thực sự khá thú vị - tôi đã bắt đầu với 17 byte và sau đó thay đổi cách tiếp cận hoàn toàn ba lần, tiết kiệm một hoặc hai byte mỗi lần.

{(3,f+:mp:|}

Đây là một khối, tương đương gần nhất với một hàm trong CJam, dự kiến ​​đầu vào trên ngăn xếp và để lại 1 (trung thực) hoặc 0 (giả) trên ngăn xếp.

Kiểm tra nó ở đây.

Đây là cách nó làm việc:

(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 byte (không cạnh tranh)

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

Hãy thử trực tuyến!

Đây là lý do tại sao tôi yêu golf mã. Tôi vẫn rất xanh với F # nhưng tôi học được rất nhiều về cách ngôn ngữ hoạt động và những gì nó có thể làm từ những thách thức này.

APL (Dyalog Classic) , 20 byte

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

Hãy thử trực tuyến!

Võng mạc , 22 byte

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

Hãy thử trực tuyến!

Lấy unary làm đầu vào

Java 8, 83 byte

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

Trả về true/ falsenhư giá trị trung thực / falsey.

Hãy thử trực tuyến.

Giải thích: "

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

Vì vậy, int p(int n)sẽ dẫn đến -1cho n=0và không phải số nguyên tố, và sẽ dẫn đến n-1cho n=1hoặc số nguyên tố. Vì p(0)+p(1)+p(2)sẽ trở thành -1+0+1 = 0và sẽ trả về false (mặc dù 2là số nguyên tố), n=1trường hợp cạnh sử dụng phương pháp này.

Một vòng lặp không có phương thức riêng biệt sẽ là 85 byte :

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

Trả về 1/ 0như giá trị trung thực / falsey.

Hãy thử trực tuyến.

Giải trình:

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 byte

´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.

Hãy thử trực tuyến!

R, 68 ký tự

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

Cách sử dụng (1 cho TRUE, 0 cho FALSE):

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 ký tự 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 ký tự

   (_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 ký tự

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

8**7 > 2**20 trong khi viết ngắn hơn một chút

Ruby, 47 ký tự nhưng rất dễ đọc

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

C ++ 97

ugoren dường như đã đánh bại tôi để giải pháp thông minh. Vì vậy, anh ấy là một phiên bản ngắn trên vòng lặp ba lần tiếp cận:

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

Forth (gforth) , 104 byte

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

Hãy thử trực tuyến!

Giải trình

Kiểm tra chính (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

Chức năng chính (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 byte

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

Hãy thử trực tuyến!

Thạch , 5 byte

‘r’ẒẸ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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