56

यह मेरा पहला कोड गोल्फ सवाल है, और उस पर एक बहुत ही सरल, इसलिए मैं पहले से माफी मांगता हूं अगर मैंने किसी भी सामुदायिक दिशानिर्देशों को तोड़ा हो सकता है।

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

उद्देश्य, अधिकांश कोड गोल्फ सबमिशन के साथ, कोड आकार को कम करना है। रनटाइम के लिए अनुकूलन भी एक बोनस है, लेकिन एक माध्यमिक उद्देश्य है।

code-golf kolmogorov-complexity primes

— डेलन अजाबनी
स्रोत

12

यह एक सटीक डुप्लिकेट नहीं है, लेकिन यह अनिवार्य रूप से सिर्फ प्राइमलिटी परीक्षण है, जो कई मौजूदा सवालों का एक घटक है (जैसे codegolf.stackexchange.com/questions/113 , codegolf.stackexchange.com/questions/5087 , codegolf.stackexchange। com / प्रश्न / 1977 )। एफडब्ल्यूआईडब्ल्यू, एक गाइडलाइन जिसका पर्याप्त रूप से पालन नहीं किया जाता है (यहां तक कि उन लोगों द्वारा भी जिन्हें बेहतर पता होना चाहिए) मेटा सैंडबॉक्स मेटा में एक प्रश्न का प्रस्ताव करना है। met.codegolf.stackexchange.com/questions/423 आलोचना और चर्चा के लिए कि यह कैसे हो सकता है इससे पहले कि लोग इसका जवाब देना शुरू करें।

— पीटर टेलर

आह, हाँ, मैं इस सवाल के बारे में चिंतित था कि पहले से ही आसपास के प्रमुख संख्या-संबंधित प्रश्नों के ढेर के समान था।

— डेलन अजाबानी

2

@ GlennRanders-Pehrson क्योंकि 10^6और भी छोटा है;)

— ʇǝɥʇıʎuRs

1

कुछ साल पहले मैंने एक IOCCC प्रविष्टि प्रस्तुत की, जिसमें C में केवल 68 वर्णों के साथ प्रिंट होता है - दुर्भाग्य से यह एक लाख से भी कम समय में बंद हो जाता है, लेकिन यह कुछ के लिए ब्याज की हो सकती है: computronium.org/ioccc.html

— Computronium

1

@ Dı --uʎs कैसे के बारे में 1e6:-D

— टाइटस

33

गणितज्ञ , १। २४

बस तुलना के लिए:

Prime@Range@78498

जैसा कि एक टिप्पणी में कहा गया है कि मैं प्रति पंक्ति एक प्राइम प्रदान करने में विफल रहा; भूल सुधार:

Column@Prime@Range@78498

— Mr.Wizard
स्रोत

4

Prime~Array~78498यह भी 17 :)

— chyanog

मुथम्मा में नौ बाइट्स होंगे, यदि वे जारी किए जाने थे।

— माइकल स्टर्न

यह आउटपुट की प्रति पंक्ति एक प्राइम की स्थिति का उल्लंघन करता है। 8 अतिरिक्त वर्णों की कीमत पर, s फिक्सेस की एक लंबी सूची के उत्पादन को रोकने के साथ Print/@और समाप्ति के साथ प्रीफ़िक्सिंग । ;Null

— celtschk

@celtschk मुझे नहीं पता कि मैं पाँच साल पहले चूक या अवहेलना कर चुका हूँ।

— श्री। छिपकली २५'१

1

खैर, मैं निश्चित रूप से याद किया कि यह पांच साल पहले से था :-)

— celtschk

27

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

k=P=1
while k<1e6:P%k and print(k);P*=k*k;k+=1

जब तक लूप परीक्षण तक पहुंचता है k, तब तक यह चुकता-भाज्य की गणना कर लेता है P=(k-1)!^2। यदि kयह प्रधान है, तो यह उत्पाद में दिखाई नहीं देता है 1 * 2 * ... * (k-1), इसलिए यह इसका कारक नहीं है P। लेकिन, अगर यह समग्र है, तो इसके सभी प्रमुख कारक उत्पाद में छोटे और इतने ही हैं। स्क्वेरिंग को केवल वास्तव में k=4प्राइम कहलाने से रोकने की आवश्यकता है ।

