Простое число является слабым, если ближайшее другое простое число меньше его. Если есть связь, простое число не является слабым.

Например, 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

Вот OEIS для сильных простых чисел (должен вернуться not weak) OEIS A051634

Желе , 7 байт

Æn+Æp>Ḥ

Попробуйте онлайн!

объяснение

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

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

Mathematica, 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элемент th является простым перед 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 мод (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'ах!)

Regex (большинство ароматов), 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)
)

Затем обратите внимание, что нам на самом деле не нужно находить A. Пока любое простое число <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
}

Обратите внимание, что тестовый код не проверяет, что вход «простое» на самом деле является простым.

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

Попробуйте онлайн!

Использует теорему Вильсона для теста простоты.