एक प्राकृतिक रूप से उत्पन्न होने वाला प्रधान जनरेटर

42

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

2003 में स्टीफन वोल्फ्राम ने NKS समर स्कूल में एक लाइव कंप्यूटर प्रयोग में नेस्टेड पुनरावृत्ति समीकरणों के एक वर्ग की खोज की। मैथ्यू फ्रैंक के आसपास के लोगों के एक समूह ने अतिरिक्त प्रयोगों के साथ पालन किया और बस पुनरावृत्ति की एक दिलचस्प संपत्ति की खोज की

a(n) = a(n-1) + gcd(n,a(n-1))

के प्रारंभ मूल्य के साथ a(1) = 7। अंतर a(n) - a(n-1) = gcd(n,a(n-1))हमेशा 1 या एक प्रधान लगता था। पहले कुछ अंतर हैं ( OEIS A132199 ):

1, 1, 1, 5, 3, 1, 1, 1, 1, 11, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 3, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 47, 3, 1, 5, 3, ...

यदि हम केवल 1s को छोड़ देते हैं तो हमें निम्नलिखित अनुक्रम ( OEIS A137613 ) मिलता है:

5, 3, 11, 3, 23, 3, 47, 3, 5, 3, 101, 3, 7, 11, 3, 13, 233, 3, 467, 3, 5, 3, 
941, 3, 7, 1889, 3, 3779, 3, 7559, 3, 13, 15131, 3, 53, 3, 7, 30323, 3, ...

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

क्योंकि इस प्राइम जनरेटर का निर्माण नहीं किया गया था, लेकिन बस दुर्घटना के कारण पाया गया, प्राइम जनरेटर को "स्वाभाविक रूप से होने वाला" कहा जाता है। लेकिन ध्यान दें कि व्यवहार में यह जनरेटर भी गणना करने के लिए काफी प्रभावी है। जैसा कि यह पता चला है, एक प्राइम पी (p–3)/2लगातार 1 एस के बाद ही दिखाई देता है । फिर भी इस प्रमुख जनरेटर को लागू करना आपका काम होगा।

चुनौती:

एक फ़ंक्शन या एक प्रोग्राम लिखें nजो अनुक्रम के पहले तत्वों A137613(1s के बिना अनुक्रम) को प्रिंट करता है । आप n >= 0STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन तर्क के माध्यम से इनपुट नंबर पढ़ सकते हैं । nकिसी भी पठनीय प्रारूप में पहले तत्वों को STDOUT में आउटपुट करें , या इन मानों के साथ एक सरणी या सूची लौटाएं।

यह कोड-गोल्फ है। इसलिए सबसे छोटा कोड जीतता है।

लीडरबोर्ड:

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

# Language Name, N bytes

जहाँ N आपके सबमिशन का आकार है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं, उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

कोड स्निपेट दिखाएं

