Napisz program, który pobiera ciąg znaków, w którym każda linia składa się ze znaku 0wciętego przez pewną liczbę spacji. Górna linia nie jest wcięta, a każda inna linia będzie wcięta o co najmniej jedną spację więcej niż linia tuż przed nią.

Żadne wiersze nie będą miały końcowych spacji, ale możesz opcjonalnie założyć, że istnieje jedna końcowa nowa linia.

Na przykład dane wejściowe mogą wyglądać mniej więcej tak:

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

Twoim zadaniem jest ponumerowanie go jak hierarchicznego konturu , przy użyciu rosnących liczb całkowitych dodatnich jako nagłówków linii. To byłby wynik dla przykładu:

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

Zwróć uwagę, że każdy hierarchiczny poziom wcięcia ma swój własny zestaw rosnących liczb, nawet jeśli zwiększają się tylko do jednego.

Na wyjściu nie powinno być żadnych spacji końcowych, ale opcjonalnie może występować pojedynczy znak nowej linii.

Napisz pełny program, który pobiera ciąg wejściowy za pomocą stdin lub wiersza poleceń, lub napisz funkcję, która przyjmuje ciąg jako argument. Wydrukuj wynik lub zwróć jako ciąg.

Najkrótszy kod w bajtach wygrywa.

Przykłady

Jeśli wprowadzono pusty ciąg, pusty ciąg powinien zostać wyprowadzony.

Kolejnym najbardziej trywialnym przykładem jest wejście

0

który powinien się stać

1

Duży przykład - dane wejściowe:

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

Wynik:

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 bajtów

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

To jest dokładne tłumaczenie @ Sp3000 . Próbowałem wielu różnych podejść i odmian, ale nie mogłem tego skrócić, więc zaznaczam to CW.

Demonstracja.

Python 2, 77

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

Jak odpowiedź Sp3000 , ale ze słownikiem. Dict Sprzechowuje bieżącą liczbę dla każdego poziomu zagnieżdżenia '0', ' 0', ' 0'i tak dalej. Dla każdej linii na wejściu zwiększ odpowiedni poziom zagnieżdżenia i zresetuj poziom zagnieżdżania o jeden wyższy do 0.

Python 2, 86 85 81 bajtów

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

(-5 bajtów dzięki @xnor)

Pobiera dane wejściowe jako ciąg znaków za pośrednictwem STDIN, np

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

Alternatywnie, oto funkcja dla 5 dodatkowych bajtów:

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 bajtów

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

Podobnie jak moja odpowiedź w języku Python , ta tablica używa do przechowywania numeru, który ma każdy poziom wcięcia. Jedną różnicą jest to, że używa t(zestaw tablic) do zamiany 0 w każdej linii na żądaną liczbę.

Wypróbuj online .

JavaScript ES6, 83 81 bajtów

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

Wykorzystuje tablicę, która przechowuje bieżącą liczbę dla każdego poziomu wcięcia. Wszystko powyżej tego poziomu jest resetowane do 0 za pomocą fill(). EDYCJA: 2 bajty zapisane dzięki końcówce vihan1086.

Poniższego fragmentu stosu można użyć do testowania, ponieważ jest on nieznacznie ulepszony i używa lepiej obsługiwanej składni ES5. Drugą funkcją jest polifill, fill()ponieważ nie ma krótkiej drogi, aby to zrobić bez 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))

Ta funkcja to z.

Pip -rn , 31 27 bajtów

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

Dane wejściowe ze standardowego wejścia. Wypróbuj online!

Wyjaśnienie

                             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)