Prime adalah lemah jika prime lainnya terdekat lebih kecil dari itu. Jika ada dasi prima tidak lemah.

Misalnya 73 adalah bilangan prima yang lemah karena 71 adalah bilangan prima tetapi 75 adalah komposit.

Tugas

Tulis beberapa kode komputer yang ketika diberi prime lebih besar dari 2 sebagai input akan menentukan apakah itu prime lemah. Ini adalah masalah keputusan standar sehingga Anda harus menampilkan dua nilai unik untuk masing-masing dari dua kasus (misalnya weakdan not weak).

Ini adalah kode-golf sehingga aturan standar untuk tag berlaku.

OEIS

Berikut adalah 47 bilangan prima lemah pertama:

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

Berikut adalah OEIS untuk bilangan prima yang lemah (harus kembali weak) OEIS A051635

Berikut adalah OEIS untuk bilangan prima seimbang (harus kembali not weak) OEIS A006562

Berikut adalah OEIS untuk bilangan prima yang kuat (harus kembali not weak) OEIS A051634

Jelly , 7 byte

Æn+Æp>Ḥ

Cobalah online!

Penjelasan

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

Sebagai bonus, mengubah >ke =atau <cek untuk bilangan prima yang seimbang dan kuat, masing-masing.

Mathematica, 24 byte

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

Itu NextPrime built-in dapat (ab?) Digunakan untuk menghitung perdana sebelumnya dengan memberi makan argumen negatif.

Jelly , 9 byte

ḤÆRạÞ⁸ḊḢ>

Pengembalian 1untuk yang lemah dan0 tidak lemah atau seimbang (pengembalian 1untuk input 2)

Cobalah online!

Bagaimana?

ḤÆ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

mencetak satu untuk prime lemah dan tidak ada untuk prime tidak lemah

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

Cobalah online!

Oktaf, 93 84 byte

Terima kasih kepada @LuisMendo dan @ rahnema1 untuk menghemat 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;

Cobalah online!

Maxima, 42 byte

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

Cobalah online!

MATL , 13 byte

qZq0)G_Yq+GE>

Ini menghasilkan 1jika lemah,0 sebaliknya.

Cobalah online!

Penjelasan

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 mendeklarasikan fungsi yang mengambil argumen.

(~R∊R∘.×R)/R←1↓⍳N×2memberikan daftar semua bilangan prima dari 2 hingga dua kali argumen. Saya berasumsi bahwa prime berikutnya kurang dari dua kali yang asli. Jika ini tidak benar, N*2beri N kuadrat dan ambil jumlah byte yang sama (mudah-mudahan itu cukup besar untuk melampaui perdana berikutnya). (Lihat penjelasan Wikipedia tentang cara kerja penemuan perdana)

X←(R←(...))⍳Nmenetapkan daftar itu ke vektor R(menimpa konten sebelumnya), menemukan indeks prime asli Ndalam daftar itu, dan kemudian menetapkan indeks itu untuk X.

|R[X-1]-Nmenghitung perbedaan antara prime sebelumnya (karena Rmengandung bilangan prima, X-1elemen th adalah prime sebelum N) Ndan kemudian mengambil nilai absolut (APL beroperasi dari kanan ke kiri).

|R[X+1]-N melakukan hal yang sama, tetapi untuk prime berikutnya.

(|R[X-1]-N)<|R[X+1]-Nmencetak 1 jika prime sebelumnya lebih dekat ke yang asli dari prime berikutnya dan 0 sebaliknya. Kurung dibutuhkan untuk diutamakan.

∇ mengakhiri fungsi.

Jelly , 9 byte

Æp;;ÆnI</

Cobalah online!

Pyth, 15 byte

>-fP_ThQfPT_tQy

Coba di sini.

Menggunakan algoritma Pietu1998.

Perl 6 , 41 byte

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

Cobalah online!

$_adalah argumen untuk fungsi tersebut. Fungsi pemetaan -> \n { $_ + n, * + n ... &is-prime }mengambil angka ndan mengembalikan urutan angka $_ + n, $_ + 2*n, ...yang berakhir ketika mencapai angka prima. Memetakan fungsi ini pada dua angka 1dan -1menghasilkan urutan dua urutan; yang pertama dimulai dengan $_ + 1dan berakhir dengan bilangan prima pertama lebih besar dari $_, dan yang kedua dimulai dengan $_ - 1dan berakhir dengan bilangan prima pertama lebih kecil dari $_. [>]mengurangi daftar dua elemen ini dengan operator lebih besar dari, mengembalikan true jika urutan pertama lebih besar (yaitu, lebih lama) dari yang kedua.

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)

Karena python tidak memiliki built-in adalah fungsi prima, kita dapat menggunakan teorema Wilson untuk mendapatkan pemeriksa prime pendek yang bagus. Teorema Wilson menyatakan bahwa angka adalah prima jika dan hanya jika (n-1)! kongruen dengan -1 mod (n). Oleh karena itu fungsi saya akan mengembalikan 1 jika bilangan prima dan 0 jika tidak. Setelah itu fungsi f akan menentukan apakah bilangan prima berikutnya dari angka itu terjadi pertama kali ketika naik turun daripada naik naik. Jika tidak satu pun dari angka yang dinaikkan yang prima, itu hanya dipanggil secara rekursif lagi.

Beberapa contoh 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

Cobalah online!

Menggunakan ide Pietu ... dan kemudian menghemat 28 byte dengan memainkan iterator daftar utama yang lebih pendek; lalu 2 lainnya dengan mengganti -3*n>0dengan >3*n(d'oh!)

Regex (kebanyakan rasa), 47 byte

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

Cobalah online!

Mengambil input di unary. Menghasilkan kecocokan untuk bilangan prima yang lemah, tidak ada kecocokan untuk bilangan prima yang tidak lemah. Bekerja dalam ECMAScript, Perl, PCRE, Python, Ruby.

Penjelasan:

Biarkan N menjadi input, A prime terdekat <N, dan B prime terdekat> N. Kesulitan utama dari pendekatan regex untuk tantangan ini adalah bahwa kami tidak dapat mewakili angka yang lebih besar dari input, seperti B. Sebaliknya, kami temukan b terkecil sehingga 2b + 1 adalah prima dan 2b + 1> N, yang memastikan 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)
)

Kemudian, catatan bahwa kita tidak benar-benar perlu untuk menemukan A. Selama setiap prime <N lebih dekat dengan N dari B, N adalah prima lemah.

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

Oktaf, 53 byte

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

Cobalah online!

JavaScript ES6, 162 154 byte

Hemat 8 byte berdasarkan trik Jörg Hülsermann "tidak mencetak apa pun dalam satu kasus". Tidak perlu ?"Y":"N"setelah ituone<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#]+¹·›

Cobalah online!

Menggunakan algoritma 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))

Cobalah online!

Saya menggunakan fungsi pembangkit prima (baris atas) yang diambil dari jawaban pertukaran tumpukan lama ini.

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>

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

Perhatikan kode tes tidak memeriksa input "prima" sebenarnya prima.

braingasm , 23 22 byte

Mencetak 1untuk bilangan prima lemah dan 0tidak lemah.

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

Panduan:

;                       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

Cobalah online!

Menggunakan teorema Wilson untuk tes primality.