कोलाकोस्की-जैसे आत्म-संदर्भित अनुक्रम

Question

इस प्रकार कोलकोस्की अनुक्रम (OEIS A000002 ) को परिभाषित किया गया है:

कोलाकोस्की अनुक्रम एक ऐसा अनुक्रम है जिसमें सम्‍मिलित है 1और 2, अनुक्रम का nth तत्व अनुक्रम nमें समान तत्वों (रन) के वें समूह की लंबाई है। अनुक्रम और संबंधित लंबाई के पहले 20 शब्द हैं:

1 2 2 1 1 2 1 2 2 1 2 2 1 1 2 1 1 2 2 1
- --- --- - - --- - --- --- - --- --- -
1  2   2  1 1  2  1  2   2  1  2   2  1

अनिवार्य रूप से, कोलाकोस्की अनुक्रम के समान तत्वों के समूहों की लंबाई ही कोलाकोस्की अनुक्रम है।

अब तक, इतना अच्छा, लेकिन यह कि हमें खुद को 1और क्यों सीमित करना चाहिए 2? हम नहीं जा रहे हैं! दो आदानों को देखते हुए, सकारात्मक पूर्णांक Aऔर एक पूर्णांक की एक सरणी N, Nपुनरावर्तन द्वारा परिभाषित कोलाकोस्की-जैसे अनुक्रम की पहली शर्तों को वापस करते हैं A। इसे बेहतर ढंग से समझने के लिए, यहां ब्रैकेट्स में नए जोड़े गए समूहों की लंबाई के साथ काम किया गया उदाहरण है:

A = [2, 3, 1]
N = 25

2: [[2], 2 ]
3: [ 2 ,[2], 3 , 3 ]
1: [ 2 , 2 ,[3], 3 , 1 , 1 , 1 ]
2: [ 2 , 2 , 3 ,[3], 1 , 1 , 1 , 2 , 2 , 2 ]
3: [ 2 , 2 , 3 , 3 ,[1], 1 , 1 , 2 , 2 , 2 , 3 ]
1: [ 2 , 2 , 3 , 3 , 1 ,[1], 1 , 2 , 2 , 2 , 3 , 1 ]
2: [ 2 , 2 , 3 , 3 , 1 , 1 ,[1], 2 , 2 , 2 , 3 , 1 , 2 ]
3: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 ,[2], 2 , 2 , 3 , 1 , 2 , 3 , 3 ]
1: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 ,[2], 2 , 3 , 1 , 2 , 3 , 3 , 1 , 1 ]
2: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 ,[2], 3 , 1 , 2 , 3 , 3 , 1 , 1 , 2 , 2 ]
3: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 ,[3], 1 , 2 , 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 ]
1: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 , 3 ,[1], 2 , 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 , 1 ]
2: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 , 3 , 1 ,[2], 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 , 1 , 2 , 2 ]
C: [ 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 , 2 , 3 , 1 , 2 , 3 , 3 , 1 , 1 , 2 , 2 , 3 , 3 , 3 , 1 , 2 , 2 ]

यहाँ एक प्रमुख के साथ एक और काम किया गया उदाहरण है 1:

A = [1, 2, 3]
N = 10

1: [[1]]
2: [ 1 ,[2], 2 ]
3: [ 1 , 2 ,[2], 3 , 3 ]
1: [ 1 , 2 , 2 ,[3], 3 , 1 , 1 , 1 ]
2: [ 1 , 2 , 2 , 3 ,[3], 1 , 1 , 1 , 2 , 2 , 2 ]
C: [ 1 , 2 , 2 , 3 , 3 , 1 , 1 , 1 , 2 , 2 ]

