प्राइम इंडेक्स के साथ प्राइम नंबर

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो पहले 10000 प्राइम-इंडेक्स किए गए प्राइम नंबर को आउटपुट / रिटर्न करता है।

अगर हम n ^वें प्राइम कहते हैं p(n), तो यह सूची है

3, 5, 11, 17, 31, 41, 59 ... 1366661

चूंकि

p(p(1)) = p(2) = 3
p(p(2)) = p(3) = 5
p(p(3)) = p(5) = 11
p(p(4)) = p(7) = 17
...
p(p(10000)) = p(104729) = 1366661

मानक कमियां निषिद्ध हैं, और मानक आउटपुट विधियों की अनुमति है। आप एक पूर्ण कार्यक्रम, एक नामित फ़ंक्शन या एक अनाम फ़ंक्शन के साथ जवाब दे सकते हैं।

Comments

आपको आम तौर पर सैंडबॉक्स में चुनौतियों को पोस्ट करने की कोशिश करनी चाहिए (मुद्दों पर लिंक देखें)।

— एडित्सू ने छोड़ दिया क्योंकि एसई EVIL

रनटाइम के लिए अनुकूलन वह नहीं है जो हम एक कोड-गोल्फ चुनौती में करते हैं; सबसे छोटा कार्यक्रम हमेशा जीतता है।

— lirtosiast

प्रधानमंत्री सबस्क्रिप्ट साथ अभाज्य संख्या: A006450 ।

कोड गोल्फ के लिए @bilbo उत्तर आमतौर पर एक सप्ताह के बाद स्वीकार किए जाते हैं, और इसे सबसे कम सफल कोड के रूप में स्वीकार किया जाना चाहिए । यदि आप कोड गति चाहते हैं , तो उसके लिए एक टैग है। इस पृष्ठ को टैग कोड-गोल्फ के बारे में देखें ।

— Addison Crump

सभी प्रतियोगिताओं को एक उद्देश्य जीतने की कसौटी की आवश्यकता होती है; वे विषय से अलग हैं। यदि आप आकार और गति के आधार पर उत्तर जज करने जा रहे हैं , तो आपको दोनों को मिलाने का तरीका बताना होगा। यह तब किया जाना चाहिए जब प्रतियोगिता पोस्ट की जाती है, न कि 14 घंटे और बाद में 10 उत्तर। मैंने सभी गति-संबंधी संपादन पूर्ववत कर दिए हैं, क्योंकि इस विषय को बंद करने के लिए एकमात्र अन्य विकल्प होगा।

— डेनिस

Answer 1

MATLAB / ऑक्टेव, 25 बाइट्स

p=primes(2e6)
p(p(1:1e4))

यह इससे ज्यादा सीधा नहीं है।

Answer 2

पायथन, 72 बाइट्स

P=p=1;l=[]
while p<82e5/6:l+=P%p*[p];P*=p*p;p+=1
for x in l:print l[x-1]

यह 10000 नंबरों को प्रिंट करने के बाद "लिस्ट इंडेक्स आउट ऑफ रेंज एरर" के साथ समाप्त होता है, जिसे डिफ़ॉल्ट रूप से अनुमति है ।

10000 वें प्राइम तक की घटनाओं की सूची तैयार करने के लिए विल्सन की प्रमेय पद्धति का उपयोग करता है l। फिर, सूची में पदों के साथ primes प्रिंट करता है, शून्य-अनुक्रमण के लिए 1 द्वारा स्थानांतरित किया जाता है, जब तक कि हम 10000 वें प्राइम-वें प्राइम के बाद सीमा से बाहर नहीं निकल जाते।

आसानी से, ऊपरी हिस्से का 1366661अनुमान लगाया जा सकता 82e5/6है 1366666.6666666667, जो कि एक चार को बचा रहा है।

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

P=p=1;l=[]
while p<104730:
 l+=P%p*[p]
 if len(l)in P%p*l:print p
 P*=p*p;p+=1

Comments

यह मेरे द्वारा लिखे गए कचरे से बेहतर है। +1

