बर्ट्रेंड की प्राइम्स

24

बर्ट्रेंड के पोस्टुलेट में कहा गया है कि प्रत्येक पूर्णांक n is 1 के लिए कम से कम एक प्राइम p ऐसा है कि n <p Post 2n । N <4000 के लिए इस प्रमेय को सत्यापित करने के लिए हमें 4000 मामलों की जाँच करने की आवश्यकता नहीं है: Landau चाल कहती है कि यह जाँचना पर्याप्त है

2, 3, 5, 7, 13, 23, 43, 83, 163, 317, 631, 1259, 2503, 5003

सभी प्रधान हैं क्योंकि इनमें से प्रत्येक संख्या अपने पूर्ववर्ती से दोगुने से कम है, प्रत्येक अंतराल {y: n <y n 2n} में कम से कम एक प्रमुख संख्या है।

संख्याओं का यह क्रम बर्ट्रैंड प्राइम्स (OEIS A006992) हैं और इन्हें निम्नानुसार परिभाषित किया गया है:

a(1) = 2
a(n) = largest prime below 2a(n-1)

चुनौती

इस क्रम को लागू करें। आप लिख सकते हैं

  • एक फ़ंक्शन या प्रोग्राम जिसने कुछ एन रिटर्न दिए हैं (एन) (0 या 1 अनुक्रमित),
  • एक फ़ंक्शन या प्रोग्राम जिसने कुछ n दिए , इस क्रम की पहली n (या n-1 या n + 1 ) प्रविष्टियाँ
  • एक अनंत सूची या स्ट्रीम या जनरेटर या आपके लैंग्वेज में समान समकक्ष।
code-golf  number  sequence  number-theory  primes 
— flawr
स्रोत

जवाबों:

8

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

k=2
do k=primes(k+k)(end)until 0

मूल्यों को अनिश्चित काल के लिए मुद्रित करता रहता है (प्रत्येक मान पूर्व होता है k =)।

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

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

k=2
for i=2:input('')k=primes(k+k)(end)end

N को इनपुट के रूप में लेता है और n प्रथम मानों को आउटपुट करता है (प्रत्येक मान पहले से है k =)।

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

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

k=2;for i=2:input('')k=primes(k+k)(end);end
disp(k)

करने के लिए इसी तरह के लुइस Mendo के Matl जवाब । N को इनपुट के रूप में लेता है और एक (n) (1-अनुक्रमित) को आउटपुट करता है ।

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

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

k=2;for i=2:input('')k*=2;while~isprime(--k)
end
end
disp(k)

N को इनपुट के रूप में लेता है और एक (n) (1-अनुक्रमित) को आउटपुट करता है ।

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

— Steadybox
स्रोत
6

05AB1E , 14 7 6 बाइट्स

$F·.ØØ

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

1-अनुक्रमित उत्तर (जब तक कि उत्पादन 1 माना जाता है), स्पष्टीकरण:

$       # Push 1 and input (n)...
 F      # n-times do... 
  ·     # Double the current prime (first iteration is 1*2=2).
   .ØØ  # Find prime slightly less than double the current prime.

यह 1-अनुक्रमित है क्योंकि सभी पुनरावृत्तियों के साथ एक 'डमी' पुनरावृत्ति है n=1।

— जादू ऑक्टोपस Urn
स्रोत
Fx.ØØबहुत करीब है ... ऊपर कुछ भी काम करता है n > 2।
— मैजिक ऑक्टोपस Urn
1
मेरे पास $F·ÅPθउसी बाइट की गिनती थी।
— एमिगा
@ इग्नू के पास था? वह 0% समान हाहा है। मेरा मतलब है, तकनीकी रूप से वही है, लेकिन नहीं। अभी भी इसे पोस्ट कर सकते हैं? पी।
— जादू ऑक्टोपस Urn
6

हास्केल , 50 बाइट्स

f p|sum(gcd p<$>[1..p-1])<p=p:f(2*p)|1>0=f$p-1
f 2

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

एक अनंत सूची का उत्पादन करता है।