जैसा कि आप ऊपर देख सकते हैं, अंतिम परिणाम N = 10तत्वों को काट दिया गया था । nवें तत्व होना चाहिए कितनी देर nवें बराबर-तत्व समूह है, भले ही तत्व में ही समूह यह को संदर्भित करता है में अंतर्गत आता है। जैसा कि उपरोक्त मामले में, पहला 1पहले ऐसे समूह को संदर्भित करता है जो कि बस है 1, और पहला 2दूसरा ऐसे समूह को संदर्भित करता है, जो इसके साथ शुरू होता है।

नियम

• आप मान सकते हैं कि Aकभी भी दो या दो से अधिक समान तत्व नहीं होंगे। Aइसमें एक से अधिक बार पूर्णांक हो सकता है, लेकिन पहले और अंतिम तत्व समान नहीं होंगे, और Aइसमें कम से कम 2 तत्व होंगे (उदाहरण के लिए [1, 2, 2, 3], [2, 4, 3, 1, 2]और [3]दिए जाने वाले नहीं हैं)। ऐसा इसलिए है क्योंकि यदि लगातार समान तत्व थे, तो अंतिम परिणाम इस तरह के अनुक्रम के लिए एक अमान्य उपसर्ग होगा।
• आप मान सकते हैं कि Aकेवल धनात्मक पूर्णांक होते हैं (क्योंकि ऐसा क्रम अन्यथा अपरिभाषित होगा)।
• आप मान सकते हैं Nकि एक गैर-नकारात्मक पूर्णांक ( N >= 0) है।
• आप अनुरोध की तुलना में अधिक शर्तें नहीं लौटा सकते।
• मानक खामियों में से किसी एक का उपयोग करना सख्त वर्जित है।
• आप किसी भी उचित I / O विधि का उपयोग कर सकते हैं ।
• आपके उत्तर को प्राकृतिक भाषा सीमाओं से परे काम करने की आवश्यकता नहीं है, लेकिन सिद्धांत रूप में आपके एल्गोरिथ्म को मनमाने ढंग से बड़े इनपुट और पूर्णांक के लिए काम करना चाहिए ।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर जीतता है।

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

[5, 1, 2], 0 -> []
[2, 3, 1], 25 -> [2, 2, 3, 3, 1, 1, 1, 2, 2, 2, 3, 1, 2, 3, 3, 1, 1, 2, 2, 3, 3, 3, 1, 2, 2]
[1, 2, 3], 10 -> [1, 2, 2, 3, 3, 1, 1, 1, 2, 2]
[1, 2], 20 -> [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1]
[1, 3], 20 -> [1, 3, 3, 3, 1, 1, 1, 3, 3, 3, 1, 3, 1, 3, 3, 3, 1, 1, 1, 3]
[2, 3], 50 -> [2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3]
[7, 4], 99 -> [7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 4]
[1, 2, 3], 5 -> [1, 2, 2, 3, 3]
[2, 1, 3, 1], 2 -> [2, 2]
[1, 3, 5], 2 -> [1, 3]
[2, 3, 2, 4], 10 -> [2, 2, 3, 3, 2, 2, 2, 4, 4, 4]

Comments

सैंडबॉक्स (2k + उपयोगकर्ता)

— आउटगॉल्फ

सम्बंधित।

— मार्टिन एंडर

@MartinEnder ने सोचा कि मैंने पहले ही लिंक कर दिया है

— एरिक द आउटगॉल्फ

Answer 1

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

