न्यूनतम गणना करें जैसे कि अभाज्य है (OEIS A051935)

Question

पृष्ठभूमि

निम्नलिखित अनुक्रम पर विचार करें ( OEIS में A051935 ):

• शब्द से शुरू करें ।$2$
• सबसे कम पूर्णांक ज्ञात कीजिये से अधिक ऐसा अभाज्य है।2 2 + $n$$2$$2+n$
• सबसे कम पूर्णांक का पता लगाएं से अधिक ऐसा है कि प्रधानमंत्री है आदि n 2 + n + n $n'$$n$$2 + n + n'$

एक अधिक औपचारिक परिभाषा:

$$a_n=\begin{cases}2 & \text{if }n=0 \\ \min\{x\in\Bbb{N}\mid x>a_{n-1} \text{ and }\left(x+\sum_{i=0}^{n-1}a_i\right) \text{ is prime}\} & \text{otherwise}\end{cases}$$

अनुक्रम की पहली कुछ शर्तें हैं (कृपया इन्हें परीक्षण मामलों के रूप में देखें):

2, 3, 6, 8, 10, 12, 18, 20, 22, 26, 30, 34, 36, 42, 44, 46, 50, 52, 60, 66, 72, 74, ...

कार्य

आपका कार्य निम्न में से किसी भी तरीके से इस क्रम को उत्पन्न करना है:

• अपनी शर्तों को अनिश्चित काल तक आउटपुट करें।
• दिए गए $n$ , आउटपुट $a_{n}$ ( $n^{\text{th}}$ टर्म, $0$ या $1$ अनुक्रमित)।
• दिए गए $n$ , आउटपुट $\{a_1, a_2, \dots, a_n\}$ (पहला $n$ शब्द)।

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

Comments

चुनौतियां लिखते समय बचने के टिप्स: प्रमुख संख्याएँ । आप कुछ और प्रयोग कर सकते हैं।

— ओकेक्स

@ ओकेक्स के कारण मेरे मन में कुछ कारण थे जब मैं इस बार primality चुनता हूं: 1) कुछ चतुर एल्गोरिदम हैं जो इस क्रम के लिए विशिष्ट हैं, जैसे कि एक डेनिस ने 2 को लागू किया ) इसके लिए पहले से ही एक OEIS प्रविष्टि है

— श्री। Xcoder

Answer 1

ब्रेकीलॉग , 13 बाइट्स

~l.<₁a₀ᵇ+ᵐṗᵐ∧

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

आउटपुट अनुक्रम के पहले n शब्दों की सूची है ।

?~l.<₁a₀ᵇ+ᵐṗᵐ∧    Full code (? at beginning is implicit)

?~l.              Output is a list whose length is the input
    <₁            Output is an increasing list
      a₀ᵇ+ᵐ       And the cumulative sum of the output
           ṗᵐ     Consists only of prime numbers
             ∧    No further constraints on output

Explanation for a₀ᵇ+ᵐ:
a₀ᵇ               Get the list of all prefixes of the list
                  Is returned in increasing order of length
                  For eg. [2, 3, 6, 8] -> [[2], [2, 3], [2, 3, 6], [2, 3, 6, 8]]
   +ᵐ             Sum each inner list  -> [2, 5, 11, 19]

Answer 2

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

n=f=a=b=1
while 1:
 f*=n;n+=1;a+=1
 if~f%n<a-b:print a;b=a;a=0

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

Answer 3

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

0Ḥ_ÆnɗСI

यह एक पूर्ण कार्यक्रम है जो एक तर्क के रूप में n लेता है और अनुक्रम के पहले n शब्दों को प्रिंट करता है ।

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

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

0Ḥ_ÆnɗСI  Main link. Argument: n

0          Set the return value to 0.
      С   Accumulating iterate. When acting on a dyadic link d and called with
           arguments x and y, the resulting quicklink executes
           "x, y = d(x, y), x" n times, returning all intermediate values of x.
           Initially, x = 0 and  y = n.
     ɗ       Drei; combine the three links to the left into a dyadic chain.
 Ḥ             Unhalve; double the left argument.
  _            Subtract the right argument.
   Æn          Compute the next prime.
           This computes the partial sums of the sequence a, starting with 0.
        I  Increments; compute the forward differences.

Answer 4

05AB1E v2 , 10 बाइट्स

2λλOD₁+ÅNα

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

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

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

2λ

बेस केस साथ एक पुनरावर्ती अनंत अनुक्रम को परिभाषित करता है । संरचना 05AB1E के बहुत बेहतरीन नई सुविधाओं में से एक है। संक्षेप में कहा जाए तो यह एक समारोह लेता है , की स्थापना इस मामले में दिए गए, पूर्णांक तर्क को ।एक ( एन ) एक ( 0 ) $2$λ$a(n)$$a(0)$$2$

λO