हास्केल , 40 बाइट्स?

f p|mod(2^p-2)p<1=p:f(2*p)|1>0=f$p-1
f 2

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

यह काम करता है अगर बर्ट्रेंड के अपराधों में 2 के लिए कोई फ़र्मेट स्यूडोप्रिम्स नहीं है ।

— XNOR
स्रोत
5

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

2ḤÆp$¡

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

0 अनुक्रमित।

व्याख्या

2ḤÆp$¡  Main link. Input: n
2       Constant 2
    $¡  Repeat n times
 Ḥ        Double
  Æp      Find the largest prime less than the double
— मील की दूरी पर
स्रोत
पोक आपको अभी एक और बाइट की आवश्यकता है ;) ...
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn 0 रिटर्न 2, 1 रिटर्न 3, और इसी तरह का एक इनपुट। मुझे कोई समस्या नहीं दिख रही है।
— मील
मेरा मतलब था कि आपको जीतने के लिए इस उत्तर पर एक बाइट को बचाने की आवश्यकता है क्योंकि मैंने आपको 6-बाइट्स में बांधा है, आपका उत्तर स्वयं ठीक है।
— मैजिक ऑक्टोपस Urn
5

स्टैक्स , 10 बाइट्स

ü☼┌τ,æ▒ìn(

परीक्षण के मामले चलाएं

इस समस्या ने स्टेक्स के कार्यान्वयन में एक बग को उजागर कर दिया है :p, जो कि एक निर्देश है जो इसके इनपुट की तुलना में सबसे बड़ा प्राइम प्राप्त करता है। यदि यह सही ढंग से काम करता है, तो एक 5 6 बाइट समाधान होगा। लेकिन अफसोस, यह नहीं है, और वहाँ नहीं है। भाषा के निर्माता के रूप में, मैं इसे ठीक कर दूंगा, लेकिन समस्या पोस्ट होने के बाद इसे ठीक करना और इसका उपयोग करना सस्ता लगता है।

वैसे भी, यहां ऊपर दिए गए प्रोग्राम का संबंधित एएससीआई प्रतिनिधित्व है।

ODH{|p}{vgs

यह समस्या कथन का अपेक्षाकृत सीधा-सीधा कार्यान्वयन है। केवल एक चीज जो संभवतः इसके बारे में दिलचस्प है वह gsजनरेटर फॉर्म का उपयोग है । जेनरेटर निर्माण का एक परिवार है जो एक या अधिक संतोषजनक मूल्यों का उत्पादन करने के लिए एक प्रारंभिक स्थिति, एक परिवर्तन, और एक फिल्टर को जोड़ती है। इस मामले में, इसका उपयोग टूटे हुए :pनिर्देश के स्थान पर किया जाता है ।

O               Push integer 1 underneath the input number.
 D              Pop the input and repeat the rest of the program that many times.
  H             Double number.
   {|p}         Predicate block: is prime?
       {vgs     Decrement until the predicate is satisfied.
                Output is implicitly printed.

संपादित करें: यहाँ 6 बाइट समाधान है, लेकिन इसे बग-फिक्स की आवश्यकता है जो इस चुनौती को पोस्ट करने के बाद ही लागू किया गया था।

— पुनरावर्ती
स्रोत
अच्छी भाषा! मैंने इसे गोल्फ लैंग की अपनी सूची में शामिल किया है । मुझे बताएं कि क्या आप कुछ भी गलत देखते हैं, या यदि आप कुछ और जोड़ना चाहते हैं।
— ETHproductions
@ETHproductions: अच्छा, धन्यवाद! यदि आपको कोई आपत्ति नहीं है, तो क्या आप दुभाषिया यूआरएल को staxlang.xyz में बदल सकते हैं, मैंने इसके लिए एक डोमेन प्राप्त करने का फैसला किया है।
— पुनरावर्ती
1
वाह, एक गोल्फिंग भाषा के लिए एक संपूर्ण डोमेन? लकी एसोलंग;) अपडेट किया गया!
— ETHproductions
@recursive WOW, प्रत्येक xyz डोमेन के लिए $ 1.99? मैं अंदर हूं।
— मैजिक ऑक्टोपस Urn
4

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

r=m=k=P=2
while k:
 P*=k;k+=1
 if k>m:print r;m=r*2
 if P%k:r=k

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

हमेशा के लिए प्रिंट।

विल्सन प्रमेय जनरेटर का उपयोग करता है, भले ही आगे की प्राइमिंग उत्पन्न करना इस समस्या के लिए क्लंकी हो। वर्तमान की सबसे बड़ी प्राइम rऔर दोहरीकरण सीमा को ट्रैक करता है m।

दो बाइट्स सामान्य रूप P*=kसे करने के बजाय सहेजे जाते हैं P*=k*k, क्योंकि एकमात्र प्रभाव यह दावा करने के लिए है कि 4 अभाज्य है, और दोहरीकरण का क्रम इसे याद करता है।

— XNOR
स्रोत
4

CJam (15 बाइट्स)

2{2*{mp},W=}qi*

ऑनलाइन डेमो । ध्यान दें कि यह 0-अनुक्रमित है।

एक अधिक कुशल दृष्टिकोण पीछे की ओर खोजना होगा, लेकिन इसके लिए एक वर्ण की अधिक आवश्यकता होती है क्योंकि यह निहित ,(रेंज) का उपयोग नहीं कर सकता है :

2{2*,W%{mp}=}qi*
— पीटर टेलर
स्रोत
4

जाप , 16 14 13 12 बाइट्स

एक की कीमत के लिए दो समाधान, दोनों 1-अनुक्रमित।

नौवां कार्यकाल

अंत में, एक चुनौती मैं उपयोग करने के लिए एक कार्य समाधान लिख सकता हूं F.g()।

_ôZ fj Ì}g°U

कोशिश करो

                 :Implicit input of integer U
_       }g       :Starting with the array [0,1] take the last element (Z),
                 :pass it through the following function
                 :and push the returned value to the array
 ôZ              :  Range [Z,Z+Z]
    fj           :  Filter primes
       Ì         :  Get the last item
          °U     :Repeat that process U+1 times and return the last element in the array

