जंपिंग सीक्वेंस

Question

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

0 1 3 2 5 4 8 6 7 12 9 10 11 17 13 14 15 16 23 ...

बहुत पैटर्न-कम लगता है, है ना? यहां देखिए यह कैसे काम करता है। के साथ शुरू , पूर्णांक 0ऊपर कूद n, पर nशुरू करने के साथ 1। यही क्रम में अगला नंबर है। फिर, किसी भी संख्या को "छोड़ दिया" जोड़ें और जो अभी तक आरोही क्रम में नहीं देखा गया है। फिर, nअंतिम संख्या से वृद्धि और कूद। इस पैटर्न को दोहराएं।

इसलिए, उदाहरण के लिए, जब हम पहुंचते हैं 11, तो हम पर होते हैं n=5। हम वृद्धि nकरते हैं n=6, कूदते हैं 17, फिर जोड़ते हैं 13 14 15 16क्योंकि जो अभी तक नहीं देखा गया है। हमारी अगली छलांग है n=7, इसलिए अनुक्रम में अगला तत्व है 23।

चुनौती

इनपुट को देखते हुए x, xइस अनुक्रम के वें पद का उत्पादन, अनुक्रम की पहली xशर्तें, या अनुक्रम की अनंत सूची का निर्माण करें। आप 0- या 1-इंडेक्सिंग चुन सकते हैं।

I / O और नियम

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

Comments

यह OEIS

— JayCe

@JayCe मुझे आश्चर्य नहीं है - यह एक बहुत ही मनमाना अनुक्रम है।

— AdmBorkBork

Answer 1

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

अनुक्रम के n-वें शब्द को लौटाता है , 0-अनुक्रमित।

n=>(d=(n--*8-23)**.5)%1?n:'121'[n]^n-~d/2

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

कैसे?

मुख्य मामला:$n > 3$

अनुक्रम के पहले चार शब्द विशेष हैं, तो आइए अब उनके लिए अलग रख दें।

के लिए , इस तरह अनुक्रम दिखता है:$n > 3$

 n  | [4] 5 [6] 7 8 [ 9] 10 11 12 [13] 14 15 16 17 [18] 19 20 21 22 23 [24] 25 26 27 ...
----+------------------------------------------------------------------------------------
a(n)| [5] 4 [8] 6 7 [12]  9 10 11 [17] 13 14 15 16 [23] 18 19 20 21 22 [30] 24 25 26 ...
----+------------------------------------------------------------------------------------
 k  |  2  -  3  - -   4   -  -  -   5   -  -  -  -   6   -  -  -  -  -   7   -  -  - ...

हम देख सकते हैं कि वास्तव में दो इंटरलेय्ड सब-सीक्वेंस हैं:

• अधिकांश मूल्य उप-अनुक्रम के हैं जिनके लिए हमारे पास बस:$A$

  $$A(n) = n - 1$$

• कुछ अन्य मूल्य उप-अनुक्रम (उपरोक्त आरेख में कोष्ठक के साथ हाइलाइट किए गए) से संबंधित हैं, जिनके सूचकांक अंकगणितीय अनुक्रम 3, 3, 4, 6, 9, 13, 18, 24 ... और जिसके लिए हमारे पास हैं:$B$

  $$B(n,k) = n + k - 1$$

  जहाँ मुख्य अनुक्रम में सूचकांक है और उप-अनुक्रम में सूचकांक है ।के $n$$k$$B$

मुख्य अनुक्रम में सूचकांक निम्न द्वारा दिए गए हैं:$B$

$$n_k = \frac{k^2 - k + 6}{2}$$

को देखते हुए , हम जानते हैं कि मुख्य अनुक्रम में संबंधित शब्द संबंधित है यदि द्विघात समीकरण का पूर्णांक हल है:बी $n$$B$$n$

$$x^2 - x + 6 - 2n = 0$$

किसका भेदभाव है:

$$\Delta = 1 - 4(6 - 2n) = 8n - 23$$

और जिसका सकारात्मक समाधान है:

$$x = \frac{1 + \sqrt{\Delta}}{2}$$

हम एक पूर्णांक बनने के लिए अपेक्षा करते हैं । इसलिए परीक्षण:$\sqrt{\Delta}$

(d = (n-- * 8 - 23) ** .5) % 1

विशेष मामले:$0 \le n \le 3$

के लिए , विभेदक नकारात्मक और अपने वर्गमूल परिणाम ले रहा है NaN । के लिए , विभेदक है । इसलिए, अनुक्रम के इन पहले चार पदों को उप-अनुक्रम से संबंधित माना जाता है ।n = 3 1 $n < 3$$n = 3$$1$$B$