कोड के इस हिस्से में, λभूमिका अलग है। पहले से ही एक पुनरावर्ती वातावरण के अंदर होने के कारण, यह बजाय , पिछले सभी परिणामों की सूची उत्पन्न करता है। फिर, उन्हें रकम देता है।$[a(0),a(1),\dots,a(n-1)]$O

D₁+

बाद में उपयोग के लिए राशि को डुप्लिकेट करें और दूसरी प्रति में जोड़ें ।$a(n-1)$

ÅN

उपरोक्त योग की तुलना में सबसे कम प्रधानता उत्पन्न करता है।

α

अंत में, ऊपर गणना किए गए अभियोक्ता और पहले की गई गणना की पहली प्रति (पिछले सभी पुनरावृत्तियों का योग) के बीच पूर्ण अंतर को पुनः प्राप्त करें।

फिर धारा को अनिश्चित काल के लिए STDOUT में छाप दिया जाता है।

Answer 5

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

2,{first (*+@_.sum).is-prime,@_[*-1]^..*}...*

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

एक आलसी सूची देता है जो अनुक्रम को बिना किसी अंत के उत्पन्न करता है।

स्पष्टीकरण:

यह अनुक्रम ऑपरेटर का उपयोग ...करता है जो अनुक्रम को परिभाषित करता है:

2,  # The first element is 2
  {  # The next element is:
    first  # The first value that:
          (*+@_.sum).is-prime,  # When added to the sum is a prime
          @_[*-1]^..*  # And is larger than the previous element
  }
...*  # And continue the sequence indefinitely

Answer 6

रूबी -rprime , 34 बाइट्स

2.step{|i|$.+=p(i)if($.+i).prime?}

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

अनिश्चित काल के लिए आउटपुट।

Answer 7

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

शब्द, 1-अनुक्रमित लौटाता है।$n^{th}$

n=>(k=0,s=1,g=d=>s%d?g(d-1):d<2?--n?g(s-=k-(k=s)):s-k:g(s++))()

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

Answer 8

पायथ ,12 11 बाइट्स

.f&P-;Z=-;Z

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

इसहाक के लिए 1 बाइट का धन्यवाद सहेजा गया।

n1 आधारित सूचकांक का उपयोग करके इस तरह की पहली संख्या बनाता है।

.fपहला kपूर्णांक पाता है जो शून्य से शुरू होने वाले एक विशेष मानदंड को पूरा करता है। यहां, मानदंड यह है कि हमने पिछले प्रधानमंत्री की गणना की, ;और वर्तमान संख्या, Zप्रधान है ( P)। यदि ऐसा है, तो हम तार्किक और फ़ंक्शन के शॉर्ट-सर्कुलेटिंग व्यवहार ( &) का उपयोग करके अंतिम गणना किए गए प्राइम को भी अपडेट करते हैं । दुर्भाग्य से .fडिफ़ॉल्ट चर है Zजो अद्यतन में एक बाइट की लागत है।

इसाॅक को जिस तरकीब से खोजा गया, वह था कि आखिरी प्राइम की निगेटिव को स्टोर करना और मौजूदा वैल्यू को माइनस करना। यह पाइल्थ में छोटा होता है क्योंकि प्राइमलिटी चेक ओवरलोडेड होता है: पॉजिटिव नंबर्स पर यह प्राइम फैक्टर का पता लगाता है जबकि नेगेटिव नंबर्स पर यह निर्धारित करता है कि नंबर की पॉजिटिव वैल्यू प्राइम है या नहीं।

यह कमोबेश अनुवाद में है:

to_find = input()
last_prime = 0
current = 0
results = []
while to_find > 0:
    if is_prime( current + last_prime ):
        results.append( current )
        to_find -= 1
        last_prime += current
    current += 1
print results

Comments

-1 बाइट के _+साथ -और उसके +साथ बदलें -।

— isaacg

@isaacg यह काफी चतुर है! मैं इसे संपादित करूँगा।

— FryAmTheEggman

Answer 9

MATL , 21 बाइट्स

O2hGq:"t0)yd0)+_Yqh]d

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

आउटपुट अनुक्रम का पहला n शब्द है।

स्पष्टीकरण:

(प्रारंभिक 0 के साथ) primes की एक सूची का निर्माण करता है, और अंत में सूची में क्रमिक primes के बीच के अंतर का पता लगाता है।

              % Implicit input, say n
O2h           % Push P = [0, 2] on the stack 
Gq:"          % for loop: 1 to n-1
  t0)           % Take the last element of P
                %  Stack: [[0, 2], [2]] (in first iteration)
  yd0)          % Take the difference between the last
                %   two elements of P
                %  Stack: [[0, 2], [2], [2]]
  +             % Add those up
                %  Stack: [[0, 2], [4]]
  _Yq           % Get the next prime higher than that sum
                %  Stack: [[0, 2], [5]]
  h             % Concatenate that to the list P
                %  Stack: [[0, 2, 5]]
]             % End for loop
d             % Get the differences between successive elements of
              %   the final list P

