अनुक्रम भी मेटा है

Question

हम रिक्त 1-अनुक्रमित अनुक्रम से शुरू करते हैं:

_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,...

N ^वें चरण में, हम प्रत्येक (n) रिक्त स्थान को पूर्णांक वाले रिक्त स्थान पर शुरू करने वाले पूर्णांक के साथ प्रत्येक (n) रिक्त स्थान को भरते हैं, जहाँ a (n) n है अनुक्रम में ^वें प्रविष्टि है।

पहले चरण के बाद:

2,_,3,_,4,_,5,_,6,_,7,_,8,_,9,_,10,_,11,_,12,_,13,_,...

ध्यान दें कि ए (1) को 2 होना चाहिए क्योंकि 1 से अधिक पूर्णांक 2 है।

दूसरे चरण में, हम प्रत्येक (2) रिक्त स्थान को भरते हैं। यह स्पष्ट होगा कि एक (2) 2 होना चाहिए।

2,2,3,_,4,3,5,_,6,4,7,_,8,5,9,_,10,6,11,_,12,7,13,_,...

तीसरे चरण में, हम प्रत्येक (3) रिक्त स्थान को भरते हैं। अनुक्रम से, (3) = 3।

2,2,3,2,4,3,5,_,6,4,7,_,8,5,9,3,10,6,11,_,12,7,13,_,...

चौथे चरण में, हम प्रत्येक (4) रिक्त स्थान को भरते हैं। अनुक्रम से, (4) = 2।

2,2,3,2,4,3,5,2,6,4,7,_,8,5,9,3,10,6,11,3,12,7,13,_,...

आखिरकार:

2,2,3,2,4,3,5,2,6,4,7,2,8,5,9,3,10,6,11,3,12,7,13,2,...

कार्य

दिए गए n, अनुक्रम के n ^वें तत्व को वापस करें ।

अनुक्रम के पहले 10,000,000 शब्द यहां देखे जा सकते हैं ।

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

Comments

@LuisMendo धन्यवाद, मैंने इसे जोड़ा है।

— लीके नन

बस जिज्ञासु, क्या गलत है। एक अनुक्रम से बाहर रखा जा सकता है?

— मृत पोसुम

@DeadPossum अच्छी तरह से, यदि आप हर एक रिक्त स्थान को भरते हैं, तो आप एक चरण में कर रहे हैं।

— लीक नून

@DeadPossum यदि a (n) 1 है, तो n-th चरण पीढ़ी को समाप्त करते हुए, प्रत्येक शेष रिक्त स्थान को भरेगा।

— लीक नून

@ प्रश्न मैं पहले १०,०००,००० की सूची प्रदान की गई थी जो प्रश्न में जुड़ी हुई थी; बस उन्हें साजिश।

— लीक नून

Answer 1

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

g~(a:b)|let k!l=k:take(a-1)l++(k+1)!drop(a-1)l=2!g b
m=g m
(!!)$0:m

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

हास्केल स्वयं के संदर्भ में एक अनंत सूची को परिभाषित करने के लिए सही भाषा है।

Comments

यह देखते हुए कि TIO लिंक अपेक्षा के अनुरूप काम करता है, मुझे लगता है कि मेरे प्रश्न को लगातार होना चाहिए: क्या आप इस बात का स्पष्टीकरण जोड़ सकते हैं कि यह कैसे काम करता है?

— जूलियन वुल्फ

@ जूलियनवुल्फ ऐसा लगता है कि आप letपैटर्न गार्ड से अपरिचित हैं । pattern1 | let pattern2 = expr2 = expr1का मतलब वही है जो pattern1 = let pattern2 = expr2 in expr1(उसी कारण से जिसका [expr1 | let pattern2 = expr2]मतलब वही है [let pattern2 = expr2 in expr1])।

— एंडर्स कासोर्ग

मुझे letपैटर्न गार्ड याद करने के लिए मिला है (विशेषकर यह कि वे कार्य कर सकते हैं)! इसके अलावा, m=2:2:2`drop`g mएक बाइट कम है।

— अर्जन जोहानसन

(!!)$0:mदो बाइट्स कम है।

— अर्जन जोहानसन

वास्तव में, आप 2:2:सामान को पूरी तरह से थोड़ा और आलस्य के साथ छोड़ सकते हैं : g ~(a:b)|...और m=g m।

— अर्जन जोहानसन

Answer 2

सी, 123 बाइट्स

f(n){int*p=calloc(n,4),i=0,j,k;for(*p=p[1]=2;i<n;++i)for(j=0,k=i/2?0:2-i;j<n;++j)p[j]||k++%p[i]||(p[j]=k/p[i]+2);n=p[n-1];}

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

