कोलाकोस्की कटौती

Question

अवलोकन

आप में से कुछ को कोलाकोस्की सीक्वेंस ( A000002 ) के बारे में पता हो सकता है , एक अच्छी तरह से आत्म-संदर्भित अनुक्रम है जो निम्नलिखित संपत्ति है:

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

---

चुनौती

चुनौती, पूर्णांक की एक सूची दी गई है:

• आउटपुट -1यदि सूची कोलाकोस्की अनुक्रम का कार्यशील उपसर्ग नहीं है।
• अनुक्रम बनने से पहले पुनरावृत्तियों की संख्या को आउटपुट करें [2]।

---

वर्क आउट उदाहरण

एक उदाहरण के रूप में प्रदान की गई छवि का उपयोग करना:

[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1] # Iteration 0 (the input).
[1,2,2,1,1,2,1,2,2,1,2]             # Iteration 1.
[1,2,2,1,1,2,1,1]                   # Iteration 2.
[1,2,2,1,2]                         # Iteration 3.
[1,2,1,1]                           # Iteration 4.
[1,1,2]                             # Iteration 5.
[2,1]                               # Iteration 6.
[1,1]                               # Iteration 7.
[2]                                 # Iteration 8.

इसलिए, परिणामी संख्या 8इनपुट के लिए है [1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1]।

9 1-इंडेक्सिंग होने पर भी ठीक है।

---

टेस्ट सूट (आप उप-पुनरावृत्तियों के साथ भी परीक्षण कर सकते हैं)

------------------------------------------+---------
Truthy Scenarios                          | Output
------------------------------------------+---------
[1,1]                                     | 1 or 2
[1,2,2,1,1,2,1,2,2,1]                     | 6 or 7
[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1]       | 8 or 9
[1,2]                                     | 2 or 3
------------------------------------------+---------
Falsy Scenarios                           | Output
------------------------------------------+---------
[4,2,-2,1,0,3928,102904]                  | -1 or a unique falsy output.
[1,1,1]                                   | -1
[2,2,1,1,2,1,2] (Results in [2,3] @ i3)   | -1 (Trickiest example)
[]                                        | -1
[1]                                       | -1

यदि आप भ्रमित हैं:

सच्चाई: यह अंतत : किसी भी मध्यवर्ती कदम के बिना दो तक पहुंच जाएगा 1और इसके अलावा कोई भी तत्व होगा 2। -Einkorn Enchanter 20 hours ago

मिथ्या: समाप्ति मूल्य नहीं है [2]। इंटरमीडिएट शर्तों में सेट के कुछ के अलावा कुछ और होता है [1,2]। कुछ अन्य बातें, उदाहरण देखें।

---

यह कोड-गोल्फ है , सबसे कम बाइट-काउंट विजेता होगा।

Comments

क्या हम सिर्फ के बजाय किसी भी गलत मूल्य का उपयोग कर सकते हैं -1?

— mbomb007

"कोलाकोस्की अनुक्रम का एक काम करने वाला उपसर्ग नहीं" से आपका क्या मतलब है? मैंने मान लिया था कि [2]जब तक मैं [2,2,1,1,2,1,2]परीक्षण मामले को नहीं देख लेता, तब तक सूची अंत में नहीं पहुंचती ।

— 21

@ngenisis यह अंततः किसी भी मध्यवर्ती कदम के बिना दो तक पहुंच जाएगा 1और इसके अलावा कोई भी तत्व होगा 2।

— गेहूं जादूगर

[1]परीक्षण मामले के रूप में जोड़ना एक अच्छा विचार हो सकता है ।

— इमीना

@ mbomb007 कोई अलग मूल्य ठीक है। एक सकारात्मक पूर्णांक ठीक नहीं है। यदि आप 1-इंडेक्सिंग कर रहे हैं तो 0 ठीक है। "झूठा" ठीक है। इररिंग ठीक है। कोई भी गैर-सकारात्मक रिटर्न मूल्य ठीक है, यहां तक ​​कि -129.42910।

— मैजिक ऑक्टोपस Urn

Answer 1

