Прем'єр слабкий, якщо найближчий інший прайм менший за нього. Якщо є краватка, прайм не слабкий.

Наприклад, 73 є слабким простим рівнем, тому що 71 є простим, але 75 - складним.

Завдання

Напишіть деякий комп’ютерний код, який при введенні простої, що перевищує 2, як вхід визначає, чи є слабким простим. Це стандартна проблема вирішення, тому вам слід вивести два унікальних значення для кожного з двох випадків (наприклад, weakта not weak).

Це код-гольф, тому застосовуються стандартні правила для тегу.

OEIS

Ось перші 47 слабких праймерів:

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

Ось OEIS для слабких прайменів (повинен повернутися weak) OEIS A051635

Ось OEIS для збалансованих прайменів (повинен повернутися not weak) OEIS A006562

Ось ОЕІС для сильних прайменів (повинен повернутися not weak) OEIS A051634

Желе , 7 байт

Æn+Æp>Ḥ

Спробуйте в Інтернеті!

Пояснення

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

В якості бонусу, зміни >в =або <перевірки збалансованих і сильних простих чисел, відповідно.

Математика, 24 байти

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

NextPrimeВбудований можуть бути (аби?) Використовуються для обчислення попереднього прем'єра, подаючи йому негативний аргумент.

Желе , 9 байт

ḤÆRạÞ⁸ḊḢ>

Повертається 1для слабких і 0для слабких або врівноважених (повернення 1для введення 2)

Спробуйте в Інтернеті!

Як?

ḤÆ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 байт

друкує один для слабкого прайму і нічого для не слабкого прайму

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

Спробуйте в Інтернеті!

Октава, 93 84 байт

Дякуємо @LuisMendo та @ rahnema1 за збереження байтів!

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

Спробуйте в Інтернеті!

Максима, 42 байти

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

Спробуйте в Інтернеті!

MATL , 13 байт

qZq0)G_Yq+GE>

Це виходить, 1якщо слабкий, 0інакше.

Спробуйте в Інтернеті!

Пояснення

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 байт

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

∇f N оголошує функцію, яка бере аргумент.

(~R∊R∘.×R)/R←1↓⍳N×2дає список усіх простих чисел від 2 до два рази аргументу. Я припускаю, що наступний прайм є меншим, ніж удвічі більше, ніж початковий. Якщо це неправда, N*2дає N квадрат і займає стільки ж байтів (сподіваємось, це достатньо велика кількість, щоб перевищити наступний прайм). (Дивіться пояснення Вікіпедії про те, як працює основний пошук)

X←(R←(...))⍳Nпризначає цей список вектору R(перезаписуючи його попередній вміст), знаходить Nв цьому списку індекс початкового простого і потім присвоює цьому індексу X.

|R[X-1]-Nобчислює різницю між попереднім простим числом (оскільки Rмістить праймес, цей X-1елемент є простим раніше N), Nа потім приймає абсолютне значення (APL працює справа наліво).

|R[X+1]-N робить те ж саме, але для наступного розквіту.

(|R[X-1]-N)<|R[X+1]-Nдрукує 1, якщо попередній прайм ближче до оригіналу, ніж наступний простір, і 0 в іншому випадку. Для переваги потрібні дужки.

∇ закінчує функцію.

Желе , 9 байт

Æp;;ÆnI</

Спробуйте в Інтернеті!

Pyth, 15 байт

>-fP_ThQfPT_tQy

Спробуйте тут.

Використовує алгоритм Pietu1998.

Perl 6 , 41 байт

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

Спробуйте в Інтернеті!

$_є аргументом функції. Функція відображення -> \n { $_ + n, * + n ... &is-prime }приймає число nі повертає послідовність чисел, $_ + n, $_ + 2*n, ...яка закінчується, коли вона досягає простого числа. Зіставлення цієї функції над двома числами 1і -1створює послідовність з двох послідовностей; перший починається з $_ + 1і закінчується першим простим числом більше $_, а другий починається з $_ - 1першого і закінчується першим простим числом менше, ніж $_. [>]зменшує цей двоелементний список з оператором більшого, ніж оператор, повертаючи істину, якщо перша послідовність більша (тобто довша), ніж друга.

Python 2.7 - 120 байт

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)

Оскільки в python немає вбудованої функції - прайм, ми можемо використовувати теорему Вілсона, щоб отримати хороший короткий прапор. Теорема Вілсона стверджує, що число є простим тоді і лише тоді, коли (n-1)! конгруентний до -1 mod (n). Отже, функція i поверне 1, якщо число є простим, і 0, якщо це не так. Виходячи з цього, функція f визначає, чи буде наступний простим числом з цього числа першим при збільшенні вниз, а не збільшенням вгору. Якщо жодне із збільшених чисел не є простим, воно повторно викликається повторно.

Деякі приклади вводу-виводу

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

Python 2 , 122 108 103 94 92 байт

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

Спробуйте в Інтернеті!

Використовує ідею Піетю ..., а потім врятував 28 байт, погравши в гольф ітераторів коротших списків; потім ще 2 замінивши -3*n>0на >3*n(d'oh!)

Регекс (більшість ароматів), 47 байт

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

Спробуйте в Інтернеті!

Здійснює введення в одинаковому режимі. Виводить відповідність для слабких прайменів, не відповідає слабким праймем. Працює в ECMAScript, Perl, PCRE, Python, Ruby.

Пояснення:

Нехай N є вхідним, A найближчим простим <N, а B найближчим простим> N. Основна складність підходу регулярного вираження до цього виклику полягає в тому, що ми не можемо представити числа, більші за вхід, як B. Натомість ми знайдіть найменший b такий, що 2b + 1 є простим, а 2b + 1> N, що забезпечує 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)
)

Тоді зауважте, що насправді нам не потрібно знаходити А. Поки будь - який простий <N ближче до N, ніж B, N є слабким простим.

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

Октава, 53 байти

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

Спробуйте в Інтернеті!

JavaScript ES6, 162 154 байт

Збережіть 8 байт, виходячи з хитрості Йорга Гюльсермана "нічого не надрукувати в одному випадку". Не потрібно ?"Y":"N"післяone<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 байт

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

Спробуйте в Інтернеті!

Використовує алгоритм Pietu1998.

Python 3 , 149 байт

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

Спробуйте в Інтернеті!

Я використовую основну функцію генерації (верхній рядок), взяту з цієї старої відповіді обміну стеками.

JavaScript, 98 байт

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>

Менше Голфед

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
}

Зверніть увагу, що тестовий код не перевіряє, що вхід "prime" насправді є простим.

braingasm , 23 22 байт

Відбитки 1для слабких прайменів і 0для слабких.

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

Покрокова інструкція:

;                       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

Джулія 0,6, 64 байти

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 байт

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

Спробуйте в Інтернеті!

Використовує теорему Вілсона для тесту на первинність.