किम्बरलिंग अनुक्रम

Question

परिचय

बेशक, हमें बहुत सी अनुक्रम चुनौतियां मिली हैं , इसलिए यहां एक और एक है।

किम्बरलिंग अनुक्रम ( A007063 ) निम्नानुसार है:

1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, ...

यह सामान्य पुनरावृत्ति को बदलकर निर्मित होता है:

[1] 2  3  4  5  6  7  8

अनुक्रम का पहला शब्द है 1। उसके बाद, हम अनुक्रम को फेरबदल करते हैं जब तक कि बाईं ओर सभी शब्दों का उपयोग नहीं किया जाता है। फेरबदल का पैटर्न है right - left - right - left - ...। चूंकि बाईं ओर कोई शब्द नहीं हैं 1, इसलिए कोई फेरबदल नहीं है। हम निम्नलिखित प्राप्त करते हैं:

 2 [3] 4  5  6  7  8  9

I ^वें पुनरावृत्ति पर, हम i ^वें आइटम को छोड़ देते हैं और इसे हमारे अनुक्रम में डालते हैं। यह 2 पुनरावृत्ति है, इसलिए हम 2 आइटम को छोड़ देते हैं । अनुक्रम बन जाता है 1, 3:। हमारे अगले पुनरावृत्ति के लिए, हम ऊपर दिए गए पैटर्न के साथ वर्तमान पुनरावृत्ति में फेरबदल करने जा रहे हैं। हम पहली अप्रयुक्त वस्तु को i ^वें आइटम के दाईं ओर ले जाते हैं । ऐसा होता है 4। हम इसे अपनी नई यात्रा में शामिल करेंगे:

 4

अब हम पहली अप्रयुक्त वस्तु को i ^वें आइटम के बाईं ओर ले जा रहे हैं । यह वह जगह है 2। हम इसे अपनी नई यात्रा में शामिल करेंगे:

 4  2

चूँकि i ^th आइटम के बाईं ओर कोई आइटम नहीं हैं , इसलिए हम शेष अनुक्रम को नए पुनरावृत्ति में जोड़ देंगे:

 4  2 [5] 6  7  8  9  10  11  ...

यह हमारी तीसरी पुनरावृत्ति है, इसलिए हम 3rd आइटम को छोड़ देंगे , जो है 5। यह हमारे अनुक्रम में तीसरा आइटम है:

 1, 3, 5

अगली पुनरावृत्ति प्राप्त करने के लिए, बस प्रक्रिया को दोहराएं। अगर यह स्पष्ट नहीं है तो मैंने एक जिफ़ बनाया है:

^{वास्तविक पोस्ट लिखने से gif मुझे अधिक समय लगा}

कार्य

• एक गैर-नकारात्मक पूर्णांक n को देखते हुए , अनुक्रम के पहले n शब्दों को आउटपुट करें
• आप एक समारोह या एक कार्यक्रम प्रदान कर सकते हैं
• यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

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

Input: 4
Output: 1, 3, 5, 4

Input: 8
Output: 1, 3, 5, 4, 10, 7, 15, 8

Input: 15
Output: 1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28

नोट: आउटपुट में अल्पविराम आवश्यक नहीं है। उदाहरण के लिए आप नई सूची का उपयोग कर सकते हैं, या सूची का उत्पादन कर सकते हैं, आदि।

Comments

मैं स्टैक रोटेशन का उपयोग करके एक विधि पर काम कर रहा हूं

— साइको डिस

@Cyoce सौभाग्य :)

— अदनान

ऐसा लग रहा है कि मुझे इसकी आवश्यकता होगी

— Cyoce

Answer 1

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

JS*3QVQ@JN=J.i>JhN_<JN

इसे ऑनलाइन आज़माएँ: प्रदर्शन

बस ओपी में वर्णित फेरबदल तकनीक करता है।

स्पष्टीकरण:

