Écrivez un programme qui prend une chaîne où chaque ligne se compose du caractère 0indenté par un certain nombre d'espaces. La ligne supérieure n'est pas en retrait et toutes les autres lignes seront en retrait d'au plus un espace de plus que la ligne juste avant.

Aucune ligne n'aura d'espaces de fin, mais vous pouvez éventuellement supposer qu'il existe une seule nouvelle ligne de fin.

Par exemple, l'entrée peut ressembler à ceci:

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

Votre tâche consiste à le numéroter comme un plan hiérarchique , en utilisant des entiers positifs croissants comme en-têtes de ligne. Ce serait la sortie de l'exemple:

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

Notez que chaque niveau d'indentation hiérarchique possède son propre ensemble de nombres croissants, même s'ils ne vont que jusqu'à un.

Dans la sortie, il ne doit pas y avoir d'espaces de fin, mais il peut éventuellement y avoir une seule nouvelle ligne de fin.

Écrivez un programme complet qui prend la chaîne d'entrée via stdin ou la ligne de commande, ou écrivez une fonction qui prend la chaîne en argument. Imprimez le résultat ou renvoyez-le sous forme de chaîne.

Le code le plus court en octets gagne.

Exemples

Si la chaîne vide est entrée, la chaîne vide doit être sortie.

L'exemple le plus trivial suivant est l'entrée

0

qui devrait devenir

1

Grand exemple - Entrée:

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

Production:

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 octets

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

Ceci est une traduction exacte de la réponse de @ Sp3000 . J'ai essayé de nombreuses approches et variations différentes, mais je ne pouvais pas le raccourcir, donc je marque cette CW.

Manifestation.

Python 2, 77

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

Comme la réponse de Sp3000 , mais avec un dictionnaire. Le dict Sstocke le numéro actuel pour chaque niveau d'imbrication, '0', ' 0', ' 0'etc. Pour chaque ligne de l'entrée, incrémentez le niveau d'imbrication correspondant et réinitialisez le niveau d'imbrication un plus haut à 0.

Python 2, 86 85 81 octets

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

(-5 octets grâce à @xnor)

Prend l'entrée sous forme de chaîne via STDIN, par exemple

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

Alternativement, voici une fonction pour 5 octets supplémentaires:

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 octets

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

Comme ma réponse Python , cela utilise un tableau pour stocker le nombre jusqu'à ce que chaque niveau d'indentation soit. Une différence, cependant, est que cela utilise t(ensemble de tableaux) pour remplacer le 0 sur chaque ligne par le nombre que nous voulons.

Essayez-le en ligne .

JavaScript ES6, 83 81 octets

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

Cela utilise un tableau qui contient le numéro actuel pour chaque niveau d'indentation. Tout ce qui dépasse ce niveau est réinitialisé à 0 en utilisant fill(). EDIT: 2 octets enregistrés grâce à la astuce de vihan1086.

L'extrait de pile ci-dessous peut être utilisé pour les tests, car il est légèrement non-golfé et utilise une syntaxe ES5 mieux prise en charge. La deuxième fonction est un polyfill fill()car il n'y a pas de moyen court de le faire sans 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 fonction est z.

Pip -rn , 31 27 octets

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

Entrée de stdin. Essayez-le en ligne!

Explication

                             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)