code-golf  number  sequence  primes  number-theory 
— Jakube
स्रोत
1
जबकि प्रधान जनरेटर का निर्माण नहीं किया गया है, आप पुनरावर्तन का उपयोग करके प्रभावी रूप से एक परीक्षण प्रभाग को लागू कर रहे हैं।
— orlp
यदि एक (1) = 7, अनुक्रम 7 से क्यों शुरू नहीं होता है?
— feersum
3
@ फ़ेर्सम क्योंकि जिस क्रम से हम चिंतित हैं वह हैa(n)-a(n-1)
— माल्टीसेन
कर सकते हैं nशून्य हो सकता है?
— Sp3000
1
@jrenk यकीन नहीं होता। शायद इसे 2 बाइट्स के रूप में गिना जाए (क्योंकि आप 2 चार्ट हटा रहे हैं //) और इसे अपने सबमिशन में समझाएं। यदि कोई आपसे असहमत है, तो आप हमेशा अपनी पोस्ट को संपादित कर सकते हैं।
— जकुब

जवाबों:

7

पायथन 3.5.0b1 +, 95 93 बाइट्स

पायथन 3.5.0b1 + रिलीज़ से लिंक करें

import math
def f(k,n=2,a=7,L=[]):x=math.gcd(n,a);return k and f(k-1%x,n+1,a+x,L+1%x*[x])or L

पुनरावृत्ति का एक सीधा कार्यान्वयन, विशेषता:

  • हमारे अच्छे दोस्त 1%x, और
  • math.gcd, के रूप में विरोध किया fractions.gcd।
— Sp3000
स्रोत
क्या करता 1%xहै? साइड सवाल: मुझे पायथन के संशोधन इतिहास के दस्तावेज कहां मिलते हैं जिसमें बेट्स शामिल हैं? संपादित करें: कोई बात नहीं, इसे संशोधन इतिहास में सबसे नीचे पाया गया ।
— mbomb007
@ mbomb007 के बाद से x >= 1, 1%x0 अगर x == 1, 1 अन्यथा लौटाता है ( xसूची में जोड़ने के लिए तय किया जाता है )
— Sp3000
5

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

n->(a(n)=(n≥1&&(n==1?7:a(n-1)+gcd(n,a(n-1))));i=2;j=0;while j<n x=a(i)-a(i-1);x>1&&(j+=1;println(x));i+=1end)

Ungolfed:

function a(n::Int)
    n ≥ 1 && (n == 1 ? 7 : a(n-1) + gcd(n, a(n-1)))
end

function f(n::Int)
    i = 2;
    j = 0;
    while j < n
        x = a(i) - a(i-1)
        if x > 1
            j += 1
            println(x)
        end
        i += 1
    end
end
— एलेक्स ए।
स्रोत
वाह, एक आदर्श 8k, अच्छा: D
— बीटा Decay
1
के n<2बजाय का उपयोग करें n==1। इसके अलावा, अगर आप आगे पीछे की ओर के बजाय देखें, तो आप उपयोग कर सकते हैं i=1और x=a(i)-a(i+=1), और फिर println(-x)और -x>1सही करने के लिए नकारात्मकता के लिए है, जिससे की एक अलग वेतन वृद्धि के लिए की जरूरत से परहेज i। और ≥तीन बाइट्स है, जबकि >=दो है ... लेकिन फिर, आप इसके n<1||()बजाय n>=1&&()... का उपयोग कर सकते हैं और फिर भी, यह पहली जगह में भी आवश्यक नहीं है (सशर्त ड्रॉप करें, एन कभी भी 1 से कम नहीं होगा)। (N) को परिभाषित करते समय आपको सबसे बाहरी कोष्ठक की भी आवश्यकता नहीं होती है। इन परिवर्तनों के साथ, आपको कम से कम 97 बाइट्स तक नीचे उतरना चाहिए।
— ग्लेन ओ
5

PHP, 101 96 99 98 77 72 बाइट्स

<?for(;2>$t=gmp_strval(gmp_gcd(~++$i,7+$e+=$t))or$argv[1]-=print"$t ";);


उपयोग:
एक तर्क के साथ स्क्रिप्ट को कॉल करें: php -d error_reporting=0 script.php 30
यदि आप इसका परीक्षण करना चाहते हैं तो आपको ;extension=php_gmp.dllअपने php.ini में असहजता की आवश्यकता है
-> extension=php_gmp.dll
क्या मुझे अपने बाइट काउंट में एक्सटेंशन जोड़ना चाहिए? कोई विचार?


लॉग:
Ismael Miguel के लिए 3 बाइट्स सहेजे गए।
प्राइमो की बदौलत 26 बाइट्स बचाए।

— jrenk
स्रोत
1
आप अपनी शुरुआती टैग को छोटा कर सकते हैं <?और की परिभाषा को हटा सकते हैं $j।
— इस्माइल मिगुएल
1
हाँ, यह मायने रखता है। लेकिन आप उस न्यूलाइन को हटा सकते हैं। जो 1-2 बाइट्स बचाएगा, इस पर निर्भर करता है कि आपने अपने कोड का आकार कैसे गिना।
— इस्माइल मिगुएल
1
मामूली सुधार: उपयोग <में $j<=$argv[1](प्रिंट एक भी कई) (-1)। $eअसंवैधानिक छोड़ दें , $e+7इसके बजाय (-3) का उपयोग करें । के for(;;)बजाय का उपयोग करें while(), पूर्व और बाद के भाव का उपयोग कर (-2)। बदलें echo$t.' ';$j++के साथ $j+=print"$t ", कोष्ठक ड्रॉप (-3)। बदलें if($t>1)के साथ 2>$t||(-2)। असाइनमेंट कम्बाइन $tसशर्त, स्विच के साथ ||के लिए or, कोष्ठक ड्रॉप (-5)। ले जाएँ $argv[1]करने के लिए $j, वेतन वृद्धि करने के लिए पूरे अभिव्यक्ति के लिए कदम forसशर्त (-2)। बदलें >=$j+=printकरने के लिए -=print(-3)। चरण दर चरण: codepad.org/s6LNSPSM
— primo
1
@primo अच्छी व्याख्या के लिए धन्यवाद! नहीं जानता था कि मैं वह सब कर सकता हूँ।
— jrenk
1
कुछ और: (-2) के $e+7साथ मिलाएं $e+=$t। $iअसंवैधानिक छोड़ दें , ~++$iइसके बजाय (-3) का उपयोग करें । codepad.org/fDIImajp
— प्राइमो
4

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

d=zipWith gcd[2..]$scanl(+)7d
f=($filter(>1)d).take

ध्यान दें कि fएक फ़ंक्शन है जो पहले n तत्वों को लौटाएगा ।

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

Ungolfed:

a = scanl (+) 7 d        -- yielding a(n) = 7 + d(1) + d(2) + ... + d(n-1)
d = zipWith gcd [2..] a  -- yielding d(n) = gcd(n+1, a(n))

f n = take n $ filter (> 1) d -- get rid of 1s and take the first n
— Artelius
स्रोत
4

पायथ, 30 बाइट्स

बहुत बुरी तरह से गोल्फ, काफी कम किया जा सकता है। फ्रंट पर पुनरावर्ती कार्य को परिभाषित करता है, .first-n फ़िल्टर करता है , और फिर अंतर को मैप करता है।

L?tb+KytbibK7m-yhdyd.ft-yhZyZQ

इसे यहाँ ऑनलाइन प्रयास करें ।

— Maltysen
स्रोत
यह गलत आउटपुट देता हैn = 0
— Sp3000
2
@ Sp3000 जो पाइथ में एक बग है। मैं एक पुल अनुरोध में डालूँगा।
— माल्टीसेन
बग पाया गया और तय किया गया - पैच को एक बार लागू किया जाएगा जब github DDoS'd होना बंद हो जाएगा।
— isaacg
1
यहाँ यह है: meta.codegolf.stackexchange.com/questions/5318/… । व्यक्तिगत रूप से मैं एक जवाब के रूप में प्रोग्रामिंग भाषाओं में बग फिक्स पर विचार करूंगा
— थॉमस वेलर
2
@ThomasWeller इस तरह की पूरी भाषा हासिल की ...
— isaacg
4

जूलिया, 69 67 बाइट्स

n->(i=1;a=7;while n>0 x=gcd(i+=1,a);a+=x;x>1&&(n-=1;println(x))end)

यह समस्या का एक सरल पुनरावृत्त समाधान है। xअंतर है (जो है gcd), और फिर मैं aजोड़कर अद्यतन करता हूं x।

— ग्लेन हे
स्रोत
मुझे लगता है कि यह A231900 प्रिंट करता है ।
— एलेफाल्फा
@alephalpha - मुझे लगता है कि मुझे त्रुटि दिखाई दे रही है। आसानी से तय किया हुआ। यहां तक ​​कि इस प्रक्रिया में दो बाइट्स का मुंडन किया गया।
— ग्लेन ओ
3

जावास्क्रिप्ट (ईएस 6), 91

पुनरावर्ती gcd, पुनरावृत्त मुख्य कार्य। इतना शीघ्र नही।

सामान्य नोट: किसी भी EcmaScript 6 अनुरूप ब्राउज़र (विशेष रूप से क्रोम नहीं MSIE। मैंने फ़ायरफ़ॉक्स पर परीक्षण किया, सफ़ारी 9 जा सकता है पर स्निपेट चलाने का परीक्षण करें।) 

F=m=>{
  for(G=(a,b)=>b?G(b,a%b):a,o=[],p=7,n=1;m;d>1&&(o.push(d),--m))
    p+=d=G(++n,p);
  return o
}

O.innerHTML=F(+I.value)
<input id=I value=10><button onclick='O.innerHTML=F(+I.value)'>-></button>
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

हास्केल, 74 71 66 बाइट्स

f=($filter(>1)$tail>>=zipWith(-)$scanl(\x->(x+).gcd x)7[2..]).take

यहाँ ट्रिक का उपयोग किया: https://codegolf.stackexchange.com/a/39730/43318 , और बिंदु-रहित बनाया।

(पिछला: 71 बाइट्स)

a=scanl(\x->(x+).gcd x)7[2..]
f m=take m$filter(>1)$zipWith(-)(tail a)a

पहले एक का अनुक्रम बनाएं, और फिर अंतर लें।

(पिछला: 74 बाइट्स)

f m=take m$filter(>1)$map snd$scanl(\(x,d)->(\y->(x+y,y)).gcd x)(7,1)[2..]

मानक सूची फ़ंक्शंस, लंबोदा फ़ंक्शन का अधिक चतुर उपयोग। ध्यान दें कि यह 1 बाइट से अधिक स्पष्ट है

g m=take m$filter(>1)$map snd$scanl(\(x,d)n->(x+gcd x n,gcd x n))(7,1)[2..]

यदि हम आयातों की गणना नहीं करते हैं, तो मैं इसे 66 तक नीचे ला सकता हूं।

import Data.List
h m=take m$filter(>1)$snd$mapAccumL(\x->(\y->(x+y,y)).gcd x)7[2..]
— होल्डन ली
स्रोत
3

PARI / GP, 60 बाइट्स

a(n)=a=7;i=1;while(n,if(1<d=gcd(i+=1,a),n-=1;print(d));a+=d)

परिभाषा से अधिक या कम सीधे लिया गया (n) - a (n-1) = gcd (n, a (n-1))

इसके लिए आउटपुट a(20):

5
3
11
3
23
3
47
3
5
3
101
3
7
11
3
13
233
3
467
3
— Primo
स्रोत
2

सी ++, 193 182 180 172 बाइट्स

धन्यवाद @Jakube - आउटपुट पर 8 बाइट्स बचाया। 

int g(int a,int b){return a==b?a:a>b?g(b,a-b):g(a,b-a);}void f(int *r,int n){int m=1,i=0,a=7,b;while(i<n){b=g(a,++m);if(b>1){r[i]=b;++i;}a+=b;}}int main(){int r[6];f(r,6);}
— EvgeniyZh
स्रोत
आप शायद एक फ़ंक्शन को परिभाषित करके कुछ बाइट्स बचा सकते हैं f, जो परिणामों के साथ एक सरणी देता है। इस तरह आप शामिल, स्कैनफ और प्रिंट निकाल सकते हैं।
— जक्यूब
2

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

For[i=j=1;a=7,i<=#,,d=GCD[++j,a];If[d>1,Print@d;i++];a+=d]&
— alephalpha
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.