अधिक दृढ़ता से, यह विल्सन के प्रमेय से है कि जब kप्राइम होता है, P%kबराबर होता है 1। हालाँकि हमें केवल यह चाहिए कि यह नॉनजेरो है यहाँ, यह सामान्य रूप से उपयोगी P%kहै जो कि kप्रमुख है के लिए एक संकेतक चर है।

— XNOR
स्रोत

23

C, 61 वर्ण

लगभग यह एक जैसा ही है (सवाल भी लगभग एक जैसा ही है)।

n=2;main(m){n<1e6&&main(m<2?printf("%d\n",n),n:n%m?m-1:n++);}

— ugoren
स्रोत

SEG-FAULTछपाई के बाद मिला881

— मानव

7

@ मानव, शायद आपने अनुकूलन के बिना संकलित किया। यह एक अच्छे आशावादी पर निर्भर करता है, जो पुनरावृत्ति को दूर करेगा।

— बदसूरत

4

हाँ समस्या -O3को gccहल करने के लिए जोड़ना !!

— मैनाव एमएन

यह तरीका पागल है। मुझे यह पसंद है।

— टॉड लेहमन

2

मैं आपको 57 बाइट्सn=2;main(m){n<1e6&&main(m<2?printf("%d\n",n),n:m-++n%m);}

— अल्बर्ट रेनशॉ

22

MATLAB (16) (12)

दुर्भाग्य से, यह एक ही लाइन पर आउटपुट:

primes(1000000)

लेकिन यह एक सरल मैट्रिक्स द्वारा हल किया गया है:

primes(1000000)'

और मैं कुछ वर्णों को घातीय संकेतन का उपयोग करके काट सकता हूं (जैसा कि टिप्पणियों में सुझाया गया है):

primes(1e6)'

— MBraedley
स्रोत

5

यहां भी मदद के 1e6बजाय उपयोग करना 1000000।

— ओरियन

@orion कि यह 11 अक्षर

— बनाएगा

@Axoren जिसमें 'अंत में शामिल नहीं है

— स्टेन स्ट्रम

20

बैश (37 वर्ण)

seq 2 1e6|factor|sed 's/.*: //g;/ /d'

(60 वर्ण)

seq 2 1000000|factor|sed -e 's/[0-9]*: //g' -e '/^.* .*$/ d'

मेरे कंप्यूटर पर (2.0 गीगाहर्ट्ज सीपीयू, 2 जीबी रैम) 14 सेकंड लगते हैं।

— saeedn
स्रोत

इसमें सुधार किया जा सकता है: seq 2 1000000|factor|sed 's/[0-9]*: //g;/^.* .*$/ d'

— डेलन अजाबानी

हाँ तुम सही हो। मैंने अपनी सीड कमांड को साफ लिखा, गोल्फ नहीं: पी

— सईदीन

3

seq 1e6|factor|awk '$0=$2*!$3'थोड़ा छोटा है।

— डेनिस

1

seq, factor and sed बाहरी प्रोग्राम हैं, यह भी हो सकता है c pकि c कहाँ है, जो कि सिम्बलिन टू कैट है और p एक टेक्स्ट फाइल है, जिसमें मिलियन तक प्राइम हैं ... क्या आप इसे शेल बिल्डिंस के साथ कर सकते हैं?

— टेक्नोसॉरस

7

@technosaurus seqऔर में factorहैं coreutils, इसलिए यह वैध है। sedभी सुंदर सर्वव्यापी है। coreutilsबिल्ट-इन की तरह व्यवहार किया जा सकता है। बिना कोरूटिल के बैश, एसटीएल के बिना सी ++ की तरह है।

16

जे, 21 अक्षर