हास्केल , 126 87 79 76 75 बाइट्स

39 बाइट्स ने अर्जन जोहान्सन को धन्यवाद दिया

import Data.List
f[2]=0
f y@(_:_:_)|all(`elem`[1,2])y=1+f(length<$>group y)

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

खराब इनपुट पर यह त्रुटियां।

Comments

f(और फलस्वरूप !) आलसी उत्पादन का उपयोग करके बहुत कम किया जा सकता है + span/ lengthसंचयकों के बजाय। इसे ऑनलाइन आज़माएं!

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

के लिए एक अनंत लूप दर्ज करने के लिए लगता है[1]

— Emigna

@ ईमनिगा डारन। इसे ठीक करने के लिए मुझे 6 बाइट्स की लागत है, लेकिन मैंने इसे ठीक कर लिया है।

— गेहूं जादूगर

@ GoodrjanJohansen यह एक अच्छी टिप की तरह लगता है, लेकिन मैं हास्केल में इतना कुशल नहीं हूं कि वहां क्या चल रहा है। यदि आप चाहते हैं कि आप इसे अपने उत्तर के रूप में पोस्ट कर सकते हैं, लेकिन कम से कम जब तक मुझे नहीं पता कि आपका समाधान कैसे काम करता है, तो मैं इसे अपने उत्तर में नहीं जोड़ने वाला हूं। :)

— गेहूं जादूगर

मैंने तब महसूस किया कि यह एक ऐसा मामला है जहाँ आयात वास्तव में कम है (और समझने में भी सरल है) import Data.List;f l=length<$>group l:। ( यहाँ के <$>लिए एक समानार्थी mapहै।) इसके अलावा, दो अलग-अलग -1मामलों के बजाय, यह @(_:_:_)मुख्य मामले को केवल लंबाई> = 2 सूचियों से मेल खाने के लिए बाध्य करने के लिए एक पैटर्न का उपयोग करने के लिए कम है । इसे ऑनलाइन आज़माएं!

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

Answer 2

05AB1E , 22 बाइट्स

[Dg2‹#γ€gM2›iX]2QJiNë®

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

व्याख्या

[                        # start a loop
 D                       # duplicate current list
  g2‹#                   # break if the length is less than 2
      γ                  # group into runs of consecutive equal elements
       €g                # get length of each run
         M2›iX           # if the maximum run-length is greater than 2, push 1
              ]          # end loop
               2QJi      # if the result is a list containing only 2
                   N     # push the iteration counter from the loop
                    ë®   # else, push -1
                         # implicitly output top of stack

Comments

फेल[1,1,2,2,1,2,1,1,2,2,1,2,2,1,1,2,1,1]

— वीजुन झोउ

@ WeijunZhou: धन्यवाद, निश्चित!

— Emigna

आप लिंक अपडेट करना भूल गए होंगे ...

— वीजुन झोउ

@ WeijunZhou: वास्तव में मेरे पास था। धन्यवाद फिर से :)

— Emigna

Answer 3

SCALA, 290 (282?) वर्ण, 290 (282?) बाइट्स

यह मुझे लू लग गया ... लेकिन मैं अंत में कर रहा हूँ!

इस कोड के साथ:

var u=t
var v=Array[Int]()
var c= -1
var b=1
if(!u.isEmpty){while(u.forall(x=>x==1|x==2)){c+=1
if(u.size>1){var p=u.size-1
for(i<-0 to p){if(b==1){var k=u(i)
v:+=(if(i==p)1 else if(u(i+1)==k){b=0
if(p-i>1&&u(i+2)==k)return-1
2}else 1)} else b=1}
u=v
v=v.take(0)}else if(u(0)==2)return c}}
c

मुझे नहीं पता कि क्या मुझे var u=tबाइट्स में गिनना चाहिए , यह देखते हुए कि मैं tएल्गोरिथ्म के दौरान उपयोग नहीं करता हूं (कॉपी को varपैरामीटर के बजाय एक संशोधित करने योग्य tमाना जाता है val- धन्यवाद स्कैला )। कृपया मुझे बताएं कि क्या मुझे इसे गिनना चाहिए।