JS*3QVQ@JN=J.i>JhN_<JN
JS*3Q                    assign the list [1, 2, ..., 3*input-1] to J
     VQ                  for N in range(Q):
       @JN                  print J[N]
            .i              interleave 
              >JhN             J[N+1:] with
                  _<JN         reverse J[:N]
          =J                assign the resulting list to J

Answer 2

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

n->[(i=j=x;while j<2i-3 j=i-(j%2>0?1-j:j+2)÷2;i-=1end;i+j-1)for x=1:n]

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक सरणी देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

यहाँ दृष्टिकोण वही है जो OEIS पर वर्णित है।

Ungolfed:

# This computes the element of the sequence
function K(x)
    i = j = x
    while j < 2i - 3
        j = i - (j % 2 > 0 ? 1 - j : j + 2)÷2
        i -= 1
    end
    return i + j - 1
end

# This gives the first n terms of the sequence
n -> [K(i) for i = 1:n]

मॉरिस को धन्यवाद दिया 7 बाइट्स बचाए!

Answer 3

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

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&

हम एक सूची से शुरू करते हैं, जिसमें से रेंज 1है 3x, जहां xकिम्बरलिंग अनुक्रम की वांछित संख्या है।

हर कदम पर, n, TakeDropएक सामने की सूची में वर्तमान सूची टूट जाता है 2n+1शर्तों (जहां काम हो गया है) और पीछे सूची (जो बाद में साथ शामिल किया जाएगा सामने सूची पर फिर से काम)। फ्रंट लिस्ट का मिलान निम्नलिखित पैटर्न से किया जाता है, {t___,z,r___}जहाँ फ्रंट लिस्ट के केंद्र में z किम्बरलिंग शब्द है। rका Riffleउल्टा है tऔर फिर पीछे की सूची संलग्न है। बढ़ते किम्बरलिंग अनुक्रम zको हटा दिया गया है और उन्हें जोड़ दिया AppendToगया है।

nद्वारा वृद्धि की जाती है 1और वर्तमान सूची उसी फ़ंक्शन द्वारा संसाधित की जाती हैNest.

---

उदाहरण

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&[100]

{1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, 42, 35, 33, 46, 53, 6, 36, 23, 2 , 55, 62, 59, 76, 65, 54, 11, 34, 48, 70, 79, 99, 95, 44, 97, 58, 84, 25, 13, 122, 83, 26, 115, 82, 91 , 52, 138, 67, 90, 71, 119, 64, 37, 81, 39, 169, 88, 108, 141, 38, 16, 146, 41, 21, 175, 158, 165, 86, 191, 45 , 198, 216, 166, 124, 128, 204, 160, 12, 232, 126, 208, 114, 161, 156, 151, 249, 236, 263, 243, 101, 121, 72, 120, 47, 229 }

Answer 4

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

for a in range(input()):
 b=a+1
 while-~b<2*a:b=a-(b^b%-2)/2;a-=1
 print a+b

व्याख्या

कई गोल्फ-वाई परिवर्तनों के बाद यह OEIS सूत्र है! इसने खूबसूरती से काम किया । मूल कोड था

i=b=a+1
while b<2*i-3:b=i-(b+2,1-b)[b%2]/2;i-=1
print i+b-1

मैंने पहली बार छुटकारा पाया i, इसे a+1हर जगह बदल दिया और भावों का विस्तार किया:

b=a+1
while b<2*a-1:b=a+1-(b+2,1-b)[b%2]/2;a-=1
print a+b

फिर, दुबारा लिखा b<2*a-1के रूप में -~b<2*aखाली स्थान के की एक बाइट को बचाने के लिए, और चले गए +12 से, चयन में विभाजन है, और निषेध:

while-~b<2*a:b=a-(b,-b-1)[b%2]/2;a-=1

फिर, -b-1बस है ~b, इसलिए हम लिख सकते हैं (b,~b)[b%2]। यह b^0 if b%2 else b^-1XOR ऑपरेटर या वैकल्पिक रूप से उपयोग करने के बराबर है b^b%-2।

while-~b<2*a:b=a-(b^b%-2)/2;a-=1

Answer 5

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