1[\p:i.(_1 p:1000000)

जिसे छोटा किया जा सकता है

1[\p:i.78498

यदि आप जानते हैं कि कितने अपराध 1000000 से नीचे हैं।

— गैरेथ
स्रोत

2

,.एक चरित्र को बचाने के लिए 1 [\\ के बजाय , enfile आइटम का उपयोग करना । अनावश्यक कोष्ठक निकालें, और घातीय संकेतन का उपयोग करें 1e6:।

— उमर

इसके साथ आया: ,.i.&.(p:^:_1)1e6कम नहीं (@ उमर के सुझावों को लागू करने के बाद), लेकिन मुझे दिलचस्प के तहत उपयोग मिला।

— काओद

10

पॉवरशेल, 47 44 बाइट्स

बहुत धीमे, लेकिन सबसे छोटा मैं साथ आ सकता था।

$p=2..1e6;$p|?{$n=$_;!($p-lt$_|?{!($n%$_)})}

पॉवरशेल, 123 बाइट्स

यह बहुत तेज है; इष्टतम से दूर, लेकिन दक्षता और संक्षिप्तता के बीच एक अच्छा समझौता।

 $p=2..1e6;$n=0
 while(1){$p=@($p[0..$n]|?{$_})+($p[($n+1)..($p.count-1)]|?{$_%$p[$n]});$n++;if($n-ge($p.count-1)){break}}
 $p

— Rynant
स्रोत

9

रूबी 34

require'prime';p Prime.take 78498

— Hauleth
स्रोत

9

बैश, 30 बाइट्स

चूंकि सईदन मेरे सुझाव पर कार्रवाई नहीं करेगा - जो उसके दृष्टिकोण से कम और तेज दोनों है - मैंने सोचा कि मैं अपना जवाब पोस्ट करूंगा:

seq 1e6|factor|awk '$0=$2*!$3'

यह काम किस प्रकार करता है

seq 1e6

1,000,000 तक सभी सकारात्मक पूर्णांकों को सूचीबद्ध करता है।

factor

उन्हें एक के बाद एक कारक। पहले दस के लिए, आउटपुट निम्न है:

आखिरकार,

awk '$0=$2*!$3'

$0दूसरे क्षेत्र (पहले प्रमुख कारक) के उत्पाद के लिए पूरी लाइन ( ) और तीसरे क्षेत्र के तार्किक निषेध ( 1यदि एक प्रमुख कारक है या कम है, 0अन्यथा)।

यह संख्याओं को अभाज्य संख्याओं की संख्या और शून्य के साथ अन्य सभी रेखाओं के साथ बदल देता है। चूंकि awk केवल सत्य मूल्यों को प्रिंट करता है, केवल प्राइम संख्या मुद्रित हो जाएगी।

— डेनिस
स्रोत

4

awk '$0=$2*!$3'अजीब शांत है!

— यति

8

रूबी ५० ४१

require'mathn'
p (2..1e6).select &:prime?

— क्रिस्टियन लुपस्कू
स्रोत

2

Enumerable पहले से ही शामिल है .to_a, के लिए कोई ज़रूरत नहीं है । आप इसे आगे छोटा करने के लिए सिंबल # to_proc के लिए शॉर्टहैंड नोटेशन का भी उपयोग कर सकते हैं : (1 अभाज्य नहीं है)selectp (2..1e6).select &:prime?

— वेंटरो

@ वेंचरो बहुत बहुत धन्यवाद! मुझे सिंबल # to_proc के बारे में नहीं पता था। रूबी ऑफर के शॉर्टकट्स पर ज्यादा ध्यान देती हूँ।

— क्रिस्टियन लुपस्कू

2

छोटा संस्करण require'prime';p Prime.take 78498।

— हौलेथ

@ ŁukaszNiemier महान! मुझे लगता है कि यह इतना अलग है कि आप इसे एक अलग उत्तर के रूप में पोस्ट कर सकते हैं।

— क्रिस्टियन लुपस्कू

कुछ अच्छे राजभाषा 'देश बॉय मैथ्न' का अच्छा उपयोग

— डॉक्टरहेकल

8

बैश, ३,

यदि मैं कर सकता हूं, तो गोल्फ अधिक ...

इसमें से अधिकांश factorआउटपुट आउटपुट अजीब है।

seq 1e6|factor|grep -oP "(?<=: )\d+$"

मेरी मशीन पर पूरा करने के लिए 5.7 या इतने सेकंड लगते हैं।

(यह सिर्फ इसलिए हुआ कि उत्तर के दूसरे पृष्ठ पर जाने के लिए मेरी पोस्ट पहली थी , इसलिए कोई भी इसे देखने नहीं जा रहा है ...)

पुराना हल

यह लंबा और धीमा है (10 सेकंड लेता है)।

seq 1e6|factor|egrep ':.\S+$'|grep -oE '\S+$'

2

वाह - मैं factorपहले कभी नहीं आया था , लेकिन यह कोरुटिल में वहीं है!

— डिजिटल ट्रॉमा

1

एक चरित्र को शेव करें: seq 1e6|factor|grep -oP "(?<=: )\d+$"एक perl-grep लुकअप के साथ

— डिजिटल ट्रॉमा

@DigitalTrauma उस काम को कैसे करती है

1

-Pप्रति-शैली रीगेक्स को सक्षम करता है। स्ट्रिंग के लिए (?<=: )एक सकारात्मक खोज है ":"। मूल रूप से यह कहता है कि ":" मैच से पहले आना चाहिए \d+$, लेकिन वास्तव में मैच का हिस्सा नहीं है, इसलिए -oविकल्प सिर्फ हमें कॉलन के बाद एक मेल खाता नंबर देता है, यानी सिर्फ नंबर देता है जहां केवल एक कारक है, अर्थात प्राइम।

— डिजिटल ट्रामा

@DigitalTrauma ने कहा

8

पायथन 3.x: 66 वर्ण

for k in range(2,10**6):
 if all(k%f for f in range(2,k)):print(k)

अधिक कुशल समाधान: 87 वर्ण

एराटोस्थनीज की छलनी के आधार पर।

p=[];z=range(2,10**6)
while z:f=z[0];p+=[f];z=[k for k in z if k%f]
for k in p:print(k)

— dan04
स्रोत

1

पहले वाला गलत तरीके से प्रिंट करता है 0और 1। आप इसका उपयोग करने के बजाय इसे ठीक कर सकते हैं range(2,10**6)। इसके अलावा, मुझे लगता है कि ifस्टेटमेंट को आउट से अलग लाइन पर होना चाहिए forया आपको कोई त्रुटि मिलेगी।

— xnor

@xnor: इसे ठीक किया।

— dan04

8

हास्केल, 51

mapM print [n|n<-[2..10^6],all((>0).rem n)[2..n-1]]

— pt2121
स्रोत

आप बदल सकते हैं mapM_करने के लिए mapM, वापसी मान प्रिंट नहीं होगा, और इस संहिता गोल्फ है। ;)

— डॉगबर्ट

प्रिंट और (> 0) के बाद अतिरिक्त स्थान क्यों हैं?

— गर्वित हैकेलर

अच्छा पकड़ा! धन्यवाद

— pt2121

आप 999 ^ को 10 ^ 6 से बदल सकते हैं। और कृपया अपनी बाइट गिनती को अपडेट करें - 63 संभवतः सही नहीं हो सकते।

— user2845840

@ user2845840 ठीक है धन्यवाद। अच्छा विचार!

— pt2121

8

एपीएल, १५

p~,p∘.×p←1↓⍳1e6

मेरा दुभाषिया स्मृति समस्याओं में भाग गया, लेकिन यह सिद्धांत रूप में काम करता है।

— TwiNight
स्रोत

कैसे? क्या आप एक डेस्कटॉप दे सकते हैं?

— रासमस डमगार्ड नीलसन

आपको ⍪प्रति पंक्ति एक नंबर बनाने के लिए सामने की आवश्यकता है , और आपको इसकी आवश्यकता नहीं है ,।

— आदम

@RasmusDamgaardNielsen ⍳पहले पूर्णांक हैं। 1↓पहले वाले को छोड़ देता है। p←p को असाइन करता है। p∘.×pगुणा तालिका बनाता है। p~जो कुछ दाईं ओर है उसे p से निकालता है। ( ,जरूरत नहीं है, यह सूची में तालिका को बढ़ाता है।)

— एडम

8

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

नियमित अभिव्यक्ति कुंग फू :)

for(1..1E6){(1x$_)=~/^(11+?)\1+$/ or print"$_\n"}

Ungolfed संस्करण:

for(1 .. 1_000_000) { 
    (1x$_) =~ /^(11+?)\1+$/ or print "$_\n";
}

यह पोस्ट लिखते समय मैंने 10% भी प्रगति नहीं की है!

रेगेक्स के लिए स्रोत: http://montreal.pm.org/tech/neil_kandalgaonkar.shtml

— Gowtham
स्रोत

2

मुझे एक perl6 संस्करण लिखने के लिए प्रेरित किया। यह भी 1000000लिखा जा सकता है10**6

— पाबू

1

इसके अलावा, 1000000 लिखा जा सकता है 1E6

— भीड़

मेरे उत्तर को अपडेट किया। धन्यवाद @ मम

— गौतम

हमेशा मेरा एक पसंदीदा रेगेक्स था, लेकिन आपको यह याद रखना होगा कि जब आप उच्च संख्या में पहुंचते हैं तो यह शानदार रूप से विफल हो जाता है - इस तथ्य के कारण कि यह बड़ी संख्या को एकात्मक में परिवर्तित कर रहा है। यह रेगेक्स भाषा के किसी भी विन्यास (और आपकी मशीन) के आधार पर हजारों और उससे अधिक की संख्या में होने वाले

— अपराधों

7

जूलिया, ११

primes(10^6)

ऐसा लग रहा है कि बिल्ट इन इंस्पेक्ट हो रहे हैं, साथ ही मुझे लंबे उत्तर के लिए अधिक शब्दों की आवश्यकता है।

— gggg
स्रोत

7

जे (15 या 9)

मुझे विश्वास नहीं हो रहा है कि यह गणितज्ञ को हरा देगा (भले ही यह 2 चार्ट में से ~~एक ही हो~~ )

a#~1 p:a=:i.1e6

या:

p:i.78498

— ɐɔıʇǝɥʇuʎs
स्रोत

1

... The output format should be one number per line of output.इसलिए मेरा जवाब इसके साथ शुरू होता है 1[\ ।

— गारेथ

6

gs2, 5 बाइट्स

CP437 में एन्कोडेड:

∟)◄lT

1C 29एक लाख धक्का, 11 6Cनीचे primes है, 54शो लाइनें है।

— लिन
स्रोत

5

गोल्फस्क्रिप्ट, 22/20 (20/19) बाइट्स

n(6?,:|2>{(.p|%-.}do:n

गति की लागत पर, कोड को दो बाइट्स कम किया जा सकता है:

n(6?,:|2>.{|%2>-}/n*

यदि संपादित प्रश्न में निर्दिष्ट आउटपुट स्वरूप की अवहेलना की जाती है (जो कि मौजूदा उत्तरों में से कई करते हैं), दो बाइट्स को तेज संस्करण में सहेजा जा सकता है और एक को धीमी गति से बचाया जा सकता है:

n(6?,:|2>{(.p|%-.}do
n(6?,:|2>.{|%2>-}/`

यह तेजी से संस्करण के लिए primes के बाद एक अतिरिक्त LF मुद्रित करेगा, और यह धीमी गति के लिए एक सरणी के रूप में primes मुद्रित करेगा।

यह काम किस प्रकार करता है

दोनों संस्करण एराटोस्थनीज की छलनी के कार्यान्वयन हैं ।

तेज़ संस्करण निम्न कार्य करता है:

सेट A = [ 2 3 4 … 999,999 ]और | = [ 0 1 2 … 999,999 ]।
सेट करें N = A[0]और प्रिंट करें N।
से हर एन वें तत्व इकट्ठा |में C। ये कई गुना हैं N।
सेट करें A = A - C।
यदि Aगैर-रिक्त है, तो 2 पर वापस जाएं।

n(6?   # Push "\n".pop() ** 6 = 1,000,000.
,:|    # Push | = [ 0 1 2 … 999,999 ].
,2>    # Push A = [ 2 3 4 … 999,999 ].
{      #
  (    # Unshift the first element (“N”) of “A”.
  .p   # Print “N”.
  |%   # Collect every N-th element from “A” into a new array, starting with the first.
  -    # Take the set difference of “A” and the array from above.
  .    # Duplicate the set difference.
}do    # If the set difference is non-empty, repeat.
:n     # Store the empty string in “n”, so no final LF will get printed.

धीमे संस्करण समान शैली में काम करता है, लेकिन क्रमिक रूप से "ए" के न्यूनतम के गुणकों को हटाने के बजाय (जो हमेशा प्रमुख होता है), यह 1,000,000 से नीचे के सभी सकारात्मक पूर्णांक के गुणकों को हटा देता है।

प्रतिस्पर्धा

किसी भी अंतर्निहित गणितीय कार्यों की अनुपस्थिति में, गवाही के लिए कारक या जांच करने के लिए, सभी गोल्फस्क्रिप्ट समाधान या तो बहुत बड़े या बहुत अक्षम होंगे।

हालांकि अभी भी कुशल होने से, मुझे लगता है कि मैंने एक अच्छा गति-से-आकार अनुपात प्राप्त किया है। इसकी सबमिशन के समय, यह दृष्टिकोण उन लोगों में सबसे छोटा लगता है जो किसी भी निर्मित पूर्व-इन्स का उपयोग नहीं करते हैं। मैं कहता हूँ लगता है क्योंकि मुझे पता नहीं कैसे कुछ उत्तर काम है ...

मैंने सभी चार सबमिट किए गए गोल्फस्क्रिप्ट समाधानों को बेंचमार्क किया है: w0lf's (ट्रायल डिवीजन), मेरे अन्य उत्तर (विल्सन प्रमेय) और इस उत्तर के दो। ये परिणाम थे:

Bound     | Trial division     | Sieve (slow)       | Wilson's theorem | Sieve (fast)
----------+--------------------+--------------------+------------------+----------------
1,000     | 2.47 s             | 0.06 s             | 0.03 s           | 0.03 s
10,000    | 246.06 s (4.1 m)   | 1.49 s             | 0.38 s           | 0.14 s
20,000    | 1006.83 s (16.8 m) | 5.22 s             | 1.41 s           | 0.38 s
100,000   | ~ 7 h (estimated)  | 104.65 (1.7 m)     | 35.20 s          | 5.82 s
1,000,000 | ~ 29 d (estimated) | 111136.97s (3.1 h) | 3695.92 s (1 h)  | 418.24 s (7 m)

— डेनिस
स्रोत

क्या "धीमी" चलनी सिर्फ एराटोस्थनीज की छलनी है?

— दोरुखायण

दोनों हैं। धीमा संस्करण सिर्फ एक भयानक कार्यान्वयन है।

— डेनिस

5

NARS2000 APL, 7 वर्ण

⍸0π⍳1e6

— मधुमक्खी का छत्ता
स्रोत

3

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— डेनिस

4

गोल्फस्क्रिप्ट 26 25 24

संपादित करें (पीटर टेलर के लिए एक और चार धन्यवाद):

10 6?,{:x,{)x\%!},,2=},`

पुराना कोड:

10 6?,{.,{)\.@%!},,2=*},`

इस कोड का केवल सैद्धांतिक मूल्य है, क्योंकि यह अविश्वसनीय रूप से धीमा और अक्षम है। मुझे लगता है कि इसे चलाने में घंटों लग सकते हैं।

यदि आप इसका परीक्षण करना चाहते हैं, तो उदाहरण के लिए केवल 100 तक के प्राइम्स देखें:

10 2?,{:x,{)x\%!},,2=},`

— क्रिस्टियन लुपस्कू
स्रोत

आप के \;साथ बदलकर एक चरित्र को बचा सकते हैं *। (आप उन सभी के बजाय पहले विभाजक को ढूंढकर वर्तमान वर्ण गणना के लिए बहुत तेजी से प्राप्त कर सकते हैं:10 6?,2>{.),2>{1$\%!}?=},`

— पीटर टेलर

@PeterTaylor धन्यवाद, गुणन का उपयोग करते हुए एक बहुत साफ चाल है।

— क्रिस्टियन लुपस्कू

बदल देते हैं: एक और चार एक चर के साथ बचत है .,के साथ :x,और \.@साथ x\ (सफेद स्थान है क्योंकि टिप्पणी में एमडी के साथ मुद्दों से बचने का है) और हटाने *।

— पीटर टेलर

@PeterTaylor अच्छा है, धन्यवाद! मैंने अपना कोड संपादित कर लिया है।

— क्रिस्टियन लुपस्कू

4

CJam - 11

1e6,{mp},N*

1e6, - 0 की सरणी ... 999999
{mp}, - चुनिंदा -
N*newlines के साथ जुड़ें

— aditsu
स्रोत

1

क्या सीजेएम इस सवाल से ज्यादा हाल का नहीं है?

— पीटर टेलर

@PeterTaylor ओह, हाँ यह है

— ad

4

गोल्फस्क्रिप्ट, 25 (24) बाइट्स

!10 6?,2>{.(@*.)@%!},n*\;

यदि संपादित प्रश्न में निर्दिष्ट आउटपुट प्रारूप की अवहेलना की जाती है, तो एक बाइट को बचाया जा सकता है:

!10 6?,2>{.(@*.)@%!},`\;

यह एक पंक्ति के बजाय एक सरणी (जैसे कई अन्य समाधान करते हैं) के रूप में primes मुद्रित करेगा।

यह काम किस प्रकार करता है

सामान्य विचार विल्सन के प्रमेय का उपयोग करना है , जिसमें कहा गया है कि n > 1 अभाज्य है यदि और केवल यदि

(एन - 1)! = -1 (मॉड एन)

!     # Push the logical NOT of the empty string (1). This is an accumulator.
10 6? # Push 10**6 = 1,000,000.
,2>   # Push [ 2 3 4 … 999,999 ].
{     # For each “N” in this array:
  .(  # Push “N - 1”.
  @   # Rotate the accumulator on top of the stack.
  *   # Multiply it with “N - 1”. The accumulator now hold “(N - 1)!”.
  .)  # Push “(N - 1)! + 1”
  @   # Rotate “N” on top of the stack.
  %!  # Push the logical NOT of “((N - 1)! + 1) % N”.
},    # Collect all “N” for which “((N - 1)! + 1) % N == 0” in an array.
n*    # Join that array by LF.
\;    # Discard the accumulator.

मानक

ट्रायल डिवीजन की तुलना में तेज़, लेकिन एराटोस्थनीज़ की छलनी से धीमी। मेरा दूसरा जवाब देखिए ।

— डेनिस
स्रोत

4

जावा, 110 बाइट्स

void x(){for(int i=1;i++<1e6;)System.out.print(new String(new char[i]).matches(".?|(..+?)\\1+")?"":(i+"\n"));}

एक primality परीक्षण के रूप में regex के माध्यम से unary विभाजन का उपयोग करना।

— एडिसन क्रम्प
स्रोत

1

अच्छा तरीका। उस प्राइम-रेगेक्स को पहले कभी नहीं देखा था। मुझ से +1। हालाँकि, प्राइम-चेकिंग के लिए नेस्टेड-लूप का उपयोग करना थोड़ा कम है । :)

— केविन क्रूज़सेन

3

सी, 91 88 85 82 81 80 76 72 वर्ण

main(i,j,b){for(;i++<1e6;b++&&printf("%d\n",i))for(j=2;j<i;)b=i%j++&&b;}

एल्गोरिथ्म बहुत अयोग्य है, लेकिन जब से हम कोड-गोल्फ कर रहे हैं जो कोई फर्क नहीं पड़ता।

— गैरेथ
स्रोत

1

आप इसे आसानी से छोटा कर सकते हैं: main(i,j,b){for(;i++<1e6;b++&&printf("%d\n",i))for(j=2;j<i;)b=i%j++&&b;}या इस तरह के कुछ विचार (क्योंकि मैं वास्तव में इसे संकलित नहीं किया था)

— अली १

i0 होना निश्चित कैसे है ? मुझे लगता है कि, यदि आप कोई तर्क प्रदान करते हैं, तो यह विफल हो जाएगा। इसके अलावा, मुझे लगता है jकि किसी प्रकार की त्रुटि होगी। bहालांकि इसके लिए निश्चित नहीं है ।

— सितंबर को आउटगोल्फ जूल

3

गणितज्ञ २५

यह मानते हुए कि आपको 10 ^ 6 से कम के अपराधों की संख्या नहीं पता है:

Prime@Range@PrimePi[10^6]

— DavidC
स्रोत

3

जे, 16 वर्ण

1]\(#~1&p:)i.1e6

आउटपुट स्वरूप की आवश्यकता के बिना, इसे 13 वर्णों तक घटाया जा सकता है :

(#~1&p:)i.1e6

1]\ सिर्फ रैंक 1 सरणी के अपराधों को लेता है, इसे रैंक 2 सरणी में बदल देता है, और प्रत्येक प्राइम को अपनी पंक्ति में रखता है - और इसलिए दुभाषिया का डिफ़ॉल्ट आउटपुट फॉर्मेट एक लाइन सूची को एक प्राइम प्रति पंक्ति में बदल देता है।

(#~ f) yमूल रूप से filter, जहां fप्रत्येक तत्व के लिए एक बूलियन देता है y। i.1e6पूर्णांकों की सीमा [0,1000000) है, और 1&p:एक बूलियन फ़ंक्शन है जो 1 primes के लिए देता है।

— rationalis
स्रोत

3

आर, ४५ ४३ अक्षर

for(i in 2:1e6)if(sum(!i%%2:i)<2)cat(i," ")

प्रत्येक संख्या x के लिए 2 से 1e6 तक, बस इसे आउटपुट करें यदि x mod 2 से x की संख्या जो 0 के बराबर है, 2 से कम है।

— plannapus
स्रोत

इस कोड द्वारा निर्मित पहली संख्या 1 है, लेकिन 1 अभाज्य नहीं है।

— स्वेन होइनस्टीन

@SvenHohenstein धन्यवाद, सही किया।

— प्लेनैपस

3

बैश (433643)

मेरी (इतनी चतुराई नहीं) कोशिश थी कि उत्पाद को कारक बनाया जाए।

factor ${PRODUCT}

दुर्भाग्य से बड़ी संख्या में उत्पाद बहुत बड़ा है। इसे चलाने में भी 12 घंटे लगे। मैंने इसे पोस्ट करने का फैसला किया क्योंकि मुझे लगा कि यह अद्वितीय है।

यहाँ पूर्ण कोड है।

अगर यह छह के तहत primes था तो यह उचित होगा।

  factor 30

ओह अच्छा, मैंने कोशिश की।

— केविन कॉक्स
स्रोत

+1 यह उत्तर वास्तव में शैतानी है। काफी प्रीक्म्प्यूटेड रिजल्ट नहीं है (यह काफी हद तक पात्रों को बचाता है), और गणना करने के लिए बहुत अधिक भयानक :) यह संभवतः संभवतः एक उदाहरण भी है जो अनुकूलित factorपरीक्षण को बुनियादी ट्रायल डिवीजन एल्गोरिदम की तुलना में बहुत खराब बनाता है।

— ओरियन

3

सी #, 70

Enumerable.Range(1,1e6).Where(n=>Enumerable.Range(2,n).All(x=>x%n!=0))

आप एक लंबे समय के लिए यहाँ बहुत कुछ देखने नहीं जा रहे हैं ...

— It'sNotALie।
स्रोत

इसके गलत होने के कई कारण हैं। (1) आप परोक्ष एक से परिवर्तित नहीं कर सकते double 1e6एक करने के लिए int, लेकिन intके लिए आवश्यक है Range। (2) आंतरिक Rangeको सबसे अधिक n-2शर्तों पर लेना चाहिए , अन्यथा आप परीक्षण करेंगे n % nजो स्पष्ट रूप से है 0। (३) आप x%nजब चाहें लिखें n%x। इन मुद्दों को ठीक करना, कुछ इस तरह से काम करेगा: Enumerable.Range(2,999999).Where(n=>Enumerable.Range(2,n-2).All(x=>n%x!=0))हालांकि, यह अभी भी संख्याओं का उत्पादन नहीं करता है; आवश्यकता प्रति पंक्ति एक थी।

— जेपी स्टिग नीलसन

एक लाख के तहत primes की सूची

गणितज्ञ , १। २४

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

C, 61 वर्ण

MATLAB (16) (12)

बैश (37 वर्ण)

(60 वर्ण)

जे, 21 अक्षर

पॉवरशेल, 47 44 बाइट्स

पॉवरशेल, 123 बाइट्स

रूबी 34

बैश, 30 बाइट्स

यह काम किस प्रकार करता है

रूबी ५० ४१

बैश, ३,

पुराना हल

पायथन 3.x: 66 वर्ण

अधिक कुशल समाधान: 87 वर्ण

हास्केल, 51

एपीएल, १५

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

जूलिया, ११

जे (15 या 9)

gs2, 5 बाइट्स

गोल्फस्क्रिप्ट, 22/20 (20/19) बाइट्स

यह काम किस प्रकार करता है

प्रतिस्पर्धा

NARS2000 APL, 7 वर्ण

गोल्फस्क्रिप्ट 26 25 24

संपादित करें (पीटर टेलर के लिए एक और चार धन्यवाद):

CJam - 11

गोल्फस्क्रिप्ट, 25 (24) बाइट्स

यह काम किस प्रकार करता है

मानक

जावा, 110 बाइट्स

सी, 91 88 85 82 81 80 76 72 वर्ण

गणितज्ञ २५

जे, 16 वर्ण

आर, ४५ ४३ अक्षर

बैश (433643)

सी #, 70