Escriba un programa que tome una cadena donde cada línea consiste en el carácter 0sangrado por un número de espacios. La línea superior no tiene sangría y todas las demás líneas se sangrarán como máximo un espacio más que la línea justo antes.

Ninguna línea tendrá espacios finales, pero puede suponer opcionalmente que hay una nueva línea final.

Por ejemplo, la entrada podría verse así:

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

Su tarea es numerarlo como un esquema jerárquico , utilizando números enteros positivos crecientes como encabezados de línea. Esta sería la salida para el ejemplo:

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

Observe cómo cada nivel de sangría jerárquica tiene su propio conjunto de números crecientes, incluso si solo suben a uno.

En la salida, no debe haber espacios finales, pero opcionalmente puede haber una nueva línea final.

Escriba un programa completo que tome la cadena de entrada a través de stdin o línea de comando, o escriba una función que tome la cadena como argumento. Imprima el resultado o devuélvalo como una cadena.

El código más corto en bytes gana.

Ejemplos

Si se ingresa la cadena vacía, la cadena vacía debe salir.

El siguiente ejemplo más trivial es la entrada

0

que debería convertirse

1

Ejemplo grande - Entrada:

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

Salida:

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 bytes

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

Esta es una traducción exacta de la respuesta de @ Sp3000 . Intenté muchos enfoques y variaciones diferentes, pero no pude acortarlo, así que estoy marcando este CW.

Demostración.

Pitón 2, 77

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

Como la respuesta de Sp3000 , pero con un diccionario. El dict Salmacena el número actual para cada nivel de anidamiento, '0', ' 0', ' 0'etc. Para cada línea en la entrada, incremente el nivel de anidación correspondiente y restablezca el nivel de anidación uno más alto a 0.

Python 2, 86 85 81 bytes

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

(-5 bytes gracias a @xnor)

Toma entrada como una cadena a través de STDIN, por ejemplo

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

Alternativamente, aquí hay una función para 5 bytes adicionales:

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 bytes

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

Al igual que mi respuesta de Python , esto usa una matriz para almacenar el número que corresponde a cada nivel de sangría. Sin embargo, una diferencia es que esto usa t(conjunto de matrices) para reemplazar el 0 en cada línea con el número que queremos.

Pruébalo en línea .

JavaScript ES6, 83 81 bytes

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

Esto utiliza una matriz que contiene el número actual para cada nivel de sangría. Todo más allá de ese nivel se restablece a 0 usando fill(). EDITAR: 2 bytes guardados gracias a la sugerencia de vihan1086.

El Fragmento de pila a continuación se puede usar para realizar pruebas, ya que está ligeramente oculto y utiliza una sintaxis ES5 mejor soportada. La segunda función es un polyfill fill()ya que no hay una forma corta de hacerlo sin 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))

La función es z.

Pip -rn , 31 27 bytes

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

Entrada de stdin. Pruébalo en línea!

Explicación

                             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)