모든 줄 0이 몇 개의 공백으로 들여 쓰기 된 문자로 구성된 문자열을받는 프로그램을 작성 하십시오. 맨 위 줄은 들여 쓰기되지 않으며 다른 모든 줄은 줄 바로 앞의 줄보다 최대 한 칸 더 들여 쓰기됩니다.

줄에 후행 공백이 없지만 선택적으로 단일 후행 줄 바꿈이 있다고 가정 할 수 있습니다.

예를 들어, 입력은 다음과 같습니다.

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

당신의 작업은 증가하는 양의 정수를 라인 헤더로 사용하여 계층 적 개요 처럼 번호를 매기는 것입니다. 이것은 예제의 출력입니다.

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

모든 계층 들여 쓰기 수준이 1까지만 올라가도 어떻게 증가하는 고유 한 숫자 집합이 있는지 확인하십시오.

출력에는 후행 공백이 없어야하지만 선택적으로 단일 후행 줄 바꿈이있을 수 있습니다.

stdin 또는 명령 행을 통해 입력 문자열을 가져 오는 전체 프로그램을 작성하거나 문자열을 인수로 사용하는 함수를 작성하십시오. 결과를 인쇄하거나 문자열로 반환하십시오.

바이트 단위의 가장 짧은 코드가 이깁니다.

예

빈 문자열이 입력되면 빈 문자열이 출력되어야합니다.

다음으로 가장 간단한 예는 입력입니다.

0

어느 것이되어야 하는가

1

큰 예-입력 :

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

산출:

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 바이트

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

이것은 @ Sp3000 의 정확한 답변입니다. 나는 많은 다른 접근 방식과 변형을 시도했지만 단축 할 수 없으므로이 CW를 표시하고 있습니다.

데모.

파이썬 2, 77

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

Sp3000의 답변 처럼 하지만, 사전에. dict S에는 각 중첩 수준의 현재 번호 등이 저장 '0', ' 0', ' 0'됩니다. 입력의 각 줄에 대해 해당 네 스팅 레벨을 증가시키고 네 스팅 레벨을 1보다 높게 0으로 재설정하십시오.

파이썬 2, 86 85 81 바이트

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

(@xnor 덕분에 5 바이트)

STDIN을 통해 문자열로 입력을받습니다. 예 :

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

또는 5 여분의 바이트에 대한 함수가 있습니다.

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 바이트

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

내 파이썬 답변 과 마찬가지로 배열을 사용하여 각 들여 쓰기 수준이 어느 숫자인지 저장합니다. 그러나 한 가지 차이점은t (배열 집합)을 하여 각 줄의 0을 원하는 숫자로 바꾼다는 것입니다.

온라인으로 사용해보십시오 .

자바 스크립트 ES6, 83 81 바이트

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

이것은 각 들여 쓰기 레벨에 대한 현재 숫자를 보유하는 배열을 사용합니다. 해당 수준 이상의 모든 항목을 사용하여 0으로 재설정fill() . 편집 : vihan1086의 팁 덕분에 2 바이트가 절약되었습니다.

아래의 스택 스 니펫은 약간 압축이 풀리고 더 나은 지원 ES5 구문을 사용하므로 테스트에 사용할 수 있습니다. 두 번째 기능은 fill()ES6없이 짧은 방법이 없기 때문에 polyfill입니다 .

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>

파이썬-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))

기능은 z입니다.

핍 -rn , 31 27 바이트

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

stdin에서 입력 온라인으로 사용해보십시오!

설명

                             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)