पूर्वाभ्यास

f(n){int*p=calloc(n,4),

अनुक्रम के पहले n तत्वों को संग्रहीत करने के लिए n पूर्णांकों की एक सरणी आवंटित करें । यह हार्डकोड है , जो कि ज्यादातर मामलों में एक सुरक्षित धारणा है और निश्चित रूप से एक मैं कोड गोल्फ के संदर्भ में बनाने को तैयार हूं। :)sizeof(int)4

i=0,j,k;

ये सभी काउंटर हैं: iजिस चरण पर हम जा रहे हैं, jउसके अनुक्रम के लिए, रिक्त स्थानों की तलाश करने वाले अनुक्रम के माध्यम से लूप करना और kयह गिनना कि कितने रिक्त स्थान देखे गए हैं।

for(*p=p[1]=2;i<n;++i)

इससे पहले कि हम अपना मुख्य लूप शुरू करें, हम अनुक्रम के पहले दो तत्वों के एक प्रारंभिककरण में चुपके करते हैं 2 । ( p[0]= *(p + 0)= *p।) इस गिनती के लिए फेंकता है k, हालांकि, लेकिन ...

for(j=0,k=i/2?0:2-i;j<n;++j)

... हम भी एक डरपोक आरंभीकरण करते हैं k , जो यह देखने के लिए परीक्षण करता है कि क्या iइससे कम है 2और kयदि ऐसा है तो शुरुआती मूल्य को सही करता है। यहां आंतरिक लूप भी शुरू होता है, जो प्रत्येक चरण के दौरान पूरे अनुक्रम से दूर तक पुनरावृत्त होता है।

p[j]||k++%p[i]||(p[j]=k/p[i]+2);

यह लाइन वास्तव में कुछ समझाने का उपयोग कर सकती है। हम इसका विस्तार कर सकते हैं:

if (!(p[j] || ((k++) % p[i]))) {
    p[j] = k / p[i] + 2;
}

लघु परिशोधन द्वारा, और फिर डी मॉर्गन के नियमों और इस तथ्य से कि 0सी में मिथ्या है:

if (p[j] == 0 && ((k++) % p[i]) == 0) {
    p[j] = k / p[i] + 2;
}

यह अनिवार्य रूप से बताता है: "यदि यह स्थान खाली है, वृद्धि है k। और यदि kपहले चरण आकार के एक से अधिक था, तो निम्न कथन चलाएँ।" इसलिए, हम हर कदम के आकार के तत्वों पर बयान चलाते हैं, जो कि वास्तव में अनुक्रम का वर्णन करता है। कथन स्वयं सरल है; यह सब उत्पन्न होता है 2,3 , 4, ....

n=p[n-1];}

ट्रिकी-रिटर्न-विदाउट-ए-रिटर्न के साथ काम करने वाले का उपयोग करते हुए gcc, हम अनुक्रम में पहले एन शब्दों के अंतिम तत्व को "वापस" करते हैं , जो कि एन वें शब्द होता है।

Answer 3

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

M?tH?eJ.DtHg1GghG-tHhJ+2hJ2g1

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

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

सूचियों के साथ बेवकूफ बनाने के बजाय, यह एक सादे पुनरावर्ती सूत्र का उपयोग करता है।

M                                def g(G, H):
 ?tH                                 if H - 1:
      J.DtHg1G                           J = divmod(H - 1, g(1, G))
    ?e                                   if J[-1]:
              ghG-tHhJ                       return g(G + 1, H - 1 - J[0])
                                         else:
                      +2hJ                   return 2 + J[0]
                                     else:
                          2              return 2
                           g1Q   print(g(1, eval(input())))

Answer 4

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

0%j=2
i%j|d<-div i$f j=last$d+2:[(i-d-1)%(j+1)|d*f j<i]
f=(%1).pred

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

एक पुनरावर्ती अंकगणितीय समाधान जो मूल रूप से एंडर्स कसेग के पाइथ उत्तर के समान विधि निकला ।

इस कोड को मौसा - बदसूरत भागों में कवर किया गया है जो देखने में ऐसा लगता है कि वे दूर जा सकते हैं, लेकिन मैंने यह नहीं देखा कि कैसे।

फ़ंक्शन i%jवास्तव में यह जांचने के लिए एक गार्ड का उपयोग करना चाहता है कि क्या mod i(f j)>0संबंधित दो अभिव्यक्ति में से एक का मूल्यांकन करें। लेकिन, दोनों ही भाव का उपयोग करते हैं div i(f j)। एक गार्ड में बांधने से यह दोनों पक्षों पर लागू नहीं होगा। जहां तक ​​मुझे पता है, एक गार्ड को अन्य गार्डों पर "वितरित" करने के लिए नहीं किया जा सकता है। letऔर whereबहुत लंबे हैं। इसलिए, कोड lastदो अभिव्यक्तियों को लेने के लिए उपयोग करता है जबकि गार्ड चर को बांधता है। ओह।