— मेगो

यह केवल 1229 नंबरों को प्रिंट करता है

— एडिट्स ने छोड़ दिया क्योंकि एसई ईवीआईएल

@aditsu मुझे लगता है कि मैं अपनी गलती देखता हूं। क्या आप इस कोड को बड़ी सीमा के साथ चलाने में सक्षम हैं?

— xnor

यह शायद एक लंबा समय

— लेगा

मुझे लगता है कि यह समाप्त हो गया think ＼ ＼ ＼ ＼ ＼ ＼ ＼ it ＼, यह सही लगता है

— aditsu छोड़ दिया क्योंकि SE EVIL

Answer 3

जे, 11 बाइट्स

p:<:p:i.1e4

प्रारूप में primes आउटपुट करता है

3 5 11 17 31 41 59 67 83 109 127 ...

व्याख्या

        1e4  Fancy name for 10000
      i.     Integers from 0 to 9999
    p:       Index into primes: this gives 2 3 5 7 11 ...
  <:         Decrement each prime (J arrays are 0-based)
p:           Index into primes again

Answer 4

गणितज्ञ, २६ २५ २३ बाइट्स

Prime@Prime@Range@1*^4&

सूची लौटाने वाला शुद्ध कार्य।

Comments

प्राइम Listableइतना सरल Prime@Prime@Range@1*^4&है

मैं भावना को जानता हूं ... किसी भी मामले में, मुझे लगता है कि यह सबसे सुंदर गणितज्ञ समाधान है जिसे मैंने यहां देखा है!

मुझे लगता है, जब लिखने की @तुलना में ऑपरेटर उच्च वरीयता है ? यह क्लासिक गणितज्ञ आपके गोल्फ के खेल को गड़बड़ कर रहा है। अच्छी चाल! ^Range@10^4

Answer 5

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

p=[x|x<-[2..],all((>0).mod x)[2..x-1]]
f=take 10000$map((0:p)!!)p

आउटपुट: [3,5,11,17,31,41,59,67,83,109,127.....<five hours later>...,1366661]

बहुत तेज नहीं है। यह कैसे काम करता है: pprimes की अनंत सूची है (भोलेपन से सभी की जाँच mod x yy के लिए [2..x-1])। 10000जब आपको सूची मिलती है तो पहले तत्वों को प्राप्त करें 0:p!!(nth तत्व प्राप्त करें p) पर मैप किया गया है p। मुझे उन अपराधों की सूची को समायोजित करना होगा जहां मैं तत्वों को एक नंबर (-> 0:) से जोड़कर लेता हूं , क्योंकि सूचकांक फ़ंक्शन ( !!) शून्य आधारित है।

Answer 6

PARI / जीपी, 25 बाइट्स

apply(prime,primes(10^4))

Answer 7

AWK - 129 बाइट्स

... oookay ... कॉम्पैक्टनेस के लिए अंक जीतने के लिए बहुत लंबा ... लेकिन शायद यह गति के लिए कुछ सम्मान प्राप्त कर सकता है?

xफ़ाइल:

BEGIN{n=2;i=0;while(n<1366662){if(n in L){p=L[n];del L[n]}else{P[p=n]=++i;if(i in P)print n}j=n+p;while(j in L)j=j+p;L[j]=p;n++}}

चल रहा है:

$ awk -f x | nl | tail
  9991  1365913
  9992  1365983
  9993  1366019
  9994  1366187
  9995  1366327
  9996  1366433
  9997  1366483
  9998  1366531
  9999  1366609
 10000  1366661

पठनीय:

BEGIN {
        n=2
        i=0
        while( n<1366662 ) {
                if( n in L ) {
                        p=L[n]
                        del L[n]
                } else {
                        P[p=n]=++i
                        if( i in P ) print n
                }
                j=n+p
                while( j in L ) j=j+p
                L[j]=p
                n++
        }
}

