Bir prime, en yakın diğer primer ondan daha küçükse zayıf demektir. Bir bağ varsa, asal zayıf değildir.

Örneğin 73 zayıf bir asaldır, çünkü 71 asaldır, fakat 75 birleşiktir.

Görev

Daha asal büyüktür verildiğinde bazı bilgisayar kodunu yazın 2 zayıf bir asal sayı ise giriş belirleyecektir olarak. Bu standart bir karar sorunudur, bu yüzden iki durumun her biri için iki benzersiz değer vermelisiniz (örn. weakVe not weak).

Bu kod-golf olduğundan, etiket için standart kurallar geçerlidir.

OEIS

İşte ilk 47 zayıf astar:

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

İşte zayıf asal sayılar için OEIS (geri dönmeli weak) OEIS A051635

İşte dengeli astarlar için OEIS (geri dönmeli not weak) OEIS A006562

İşte güçlü asal sayılar için OEIS (geri dönmeli not weak) OEIS A051634

Jöle , 7 bayt

Æn+Æp>Ḥ

Çevrimiçi deneyin!

açıklama

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

Bir bonus, değiştirme gibi >hiç =veya <sırasıyla, dengeli ve güçlü asal denetler.

Mathematica, 24 bayt

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

NextPrimeYerleşik (ab?) Burayı olumsuz argüman besleyerek önceki asal hesaplamak için kullanılabilir.

Jöle , 9 bayt

ḤÆRạÞ⁸ḊḢ>

İade 1zayıf ve için 0(geri dönüş için zayıf değildir ya da dengeli 1bir giriş için 2)

Çevrimiçi deneyin!

Nasıl?

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

zayıf prime için bir tane ve zayıf prime için hiçbir şey basmaz

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

Çevrimiçi deneyin!

Octave, 93 84 bayt

Bayt tasarrufu için @LuisMendo ve @ rahnema1 için teşekkürler!

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

Çevrimiçi deneyin!

Maxima, 42 bayt

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

Çevrimiçi deneyin!

MATL , 13 bayt

qZq0)G_Yq+GE>

Bu çıkışlar 1zayıf ise, 0aksi halde.

Çevrimiçi deneyin!

açıklama

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 bayt

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

∇f N Bir argüman alan bir işlev bildirir.

(~R∊R∘.×R)/R←1↓⍳N×2argümanın 2 ila iki katı olan tüm asalların bir listesini verir. Bir sonraki asalın orijinalin iki katından daha az olduğunu farz ediyorum. Eğer bu doğru değilse, N*2N karesini verir ve aynı sayıda bayt alır (umarım bir sonraki üssü geçecek kadar büyüktür). (Asal bulmanın nasıl çalıştığı hakkında Wikipedia'nın açıklamasına bakınız)

X←(R←(...))⍳Nbu listeyi vector öğesine atar R(önceki içeriğinin üzerine yazarak), No listedeki orijinal asalın dizinini bulur ve ardından bu dizine atar X.

|R[X-1]-NÖnceki asal arasındaki farkı hesaplar (çünkü Rasalları içerir, X-1th elemanı önceki asaldır N) Nve sonra mutlak değeri alır (APL sağdan sola çalışır).

|R[X+1]-N aynısını yapar, ancak bir sonraki asal için.

(|R[X-1]-N)<|R[X+1]-NÖnceki asıl, asıldaki asıldan bir sonraki aslana göre daha yakınsa 1, aksi takdirde 0 basılır. Parantezler öncelik için gereklidir.

∇ işlevi sonlandırır.

Jöle , 9 bayt

Æp;;ÆnI</

Çevrimiçi deneyin!

Pyth, 15 bayt

>-fP_ThQfPT_tQy

Burada dene.

Pietu1998'in algoritmasını kullanır.

Perl 6 , 41 bayt

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

Çevrimiçi deneyin!

$_işlevin argümanıdır. Eşleme işlevi -> \n { $_ + n, * + n ... &is-prime }bir sayı alır nve $_ + n, $_ + 2*n, ...asal sayıya ulaştığında biten bir sayı dizisi döndürür . İki sayı üzerindeki bu işlevi Haritalama 1ve -1iki sekans bir dizi oluşturur; ilki $_ + 1, ilk asal sayıdan daha büyük $_ile başlar ve ikincisi, asıldan küçük olan $_ - 1birinci asal sayı ile başlar ve biter $_. [>]bu iki elemanlı listeyi, operatörden daha büyük olanlarla azaltır, ilk sıra ikinciden daha büyükse (yani daha uzunsa) true değerini döndürür.

Python 2.7 - 120 bayt

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'un yerleşik bir asal işlevi olmadığı için, güzel bir kısa asal denetleyici elde etmek için Wilson teoremini kullanabiliriz. Wilson teoremi bir sayının asal olduğunu belirtirse (eğer -1)! -1 moduna (n) uygundur. Bundan dolayı, eğer sayı asal ise i, 1 değilse 0 döndürür. Bunu takiben, f işlevi, bu sayıdan sonraki asalın, artırılmak yerine aşağı doğru artırıldığında gerçekleşip gerçekleşmediğini belirler. Artan sayıların hiçbiri asal olmazsa, tekrar tekrar çağırılır.

Bazı örnek I / O

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

Python 2 , 122 108 103 94 92 bayt

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

Çevrimiçi deneyin!

Pietu'nun fikrini kullanır ... ve daha kısa ana liste yineleyicileri oynayarak 28 bayt kurtardı; daha sonra (d'oh!) -3*n>0ile değiştirerek 2 tane daha>3*n

Regex (çoğu lezzetler), 47 bayt

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

Çevrimiçi deneyin!

Tekli girişi alır. Zayıf astarlar için bir eşleşme, zayıf olmayan astarlar için bir eşleşme çıkarmaz. ECMAScript, Perl, PCRE, Python, Ruby'de çalışır.

Açıklama:

Girdi N olsun, A en yakın asal <N ve B en yakın asal> N olsun. Regex yaklaşımının bu zorluğa girmesinin temel zorluğu, B gibi girdilerden daha büyük sayıları temsil edemememizdir. 2b + 1'in asal ve 2b + 1> N olmasını sağlayacak en küçük b'yi bulun;

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

Öyleyse, aslında A'yı bulmamız gerekmediğine dikkat edin. Herhangi bir asal <N, N'den B'ye daha yakın olduğu sürece , N zayıf bir asaldır.

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 bayt

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

Çevrimiçi deneyin!

JavaScript ES6, 162 154 bayt

Jörg Hülsermann hilesiyle "bir davada hiçbir şey basmaz " temelinde 8 bayt tasarruf . ?"Y":"N"Sonra gerek yokone<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 bayt

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

Çevrimiçi deneyin!

Pietu1998'in algoritmasını kullanır.

Python 3 , 149 bayt

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

Çevrimiçi deneyin!

Bu eski yığın takas cevabından alınan bir temel üretme işlevi (üst satır) kullanıyorum .

JavaScript, 98 bayt

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>

Daha az 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
}

Test kodunun giriş "prime" olup olmadığını kontrol etmediğine dikkat edin.

beyin fırtınası , 23 22 bayt

1Zayıf astarlar ve 0zayıf olmayanlar için yazdırır .

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

İzlenecek yol:

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

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 bayt

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

Çevrimiçi deneyin!

İlkellik testi için Wilson teoremini kullanır.