Scrivi un programma che contiene una stringa in cui ogni riga è composta dal carattere 0indentato da un numero di spazi. La riga superiore non è rientrata e ogni altra riga sarà rientrata al massimo da uno spazio in più rispetto alla riga immediatamente precedente.

Nessuna linea avrà spazi finali ma puoi facoltativamente supporre che ci sia una sola nuova riga finale.

Ad esempio, l'input potrebbe essere simile al seguente:

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

Il tuo compito è numerarlo come uno schema gerarchico , usando numeri interi positivi crescenti come intestazioni di linea. Questo sarebbe l'output per l'esempio:

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

Nota come ogni livello di rientro gerarchico ha il proprio set di numeri crescenti, anche se arrivano solo a uno.

Nell'output, non dovrebbero esserci spazi finali, ma facoltativamente può esserci una sola nuova riga finale.

Scrivi un programma completo che accetta la stringa di input tramite stdin o riga di comando oppure scrivi una funzione che accetta la stringa come argomento. Stampa il risultato o restituiscilo come stringa.

Vince il codice più breve in byte.

Esempi

Se viene immessa la stringa vuota, dovrebbe essere emessa la stringa vuota.

Il prossimo esempio più banale è l'input

0

che dovrebbe diventare

1

Grande esempio - Input:

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

Produzione:

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 byte

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

Questa è una traduzione esatta della risposta di @ Sp3000 . Ho provato molti approcci e varianti diversi, ma non ho potuto accorciarlo, quindi segnerò questo CW.

Dimostrazione.

Python 2, 77

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

Come la risposta di Sp3000 , ma con un dizionario. Il dict Smemorizza il numero corrente per ciascun livello di annidamento '0', ' 0', ' 0'e così via. Per ogni riga nell'input, aumentare il livello di annidamento corrispondente e reimpostare il livello di annidamento su uno superiore a 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 grazie a @xnor)

Accetta input come stringa tramite STDIN, ad es

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

In alternativa, ecco una funzione per 5 byte extra:

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;

Come la mia risposta Python , questo utilizza un array per memorizzare il numero fino a ciascun livello di rientro. Una differenza, tuttavia, è che questo utilizza t(set di array) per sostituire lo 0 su ogni riga con il numero che vogliamo.

Provalo online .

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

Questo utilizza un array che contiene il numero corrente per ciascun livello di rientro. Tutto ciò che supera quel livello viene ripristinato su 0 utilizzando fill(). MODIFICA: 2 byte salvati grazie al suggerimento di vihan1086.

Lo snippet di stack di seguito può essere utilizzato per i test perché è leggermente non modificato e utilizza una sintassi ES5 meglio supportata. La seconda funzione è un polyfill in fill()quanto non esiste un modo breve per farlo senza 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 funzione è z.

Pip -rn , 31 27 byte

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

Input da stdin. Provalo online!

Spiegazione

                             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)