Her satırın 0belirli sayıda boşlukla girintili karakterden oluştuğu bir dize alan bir program yazın . Üst satır girintili değildir ve diğer tüm satırlar, hemen önceki satırdan en fazla bir boşluk daha girintili olacaktır.

Hiçbir satırın sonunda boşluk olmaz, ancak isteğe bağlı olarak tek bir satırsonu satırı olduğunu varsayabilirsiniz.

Örneğin, girdi şöyle görünebilir:

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

Göreviniz , satır başlıkları olarak artan pozitif tam sayıları kullanarak bunu hiyerarşik bir anahat gibi numaralandırmaktır . Bu, örneğin çıktısı olacaktır:

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

Her bir hiyerarşik girinti seviyesinin, sadece bir taneye kadar olsalar bile, kendi artan sayı kümesine sahip olduğuna dikkat edin.

Çıktıda, sondaki boşluk olmamalıdır, ancak isteğe bağlı olarak tek bir sondaki yeni satır olabilir.

Giriş dizesini stdin veya komut satırı üzerinden alan tam bir program yazın veya dizeyi bağımsız değişken olarak alan bir işlev yazın. Sonucu yazdırın veya dize olarak döndürün.

Bayt cinsinden en kısa kod kazanır.

Örnekler

Boş dize girilirse, boş dize çıkarılmalıdır.

Bir sonraki en önemsiz örnek girdi

0

hangisi olmalı

1

Büyük örnek - Giriş:

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

Çıktı:

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 bayt

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

Bu tam bir çevirisidir @ Sp3000 cevabının . Birçok farklı yaklaşım ve varyasyon denedim, ancak kısaltamadım, bu yüzden bu CW'yi işaretliyorum.

Gösteri.

Python 2, 77

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

Gibi SP3000 cevabı ancak bir sözlükle. Dikte Sher yuvalama seviyesi için geçerli sayıyı kaydeder '0', ' 0', ' 0'vb. Girişteki her satır için karşılık gelen yuvalama seviyesini artırın ve yuvalama seviyesini 0'dan bir üste sıfırlayın.

Python 2, 86 85 81 bayt

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

(@Xnor sayesinde -5 bayt)

Girişi STDIN aracılığıyla dize olarak alır, örn.

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

Alternatif olarak, 5 ekstra bayt için bir fonksiyon:

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 bayt

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

Benim gibi Python cevap bu, her girinti düzeyi kadardır sayı deposuna bir dizi kullanır. Ancak bir fark, bunun ther satırdaki 0'ı istediğimiz sayı ile değiştirmek için (dizi seti) kullanmasıdır.

Çevrimiçi deneyin .

JavaScript ES6, 83 81 bayt

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

Bu, her girinti düzeyi için geçerli sayıyı tutan bir dizi kullanır. Bu seviyeyi geçen her şey kullanılarak 0'a sıfırlanır.fill() . EDIT: vihan1086's ipucu sayesinde 2 bayt kaydedildi.

Aşağıdaki Yığın Snippet'i test için kullanılabilir, çünkü hafifçe çözülür ve daha iyi desteklenen ES5 sözdizimi kullanır. İkinci işlev, fill()ES6'sız yapmanın kısa bir yolu olmadığından çok amaçlı bir dolgudur.

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

İşlevi z.

Pip -rn , 31 27 bayt

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

Stdin'den girdi. Çevrimiçi deneyin!

açıklama

                             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)