आदर्श रूप में हम प्रयोग करेंगे divModक्योंकि दोनों divऔर modउपयोग किया जाता है, लेकिन (d,m)<-divMod ...एक लंबे अभिव्यक्ति है। इसके बजाय हम हैक के माध्यम से जाँचता है कि गैर- divभाजक मूल मान से कम है या नहीं यह देखने के द्वारा गैर-अक्षरा है ।

0%j=2यदि हास्केल शॉर्ट-सर्कुलेटेड है div 0, तो यह मामला जरूरी नहीं है। .predधर्मान्तरित करने के लिए 1-अनुक्रमित इनपुट शून्य अनुक्रमित, वरना होगा -1सुधार हर जगह।

Comments

यदि आप %1-अनुक्रमित को चालू करते हैं , तो आपको पांच बाइट्स सुधार की आवश्यकता होती है - जो सिर्फ संबंध रखता है। हालांकि , इसके बाद आपको इनलाइन कर सकते हैं fमें %किसी कीमत पर, और फिर fगुमनाम हो जाता है तो आप दो बाइट्स समग्र सहेजें।

— अर्जन जोहान्सन

@ HererjanJohansen इनलाइन से आपका क्या मतलब है? मैं यह नहीं देखता कि fबाइट्स खोए बिना संदर्भों को कैसे बदला जाए ।

— xnor

divModयह एक बाइट सस्ता लगता है, क्योंकि यह ब्रांचिंग की अनुमति देता है !!(0^m)। अब तक मुझे मिल गया है:1%j=2;i%j|(d,m)<-divMod(i-1)$j%1=[(i-d-1)%(j+1),d+2]!!(0^m);(%1)

— senrjan जोहानसन

जैसा कि आप देखते हैं, इनलाइनिंग 1-रीइंडेक्सिंग को निर्धारित करता है, जो कि हटा देता है .pred।

— अर्जन जोहानसन

Answer 5

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

एक पुनरावर्ती फ़ंक्शन जो परिणाम उपलब्ध होते ही बंद हो जाता है।

f=(n,p,a=[...Array(n)])=>a[n-1]||f(n,-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

वैकल्पिक संस्करण, 90 बाइट्स

1 बाइट के लिए झबरा द्वारा सुझाया गया

इस एक के साथ बुलाया जाना चाहिए f(n)()। यद्यपि वर्तमान में मेटा में संबंधित पोस्ट एक सकारात्मक स्कोर देता है, यह वाक्यविन्यास स्पष्ट रूप से विवादित है।

n=>g=(p,a=[...Array(n)])=>a[n-1]||g(-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

डेमो

f=(n,p,a=[...Array(n)])=>a[n-1]||f(n,-~p,a.map(c=>c?c:i?i++%(a[p]||2)?c:++v:(i=1,v=2),i=0))

for(n = 1; n <= 50; n++) {
  console.log('a[' + n + '] = ' + f(n));
}

Comments

n=>g=(p,a=[...Array(n)])=>a[n-1]||g(-~p,a.map(c=>c?c:i?i++%k?c:++v:(i=1,v=2),i=0,k=a[p]||2))92 बाइट्स के लिए काम करना चाहिए। इसके साथ बुलाओ f(n)()।

— झबरा

@ शगुन थैंक्स! एक वैकल्पिक संस्करण के रूप में जोड़ा गया।

— अरनौलड़

Answer 6

जावा 8, 124 बाइट्स

(i)->{int j=1,a[]=new int[i+1],k,s,n;for(;a[i]<2;){for(k=0,n=2;a[++k]>0;);for(s=a[j++]|2*k;k<=i;k+=s)a[k]=n++;}return a[i];}

लैंबडा अभिव्यक्ति।

एक पूर्णांक सरणी बनाता है और लगातार इसे तब तक पॉप्युलेट करता है जब तक कि nth मान पॉपुलेट नहीं हो जाता।

intजोड़ने के विरोध में प्रत्येक स्थान पर 4 बाइट्स के रूप में संभव के रूप में कई घोषणाओं में कटौती करने के लिए शीर्ष पर पूर्व घोषित चर,n जो 2 है।

jगणना के 'वें पुनरावृत्ति पर,' रिक्त 'की संख्या को छोड़ना पड़ता है a[j](या 2, यदि रिक्त है) के बराबर है । यह पता चलता है कि यदि पहले खाली स्थान को हमें भरना है k, k * a[j] वह हमें 'चरण' ( s) देता है।