VQ+.W<hHyN-~tN/x%Z_2Z2hNN

जकुबे ने 4 बाइट्स बचाए, लेकिन मुझे कोई सुराग नहीं है कि अब कोड को कैसे पढ़ा जाए।

यहाँ पुराने समाधान है:

VQKhNW<hKyN=K-~tN/x%K_2K2)+KN

मेरे पायथन जवाब का अनुवाद। मैं पाइथ में बहुत अच्छा नहीं हूं, इसलिए शायद इसे छोटा करने के तरीके अभी भी हैं।

VQ                              for N in range(input()):
  KhN                             K = N+1
     W<hKyN                       while 1+K < 2*N:
           =K-~tN/x%K_2K2)         K = (N--) - (K%-2 xor K) / 2
                          +KN     print K + N

Comments

आप .W4 बाइट्स से गोल्फ का उपयोग कर सकते हैं VQ+.W<hHyN-~tN/x%Z_2Z2hNN:।

— जकुबे

यह अच्छा है - क्या आप मोटे तौर पर बता सकते हैं कि यह कैसे काम करता है?

— लिन

.Wका रूप है .W<condition><apply><start-value>:। मैंने प्रारंभ मूल्य का उपयोग किया hN, जैसे आपने किया था KhN। .Wयह मान तब तक बदलता है जब तक <condition>यह सत्य है। मैंने भी तुम्हारी जैसी हालत की <hHyN। शर्त पैरामीटर के साथ एक लंबो-फ़ंक्शन है H, इसलिए वर्तमान मूल्य (आपके कोड में K) है H। और मैंने भी <apply>आपके जैसे ही कथन का उपयोग किया , मैंने केवल प्रतिस्थापित Kकिया Z, क्योंकि <apply>कथन पैरामीटर के साथ एक लंबो-फ़ंक्शन है Z। हम अनदेखा कर सकते हैं =K, .Wइस संभालती है। यह गणना की गई के साथ पुराने मूल्य को बदल देता है। अंत में प्रिंट करें+...N

— जकुबे

Answer 6

एपीएल, 56 44 बाइट्स

{⍵<⍺+⍺-3:(⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵⋄⍺+⍵-1}⍨¨⍳

यह एक अनाम अनाम ट्रेन है जो दाईं ओर एक पूर्णांक को स्वीकार करता है और एक सरणी देता है। यह लगभग मेरे जूलिया जवाब के समान दृष्टिकोण है ।

अंतरतम फ़ंक्शन एक पुनरावर्ती डायैडिक फ़ंक्शन है जो कि रिटर्न देता है n Kimberling अनुक्रम में वें अवधि, यह देखते हुए एन समान छोड़ दिया और सही तर्क के रूप में।

{⍵<⍺+⍺-3:                                    ⍝ If ⍵ < 2⍺ - 3
         (⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵           ⍝ Recurse, incrementing a and setting
                                             ⍝ ⍵ = ⍺ - (3 + (-1)^⍵ * (1 + 2⍵))/4
                                   ⋄⍺+⍵-1}   ⍝ Otherwise return ⍺ + ⍵ - 1

उस हाथ में, हम अनुक्रम की अलग-अलग शर्तें प्राप्त करने में सक्षम हैं। हालाँकि, समस्या तब यह हो जाती है कि यह एक रंगाई संबंधी कार्य है, जिसका अर्थ है कि इसके लिए दोनों पक्षों में तर्क की आवश्यकता है। प्रवेश करें⍨ऑपरेटर ! फ़ंक्शन fऔर इनपुट को देखते हुए x, f⍨xजैसा है वैसा ही है x f x। तो हमारे मामले में, उपरोक्त कार्य का जिक्र करते हुए f, हम निम्नलिखित मोनैडिक ट्रेन का निर्माण कर सकते हैं:

f⍨¨⍳

हम f1 से इनपुट तक प्रत्येक पूर्णांक पर लागू होते हैं , एक सरणी उपज।

डेनिस की बदौलत 12 बाइट बच गईं!