एक प्राइमरी कमजोर होती है यदि निकटतम अन्य प्राइम उससे छोटा होता है। यदि कोई टाई है तो प्राइम कमजोर नहीं है।

उदाहरण के लिए 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

यहाँ कमजोर primes के लिए OEIS है (वापस लौटना चाहिए weak) OEIS A051635

यहाँ संतुलित अपराधों के लिए OEIS (वापस आना चाहिए not weak) OEIS A006562 है

यहाँ मजबूत primes के लिए OEIS है (वापस जाना चाहिए not weak) OEIS A051634

— गेहूं का जादूगर
स्रोत

not weakया strong?

— कैलकुलेटर

7

@CalculatorFeline कमजोर से मजबूत नहीं है

— गेहूं जादूगर

26

जेली , 7 बाइट्स

Æn+Æp>Ḥ

इसे ऑनलाइन आज़माएं!

व्याख्या

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

एक बोनस के रूप में , क्रमशः संतुलित और मजबूत अपराधों के लिए बदल रहा >है =या <जाँच कर रहा है।

— PurkkaKoodari
स्रोत

वह होना चाहिए >, नहीं?

— डेनिस

2

अरे वाह, यह चालाक है ...

— ETHproductions

मैंने अभी इस तरह से भी काम किया है। अच्छा काम!

— जोनाथन एलन

यह बहुत चालाक है ...

— निकोलर जूल

12

गणितज्ञ, 24 बाइट्स

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

NextPrimeनिर्मित में (अब?) यह एक नकारात्मक तर्क खिला द्वारा पिछले प्रधानमंत्री गणना करने के लिए इस्तेमाल किया जा सकता।

— मार्टिन एंडर
स्रोत

6

जेली , 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?

— जोनाथन एलन
स्रोत

निंजा मुझे एक जटिल समाधान के साथ चाहेंगे ...

— आउटगॉल्फ जूल

यह एक दूसरा विभाजन था!

— जोनाथन एलन

1

नहीं, यह 9 पूर्ण सेकंड iirc नहीं था। नहीं, 10 सेकंड।

— निकोलर जूल

तो यह (समय को देखते हुए) यह हुआ जैसा कि मैंने यहां प्रस्तुत किया :) :)

— जोनाथन एलन

1

ठीक है, ऐसा लगता है तुम सिर्फ तेजी से मुझ से (इसे से पहले जाने के लिए काफी एक यात्रा है golfed ... IIṠ⁼1करने II>0के लिए I<\) ... तुम्हारा बहुत अलग हालांकि है। ऐसा लगता है कि आप मुझसे अलग सोचते हैं ... EDIT: Pietu1998 लौट आया!

— आउटगोल्फ जूल

5

PHP , 69 बाइट्स

कमजोर प्रधान के लिए एक प्रिंट और कमजोर प्रधानमंत्री के लिए कुछ भी नहीं

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

इसे ऑनलाइन आज़माएं!

— जार्ग हुल्सरमन
स्रोत

3

ऑक्टेव, 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;

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत

आप i-=1आदि का उपयोग नहीं कर सकते ? इसके अलावा, endफ़ंक्शन में आवश्यक नहीं है; आप इसे पाद लेख पर ले जा सकते हैं

— लुइस मेंडू

3

मैक्सिमा, 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— rahnema1
स्रोत

3

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

— लुइस मेंडो
स्रोत

3

जीएनयू एपीएल 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×22 से दो बार तर्क से सभी अपराधों की एक सूची देता है। मैं मान रहा हूं कि अगला प्राइम दो बार मूल से कम है। यदि यह असत्य है, तो N*2N वर्ग देता है और समान संख्या में बाइट्स लेता है (उम्मीद है कि यह अगले प्राइम को पार करने के लिए काफी बड़ा है)। (देखें कि विकिपीडिया की व्याख्या कैसे-कैसे काम करती है)

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]-N1 प्रिंट करता है अगर पिछले प्राइम अगले प्राइम की तुलना में मूल के करीब है और 0 अन्यथा। वरीयता के लिए कोष्ठक की आवश्यकता होती है।

∇ फ़ंक्शन को समाप्त करता है।

— Arc676
स्रोत

2

जेली , 9 बाइट्स

Æp;;ÆnI</

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत

2

अजगर, 15 बाइट्स

>-fP_ThQfPT_tQy

इसे यहाँ आज़माएँ।

Pietu1998 के एल्गोरिथ्म का उपयोग करता है।

— आउटग्रॉफर को एरिक करें
स्रोत

2

पर्ल 6 , 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