Answer 10

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

(1#1)2 2
(p#n)s k|p`mod`n>0,n-s>k=k:(p#n)n(n-s)|w<-p*n=(w#(n+1))s k

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

(1#1)2 2एक ऐसा कार्य है जो कोई इनपुट नहीं लेता है और एक अनंत सूची को आउटपुट करता है।

---

पुराना उत्तर:

हास्केल , 88 83 78 76 बाइट्स

प्राइमलिटी टेस्ट इस उत्तर से होता है और क्रिश्चियन सिवर्स (-2 बाइट्स) द्वारा सुधार किया जाता है ।

-5 बाइट्स WW के लिए धन्यवाद ।

2#2
(p#s)n|n<1=p|w<-until(\m->mod(product[1..m-1])m>0)(+1)$s+p+1=(w-s)#w$n-1

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

Comments

आप बिना कर सकते हैं ^2। यह बदलेगा कि परीक्षण से विधेय मुख्य रूप से परीक्षण के लिए अभाज्य है या 4 , जो इस अनुप्रयोग में मायने नहीं रखता है।

— क्रिश्चियन सिवर्स

Answer 11

05AB1E (विरासत) , 12 बाइट्स

0U[XN+DpiN,U

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

व्याख्या

0U              # initialize X as 0
  [             # start an infinite loop
   XN+          # add X to N (the current iteration number)
      Dpi       # if the sum is prime:
         N,     #   print N
           U    #   and store the sum in X

अलग-अलग 12-बाइट समाधानों की एक जोड़ी संभव है।
यह विशेष रूप से 10 बाइट्स हो सकता है यदि हमारे पास 0 (1 और 2 के बजाय) के रूप में प्रयोग करने योग्य चर हो।

Answer 12

अजगर 2 , 119 बाइट्स

f=lambda n,k=1,m=1:m%k*k>n or-~f(n,k+1,m*k*k)
def g(i):
 r=[2]
 for j in range(i):r+=[f(sum(r)+r[-1])-sum(r)]
 return r

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

इस उत्तर से लिया गया अगला प्रधान कार्य f () ।

फंक्शन g () एक गैर-नकारात्मक पूर्णांक i लेता है और अनुक्रम में सभी वस्तुओं की सूची को उस सूचकांक तक लौटाता है।

Comments

-7 बाइट्स ।

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

Answer 13

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

def f(n,s=2,v=2):
 k=s-~v
 while any(k%i<1for i in range(2,k)):k+=1
 return n and f(n-1,k,k-s)or v

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

मिस्टर एक्सकोडर को 1 बाइट ।

Comments

मुझे पता है ... मुझे पता है ... मुझे और मेरे बिटव्यू-ट्रिक पेडेंट्री :) लेकिन आप के साथ एक बाइट बचा सकते हैं k=s-~v।

— श्री एक्सकोडर

@श्री। Xcoder: आपका अपवित्र बिटवाइज़ टोना आप का अंत होगा! :)

— चास ब्राउन

Answer 14

हास्केल , 101 99 97 बाइट्स

फ़ंक्शन lकोई तर्क नहीं लेता है और एक अनंत सूची देता है। @Ovs द्वारा अधिक प्रत्यक्ष दृष्टिकोण जितना छोटा नहीं है (और मैंने स्पष्ट रूप से उनके कुछ हिस्सों को चुरा लिया है), लेकिन शायद अभी भी गोल्फ है?

धन्यवाद @ H.PWiz -2 बाइट्स के लिए!

import Data.List
p m=mod(product[1..m-1])m>0
l=2:[until(p.(+sum a))(+1)$last a+1|a<-tail$inits l]

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

Answer 15

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

s=p=2
i=input()
P=n=1
while i:
 P*=n;n+=1
 if P%n>0<n-s-p:p=n-s;s=n;i-=1
print p

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

यह अनुक्रम (0-आधारित) की nth संख्या को आउटपुट करता है। printलूप में स्थानांतरित करके , यह पहले nआइटम को एक ही बायटेकाउंट में आउटपुट करने के लिए संशोधित किया जा सकता है : इसे ऑनलाइन आज़माएं!

Answer 16

सी (जीसीसी) , 100 99 बाइट्स

• छत के लिए धन्यवाद एक बाइट बचाया ।

p(r,i,m,a,l){for(l=m=a=0;a-r;)m+=i=p(a++);while(r*!l)for(++i,l=a=2;a-m-i;)l=(m+i)%a++?l:0;r=r?i:2;}

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

Answer 17

जाप, 17 बाइट्स

nवें पद को आउटपुट करता है , 0-अनुक्रमित।

@_+T j}aXÄT±X}g2ì

कोशिश करो