क्या हमें अपना मानक सूत्र n - ~ d / 2 लागू करना चाहिए , हमें मिलेगा:

$$-\frac 1 2, \frac 1 2, \frac 3 2, 3$$

के बजाय:

$$0, 1, 3, 2$$

यही कारण है कि हम इन परिणामों को क्रमशः हैं।$0,1,2\text{ and }1$

Answer 2

भूसी , 12 बाइट्स

Θṁṙ_1C+ḣ2tNN

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

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

व्याख्या

Θṁṙ_1C + t2tNN - पूर्ण कार्यक्रम। कोई इनपुट नहीं लेता है, STDOUT को आउटपुट देता है।
         tN - 2 से शुरू होने वाली प्राकृतिक संख्याओं की अनंत सूची का निर्माण।
      + ]2 - और इसे [1, 2] जोड़ें। पैदावार [1,2,2,3,4,5,6,7,8,9,10,11, ...]।
     CN - उन लोगों के टुकड़ों में सकारात्मक पूर्णांकों की अनंत सूची को काटें
               आकार। पैदावार [[१], [२,३], [४,५], [६, ,,,], [९,१०,११,१२], ...]।
 fl - इसके बाद के परिणामों को मैप और समतल करें।
  ṙ_1 - प्रत्येक को दाईं ओर 1 इकाई से घुमाएं।
               पैदावार [1,3,2,5,4,8,6,7,12,9,10,11, ...]
End - एक 0. उपज दें [0,1,3,2,5,4,8,6,6,7,12,9,10,11, ...]

Answer 3

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

0:1:3:2:5!3
a!n=a:[a-n+2..a-1]++(a+n)!(n+1)

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

एक अनंत सूची को परिभाषित करता है:

  0:1:3:2:(5!3)
≡ 0:1:3:2:5:4:(8!4)
≡ 0:1:3:2:5:4:8:6:7:(12!5)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:(17!6)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:17:13:14:15:16:(23!7) …

Answer 4

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

+‘ɼṪRṙ-œ|@
0Ç¡ḣ

यह एक पूर्ण कार्यक्रम है जो n दिया गया है , अनुक्रम के पहले n आइटम को प्रिंट करता है ।

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

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

0Ç¡ḣ        Main link. Argument: n

0           Set the return value to 0.
 Ç¡         Call the helper link n times, first with argument 0, then n-1 times
            with the previous return value as argument.
   ḣ        Head; extract the first n items of the last return value.


+‘ɼṪRṙ-œ|@  Helper link. Argument: A (array)

 ‘ɼ         Increment the value in the register (initially 0) and yield it.
+           Add that value to all items in the sequence.
   Ṫ        Tail; extract the last item.
    R       Range; map k to [1, .., k].
     ṙ-     Rotate -1 units to the left, yielding [k, 1, ..., k-1].
       œ|@  Perform multiset union of A and the previous return value.

Answer 5

सी (जीसीसी), 73 67 64 बाइट्स

t,d;f(x){for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);t=x<4?x^x/2:x-1;}

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

एक फ़ंक्शन को परिभाषित करता है fजो 0-अनुक्रमित लेता है nऔर nअनुक्रम में वें नंबर का उत्पादन करता है ।

हम निम्नानुसार अनुक्रम का विश्लेषण कर सकते हैं:

f(n)  = n   where n = 0, 1

f(2)  = 3   // 2 and 3 are swapped
f(3)  = 2

f(4)  = 5   // (+2,+3)
f(6)  = 8   // (+3,+4)
f(9)  = 12  // (+4,+5)
f(13) = 17  // (...)
...

f(n)  = n-1 // for all cases not yet covered

पहले हम मध्य खंड को संभालते हैं:

for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);

ध्यान दें कि बाईं ओर तर्क (4, 6, 9, 13, ...) एक पैटर्न का पालन करें: पहले दो को जोड़ें, फिर तीन को जोड़ें, फिर चार को जोड़ें, और इसी तरह। हम शुरू करते हैं t=4और जोड़ते हैं d(जो 2 से शुरू होता है) लूप के प्रत्येक पुनरावृत्ति, dप्रक्रिया में वृद्धि ।

लूप का शरीर अधिक दिलचस्प है। याद रखें कि हम 4 से 5, 6 से 8, 9 से 12, आदि का नक्शा बनाना चाहते हैं; कि सिर्फ जोड़ने है d-1अगर xहै t। हालाँकि, यह तर्क अंतिम मामले से पहले आता है f(n) = n - 1, इसलिए हम जानते हैं कि हम अंत में 1 घटा सकते हैं। इसलिए, हम बस dअगर x == t( x-t||(x+=d)) जोड़ सकते हैं । हालांकि, हम भी इस के तुरंत बाद लूप से बाहर तोड़ने के लिए की आवश्यकता होगी - तो हम जोड़ने कि करने के लिए dप्राप्त करने के लिए बेतुका दिखने d+=x+=dहै, जो हमेशा कर देगा d<xहालत असफल।