काफी मुश्किल। इसे ऑनलाइन आज़माएं!

पुनश्च: मैं इसे पुनरावर्ती रूप से करने के बारे में सोच रहा था, लेकिन मुझे सच्चे पुनरावर्ती "अधीनता" के पैरामीटर के रूप में एक काउंटर पास करना होगा; यह तथ्य मुझे दो कार्यों की घोषणा करता है, और ये आकर्षण / बाइट कुछ नहीं बल्कि खो गए हैं।

संपादित करें: मुझे बदलना होगा (?) क्योंकि हमें यकीन नहीं है कि हमें गिनती के [1]मामले में लेना चाहिए । तो यहाँ संशोधित कोड है:

var u=t
var v=Array[Int]()
var c= -1
var b=1
if(!u.isEmpty){try{t(1)}catch{case _=>return if(t(0)==2)0 else -1}
while(u.forall(x=>x==1|x==2)){c+=1
if(u.size>1){var p=u.size-1
for(i<-0 to p){if(b==1){var k=u(i)
v:+=(if(i==p)1 else if(u(i+1)==k){b=0
if(p-i>1&&u(i+2)==k)return-1
2}else 1)} else b=1}
u=v
v=v.take(0)}else if(u(0)==2)return c}}
c

यह अनुकूलित नहीं है (मेरे पास समान स्थितियों के लिए एक डुप्लिकेट "आउट" है: जब मुझे मिलता है [2]और जब परम को [2]अलग से व्यवहार किया जाता है)।

NEW COST = 342 (मैंने उद्देश्य पर शीर्षक को संशोधित नहीं किया)

Comments

के लिए एक अनंत लूप दर्ज करने के लिए लगता है[1]

— Emigna

हाँ, लेकिन जैसा कि ओपी ने कहा (जैसा कि मैंने कम से कम समझा): "प्रारंभिक 1 हटाए गए" और "अनुक्रम बनने से पहले पुनरावृत्तियों की संख्या [2]"

— वी। कोर्टोइस

मेरी समझ में, [1]कभी नहीं पहुंचता है [2]और इस तरह -1 लौट आना चाहिए ।

— इमीना

समझा। तो क्या आपको लगता है कि मुझे शुरू में एक ज्वलंत स्थिति डालनी चाहिए? आपके सुझाव के लिए धन्यवाद।

— वी। कोर्टोइस

मुझे नहीं पता है कि मुझे लगता है कि सूची से लंबाई 2 से कम होने पर आप केवल लूप को बंद कर सकते हैं।

— इमीना

Answer 4

जावास्क्रिप्ट, 146 142 बाइट्स

पहले कोड गोल्फिंग में प्रयास करें, ऐसा लगता है कि बड़े समारोह में "वापसी" काफी थकाऊ है ...

इसके अलावा, b = 1 और b = 2 की जाँच में कुछ बाइट्स लगते हैं ...

यहाँ कोड है:

f=y=>{i=t=!y[0];while(y[1]){r=[];c=j=0;y.map(b=>{t|=b-1&&b-2;if(b-c){if(j>0)r.push(j);c=b;j=0}j++});(y=r).push(j);i++}return t||y[0]-2?-1:0^i}

व्याख्या

f=y=>{/*1*/}                                        //function definition

//Inside /*1*/:
  i=t=!y[0];                                        //initialization
                                                    //if the first one is 0 or undefined, 
                                                    //set t=1 so that it will return -1   
                                                    //eventually, otherwise i=0
  while(y[1]){/*2*/}                                //if there are 2+ items, start the loop

  //Inside /*2*/:
    r=[];c=j=0;                                     //initialization
    y.map(b=>{/*3*/});                              //another function definition

    //Inside /*3*/:
      t|=b-1&&b-2;                                  //if b==1 or b==2, set t=1 so that the
                                                    //entire function returns -1
      if(b-c){if(j>0)r.push(j);c=b;j=0}             //if b!=c, and j!=0, then push the 
                                                    //count to the array and reset counter
      j++                                           //counting duplicate numbers

    (y=r).push(j);i++                               //push the remaining count to the array
                                                    //and proceed to another stage

  return t||y[0]-2?-1:0^i                           //if the remaining element is not 2, or
                                                    //t==1 (means falsy), return -1,
                                                    //otherwise return the counter i

