Một số nguyên tố yếu nếu số nguyên tố gần nhất khác nhỏ hơn nó. Nếu có sự ràng buộc thì nguyên tố không yếu.

Ví dụ 73 là số nguyên tố yếu vì 71 là số nguyên tố nhưng 75 là số nguyên tố .

Bài tập

Viết một số mã máy tính mà khi đưa ra một số nguyên tố lớn hơn 2 làm đầu vào sẽ xác định xem đó có phải là một số nguyên tố yếu hay không. Đây là một vấn đề quyết định tiêu chuẩn , do đó bạn nên xuất hai giá trị duy nhất cho mỗi trường hợp (ví dụ weakvà not weak).

Đây là mã golf nên quy tắc chuẩn cho thẻ được áp dụng.

OEIS

Dưới đây là 47 số nguyên tố yếu đầu tiên:

3, 7, 13, 19, 23, 31, 43, 47, 61, 73, 83, 89, 103, 109, 113, 131, 139, 151, 167, 181, 193, 199, 229, 233, 241, 271, 283, 293, 313, 317, 337, 349, 353, 359, 383, 389, 401, 409, 421, 433, 443, 449, 463, 467, 491, 503, 509, 523, 547, 571, 577, 601, 619, 643, 647

Đây là OEIS cho các số nguyên tố yếu (nên trả về weak) OEIS A051635

Đây là OEIS cho các số nguyên tố cân bằng (nên trả về not weak) OEIS A006562

Đây là OEIS cho các số nguyên tố mạnh (nên trả về not weak) OEIS A051634

Thạch , 7 byte

Æn+Æp>Ḥ

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

Giải trình

           See if
Æn         the next prime
  +Æp      plus the previous prime
     >Ḥ    is greater than 2n

Như một phần thưởng, thay đổi >đến =hoặc <kiểm tra các số nguyên tố cân bằng và mạnh mẽ, tương ứng.

Toán học, 24 byte

n=NextPrime;2#+n@-#<n@#&

Các NextPrimeđược xây dựng-in có thể được (ab?) Được sử dụng để tính toán thủ trước bằng cách cho ăn nó một cuộc tranh luận tiêu cực.

Thạch , 9 byte

ḤÆRạÞ⁸ḊḢ>

Trả về 1 cho yếu và 0không yếu hoặc cân bằng (trả về 1cho đầu vào của 2)

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

Làm sao?

ḤÆRạÞ⁸ḊḢ> - Link: prime number > 2, p
Ḥ         - double -> 2*p
 ÆR       - yield primes between 2 and 2*p inclusive
     ⁸    - chain's left argument, p
    Þ     - sort by:
   ạ      -   absolute difference (i.e. distance from p)
      Ḋ   - dequeue (removes p from the list, since it has distance zero)
       Ḣ  - head (gives us the nearest, if two the smallest of the two)
        > - greater than p?

PHP , 69 byte

in một cho số nguyên tố yếu và không có gì cho số nguyên tố không yếu

for(;!$t;$t=$d<2)for($n=$d=$argn+$i=-$i+$w^=1;$n%--$d;);echo$n<$argn;

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

Octave, 93 84 byte

Cảm ơn @LuisMendo và @ rahnema1 vì đã lưu byte!

function r=f(x);i=j=x;do--i;until(i<1|isprime(i));do++j;until(isprime(j));r=x-i<j-x;

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

Tối đa, 42 byte

f(n):=is(n-prev_prime(n)<next_prime(n)-n);

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

MATL , 13 byte

qZq0)G_Yq+GE>

Điều này đầu ra 1nếu yếu, 0nếu không.

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

Giải trình

q      % Implicit input, Subtract 1
Zq     % Vector of primes up to that
0)     % Get last one
G      % Push input again
_Yq    % Next prime
+      % Add
G      % Push input
E      % Multiply by 2
>      % Greater than? Implicit display

GNU APL 1.2, 78 byte

∇f N
X←(R←(~R∊R∘.×R)/R←1↓⍳N×2)⍳N
(|R[X-1]-N)<|R[X+1]-N
∇

∇f N khai báo một hàm có một đối số.