इसमें पहले चार मूल्यों को छोड़कर सब कुछ शामिल है। उन्हें बाइनरी में देखते हुए, हमें मिलता है:

00 -> 00
01 -> 01
10 -> 11
11 -> 10

तो, हम अंतिम बिट को फ्लिप करना चाहते हैं यदि 2 <= x < 4। इससे पूरा किया जाता है x^x/2। x/2दूसरा कम से कम महत्वपूर्ण बिट देता है, इसलिए मूल संख्या के साथ XORing अंतिम बिट को फ़्लिप करता है यदि संख्या 2 या 3 है।

Answer 6

जेली ,  13  10 बाइट्स

-3 डेनिस के लिए धन्यवाद (संचयी योग सेटअप से 2 को बचाने के लिए 0-इंडेक्सिंग का उपयोग करें और एक अंतिम गिरावट)

Ḷ»2Äi+_>2$

एक पूर्णांक, 0 -indexed n , जो एक पूर्णांक, (n) लौटाता है, को स्वीकार करने वाला एक लिंक

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें

Comments

अच्छा! मेरे पास था ḶÄ+3i+’, लेकिन मुझे पता नहीं था कि किनारे के मामलों को कैसे संभालना है।

— डेनिस

मैं भी है Ḷ»ạ¥3के लिए Ḋ3,2;- की तरह महसूस करता है कि इस बिट के लिए terser होना चाहिए।

— जोनाथन एलन

Ḷ»2Äi+_>2$0-आधारित अनुक्रमण के साथ 3 बाइट्स बचाता है।

— डेनिस

ओह कमाल का गोल्फ! मैं 1-इंडेक्स भूमि में फंस गया था।

— जोनाथन एलन

Answer 7

पर्ल 5 के साथ -pl, 70 बाइट्स

$"="|";push@f,$;=$f[-1]+$-++,grep!/^(@f|$;)$/,0..$;for 0..$_;$_=$f[$_]

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

Answer 8

MATL , 22 बाइट्स

1y:"t0)@+h5M:yX-h]qw:)

nअनुक्रम की पहली शर्तें आउटपुट ।

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

व्याख्या

1         % Push 1
y         % Implicit input: n. Duplicate from below
":        % For each k in [1 2 ... n]
  t0)     %   Duplicate sequence so far. Get last entry, say m
  @+      %   Add k: gives m+k
  h       %   Concatenate horizontally
  5M      %   Push m+k again
  :       %   Range [1 2 ... m+k]
  y       %   Duplicate from below
  X-      %   Set difference
  h       %   Concatenate horizontally
]         % End
q         % Subtract 1, element-wise
w         % Swap. Brings original copy of n to the top
:)        % Keep the first n entries. Implicit display

Comments

मुझे अंत में स्माइली पसंद है, अब मैं चाहता हूं कि मेरे सभी MATL कार्यक्रम मुस्कान के साथ समाप्त हों। :)

— सूंदर - मोनिका

@sundar हां, मुझे खुशी है कि MATL में यह एक अपेक्षाकृत आम मुहावरा है :-D

— लुइस

Answer 9

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

0:1:do(a,b)<-zip=<<(1:)$scanl(+)3[2..];b:[a+1..b-1]

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

लिन के हास्केल उत्तर की तुलना में थोड़ा लंबा है , लेकिन अलग-अलग दृष्टिकोण कम गैर दिलचस्प हो सकता है।

Answer 10

रूबी , 73 बाइट्स

f=->x,l,n{!l[x]&&(i=l[-1];f[x,l+[i+n]+([*(i+1...i+n)]-l),n+1])||l[0...x]}

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

पुनरावर्ती फ़ंक्शन जो सूची के पहले x संख्याओं को लौटाता है।

Answer 11

QBasic, 58 बाइट्स

DO
b=r+j
?b
r=b
FOR x=a+1TO b-1
?x
r=x
NEXT
a=b
j=j+1
LOOP

अनिश्चित काल के लिए आउटपुट। आप परिणामों को देखने के SLEEP 1लिए लूप के अंदर जोड़ना या बनाना LOOP WHILE b<100या ऐसा कुछ कर सकते हैं।