परीक्षण डेटा (दिए गए परीक्षण डेटा का उपयोग करके)

l=[[1,1],[1,2,2,1,1,2,1,2,2,1],[1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1],[1,2],[4,2,-2,1,0,3928,102904],[1,1,1],[2,2,1,1,2,1,2],[]];
console.log(l.map(f));
//Output: (8) [1, 6, 8, 2, -1, -1, -1, -1]

संपादित करें 1: 146 -> 142: बाइट को कम करने पर मेरे संपादन को रद्द करना, क्योंकि यह आउटपुट को प्रभावित करता है; और कुछ अंतिम विवरण पर संपादित करें

Comments

f=a=>{for(i=t=!a[0];a[1];)r=[],c=j=0,a.map(a=>{t|=a-1&&a-2;a-c&&(0<j&&r.push(j),c=a,j=0);j++}),(a=r).push(j),i++;return t||a[0]-2?-1:0^i}5 बाइट्स बचाता है (लूप के बजाय थोड़ी देर के लिए; कॉमास बनाम ब्रेसेस; && बनाम यदि)। आपके लिए किए गए इन आशावादों को प्राप्त करने के लिए आप google के क्लोजर कंपाइलर ( क्लोजर- compiler.appspot.com ) का उपयोग कर सकते हैं

— Oki

Answer 5

जेली ,26 25 22 21 20 बाइट्स

FQœ-2R¤
ŒgL€µÐĿṖ-LÇ?

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

यह कोड वास्तव में 20 बाइट्स तक सही ढंग से काम नहीं कर रहा था और मैंने नोटिस भी नहीं किया था; यह [2,2]परीक्षण के मामले में विफल रहा था । अब पूरी तरह से काम करना चाहिए।

Answer 6

जावास्क्रिप्ट (ईएस 6), 127 126 95 80 बाइट्स

g=(a,i,p,b=[])=>a.map(x=>3>x&0<x?(x==p?b[0]++:b=[1,...b],p=x):H)==2?i:g(b,~~i+1)

0 अनुक्रमित। खराब इनपुट पर "ReferenceError: X is not defined"और फेंकता है "InternalError: too much recursion"।

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

g=(a,i,p,b=[])=>a.map(x=>3>x&0<x?(x==p?b[0]++:b=[1,...b],p=x):H)==2?i:g(b,~~i+1)

function wrapper(testcase) {
  try {console.log(g(testcase))} catch(e) {
    console.log("Error")
  }
}

wrapper([1,1])
wrapper([1,2,2,1,1,2,1,2,2,1])
wrapper([1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1])
wrapper([1,2])
wrapper([4,2,-2,1,0,3928,102904])
wrapper([1,1,1])
wrapper([2,2,1,1,2,1,2])
wrapper([])
wrapper([1])

Answer 7

क्लोजर, 110 बाइट्स

#(if-not(#{[][1]}%)(loop[c % i 0](if(every? #{1 2}c)(if(=[2]c)i(recur(map count(partition-by + c))(inc i))))))