Ṡωȯ↑⁰`Ṙ¢

पहले लंबाई लेता है, फिर सूची। इसे ऑनलाइन आज़माएं!

व्याख्या

Ṡωȯ↑⁰`Ṙ¢  Inputs: n=9 and x=[2,1,3]
Ṡωȯ       Apply the following function to x until a fixed point is reached:
           Argument is a list, say y=[2,2,1,3,3,3]
       ¢   Cycle x: [2,1,3,2,1,3..
     `Ṙ    Replicate to lengths in y: [2,2,1,1,3,2,2,2,1,1,1,3,3,3]
   ↑⁰      Take first n elements: [2,2,1,1,3,2,2,2,1]
          Final result is [2,2,1,1,3,2,1,1,1], print implicitly.

Answer 2

अजगर, 14 बाइट्स

u<s*V]M*QlGGvz

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

स्पष्टीकरण:

u                 start with G = input array
       *QlG       repeat input array
     ]M           put every element into its own list
   *V      G      repeat every list vectorized by the counts in G
  s               flatten
 <          vz    take the first (second input line) numbers
                  and assign them to G until you reach fixed point

Comments

दिलचस्प विकल्प:u&VSvzs*V]M*Ql

— जकुबे

यह एक अच्छा तरीका है।

— आउटगॉल्फ

Answer 3

जावा 8, 151 + 19 119 115 बाइट्स

a->n->{int c=0,l[]=new int[n],i=0,j;for(;i<n;i++)for(j=0;j<(c==i?a[i]:l[i])&c<n;j++)l[c++]=a[i%a.length];return l;}

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

Comments

आप दो कोष्ठकों से छुटकारा पाकर चार बाइट्स कम कर सकते हैं, एक अल्पविराम में बदल &&सकते हैं &और निकाल सकते हैं: a->n->{int c=0,l[]=new int[n],i=0,j;for(;i<n;i++)for(j=0;j<(c==i?a[i]:l[i])&c<n;j++)l[c++]=a[i%a.length];return l;}( 115 बाइट्स )

— केविन क्रूज़सेन

सुझाएँ (c==i?a:l)[i]बजायc==i?a[i]:l[i]

— ceilingcat

Answer 4

आर , 120 114 108 108 बाइट्स

-6 बाइट्स प्लेनैपस के लिए धन्यवाद

function(A,N){i=inverse.rle
w=length
a=rle(A)
while(w(a$l)<N){a[[1]]=i(a)
a[[2]]=rep(A,l=w(a$l))}
i(a)[0:N]}

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

अनाम फ़ंक्शन; क्रमिक रूप से RLE का विरोध करता है, a[[1]]उल्टे RLE के साथ लंबाई की जगह , और मानों की लंबाई के बराबर लंबाई के a[[2]]साथ Aदोहराया जाता है a$l।

Comments

@plannapus आह, ठीक है! मैंने कोशिश की थी कि आर को क्रैश कर दिया क्योंकि असाइनमेंट में, यह पैदा करेगा a$lऔर a$vअगर वे मौजूद नहीं हैं, लेकिन वे कॉल को प्रभावित नहीं करेंगे inverse.rle, जिससे एक अनंत लूप पैदा होगा। मुझे लगता है कि मैं केवल स्थिति और स्थिति a$lमें उपयोग कर सकता हूं । whilerep

— ग्यूसेप

Answer 5

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

Laikoni बहुत धन्यवाद और डिबगिंग और PPCG हास्केल चैटरूम में इस उत्तर, गोल्फ में उनकी मदद के लिए flawr monads और पुरुषों के । गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

(.f).take
f a@(z:_)=(z<$[1..z])++do i<-[1..];cycle a!!i<$[1..f a!!i]

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

व्याख्या

सबसे पहले, हम zके प्रमुख के रूप में परिभाषित aकरते हैं a@(z:_)। फिर, हम अनुक्रम के साथ आरंभ करते हैं (z<$[1..z])।

फिर, 1आगे से, do i<-[1..]हम निम्नलिखित अनुक्रम को जोड़ते हैं: cycle a!!i<$[1..f a!!i](जो कि अनिश्चित काल के लिए iचक्रवात का) सदस्य है ।af a!!i

अंत में, अनाम फ़ंक्शन nहमारे Kolaskoski की तरह अनुक्रम का पहला शब्द लेता है ।

Answer 6

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

x,y=input()
k=x[0]
t,j=[],0
if k==1:t,j=[k]+x[1]*[x[1]],2
while len(t)<y:t+=(j and t[j]or k)*[x[j%len(x)]];j+=1
print t[:y]

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