पहला एन नियम

ÆV=ôV fj ̪2

कोशिश करो

                 :Implicit input of integer U
                 :Also makes use of variable V, which defaults to 0
Æ                :Create range [0,U) and pass each through a function
  ôV             :  Range [V,V+V]
     fj          :  Filter primes
        Ì        :  Get the last item
         ª2      :  Logical OR with 2, because the above will return undefined on the first iteration
 V=              :  Assign the result of the above to V
— झबरा
स्रोत
2

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

अनुक्रम को अनिश्चित काल के लिए प्रिंट करता है (आपको निष्पादन को रोकने के लिए दूसरी बार "रन" पर क्लिक करना होगा)।

k=2
while 1:
 print k;k+=k
 while any(k%u<1for u in range(2,k)):k-=1

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

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

एन वें कार्यकाल लौटाता है ।

f=lambda n,i=1,p=1:n*[0]and p%i*[i]+f(n-1,i+1,p*i*i) 
a=lambda n:n and f(2*a(n-1))[-1]or 1

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

— मिस्टर एक्सकोडर
स्रोत
2

सी (जीसीसी) , 97 87 86 80 79 बाइट्स

  • Pमुख्य लूप में एक गैर-primality जाँच फ़ंक्शन को सम्मिलित करके दस बाइट्स सहेजे गए ।
  • printfकॉल को घुमाकर एक बाइट को बचाया ।
  • लौटकर छह बाइट्स बचाए iएक कभी न खत्म होने वाली धारा के उत्पादन के बजाय -th अनुक्रम प्रविष्टि (0-अनुक्रमित) ।
  • छत के लिए धन्यवाद एक बाइट बचाया ।
f(p,r,i,m,e){for(r=2;p--;)for(e=0,i=r+r;e=m=!e;r=i--)for(;i-++m;e=e&&i%m);p=r;}

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