(~R∊R∘.×R)/R←1↓⍳N×2đưa ra một danh sách tất cả các số nguyên tố từ 2 đến hai lần đối số. Tôi giả định rằng số nguyên tố tiếp theo ít hơn hai lần so với bản gốc. Nếu điều này là không đúng sự thật, hãy N*2cho N bình phương và lấy cùng số byte (hy vọng nó đủ lớn để vượt quá số nguyên tố tiếp theo). (Xem phần giải thích của Wikipedia để biết cách hoạt động của công cụ tìm kiếm chính)

X←(R←(...))⍳Ngán danh sách đó cho vectơ R(ghi đè nội dung trước đó của nó), tìm chỉ mục của số nguyên tố gốc Ntrong danh sách đó và sau đó gán chỉ mục đó cho X.

|R[X-1]-Ntính toán sự khác biệt giữa số nguyên tố trước (vì Rchứa các số nguyên tố, X-1phần tử thứ là số nguyên tố trước N) Nvà sau đó lấy giá trị tuyệt đối (APL hoạt động từ phải sang trái).

|R[X+1]-N làm như vậy, nhưng cho các nguyên tố tiếp theo.

(|R[X-1]-N)<|R[X+1]-Nin 1 nếu số nguyên tố trước gần với nguyên bản hơn số nguyên tố tiếp theo và 0 khác. Dấu ngoặc đơn là cần thiết cho quyền ưu tiên.

∇ kết thúc chức năng.

Thạch , 9 byte

Æp;;ÆnI</

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

Bình thường, 15 byte

>-fP_ThQfPT_tQy

Hãy thử nó ở đây.

Sử dụng thuật toán của Pietu1998.

Perl 6 , 41 byte

{[>] map ->\n{$_+n,*+n...&is-prime},1,-1}

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

$_là đối số của hàm. Hàm ánh xạ -> \n { $_ + n, * + n ... &is-prime }lấy một số nvà trả về một chuỗi các số $_ + n, $_ + 2*n, ...kết thúc khi nó đạt đến một số nguyên tố. Ánh xạ hàm này qua hai số 1và -1tạo ra một chuỗi gồm hai chuỗi; số thứ nhất bắt đầu bằng $_ + 1và kết thúc bằng số nguyên tố thứ nhất lớn hơn $_và số thứ hai bắt đầu bằng $_ - 1và kết thúc bằng số nguyên tố thứ nhất nhỏ hơn $_. [>]giảm danh sách hai phần tử này với toán tử lớn hơn toán tử, trả về giá trị true nếu chuỗi thứ nhất lớn hơn (nghĩa là dài hơn) thứ hai.

Python 2.7 - 120 byte

from math import*
i=lambda x:factorial(x-1)%x==x-1
def f(n,c):return 1 if i(n-c)>i(n+c) else 0 if i(n+c)>0 else f(n,c+1)

Vì python không có hàm tích hợp là hàm nguyên tố, nên chúng ta có thể sử dụng định lý Wilson để có một trình kiểm tra nguyên tố ngắn đẹp. Định lý Wilson nói rằng một số là số nguyên tố khi và chỉ khi (n-1)! phù hợp với -1 mod (n). Do đó hàm i sẽ trả về 1 nếu số là số nguyên tố và 0 nếu không. Theo đó, hàm f sẽ xác định xem số nguyên tố tiếp theo từ số đó xảy ra đầu tiên khi tăng xuống chứ không tăng lên. Nếu cả hai số nguyên tố không tăng, nó chỉ được gọi lại một cách đệ quy.

Một số ví dụ I / O

f(3,1)
1
f(15,1)
0

Python 2 , 122 108 103 94 92 byte

def a(n):
 r=[2];x=2
 while r[-1]<=n:x+=1;r+=[x]*all(x%i for i in r)
 return sum(r[-3:])>3*n

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

