Viết chương trình lấy một chuỗi trong đó mỗi dòng bao gồm ký tự được 0thụt vào bởi một số khoảng trắng. Dòng trên cùng không được thụt lề và mọi dòng khác sẽ được thụt vào bởi nhiều nhất một khoảng trống so với dòng ngay trước nó.

Không có dòng nào có dấu cách, nhưng bạn có thể tùy ý cho rằng có một dòng mới duy nhất.

Ví dụ: đầu vào có thể trông giống như thế này:

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

Nhiệm vụ của bạn là đánh số nó giống như một phác thảo phân cấp , sử dụng tăng số nguyên dương làm tiêu đề dòng. Đây sẽ là đầu ra cho ví dụ:

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

Lưu ý làm thế nào mỗi cấp độ thụt phân cấp có bộ số tăng dần của riêng nó, ngay cả khi chúng chỉ tăng lên một.

Trong đầu ra, không nên có dấu cách, nhưng có thể có một dòng mới duy nhất.

Viết một chương trình đầy đủ lấy chuỗi đầu vào thông qua stdin hoặc dòng lệnh hoặc viết một hàm lấy chuỗi đó làm đối số. In kết quả hoặc trả lại dưới dạng chuỗi.

Mã ngắn nhất tính bằng byte thắng.

Ví dụ

Nếu chuỗi trống là đầu vào, chuỗi trống sẽ là đầu ra.

Ví dụ tầm thường nhất tiếp theo là đầu vào

0

mà nên trở thành

1

Ví dụ lớn - Đầu vào:

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

Đầu ra:

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

Bình thường, 18 byte

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

Đây là bản dịch chính xác câu trả lời của @ Sp3000 . Tôi đã thử nhiều cách tiếp cận và biến thể khác nhau, nhưng tôi không thể rút ngắn nó, vì vậy tôi đang đánh dấu CW này.

Trình diễn.

Con trăn 2, 77

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

Giống như câu trả lời của Sp3000 , nhưng với một từ điển. Dict Slưu số hiện tại cho mỗi cấp độ lồng '0', ' 0', ' 0'và như vậy. Đối với mỗi dòng trong đầu vào, tăng mức lồng tương ứng và đặt lại mức lồng nhau cao hơn 0.

Python 2, 86 85 81 byte

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

(-5 byte nhờ @xnor)

Đưa đầu vào dưới dạng chuỗi qua STDIN, ví dụ:

'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'

Ngoài ra, đây là một hàm cho 5 byte bổ sung:

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 byte

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

Giống như câu trả lời Python của tôi , điều này sử dụng một mảng để lưu trữ số lượng mỗi cấp độ thụt đầu dòng. Tuy nhiên, một điểm khác biệt là điều này sử dụng t(tập hợp mảng) để thay thế 0 trên mỗi dòng bằng số chúng ta muốn.

Hãy thử trực tuyến .

JavaScript ES6, 83 81 byte

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

Điều này sử dụng một mảng chứa số hiện tại cho mỗi cấp độ thụt đầu dòng. Tất cả mọi thứ vượt qua mức đó được đặt lại về 0 bằng cách sử dụng fill(). EDIT: 2 byte được lưu nhờ vào mẹo của vihan1086.

Đoạn mã dưới đây có thể được sử dụng để kiểm tra vì nó không được xử lý một chút và sử dụng cú pháp ES5 được hỗ trợ tốt hơn. Hàm thứ hai là một polyfill fill()vì không có cách nào ngắn để làm điều đó mà không có 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>

Con trăn - 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))

Chức năng là z.

Pip -rn , 31 27 byte

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

Đầu vào từ stdin. Hãy thử trực tuyến!

Giải trình

                             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)