Bloques de apilamiento

Dada una entrada de una lista de bloques para soltar en ciertos puntos, genera la altura de la "torre" resultante.

La mejor manera de explicar este desafío es con el ejemplo. La entrada será una lista de 2n enteros que representan n bloques. El primer entero es la posición x del bloque, indexado en 0, y el segundo es qué tan ancho es el bloque. Por ejemplo, una entrada de 2 4representa el bloque (con las coordenadas x etiquetadas a continuación):

  ####
0123456789

Ahora, digamos que la entrada es 2 4 4 6. Es decir, un bloque en x = 2 con un ancho de 4, y uno en x = 4 con un ancho de 6:

    ######
  ####

Tenga en cuenta que a.) Los bloques siempre "caen" desde la parte superior de la torre yb.) Los bloques nunca "se caerán" (es decir, siempre se equilibrarán). Entonces, una entrada de 2 4 4 6 12 1representa:

    ######
  ####      #

Tenga en cuenta que el bloque final ha caído hasta el "suelo".

Su salida final debe ser la altura máxima de la torre en cada valor de x hasta el más grande. Por lo tanto, la entrada 2 4 4 6 12 1debería dar como resultado la salida 0011222222001:

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

La entrada puede darse como una cadena separada por comas / espacios en blanco, una matriz de enteros o argumentos de línea de función / comando. Las posiciones de bloque (valores x) siempre serán enteros 0 o mayores, el ancho siempre será un entero 1 o mayor, y siempre habrá al menos un bloque.

La salida se puede dar como una sola cadena separada por caracteres no numéricos (ej. "0, 0, 1, ..."), Una sola cadena que enumera todos los dígitos (ej. "001...", La altura máxima se garantiza que sea 9 o menos), o una matriz de enteros.

Como se trata de código golf , el código más corto en bytes ganará.

Casos de prueba:

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 bytes

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

Entrada como una matriz de estilo CJam, salida como una cadena de dígitos.

Ejecute todos los casos de prueba.

Aquí hay dos variantes de otra idea, pero actualmente es 2 bytes más larga:

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

Pitón 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

Pruébalo en línea .

La función toma y devuelve una lista de enteros.

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

Rubí, 88 87 bytes

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}

Pruébalo en línea.

Inspirado por la respuesta de grc, pero en un idioma diferente y solo un poco más corto.

Explicación:

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 bytes

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

Entrada como una matriz APL, salida como una matriz APL de dígitos.

Java 1.8, 351 329 bytes

No estoy emocionado con este primer intento: estoy seguro de que el doble bucle y todos esos Integer.valueOf se pueden jugar un poco más.

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++]);}}

Sin golf

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]);
    }
}
}