Schreiben Sie ein Programm, das eine Zeichenfolge enthält, in der jede Zeile aus dem Zeichen besteht, das 0durch eine bestimmte Anzahl von Leerzeichen eingerückt ist. Die oberste Zeile wird nicht eingerückt, und jede zweite Zeile wird um höchstens ein Leerzeichen mehr eingerückt als die Zeile unmittelbar davor.

Es werden keine Zeilen mit nachgestellten Leerzeichen angezeigt, aber Sie können optional davon ausgehen, dass es eine einzelne nachgestellte Zeile gibt.

Die Eingabe könnte beispielsweise so aussehen:

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

Ihre Aufgabe ist es, es wie eine hierarchische Gliederung zu nummerieren und dabei positive Ganzzahlen als Zeilenüberschriften zu verwenden. Dies wäre die Ausgabe für das Beispiel:

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

Beachten Sie, dass für jede hierarchische Einrückungsstufe eine eigene Menge ansteigender Zahlen festgelegt ist, auch wenn nur eine davon angegeben ist.

In der Ausgabe sollten keine nachgestellten Leerzeichen vorhanden sein, es kann jedoch optional eine einzelne nachgestellte Newline vorhanden sein.

Schreiben Sie ein vollständiges Programm, das die Eingabezeichenfolge über stdin oder die Befehlszeile akzeptiert, oder schreiben Sie eine Funktion, die die Zeichenfolge als Argument verwendet. Drucken Sie das Ergebnis aus oder geben Sie es als Zeichenfolge zurück.

Der kürzeste Code in Bytes gewinnt.

Beispiele

Wenn die leere Zeichenfolge eingegeben wird, sollte die leere Zeichenfolge ausgegeben werden.

Das nächsttrivialste Beispiel ist die Eingabe

0

was soll werden

1

Großes Beispiel - Eingabe:

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

Ausgabe:

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

Dies ist eine genaue Übersetzung der Antwort von @ Sp3000 . Ich habe viele verschiedene Ansätze und Variationen ausprobiert, konnte sie aber nicht verkürzen, und ich bezeichne diese CW.

Demonstration.

Python 2, 77

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

Wie die Antwort von Sp3000 , aber mit einem Wörterbuch. Das Diktat Sspeichert die aktuelle Nummer für jede Verschachtelungsebene '0', ' 0', ' 0'und so weiter. Erhöhen Sie für jede Zeile in der Eingabe die entsprechende Verschachtelungsebene und setzen Sie die Verschachtelungsebene um eins höher auf 0 zurück.

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 dank @xnor)

Übernimmt die Eingabe als String über STDIN, z

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

Alternativ ist hier eine Funktion für 5 zusätzliche Bytes:

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;

Wie bei meiner Python-Antwort wird hier in einem Array gespeichert, bis zu welcher Zahl die einzelnen Einrückungsstufen zulässig sind. Ein Unterschied ist jedoch, dass dies verwendett (Array-Set) verwendet wird, um die 0 in jeder Zeile durch die gewünschte Zahl zu ersetzen.

Probieren Sie es online aus .

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

Hierbei wird ein Array verwendet, das die aktuelle Nummer für jede Einrückungsstufe enthält. Alles, was darüber hinausgeht, wird mit auf 0 zurückgesetztfill() . BEARBEITEN: 2 Bytes gespart dank vihan1086's Tipp.

Das folgende Stack-Snippet kann zum Testen verwendet werden, da es leicht ungolfed ist und eine besser unterstützte ES5-Syntax verwendet. Die zweite Funktion ist eine Polyfüllung, fill()da es keinen kurzen Weg gibt, dies ohne ES6 zu tun.

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

Die Funktion ist z.

Pip -rn , 31 27 Bytes

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

Eingabe von stdin. Probieren Sie es online!

Erläuterung

                             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)