यह मूल रूप से सिर्फ युक्ति को लागू करता है। ध्यान दें कि हम जिन नंबरों के लिए वापस जाते हैं, वे हमेशा सबसे हाल ही में जंप किए गए नंबरों और उससे पहले जंप किए गए नंबरों के बीच की संख्या होंगे। इसलिए हम इन बाउंड के रूप में की दुकान aऔर bऔर एक का उपयोग FORउन दोनों के बीच सभी नंबरों को मुद्रित करने के लिए पाश।

Answer 12

05AB1E , 14 बाइट्स

0)sƒ¤N+LÁ«}Ùs£

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

Answer 13

आर , 70 बाइट्स

function(e){for(i in 1:e)F=c(setdiff((F+i):1-1,F),F[1]+i,F);rev(F)[e]}

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

• 1 अनुक्रमित
• -4 बाइट्स F@JAD सुझाव के लिए निरंतर धन्यवाद का उपयोग करते हुए
• -5 बाइट्स @Giuseppe सुझाव की बदौलत सूची को उलट रही है
• -2 बाइट्स के लिए बेकार ब्रेस को हटाकर @JAD सुझाव के लिए धन्यवाद
• के setdiffबजाय का उपयोग कर -2 बाइट्सx[x %in% y]

---

पिछला संस्करण (79 बाइट्स)

Comments

79 बाइट्स

— JAD

@ जेएडी: मैं हमेशा एफ / टी का उपयोग करना भूल गया ... मैं इसकी मदद नहीं कर सकता, मैं "असुरक्षित कोड" से बचने के लिए बहुत इच्छुक हूं: डी

— डिगेटेल

सूची को रिवर्स में सहेजना 5 bytesऔर चेतावनी का एक गुच्छा पैदा करता है!

— Giuseppe

यह भी असुरक्षित नहीं है अगर F/Tफ़ंक्शन परिभाषा में इसे फिर से परिभाषित नहीं किया गया है। यह न (IIRC) वैश्विक मूल्य के लिए संशोधित करता हैF/T

— JAD

72 बाइट्स

— JAD

Answer 14

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

def f(z):[s.extend([s[-1]+n]+[x for x in range(s[-1]+1,s[-1]+n)if not x in s]) for n in range(1,z)if len(s)<z];return s    

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

दिए गए इनपुट x, अनुक्रम के पहले x शब्दों को आउटपुट करते हैं,

मैं पायथन सीख रहा हूं और यह चुनौतियां चीजों को अधिक रोचक बनाती हैं।

संपादित करें: कुछ व्हाट्सएप दाढ़ी

Comments

PPCG में आपका स्वागत है! आप में कुछ और रिक्त स्थान से छुटकारा मिल सकता है for n in range(1,z) if len(s) < z]; return s: for n in range(1,z)if len(s)<z];return s।

— लकोनी

Answer 15

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

RÄṬŻk²Ḋ$ṙ€-Ø.;Fḣ

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

मौजूदा जेली के उत्तर की तुलना में एक बाइट लंबे समय तक लेकिन यह संभवतः थोड़ा गोल्फ हो सकता है। RÄṬŻk²Ḋ$शायद कम हो सकता है।

18 बाइट्स

RÄṬŻk²Ḋ$‘ṙ€1FŻŻỤ’ḣ

लंबा लेकिन अलग।

Answer 16

रूबी , 63 बाइट्स

->x,n=0{n+=1while 0>d=n*n+n<=>2*x-6;[0,1,3,2][x]||[x+n,x-1][d]}

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

0 अनुक्रमित। शायद नीचे गोल्फ हो सकता है।

Answer 17

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

(0,{((^max @_)∖@_).min.?key//(1+@_[*-1]+$++)}...*)

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

यह ...ऑपरेटर का उपयोग करके एक जनरेटर अभिव्यक्ति है । यह पहले अनुक्रम में अंतराल के लिए लग रहा है @_के माध्यम से ((^max @_)∖@_).min.?key:

      @_  # prior sequence values         [0,1,3]
  max @_  # largest prior sequence value       3
 ^        # the Range 0..max @_            0,1,2
(       )∖@_  # set subtract prior seq     -0,1  -> (2=>True)
            .min  # smallest unseen value  2=>True
                .?key  # set yields pairs  2

?प्रारंभिक मूल्य है जो एक नहीं है के लिए आवश्यक है .key। यदि कोई अंतराल नहीं पाया जाता है, तो यह $सूची में अंतिम मान में n (यहां चर में) जोड़ देता है, साथ ही 0 त्रुटियों के लिए एक बंद।

Answer 18

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

def f(x):
 n=a=0
 l=list(range(x*x))
 while n<x:print(l[a+n],*l[a+2-(n<3):a+n],end=' ');a=a+n-(a>0);n+=1

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

इनपुट x को देखते हुए, पहला x "अनुक्रम" आउटपुट