क्रमबद्ध पदानुक्रमित रूपरेखा

Question

एक प्रोग्राम लिखें जो एक स्ट्रिंग में ले जाता है जहां हर पंक्ति में 0कुछ संख्या में रिक्त स्थान द्वारा इंडेंट किए गए चरित्र होते हैं । शीर्ष पंक्ति इंडेंटेड नहीं है और हर दूसरी लाइन लाइन से ज्यादा से ज्यादा एक जगह पर पहले से इंडेंट होगी।

किसी भी लाइन में अनुगामी स्थान नहीं होंगे लेकिन आप वैकल्पिक रूप से मान सकते हैं कि एक एकल अनुगामी न्यूलाइन है।

उदाहरण के लिए, इनपुट कुछ इस तरह दिख सकता है:

0
 0
  0
  0
 0
0
 0
 0
 0
  0
0
 0
  0
  0

आपका काम यह है कि पदानुक्रमित रूपरेखा की तरह इसे संख्याबद्ध करना है , लाइन हेडर के रूप में सकारात्मक पूर्णांक बढ़ते हुए। यह उदाहरण के लिए आउटपुट होगा:

1
 1
  1
  2
 2
2
 1
 2
 3
  1
3
 1
  1
  2

ध्यान दें कि प्रत्येक पदानुक्रमित इंडेंटेशन स्तर की बढ़ती संख्याओं का अपना सेट है, भले ही वे केवल एक तक ही जाएं।

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

एक पूर्ण प्रोग्राम लिखें जो इनपुट स्ट्रिंग को स्टड या कमांड लाइन के माध्यम से लेता है, या एक फ़ंक्शन लिखता है जो स्ट्रिंग को एक तर्क के रूप में लेता है। परिणाम प्रिंट करें या इसे स्ट्रिंग के रूप में लौटाएं।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

यदि खाली स्ट्रिंग इनपुट है, तो रिक्त स्ट्रिंग आउटपुट होना चाहिए।

अगला सबसे तुच्छ उदाहरण इनपुट है

0

जो बनना चाहिए

1

बड़ा उदाहरण - इनपुट:

0
 0
  0
 0
  0
 0
  0
  0
   0
   0
    0
     0
     0
     0
     0
    0
   0
    0
    0
  0
0
 0
  0
 0
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0
   0
    0
     0
  0
   0
0
0
0
 0
  0
   0
    0
     0
      0
      0
     0
    0
   0
  0
 0
  0
  0
   0
   0
0
0

आउटपुट:

1
 1
  1
 2
  1
 3
  1
  2
   1
   2
    1
     1
     2
     3
     4
    2
   3
    1
    2
  3
2
 1
  1
 2
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
   1
    1
     1
  12
   1
3
4
5
 1
  1
   1
    1
     1
      1
      2
     2
    2
   2
  2
 2
  1
  2
   1
   2
6
7

Answer 1

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

V.z+PNhX0=Y>lN+0Y1

यह @ Sp3000 के उत्तर का सटीक अनुवाद है । मैंने कई अलग-अलग तरीकों और विविधताओं की कोशिश की, लेकिन मैं इसे छोटा नहीं कर सका, इसलिए मैं इस सीडब्ल्यू को चिह्नित कर रहा हूं।

प्रदर्शन।

Answer 2

अजगर 2, 77

S={'0':0}
for w in input().split('\n'):S[w]+=1;S[' '+w]=0;print w[:-1]+`S[w]`

Sp3000 के उत्तर की तरह , लेकिन एक शब्दकोश के साथ। तानाशाह Sप्रत्येक घोंसले के स्तर '0', ' 0', ' 0'और इतने पर के लिए वर्तमान संख्या को संग्रहीत करता है । इनपुट में प्रत्येक पंक्ति के लिए, इसी नेस्टिंग स्तर को बढ़ाएं, और नेस्टिंग स्तर को एक से अधिक 0 पर रीसेट करें।

Answer 3

पायथन 2, 86 85 81 बाइट्स

S=[]
for r in input().split("\n"):S=([0]+S)[-len(r):];S[0]+=1;print r[:-1]+`S[0]`

(-5 बाइट्स @xnor के लिए धन्यवाद)

STDIN के माध्यम से एक स्ट्रिंग के रूप में इनपुट लेता है, जैसे

'0\n 0\n  0\n  0\n 0\n0\n 0\n 0\n 0\n  0\n0\n 0\n  0\n  0'

वैकल्पिक रूप से, यहां 5 अतिरिक्त बाइट्स के लिए एक फ़ंक्शन है:

def f(I,S=[]):
 for r in I.split("\n"):S=([0]+S)[-len(r):];S[0]+=1;print r[:-1]+`S[0]`

Comments

मैंने पाया कि आप प्रत्येक पंक्ति को रिक्त स्थान की एक स्ट्रिंग के रूप में प्रत्येक पंक्ति में ले जाकर बचा सकते हैं ताकि आप उन स्थानों को सीधे प्रिंट कर सकेंS=[]\nfor w in input()[:-1].split('0\n'):S=([0]+S)[~len(w):];S[0]+=1;print w+`S[0]`

— xnor

वास्तव में, यह सीधे लाइन में लेने के लिए एक सा कम है: S=[]\nfor w in input().split('\n'):S=([0]+S)[-len(w):];S[0]+=1;print w[:-1]+`S[0]` ।

— xnor

@xnor फिर से धन्यवाद - यह बहुत आसान है :)

— Sp3000

Answer 4

सीजेएम, 25 बाइट्स

LqN/{0+I,<))_IW@toNo+}fI;

मेरे पायथन के जवाब की तरह , यह स्टोर करने के लिए एक सरणी का उपयोग करता है जो प्रत्येक इंडेंटेशन स्तर तक की संख्या है। हालाँकि, एक अंतर यह है कि यह tप्रत्येक पंक्ति में 0 को बदलने के लिए (सरणी सेट) का उपयोग उस संख्या के साथ करता है जिसे हम चाहते हैं।

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

Answer 5

जावास्क्रिप्ट ईएस 6, 83 81 बाइट्स

f=(z,a=[])=>z.replace(/ *0/g,e=>e.replace(0,a.fill(0,l=e.length)[--l]=a[l]+1||1))

यह एक सरणी का उपयोग करता है जो प्रत्येक इंडेंटेशन स्तर के लिए वर्तमान संख्या रखता है। उस स्तर के पिछले सब कुछ का उपयोग करके 0 पर रीसेट किया जाता है fill()। संपादित करें: 2 बाइट्स ने विहान 1086 की टिप के लिए धन्यवाद बचाया।

नीचे दिए गए स्टैक स्निपेट का उपयोग परीक्षण के लिए किया जा सकता है क्योंकि यह थोड़ा असंक्रमित है और बेहतर समर्थित ES5 सिंटैक्स का उपयोग करता है। दूसरा कार्य एक पॉलीफ़िल है fill()क्योंकि ईएस 6 के बिना इसे करने का एक छोटा तरीका नहीं है।

f=function(z){
  a=[]
  return z.replace(/ *0/g,function(e){
    return e.replace(0,a.fill(0,l=e.length)[--l]=a[l]+1||1)
  })
}

if(!Array.prototype.fill){
  Array.prototype.fill = function(val, start){
    var res = this;
    for(var i = start; i<this.length; i++){
      res[i] = val;
    }
    return res;
  };
}

run=function(){document.getElementById('output').innerText=f(document.getElementById('input').value)};document.getElementById('run').onclick=run;run()

<textarea id="input" rows="15" cols="10">
0
 0
  0
  0
 0
0
 0
 0
 0
  0
0
 0
  0
  0</textarea>
<pre id="output" style="display:inline-block; vertical-align:top; margin:0"></pre><br />
<button id="run">Run</button>

Answer 6

अजगर - 191

def p(s,i,v,n=1):
    while i<len(s)and s[i]and'0'not in s[i][:v]:
        if s[i][v]=='0':s[i]=' '*v+str(n);n+=1;i+=1
        else:i=p(s,i,v+1)
    return(s,i)[v!=0]
z=lambda r:'\n'.join(p(r.split('\n'),0,0))

समारोह है z।

Answer 7

पिप -rn , 31 27 बाइट्स

{Wl#<alPU0l@>:-#aaR0++@l}Mg

स्टड से इनपुट। इसे ऑनलाइन आज़माएं!

व्याख्या

                             g is list of lines of stdin (-r flag); l is []
                             Note that l is a global variable
{                       }Mg  Map this function to each a in g:
 Wl#<a                        While l is less in length than a:
      lPU0                     Push a 0 to (the front of) l
                              (This handles increasing the indent)
          l@>:                Slice and assign back to l...
              -#a              ... its last len(a) elements
                              (This handles decreasing the indent)
                 aR0          In a, replace 0 with
                      @l       the first element of l
                    ++         incremented in-place
                              The function returns the above expression
                             The resulting list from map is printed, newline-separated
                              (-n flag)