$_फ़ंक्शन का तर्क है। मैपिंग फ़ंक्शन -> \n { $_ + n, * + n ... &is-prime }एक संख्या लेता है nऔर संख्याओं का एक क्रम देता है $_ + n, $_ + 2*n, ...जो एक प्रमुख संख्या तक पहुंचने पर समाप्त होता है। इस फ़ंक्शन को दो संख्याओं पर मैप करना 1और -1दो अनुक्रमों का एक क्रम उत्पन्न करता है; पहले के साथ शुरू होता है $_ + 1और पहले से अधिक संख्या के साथ समाप्त होता है $_, और दूसरे से शुरू होता है $_ - 1और पहले से कम संख्या के साथ समाप्त होता है $_। [>]इस दो-तत्व की सूची को अधिक से अधिक परिचालक के साथ कम कर देता है, यदि दूसरा क्रम पहले से अधिक (यानी, लंबा) हो तो सही वापस लौटता है।

— शॉन
स्रोत

2

पायथन 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)

चूंकि अजगर में एक अंतर्निहित कार्य नहीं होता है, इसलिए हम एक अच्छा शॉर्ट प्राइम चेकर प्राप्त करने के लिए विल्सन के प्रमेय का उपयोग कर सकते हैं। विल्सन के प्रमेय में कहा गया है कि एक संख्या अभाज्य है यदि और केवल यदि (n-1)! -1 अनुरूप (n) के अनुरूप है। यदि संख्या अभाज्य है और 0 नहीं है, तो इसलिए मैं फ़ंक्शन 1 पर वापस आऊंगा। उसके बाद f फ़ंक्शन यह निर्धारित करेगा कि क्या उस नंबर से अगला प्राइम पहले होता है जब वेतन वृद्धि के बजाय बढ़ा हुआ होता है। यदि दोनों में से कोई भी वृद्धि संख्या प्रधान नहीं है, तो यह केवल पुनरावर्ती है।

कुछ उदाहरण I / O

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

— जो हाबेल
स्रोत

2

पायथन 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(डी 'ओह!)

— चास ब्राउन
स्रोत

2

रेगेक्स (सबसे जायके), 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अनरीट में इनपुट लेता है। कमजोर अपराधों के लिए एक मैच का उत्पादन करता है, गैर-कमजोर अपराधों के लिए कोई मैच नहीं। ईसीएमएस्क्रिप्ट, पर्ल, पीसीआरई, पायथन, रूबी में काम करता है।

स्पष्टीकरण:

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

फिर, ध्यान दें कि हमें वास्तव में ए को खोजने की आवश्यकता नहीं है। जब तक कि कोई भी प्रधानमंत्री बी की तुलना में एन के करीब है, एन एक कमजोर प्रधानमंत्री है।

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

— ग्रिमी
स्रोत

1

ऑक्टेव, 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— rahnema1
स्रोत

1

जावास्क्रिप्ट ईएस 6, 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))})

स्निपेट का विस्तार करें

— Оввгений Новиков
स्रोत

0

05AB1E , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Pietu1998 के एल्गोरिथ्म का उपयोग करता है।

— आउटग्रॉफर को एरिक करें
स्रोत

0

पायथन 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))

इसे ऑनलाइन आज़माएं!

मैं इस पुराने स्टैक एक्सचेंज के उत्तर से लिया गया प्राइम जनरेटिंग फंक्शन (टॉप लाइन) का उपयोग कर रहा हूं ।

— wrymug
स्रोत

0

जावास्क्रिप्ट, 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
}

ध्यान दें कि परीक्षण कोड इनपुट की जांच नहीं करता है "प्राइम" वास्तव में एक प्रमुख है।

— traktor53
स्रोत

0

ब्रिंगस्म , 23 22 बाइट्स

1कमजोर primes के लिए और कमजोर के लिए प्रिंट 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

— daniero
स्रोत

0

जूलिया 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))

— Tanj
स्रोत

0

पायथन 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

इसे ऑनलाइन आज़माएं!

प्राइमलिटी टेस्ट के लिए विल्सन के प्रमेय का उपयोग करता है।

— मील की दूरी पर
स्रोत

क्या यह एक कमजोर प्रधान है?

कार्य

OEIS

जेली , 7 बाइट्स

व्याख्या

गणितज्ञ, 24 बाइट्स

जेली , 9 बाइट्स

कैसे?

PHP , 69 बाइट्स

ऑक्टेव, 93 84 बाइट्स

मैक्सिमा, 42 बाइट्स

MATL , 13 बाइट्स

व्याख्या

जीएनयू एपीएल 1.2, 78 बाइट्स

जेली , 9 बाइट्स

अजगर, 15 बाइट्स

पर्ल 6 , 41 बाइट्स

पायथन 2.7 - 120 बाइट्स

पायथन 2 , 122 108 103 94 92 बाइट्स

रेगेक्स (सबसे जायके), 47 बाइट्स

ऑक्टेव, 53 बाइट्स

जावास्क्रिप्ट ईएस 6, 162 154 बाइट्स

05AB1E , 17 बाइट्स

पायथन 3 , 149 बाइट्स

जावास्क्रिप्ट, 98 बाइट्स

ब्रिंगस्म , 23 22 बाइट्स

जूलिया 0.6, 64 बाइट्स

पायथन 2 , 81 बाइट्स