नया आदेश # 3: 5 8 6

Question

परिचय (अनदेखा किया जा सकता है)

अपने नियमित क्रम (1, 2, 3, ...) में सभी सकारात्मक संख्याओं को डालना थोड़ा उबाऊ है, है ना? इसलिए यहां सभी सकारात्मक संख्याओं के क्रमपरिवर्तन (फेरबदल) के आसपास चुनौतियों की एक श्रृंखला है। यह इस श्रृंखला में तीसरी चुनौती है ( पहली और दूसरी चुनौतियों के लिंक )।

इस चुनौती में, हम बढ़ती संख्या की पंक्तियों में प्राकृतिक संख्याओं को इस तरह व्यवस्थित करेंगे कि प्रत्येक पंक्ति का योग अभाज्य हो। मुझे इस बारे में वास्तव में आश्चर्यजनक लगता है, यह है कि इस व्यवस्था में प्रत्येक प्राकृतिक संख्या का स्थान है। कोई संख्या नहीं छोड़ रहे हैं!

इस व्यवस्था का यह दृश्य इस तरह दिखता है:

row             numbers             sum
1                  1                  1
2                2   3                5
3              4   5   8             17
4            6   7   9  15           37
5          10 11  12  13  21         67
6        14  16 17  18  19  23      107
etc.

हम इस त्रिकोण में पंक्तियों से तत्वों को पढ़ सकते हैं। पहले 20 तत्व हैं: 1, 2, 3, 4, 5, 8, 6 , 7, 9, 15, 10, 11, 12, 13, 21, 14, 16, 17, 18, 19 ( हाँ, वहाँ है) इस क्रम में छिपा एक नया आदेश गीत )।

चूंकि यह एक "शुद्ध अनुक्रम" चुनौती है, कार्य उत्पादन के लिए है $a(n)$ के लिए एक दिया $n$ इनपुट, जहां के रूप में $a(n)$ है A162371 ।

कार्य

एक पूर्णांक इनपुट को देखते हुए $n$ , उत्पादन $a(n)$ पूर्णांक प्रारूप में।

$a(n)$ कोप्राकृतिक संख्याओं के शाब्दिक रूप से जल्द से जल्द क्रमपरिवर्तन के$n$ वें तत्व केरूप में परिभाषित किया गयाहै, जब पंक्तियों द्वारा पढ़े गए त्रिकोण के रूप में देखा जाता है, तो n> 1 के लिए पंक्तियों की संख्याएँ प्रमुख संख्याएँ होती हैं। 1 के साथ शुरू होता है प्राकृतिक संख्या के पहले lexicographical क्रमचय के बाद से,$a(1)$ है 1. ध्यान दें कि यह परिभाषा से$a(1) = 1$ और$a(1)$ है नहीं प्रधानमंत्री होने के लिए आवश्यक। यह OEIS अनुक्रम A162371 है ।

नोट: 1-आधारित अनुक्रमण यहाँ मान लिया गया है; आप 0-आधारित अनुक्रमण का उपयोग कर सकते हैं, इसलिए $a(0) = 1; a(1) = 2$ , आदि कृपया अपने उत्तर में इसका उल्लेख करें यदि आप इसका उपयोग करना चाहते हैं।

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

Input | Output
---------------
1     |  1
5     |  5
20    |  19
50    |  50
78    |  87
123   |  123
1234  |  1233
3000  |  3000
9999  |  9999
29890 |  29913

नियम

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

Comments

क्या हम अनुक्रम को असीम रूप से आउटपुट कर सकते हैं, या इसके बजाय एक जनरेटर वापस कर सकते हैं?

— जो किंग

एर, 1 एक प्रमुख नहीं है

— जो राजा

@JoKing के बारे में (1) = 1: मैं इसे जोड़ूंगा। वह वास्तव में अपवाद है। यह OEIS प्रविष्टि में स्पष्ट रूप से कहा गया है, खरीदें I यह स्पष्ट रूप से उल्लेख नहीं किया गया है। मैं इसे प्रश्न में जोड़ दूँगा। धन्यवाद।

— agtoever

@ जॉकिंग ध्यान दें कि अनुक्रम की परिभाषा में केवल n> 1 के लिए पंक्ति के योग की आवश्यकता होती है। चूंकि अनुक्रम प्राकृतिक संख्याओं का पहला लेक्सोग्राफ़िक क्रमांकन है, (1) 1 के रूप में सामने आता है। इसलिए वास्तव में, 1 अभाज्य नहीं है, लेकिन अनुक्रम की चुनौती या परिभाषा 1 प्राइम होने की आवश्यकता नहीं है या इसकी आवश्यकता नहीं है .. ।

