스태킹 블록

특정 지점에서 제거 할 블록 목록을 입력하면 결과 "타워"의 높이가 출력됩니다.

이 과제를 설명하는 가장 좋은 방법은 예입니다. 입력은 n 블록을 나타내는 2n 정수 목록입니다 . 첫 번째 정수는 블록의 x 위치이고, 0- 인덱스이며, 두 번째 정수는 블록의 넓이입니다. 예를 들어, 입력은 블록 을 나타냅니다 (x 좌표는 아래에 레이블이 지정됨).2 4

  ####
0123456789

이제 입력이 2 4 4 6입니다. 즉, 너비가 4 인 x = 2에서 하나의 블록, 너비가 6 인 x = 4에서 하나의 블록.

    ######
  ####

a.) 블록은 항상 탑의 꼭대기에서 "떨어져"있으며 b.) 블록은 "떨어지지"않습니다 (즉, 항상 균형을 잡습니다). 따라서 입력은 다음을 2 4 4 6 12 1나타냅니다.

    ######
  ####      #

마지막 블록은 "지상"까지 떨어졌습니다.

최종 출력은 각 x 값에서 최대 타워의 최대 높이 여야합니다. 따라서 입력 2 4 4 6 12 1결과는 0011222222001다음과 같습니다.

    ######
  ####      #
0011222222001

입력은 공백 / 쉼표로 구분 된 문자열, 정수 배열 또는 함수 / 명령 줄 인수로 제공 될 수 있습니다. 블록 위치 (x 값)는 항상 정수 0 이상이고 너비는 항상 정수 1 이상이며 항상 하나 이상의 블록이 있습니다.

숫자가 아닌 문자 (예 :)로 구분 된 단일 문자열 "0, 0, 1, ...", 모든 숫자를 나열하는 단일 문자열 (예 : "001..."최대 높이는 9 이하 임) 또는 정수 배열로 출력 할 수 있습니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

테스트 사례 :

In                                   Out
---------------------------------------------------------
2 4 4 6 12 1                         0011222222001
0 5 9 1 6 4 2 5                      1133333222
0 5 9 1 2 5 6 4                      1122223333
0 5 2 5 6 4 9 1                      1122223334
20 1 20 1 20 1                       00000000000000000003
5 5                                  000011111
0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 4  123456789999

CJam, 34 30 바이트

Lq~2/{eeWf%e~_2$:).*:e>f*.e>}/

CJam 스타일의 배열로 입력되고, 문자열로 출력됩니다.

모든 테스트 사례를 실행하십시오.

다른 아이디어의 두 가지 변형이 있지만 현재 2 바이트 더 깁니다.

Lq~2/{_:\3$><0+:e>)aeez.*e_.e>}/
LQ~2/{_:\3$><0+:e>)aeez.+e~.e>}/

파이썬 3, 89

def f(a):
 h=[]
 while a:x,w,*a=a;h[:x+w]=(h+[0]*x)[:x]+[max(h[x:x+w]+[0])+1]*w
 return h

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

이 함수는 정수 목록을 가져 와서 반환합니다.

def f(a):                       # input as list of integers
  h=[]                          # list of heights
  while a:                      # while there's input left
    x,w,*a=a;                   # pop first 2 integers as x and w

    h[:x+w]=                    # change the heights between 0 and x+w
      (h+[0]*x)[:x]+            # left of x -> unchanged but padded with zeros
      [max(h[x:x+w]+[0])+1]*w   # between x and x+w -> set to the previous max + 1

  return h                      # return the list of heights

루비, 88 87 바이트

f=->i{o=[]
(s,l,*i=i
r=s...s+l
o[r]=[([*o[r]]+[0]).max+1]*l
o.map! &:to_i)while i[0]
o}

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

grc의 답변에서 영감을 얻었지만 다른 언어로 약간 짧았습니다.

설명:

f=->i                        # lambda with parameter i, expects array of ints
{
    o=[]                     # output
    (
        s,l,*i=i             # pop start and length
        r = s...s+l          # range is used twice, so shorten it to 1 char
        o[r] =
            [(
                    [*o[r]]  # o[r] returns nil if out of bounds, so splat it into another array
                    +[0]     # max doesn't like an empty array, so give it at least a 0
            ).max+1]*l       # repeat max+1 to fill length
        o.map! &:to_i        # replace nil values with 0
    ) while i[0]             # i[0] returns nil when i is empty, which is falsy
    o                        # return o
}

APL, 79 바이트

{⊃{o←(z←(≢⍵)⌈a←+/⍺)↑⍵⋄e←(z↑(-a)↑⍺[1]⍴1)⋄o+0⌈o-⍨e×e⌈.+e×o}/⌽(⊂⍬),↓(⌽2,0.5×≢⍵)⍴⍵}

APL 배열로 입력하고 숫자의 APL 배열로 출력합니다.

자바 1.8, 351 329 바이트

이 첫 번째 시도에 감격하지 않았습니다. 더블 루핑이 확실하며 모든 Integer.valueOf의 골프를 더 할 수 있습니다.

interface B{static void main(String[]x){Byte b=1;int i=0,s,c,m=0,h,a=x.length,t[];for(;i<a;){s=b.valueOf(x[i++]);c=b.valueOf(x[i++]);m=m>s+c?m:s+c;}t=new int[m];for(i=0;i<a;){h=0;s=b.valueOf(x[i++]);c=b.valueOf(x[i++]);for(m=s;m<s+c;m++)if(t[m]>=h)h=t[m]+1;for(m=s;m<s+c;)t[m++]=h;}for(i=0;i<t.length;)System.out.print(t[i++]);}}

언 골프

interface B {
static void main(String[]x){
    int start, count, maxWidth=0, height, args=x.length, totals[];
    Byte b=1;
    for (int i=0; i<args;){
        start = b.valueOf(x[i++]);
        count = b.valueOf(x[i++]);
        maxWidth = maxWidth>start+count ? maxWidth : start+count; 
    }
    totals=new int[maxWidth];
    for (int i=0; i<args;){
        height=0;
        start = b.valueOf(x[i++]);
        count = b.valueOf(x[i++]);
        for (int j = start; j<start+count; j++) {
            if (totals[j]>=height) {
                height=totals[j]+1;
            }
        }
        for (int j = start; j<start+count; j++) {
            totals[j] = height;
        }
    }
    for (int i=0;i<totals.length; i++){
        System.out.print(totals[i]);
    }
}
}