introduction

Ceci est un journal de longueur 5:

#####

Je veux empiler un tas de ces journaux les uns sur les autres. Pour ce faire, je glisse une nouvelle bûche sur la plus haute à partir de la droite et arrête de glisser lorsque leurs extrémités gauche ou droite s'alignent (ne demandez pas pourquoi). Si le nouveau journal est plus long, il glisse jusqu'à l'extrémité gauche du journal le plus haut:

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

S'il est plus court, il ne glisse que jusqu'à ce que leurs extrémités droites s'alignent:

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

Lorsque je glisse plus de bûches dans la pile, leurs positions sont déterminées par la bûche la plus élevée actuelle:

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

Cela semble physiquement impossible, mais supposons que cela fonctionne.

La tâche

Votre entrée doit être une liste non vide d'entiers positifs, représentant la longueur de mes journaux. Le nombre le plus à gauche est le premier rondin que j'ai mis dans la pile, il finit donc en bas. Dans l'exemple ci-dessus, l'entrée serait [5,8,6,2,4,3,6,2]. Votre sortie sera, pour chaque colonne de la pile résultante, le nombre de journaux qui traversent cette colonne. Dans l'exemple ci-dessus, la sortie correcte serait [2,2,3,3,3,2,4,6,3,3,1,2,2].

Règles et notation

L'entrée et la sortie peuvent être dans n'importe quel format raisonnable. La sortie ne peut contenir que des entiers positifs, c'est-à-dire qu'elle ne doit pas avoir de 0s de début ou de fin . Les règles de code-golf normales s'appliquent: vous pouvez écrire un programme complet ou une fonction, le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Cas de 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]

Gelée ,  18  16 octets

-2 octets provoqués par l'aide de miles

^{Peut-être existe-t-il un moyen plus rapide d'utiliser les mathématiques plutôt que la construction comme celle-ci?}

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

Essayez-le en ligne! ou voir la suite de tests .

Comment?

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]

Gelée , 19 13 octets

IN0»0;+\+"RṬS

Essayez-le en ligne!

Enregistré 2 octets grâce à @Jonathan Allan.

Explication

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 octets

Edit: 5 octets enregistrés grâce à @ 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[]

Essayez-le en ligne!

Husk , 16 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Mathematica, 76 60 58 57 octets

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

Essayez-le sur Wolfram Sandbox

Kotlin 1.1, 113 103 octets

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

Embellie

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

Tester

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