loopकिनारे के मामलों पर पूर्व-जांच के साथ एक मूल । nilअमान्य इनपुट के लिए रिटर्न मुझे नहीं पता था (= [2] '(2))है true: ओ

Answer 8

अजगर 2, 146 बाइट्स (केवल फ़ंक्शन)

f=lambda l,i=0:i if l==[1]else 0if max(l)>2or min(l)<1else f([len(x)+1for x in"".join(`v!=l[i+1]`[0]for i,v in enumerate(l[:-1])).split("T")],i+1)

मिथ्या इनपुट पर 0 लौटाता है (ठीक है क्योंकि यह 1-अनुक्रमित है)। बस इसे इस तरह से उपयोग करें:

print(f([1,2,2,1,1,2,1,2,2,1,2,2,1,1,2,1,1]))

Answer 9

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

FixedPointList[#/.{{2}->T,{(1|2)..}:>Length/@Split@#,_->0}&,#]~FirstPosition~T-1&

Functionजो बार-बार {2}अपरिभाषित प्रतीक के साथ प्रतिस्थापित करता है T, (एक या अधिक) की सूची 1और 2अगले पुनरावृत्ति के साथ, और कुछ और 0जब तक कि एक निश्चित बिंदु तक नहीं पहुंच जाता है, तब परिणामी माइनस में FirstPositionप्रतीक की वापसी Tहोती है । आउटपुट वह है जहाँ सत्य के मामले तक पहुंचने और झूठे मामले के लिए आवश्यक पुनरावृत्तियों की संख्या ( -indexed) है ।FixedPointList1{n}n1{2}-1+Missing["NotFound"]

यदि आउटपुट nइसके बजाय होना चाहिए {n}, तो इसकी लागत तीन और बाइट्स होती है:

Position[FixedPointList[#/.{{2}->T,{(1|2)..}:>Length/@Split@#,_->0}&,#],T][[1,1]]-1&

Answer 10

पायथन 2 , 184 163 156 बाइट्स

• @ फिलिप नार्डी बतिस्ता ने 21 बाइट बचाई !!!! बहुत बहुत धन्यवाद!!!!
• Halvardamm बचाए 7 बाइट्स !! धन्यवाद

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

a,c=input(),0
t=a==[]
while 1<len(a)and~-t:
 r,i=[],0
 while i<len(a):
	j=i
	while[a[j]]==a[i:i+1]:i+=1
	r+=[i-j]
 a=r;c+=1;t=any(x>2for x in a)
print~c*t+c

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

स्पष्टीकरण:

a,c=input(),0                             #input and initialize main-counter 

t=a==[]                                   #set t to 1 if list's empty. 

while len(a)>1:                           #loop until list's length is 1.

 r,i=[],0                                 #Initialize temp. list and 
                                          #list-element-pointer 

 while i<len(a):                          #loop for the element in list 

  j=0                                     #set consecutive-item-counter to 0   

  while(i+j)<len(a)and a[i]==a[i+j]:j+=1  #increase the consec.-counter

  r+=[j];i+=j                             #add the value to a list, move the 
                                          #list-element-pointer 

 a=r;c+=1;t=any(x>2for x in a)            #update the main list, increase t 
                                          #the counter, check if any number 
 if t:break;                              #exceeds 2 (if yes, exit the loop)

print[c,-1][t]                            #print -1 if t or else the 
                                          #counter's 
                                          #value 

Comments

156 बाइट्स

— हैलवार्ड शेम्पू

Answer 11

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

ŒgL€$ÐĿµẎḟ1,2ȯL_2

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

Answer 12

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

def f(s,c=2,j=0):
 w=[1]
 for i in s[1:]:w+=[1]*(i!=s[j]);w[-1]+=i==s[j];j+=1
 return(w==[2])*c-({1,2}!=set(s))or f(w,c+1)

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

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

def f(s,c=2,j=0):
 w=[1]
 for i in s[1:]:w+=[1]*(i!=s[j]);w[-1]+=i==s[j];j+=1
 return(w==[2])*c-({1,2}!={*s})or f(w,c+1)

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

व्याख्या

कटौती के अगले पुनरावृत्ति को संग्रहीत करने के लिए एक नया अनुक्रम (डब्ल्यू) आरम्भिक है। पुनरावृत्तियों की संख्या का ट्रैक रखने के लिए एक काउंटर (c) को निष्क्रिय किया गया है।

मूल अनुक्रम (ओं) में प्रत्येक आइटम की तुलना पिछले मूल्य से की जाती है। यदि वे समान हैं, तो (w) के अंतिम आइटम का मान 1 के साथ बढ़ जाता है। यदि वे भिन्न हैं, तो अनुक्रम (w) को [1] के साथ बढ़ाया जाता है।

यदि w == [2], काउंटर (सी) वापस आ गया है। अन्य, यदि मूल अनुक्रम (ओं) में 1 और 2 के अलावा अन्य आइटम हैं, तो मान -1 वापस आ जाता है। यदि न तो मामला है, तो फ़ंक्शन को नए अनुक्रम (डब्ल्यू) के साथ पुनरावर्ती कहा जाता है (एस) और काउंटर (सी) 1 से बढ़ा।

Comments

एक बाइट को बचाने के लिए, मैं पहले दो लाइनों को संयोजित करने का प्रयास कर रहा हूं def f(s,c=2,j=0,w=[1]):, लेकिन यह एक अलग परिणाम देता है। क्या कोई समझा सकता है कि ऐसा क्यों है?

— जित्स

परस्पर डिफ़ॉल्ट तर्क परस्पर बने रहेंगे

— Jo King

@JoKing जो सही समझ में आता है, धन्यवाद!

— जितसे

Answer 13

आर, 122 बाइट्स

a=scan()
i=0
f=function(x)if(!all(x%in%c(1,2)))stop()
while(length(a)>1){f(a)
a=rle(a)$l
f(a)
i=i+1}
if(a==2)i else stop()

सभी परीक्षण मामलों को पारित करता है। अन्यथा एक या एक से अधिक त्रुटियाँ फेंकता है। मुझे वैधता जांच से नफरत है; यदि इनपुट अच्छे होते तो यह कोड इतना गॉल्फ हो सकता था; यदि इनपुट 1 और 2 के अनुक्रम का हो तो भी कम होगा, यह जरूरी नहीं कि कोलाकोस्की अनुक्रम का एक उपसर्ग हो। यहां, हमें दोनों प्रारंभिक वेक्टर (अन्यथा परीक्षण का मामला [-2,1]) बीत चुका है और परिणामी वेक्टर (अन्यथा [1,1,1]पास होगा) की जांच करनी होगी।

Answer 14

रूबी , 81 77 बाइट्स

f=->a,i=1{a[1]&&a-[1,2]==[]?f[a.chunk{|x|x}.map{|x,y|y.size},i+1]:a==[2]?i:0}

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

संपादित करें: पुनरावर्ती लाम्बा में परिवर्तित करके 4 बाइट्स सहेजे गए।

1-अनुक्रमित संख्याओं की पुनरावृत्ति या 0 को झूठी के रूप में लौटाता है।

रूबी enumerable की चंक विधि का उपयोग करता है, जो हमें वही चाहिए - जो समान संख्याओं के लगातार रन के साथ समूहीकृत करता है। रन की लंबाई अगले पुनरावृत्ति के लिए सरणी का गठन करती है। सरणी को 1 तत्व से अधिक होने पर पुनरावृत्ति करता रहता है और 1 और 2 के अलावा कोई संख्या सामने नहीं आई है।

Answer 15

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

L?||qb]1!lb-{b,1 2_1?q]2b1Z.V0IKy~QhMrQ8*KhbB

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

यह शायद अभी भी गोल्फ है। यह निश्चित रूप से गोल्फ का .?काम है अगर मैंने जिस तरह से काम किया है, उम्मीद है कि यह ( बाहरीतम के elseबजाय अंतरतम संरचना के लिए) होगा

L?||qb]1!lb-{b,1 2_1?q]2b1Z # A lambda function for testing an iteration of the shortening
L                           # y=lambda b:
 ?                          # if
    qb]1                    #    b == [1]
   |    !lb                 #      or !len(b)
  |         {b              #        or b.deduplicate()
           -  ,1 2          #             .difference([1,2]):
                  _1        #               return -1
                    ?q]2b1Z # else: return 1 if [2] == b else Z (=0)

.V0                         # for b in range(0,infinity):
   IKy~Q                    # if K:=y(Q :=        (applies y to old value of Q)
        hM                  #    map(_[0],
          rQ8               #               run_length_encode(Q)):
             *Khb           #    print(K*(b+1))
                 B          #    break

Answer 16

पर्ल 5 -p , 71 बाइट्स

$_.=$";s/(. )\1*/$&=~y|12||.$"/ge&$.++while/^([12] ){2,}$/;$_=/^2 $/*$.

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

1-indexed। झूठा के 0लिए आउटपुट ।