Introducción

Este es un registro de longitud 5:

#####

Quiero apilar un montón de estos registros uno encima del otro. Cómo hago esto es que deslizo un nuevo registro en el superior desde la derecha, y dejo de deslizar cuando sus extremos izquierdo o derecho se alinean (no pregunte por qué). Si el nuevo registro es más largo, se desliza hasta el extremo izquierdo del registro superior:

########  <-
#####

Si es más corto, solo se desliza hasta que sus extremos derechos se alineen:

  ######  <-
########
#####

A medida que deslizo más registros en la pila, sus posiciones están determinadas por el registro más alto actual:

           ##
       ######
       ###
      ####
      ##
  ######
########
#####

Esto parece físicamente imposible, pero imaginemos que funciona.

La tarea

Su entrada será una lista no vacía de enteros positivos, que representa la longitud de mis registros. El número que está más a la izquierda es el primer registro que puse en la pila, por lo que termina en la parte inferior. En el ejemplo anterior, la entrada sería [5,8,6,2,4,3,6,2]. Su salida será, para cada columna de la pila resultante, el número de registros que cruzan esa columna. En el ejemplo anterior, la salida correcta sería [2,2,3,3,3,2,4,6,3,3,1,2,2].

Reglas y puntaje

La entrada y salida pueden estar en cualquier formato razonable. La salida solo puede contener enteros positivos, es decir, no debe tener 0s iniciales o finales . Se aplican las reglas normales de código de golf: puede escribir un programa completo o una función, gana el conteo de bytes más bajo y las lagunas estándar están prohibidas.

Casos de prueba

[1] -> [1]
[4] -> [1,1,1,1]
[3,2] -> [1,2,2]
[2,3] -> [2,2,1]
[2,2,2] -> [3,3]
[2,3,2] -> [2,3,2]
[3,2,3] -> [1,3,3,1]
[1,3,2,2,1,3,1] -> [2,3,5,1,2]
[4,3,4,2,4,3,4,2] -> [1,3,3,5,5,3,4,2]
[5,8,6,2,4,3,6,2] -> [2,2,3,3,3,2,4,6,3,3,1,2,2]
[5,10,15,1,1,1,1,1,2] -> [3,3,3,3,3,2,2,2,2,2,1,1,1,1,7,1]
[13,12,2,10,14,12] -> [1,2,2,2,2,2,2,2,2,2,2,5,5,3,3,3,3,3,3,3,3,2,2,2,2]
[12,14,3,6,13,1,1] -> [2,2,2,2,2,2,2,2,2,2,2,5,4,4,2,2,2,1,1,1,1,1,1,3]
[7,5,12,5,1,10,14,5] -> [1,1,3,3,3,3,3,1,1,2,2,2,2,5,2,2,2,2,2,2,2,2,3,2,2,2,2]
[14,5,1,3,12,6,2,2,1,7,9,15] -> [1,1,1,1,1,1,1,1,1,2,2,2,2,5,2,2,1,1,1,2,2,2,2,4,8,3,3,3,3,3,3,2,2,1,1,1,1,1,1]

Jalea ,  18  16 bytes

-2 bytes solicitados por la ayuda de millas

^{¿Quizás haya una forma más rápida de usar las matemáticas en lugar de la construcción como esta?}

IN0;»0+\0ẋ;"1ẋ$S

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

IN0;»0+\0ẋ;"1ẋ$S - Link: list of positive integers, logLengths  e.g. [4, 3, 3, 1, 4, 3]
I                - incremental differences                            [-1, 0,-2, 3,-1]
 N               - negate (vectorises)                                [ 1, 0, 2,-3, 1]
  0;             - zero concatenated with that                      [0, 1, 0, 2,-3, 1]
    »0           - maximum (vectorises) of that and zero            [0, 1, 0, 2, 0, 1]
      +\         - cumulative reduce with addition                  [0, 1, 1, 3, 3, 4]
        0ẋ       - zero repeated (vectorises)    [[],[0],[0],[0,0,0],[0,0,0],[0,0,0,0]]
              $  - last two links as a monad (right is implicitly logLengths):
            1ẋ   -   one repeated     [[1,1,1,1],[1,1,1],[1,1,1],[1],[1,1,1,1],[1,1,1]]
           "     - zip with:
          ;      -   concatenation
              [[1,1,1,1],[0,1,1,1],[0,1,1,1],[0,0,0,1],[0,0,0,1,1,1,1],[0,0,0,0,1,1,1]]
              ... this is an upside-down version of the logs like those in the OP
                  with 0 for spaces and 1 for # with any right-hand-side spaces missing.
               S - sum                                           [1, 3, 3, 5, 2, 2, 2]

Jalea , 19 13 bytes

IN0»0;+\+"RṬS

Pruébalo en línea!

Guardado 2 bytes gracias a @Jonathan Allan.

Explicación

IN0»0;+\+"RṬS  Input: array A
I              Increments
 N             Negate
  0»           Max with 0
    0;         Prepend 0
      +\       Cumulative sum
        +"     Vectorized add with
          R    Range, vectorizes over each integer
           Ṭ   Create a list with 1's at the specified indices
            S  Sum

Python 3 , 114 109 bytes

Editar: Guardado 5 bytes gracias a @ Mr.Xcoder

f=lambda x,i=1:x[i:]and x[i]>=x[~-i]and f(x,i+1)or[i]+f([q-(e<i)for e,q in enumerate(x)if(e<i)<q])if x else[]

Pruébalo en línea!

Casco , 16 bytes

Fż+Ṡzo`Ṙ↔ḋ2eo∫Ẋ<

Pruébalo en línea!

Explicación

              Ẋ    For all adjacent pairs, x y
               <   return max(0,x-y)
            o∫     Cumulative sum, with an extra 0 at the start
   Ṡz              Zip the input list and ^ with ...
           e         Make a two element list
        ↔ḋ2          The list [0,1]
     o`Ṙ             Repeat each in ^ by ^^
Fż+               Sum the columns

Perl 5 , 64 + 1 ( -a) = 65 bytes

for(@F){$e<$s+--$_?$e=$s+$_:($s=$e-$_);$_++for@r[$s..$e]}say"@r"

Pruébalo en línea!

Mathematica, 76 60 58 57 bytes

#2&@@@Tally[l=j=0;##&@@(Range@#+(j+=Ramp[l-(l=#)]))&/@#]&

Pruébalo en Wolfram Sandbox

Kotlin 1.1, 113103 bytes

{var l=0
var r=0
it.flatMap{l=maxOf(l,r-it+1)
r=l+it-1
(l..r).toList()}.groupBy{it}.map{it.value.size}}

Embellecido

{
    // Current row leftmost value
    var l = 0
    // Current row rightmost value
    var r = 0
    // For each log
    it.flatMap {
        // Work out the new leftmost point
        l = maxOf(
                l,
                r - it+1)
        // Use it to work out the new rightmost point
        r = l + it-1
        // Record the used columns
        (l..r).toList()}
            // Group the column numbers together
            .groupBy { it }
            // Count the amount of times each column is used
            // Put the results into a list
            .map { it.value.size }
}

Prueba

var z:(List<Int>)->List<Int> =
{var l=0
var r=0
it.flatMap{l=maxOf(l,r-it+1)
r=l+it-1
(l..r).toList()}.groupBy{it}.map{it.value.size}}

fun main(args: Array<String>) {
    println(z(listOf(5, 8, 6, 2, 4, 3, 6, 2)))
    println(listOf(2,2,3,3,3,2,4,6,3,3,1,2,2))
}