— जोनाथन फ्रेच
स्रोत
@ceilingcat धन्यवाद।
— जोनाथन फ्रेच
1

अटैच , 38 बाइट्स

{If[_,Last[Series[Prime,2*$[_-1]]],2]}

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

0-आधारित; रिटर्न देता हैnवें बर्ट्रेंड प्राइम को ।

वर्तमान में पिछले / अगले अपराधों को खोजने के लिए कोई बिल्टिन नहीं है, इसलिए मैं Seriesसभी अपराधों की गणना करने के लिए बिलिन का उपयोग करता हूं 2*$[_-1]। यह अंतिम अभिव्यक्ति $पुनरावृत्ति संबंध को आसानी से परिभाषित करने के लिए निहित पुनरावर्तन (बाध्य ) का उपयोग करती है। यदि आधार स्थिति का निर्धारण करने के लिए यदि इस स्थिति का उपयोग किया जाता है।

— कोनोर ओ ब्रायन
स्रोत
1

रेटिना , 39 बाइट्स

.K`_
"$+"{`_
__
+`^(?=(..+)\1+$).

*\`_

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.K`_

1 से शुरू करें।

"$+"{`

लूप काउंट के रूप में इनपुट का उपयोग करके लूप दोहराएं।

_
__

मूल्य को दोगुना करें।

+`^(?=(..+)\1+$).

मान से कम उच्चतम प्राइम खोजें।

*\`_

इसे मुद्रित करें।

— नील
स्रोत
0

रूबी , 51 + 7 (-प्राइम) = 58 बाइट्स

->n{x=2
n.times{x=(x..2*x).select(&:prime?)[-1]}
x}

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

0-अनुक्रमित बर्ट्रेंड प्राइम nको स्वीकार करने और वापस करने वाला एक लांबा nth। यहां बहुत कुछ नहीं है, लेकिन मुझे वैसे भी इसे अनफॉलो करने दें:

->n{
  x=2                       # With a starting value of 2
  n.times{                  # Repeat n times:
    x=(x..2*x)              # Take the range from x to its double
      .select(&:prime?)[-1] # Filter to only primes, and take the last
  }
  x                         # Return
}

रूबी , 48 + 7 = 55 बाइट्स

x=2
loop{puts x
x*=2
loop{(x-=1).prime?&&break}}

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

मज़े के लिए, यहाँ एक अनंत-लूप समाधान है। यह प्रिंट के रूप में यह जाता है, और एक बाधा की आवश्यकता है। जब आप बीच में आते हैं, तो आप आउटपुट को देख भी सकते हैं और नहीं भी। Ungolfed:

x=2
loop{
  puts x
  x*=2
  loop{
    (x-=1).prime? && break
  }
}
— benj2240
स्रोत
0

APL (Dyalog Extended) , 12 बाइट्स

N के रूप में उपयोगकर्ता से इनपुट लेता है, अनुक्रम का Nth तत्व देता है (0-अनुक्रमित)। 

{¯4⍭2×⍵}⍣⎕⊢2

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

स्पष्टीकरण:

{¯4⍭2×⍵}⍣⎕⊢2 ⍝ Full program
          ⎕   ⍝ Get input from user - call it 'N'
         ⍣ ⊢2 ⍝ Repeat the left function N times, beginning with 2
    2×⍵       ⍝ Double the function input
 ¯4⍭          ⍝ Find the largest prime less than above
— voidhawk
स्रोत
0

आर , 87 बाइट्स

दिए गए nआउटपुटa(n)

j=scan();n=2;while(j-1){for(i in (n+1):(2*n)){n=ifelse(any(i%%2:(i-1)<1),n,i)};j=j-1};n

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

मैं अभी भी "दिए गए n आउटपुट (1), a (2) ... a (n)" पर काम कर रहा हूं। मुझे लगा कि मैं इस कोड को थोड़ा संशोधित कर सकता हूं, लेकिन यह उससे कहीं ज्यादा कठिन है।

— Sumner18
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.