เขียนโปรแกรมที่ใช้ในสตริงโดยที่ทุกบรรทัดประกอบด้วยอักขระที่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

โปรดสังเกตว่าระดับการเยื้องของลำดับชั้นทุกชุดมีตัวเลขที่เพิ่มขึ้นของตัวเองอย่างไรแม้ว่าจะเพิ่มขึ้นเป็นหนึ่งเท่านั้น

ในเอาต์พุตไม่ควรมีช่องว่างต่อท้าย แต่อาจมีทางเลือกขึ้นบรรทัดใหม่เดียว

เขียนโปรแกรมเต็มรูปแบบที่รับสายป้อนข้อมูลผ่าน stdin หรือบรรทัดคำสั่งหรือเขียนฟังก์ชันที่รับสายเข้าเป็นอาร์กิวเมนต์ พิมพ์ผลลัพธ์หรือส่งคืนเป็นสตริง

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ตัวอย่าง

หากสตริงว่างคืออินพุตสตริงว่างควรเป็นเอาต์พุต

ตัวอย่างที่น่าสนใจที่สุดต่อไปคืออินพุต

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

Pyth, 18 ไบต์

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

นี่คือการแปลที่แน่นอนของคำตอบของ@ Sp3000 ฉันลองวิธีและรูปแบบที่แตกต่างกันมากมาย แต่ฉันไม่สามารถย่อให้สั้นลงได้ดังนั้นฉันจึงทำเครื่องหมาย CW นี้

สาธิต.

Python 2, 77

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

ชอบคำตอบของ Sp3000แต่มีพจนานุกรม dict จะSเก็บหมายเลขปัจจุบันของแต่ละระดับการซ้อน'0', ' 0', ' 0'เป็นต้น สำหรับแต่ละบรรทัดในอินพุตเพิ่มระดับการซ้อนที่สอดคล้องกันและรีเซ็ตระดับการซ้อนหนึ่งที่สูงกว่าเป็น 0

Python 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]`

CJam, 25 ไบต์

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

เช่นเดียวกับคำตอบ Pythonของฉันนี่ใช้อาร์เรย์เพื่อเก็บหมายเลขที่แต่ละระดับการย่อหน้า อย่างไรก็ตามความแตกต่างอย่างหนึ่งคือสิ่งนี้ใช้t(ชุดอาร์เรย์) เพื่อแทนที่ 0 ในแต่ละบรรทัดด้วยหมายเลขที่เราต้องการ

ลองมันออนไลน์

JavaScript ES6, 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 ไบต์ขอบคุณปลายของ vihan1086

Stack Snippet ด้านล่างสามารถนำมาใช้ในการทดสอบได้เนื่องจากไม่ได้รับการดูแลเล็กน้อยและใช้ไวยากรณ์ ES5 ที่รองรับได้ดีขึ้น ฟังก์ชั่นที่สองเป็น polyfill fill()เนื่องจากไม่มีวิธีสั้น ๆ ที่จะทำโดยไม่มี ES6

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>

Python - 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ฟังก์ชั่น

Pip -rn , 31 27 ไบต์

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

อินพุตจาก stdin ลองออนไลน์!

คำอธิบาย

                             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)