कार्यक्रम Lमें "नंबरों की टेप" के रूप में उपयोग किए जाने वाले प्रिम्स की एक धारा की गणना होती है, जिसमें पाया गया Lहै कि पास के नंबरों को फ़्लैग करने के लिए पहले से ही पहचाने जाने वाले प्राइमरों को कूदते हुए । ये जंपिंग प्राइम्स आगे बढ़ेंगे जबकि "नंबरों की टेप" Lको इसकी शुरुआत से ही नंबर से काट दिया जाता है।

टेप हेड L[n]को खाली करने के दौरान खाली होने का कोई मतलब नहीं है (प्राइम) विभाजक।

L[n]एक मान रखने का अर्थ है, यह मान एक प्रमुख और विभाजित करने के लिए जाना जाता है n।

इसलिए या तो हमें एक प्राइम डिविज़र या एक नया प्राइम मिला है। फिर ths prime L[n+m*p]खाली पाया जा रहा टेप पर अगले में उन्नत होगा ।

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

जबकि बाहरी लूप प्रति लूप में एक प्राइम या नॉट प्राइम डिसीजन जेनरेट करता है, पाया गया प्राइम्स काउंट हो जाता है और Pकुंजी के रूप में स्टोर हो जाता है, इस (की, वैल्यू) पेयर का वैल्यू प्रोग्राम फ्लो के लिए प्रासंगिक नहीं है।

यदि उनकी कुंजी पहले iसे Pही होती है ( i in P), हमारे पास पी (पी (आई)) नस्ल का एक प्रमुख है।

चल रहा है:

$ time awk -f x.awk | wc -l
10000

real    0m3.675s
user    0m3.612s
sys     0m0.052s

ध्यान रखें कि यह कोड बाहरी पूर्व-निर्धारित प्रधान तालिकाओं का उपयोग नहीं करता है।

मेरे अच्छे पुराने थिंकपैड टी 60 पर समय लगा, इसलिए मुझे लगता है कि यह तेजी से कहलाने लायक है।

साथ परीक्षण किया गया mawkऔर gawkDebian8 / AMD64 पर

Comments

gawk में अच्छा 129 बाइट्स: अब मेरे corei7-i870@3.6Ghz पर Debian10 / AMD64 के साथ: वास्तविक 0m2,417s उपयोगकर्ता 0m2,205s sys 0m0,042s

— JeanClaudeDaudin

आप के साथ एक बाइट बचा सकते हैं: BEGIN {n = 2; मैं = 0; जबकि (n <1366662) {if (n में L) {p = L [n]; del L [n]} और {p [p =; n] = ++ i; अगर (i in P) प्रिंट n} j = n + p; जबकि (L में j) + = = p; l [j] = p; n ++}}

— JeanClaudeDaudin

Answer 8

CJam, 19

3D#{mp},_1e4<:(\f=p

आप इसे ऑनलाइन आज़मा सकते हैं , लेकिन आपको थोड़े धैर्य की आवश्यकता होगी: पी

रिकॉर्ड के लिए, अंतिम संख्या 1366661 है।

Answer 9

पर्ल, 55 बाइट्स

use ntheory':all';forprimes{print nth_prime$_,$/}104729

---

पर्ल ( प्राग्मा के Math::Prime::Utilसाथ लोड ntheory) के लिए @DanaJ के मॉड्यूल का उपयोग करता है । इसे प्राप्त करें:

cpan install Math::Prime::Util
cpan install Math::Prime::Util::GMP

Answer 10

05AB1E, 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

कोड:

4°L<Ø<Ø

इसे ऑनलाइन आज़माएं! , ध्यान दें कि मैंने इसे 4एक में बदल दिया है 2। यदि आपके पास बहुत समय है, तो आप 2बैक को बदल सकते हैं 4, लेकिन इसमें बहुत समय लगेगा। मुझे इसके लिए एल्गोरिथ्म को तेज करने की आवश्यकता है।

स्पष्टीकरण:

4°       # Push 10000 (10 ^ 4)
  L      # Create the list [1 ... 10000]
   <     # Decrement on every element, [0 ... 9999]
    Ø    # Compute the nth prime
     <   # Decrement on every element
      Ø  # Compute the nth prime