— agtoever

संबंधित क्रम: A075348 ।

— jimmy23013

Answer 1

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

;®»ṀƊSÆn_S
ẎṀ©+LRḟẎḣL;Ç$ṭ
1Ç¡Fị@

इसे ऑनलाइन आज़माएं! - बहुत धीमी गति के रूप में यह n पंक्तियों को पहले बनाता है, एक तेज संस्करण के लिए जो 37 बाइट्स पर नहीं है, यह कोशिश करें ।

Answer 2

पर्ल 6 , 80 77 बाइट्स

{({$!=@_;+(1...{$_∉$!&&(|$!,$_).rotor(1..*).one.sum.is-prime-1})}...*)[$_]}

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

स्पष्टीकरण:

{                                  }  # Anonymous code block
 (                        ...*)[$_]   # Index into the infinite sequence
  {                      }   # Where each element is
   $!=@_;  # Save the list of previous elements into $!
   +(1...{             })    # Return the first number that
          $_∉$!         # Has not appeared in the list so far
          &&            # And
          (|$!,$_)      # The new sequence
          .rotor(1..*)  # Split into rows of increasing length
                        # And ignoring incomplete rows
          .one          # Have exactly one row
          .sum          # Where the sum
          .is-prime-1   # Is not prime (i.e. just the first row)

Answer 3

हास्केल , 122 120 बाइट्स

import Data.Numbers.Primes
l%a|(p,q)<-splitAt l a,(s,k:t)<-span(not.isPrime.(+sum p))q=p++k:(l+1)%(s++t)
((1:1%[2..])!!)

इसे ऑनलाइन आज़माएं!(के लिए एक अतिरिक्त 2 बाइट्स हैf= )

EDIT: अब 2 बाइट्स को बचाने के लिए 0-आधारित इंडेक्सिंग का उपयोग करता है। धन्यवाद @wastl कि बाहर इशारा करने के लिए, मैं इसे ओपी में याद किया होगा।

यह लिखने में बहुत मजा आया! सहायक फ़ंक्शन %एक लंबाई lऔर मानों की एक सूची लेता है जो इसका उपयोग कर सकते हैं a। यह अनुक्रम के लिए मूल्यों की एक अनंत सूची देता है। लंबाई वर्तमान त्रिकोण पंक्ति की लंबाई से कम है और सूची अनंत और पूर्व-क्रमबद्ध है। पहले हम केवल पहले lमूल्यों को प्राप्त करते हैं aऔर फिर बाकी के माध्यम से देखते हैं जब तक कि हम पहला (सबसे छोटा) मूल्य नहीं पाते हैं जो योग को प्रमुख बनाता है। हम उस मान का उपयोग कर spanऔर कुछ प्रतिमान मिलान के आसपास सूची को तोड़ते हैं । अब हमें बस इतना करना है कि नई मूल्य और अगली पंक्ति की लंबाई l+1और शेष मूल्यों के साथ पुनरावृत्ति करें a। अंतिम परिणाम के लिए हम 1 (n = 0 के लिए विशेष मामला) को प्राथमिकता देते हैं और इसके साथ अनुक्रमण करते हैं !!।

Comments

मुझे लगता है कि आप 0:चुनौती को हटा सकते हैं क्योंकि आप 0-आधारित अनुक्रमण का उपयोग कर सकते हैं।

— wastl

Answer 4

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

n=>{for(g=n=>{for(d=n;n%--d;);},i=l=0;i--||(k=s=0,i=l++),n--;g[k]=s+=r=k)for(;g[++k]|g(!i*++s)|d>1;);return r}

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

Answer 5

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

S©‘æR®Ḥ‘¤_®ḟ;F¥Ṃ
FLḤRḟFḣ0ịLƊ;祵W
1;Ç$⁸½Ḥ¤¡Fị@

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

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

Answer 6

लुआ , 242 228 226 211 बाइट्स

s={}u={}i=0 n=0+...while i<n do
n=n-i
x,S=1,0
for j=1,i do
while u[x]do x=x+1 end
s[j]=x
S=S+x
u[x]=0
end
while u[x]or p do
x=x+1
d=S+x
p=F
for c=2,d-1 do
p=p or d%c<1
end
end
i=i+1
s[i]=x
u[x]=0
end
print(s[n])

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