introduzione

Questo è un registro di lunghezza 5:

#####

Voglio impilare un mucchio di questi ceppi uno sopra l'altro. In questo modo faccio scorrere un nuovo registro su quello più in alto da destra e smetto di scivolare quando le loro estremità sinistra o destra sono allineate (non chiedere perché). Se il nuovo registro è più lungo, scorre fino all'estremità sinistra del registro più in alto:

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

Se è più corto, scorre solo fino a quando le estremità destra non si allineano:

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

Mentre faccio scorrere più tronchi nella pila, le loro posizioni sono determinate dal registro più in alto corrente:

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

Sembra fisicamente impossibile, ma facciamo finta che funzioni.

L'obiettivo

Il tuo input deve essere un elenco non vuoto di numeri interi positivi, che rappresentano le lunghezze dei miei registri. Il numero più a sinistra è il primo registro che ho inserito nella pila, quindi finisce in fondo. Nell'esempio sopra, l'input sarebbe [5,8,6,2,4,3,6,2]. L'output deve essere, per ogni colonna della pila risultante, il numero di tronchi che attraversano quella colonna. Nell'esempio sopra, l'output corretto sarebbe [2,2,3,3,3,2,4,6,3,3,1,2,2].

Regole e punteggio

L'input e l'output possono essere in qualsiasi formato ragionevole. L'output può contenere solo numeri interi positivi, ovvero non deve avere 0s iniziali o finali . Si applicano le normali regole del code-golf: è possibile scrivere un programma completo o una funzione, il conteggio dei byte più basso vince e le scappatoie standard sono vietate.

Casi test

[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]

Gelatina ,  18  16 byte

-2 byte richiesti dall'aiuto da miglia

^{Forse c'è un modo più rapido di usare la matematica piuttosto che la costruzione come questa?}

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

Provalo online! o vedi la suite di test .

Come?

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]

Gelatina , 19 13 byte

IN0»0;+\+"RṬS

Provalo online!

Salvato 2 byte grazie a @Jonathan Allan.

Spiegazione

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 byte

Modifica: salvato 5 byte grazie 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[]

Provalo online!

Buccia , 16 byte

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

Provalo online!

Spiegazione

              Ẋ    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 byte

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

Provalo online!

Mathematica, 76 60 58 57 byte

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

Provalo su Wolfram Sandbox

Kotlin 1.1, 113 103 byte

{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}}

Abbellire

{
    // 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 }
}

Test

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