Sử dụng ý tưởng của Pietu ... và sau đó lưu 28 byte bằng cách lặp các trình lặp danh sách chính ngắn hơn; sau đó thêm 2 bằng cách thay thế -3*n>0bằng >3*n(d'oh!)

Regex (hầu hết các hương vị), 47 byte

^(?=(x*)(?!(x+)(\2\2x)+$)\1)x+(?!(xx+)\4+$)\1\1

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

Đưa đầu vào trong unary. Xuất ra một trận đấu cho các số nguyên tố yếu, không khớp với các số nguyên tố không yếu. Hoạt động trong ECMAScript, Perl, PCRE, Python, Ruby.

Giải trình:

Đặt N là đầu vào, A là số nguyên tố gần nhất <N và B là số nguyên tố gần nhất> N. Khó khăn chính của cách tiếp cận regex đối với thách thức này là chúng ta không thể biểu diễn các số lớn hơn đầu vào, như B. Thay vào đó, chúng ta tìm b nhỏ nhất sao cho 2b + 1 là số nguyên tố và 2b + 1> N, đảm bảo 2b + 1 = B.

(?=
  (x*)              # \1 = N - b, tail = b
  (?!(x+)(\2\2x)+$) # Assert 2b + 1 is prime
  \1                # Assert b ≥ \1 (and thus 2b + 1 > N)
)

Sau đó, lưu ý rằng chúng ta thực sự không cần tìm A. Miễn là bất kỳ số nguyên tố <N nào gần với N hơn B, N là một số nguyên tố yếu.

x+                  # tail iterates over integers < N
(?!(xx+)\4+$)       # assert tail is prime
\1\1                # assert tail ≥ 2 * \1 (and thus tail + B > 2N)

Octave, 53 byte

@(n)diff(list_primes(h=nnz(primes(n))+1)(h-2:h),2)>0

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

JavaScript ES6, 162 154 byte

Lưu 8 byte dựa trên thủ thuật của Jörg Hülsermann "không in gì trong một trường hợp". Không cần ?"Y":"N"sauone<two

var isWeak=

a=>{p=[2];i=0;f=d=>{j=p[i];l:while(j++){for(x=0;p[x]*p[x]<=j;x++){if(j%p[x]==0){continue l}}return p[++i]=j}};while(p[i]<a+1){f()};return a*2<p[i]+p[i-2]}

[43,//true
53,//false
7901,//false
7907,//true
1299853,//true
1299869//false
].forEach(n=>{console.log(n,isWeak(n))})

05AB1E , 17 byte

[<Dp#]¹[>Dp#]+¹·›

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

Sử dụng thuật toán của Pietu1998.

Python 3 , 149 byte

f=lambda n,k=1,P=1:n*[0]and P%k*[k]+f(n-P%k,k+1,P*k*k)
def a(n):p=f(n);return p.index(n)in filter(lambda i:p[i]-p[i-1]<p[i+1]-p[i],range(1,len(p)-1))

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

Tôi đang sử dụng hàm tạo nguyên tố (dòng trên cùng) được lấy từ câu trả lời trao đổi ngăn xếp cũ này.

JavaScript, 98 byte

let test = _=>(o.innerHTML=f(+prime.value))
let f= 

n=>{P=n=>{for(i=n,p=1;--i>1;)p=p&&n%i};a=b=n;for(p=0;!p;P(--a));for(p=0;!p;P(++b));return n-a<b-n}

Enter Prime: <input id="prime">
<button type="button" onclick="test()">test if weak</button>
<pre id="o"></pre>

Ít Golphed

n=>{
   P=  // is a Prime greater than 1, result in p
       n=>{
           for(i=n,p=1;--i>1;)
               p=p&&n%i
       };

   a=b=n; // initialize lower and upper primes to n
   for(p=0;!p;P(--a)); // find lower,
   for(p=0;!p;P(++b)); // find upper,
   return n-a<b-n // is weak result
}

Lưu ý mã kiểm tra không kiểm tra "số nguyên tố" đầu vào thực sự là số nguyên tố.

braingasm , 23 22 byte

In 1cho số nguyên tố yếu và 0không yếu.

;>0$+L[->+>2[>q[#:Q]]]

Hướng dẫn:

;                       Read a number to cell 0
 >0$+                   Go to cell 1 and copy the value of cell 0
     L                  Make the tape wrap around after cell 1
      [              ]  Loop:
       ->+>               Decrease cell 1 and increase cell 0
           2[       ]     Twice do:
             >              Go to the other cell
              q[   ]        If it's prime:
                #:Q         Print the current cell number and quit

Julia 0,6, 64 byte

g(x,i)=0∉x%(2:x-1)?1:1+g(x+i,i);x->g(x,1)&(g(x-1,-1)<g(x+1,1))

Python 2 , 81 byte

n=input()
a=b=c=i=2;p=1
while b<n:
 p*=i;i+=1
 if p*p%i:a,b,c=b,c,i
print a+c>2*b

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

Sử dụng định lý Wilson cho bài kiểm tra nguyên thủy.