Wprowadzenie

To jest dziennik o długości 5:

#####

Chcę ułożyć kilka takich dzienników jeden na drugim. Jak to robię, wsuwam nowy dziennik na najwyższy z prawej strony i przestaję ślizgać się, gdy jego lewy lub prawy koniec są wyrównane (nie pytaj dlaczego). Jeśli nowy dziennik jest dłuższy, przesuwa się do lewego końca najwyższego dziennika:

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

Jeśli jest krótszy, przesuwa się tylko do momentu wyrównania jego prawego końca:

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

Gdy wsuwam kolejne kłody na stos, ich pozycje są określane przez bieżący najwyższy dziennik:

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

Wygląda to fizycznie niemożliwe, ale udawajmy, że działa.

Zadanie

Twój wkład będzie niepustą listą liczb całkowitych dodatnich, reprezentujących długości moich logów. Najbardziej wysunięta na lewo liczba to pierwszy dziennik, który wkładam na stos, więc kończy się na dole. W powyższym przykładzie dane wejściowe to [5,8,6,2,4,3,6,2]. Twój wynik powinien wynosić, dla każdej kolumny wynikowego stosu, liczbę kłód przecinających tę kolumnę. W powyższym przykładzie poprawne wyjście to[2,2,3,3,3,2,4,6,3,3,1,2,2] .

Zasady i punktacja

Dane wejściowe i wyjściowe mogą być w dowolnym rozsądnym formacie. Dane wyjściowe mogą zawierać tylko dodatnie liczby całkowite, tzn. Nie mogą mieć wiodących ani końcowych 0s. Obowiązują normalne zasady gry w golfa: możesz napisać pełny program lub funkcję, wygrywa najmniej bajtów, a standardowe luki są zabronione.

Przypadki testowe

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

Galaretka ,  18  16 bajtów

-2 bajty monitowane przez pomoc z odległości

^{Może istnieje szybszy sposób korzystania z matematyki niż z konstrukcji takiej jak ta?}

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

Wypróbuj online! lub zobacz zestaw testowy .

W jaki sposób?

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]

Galaretka , 19 13 bajtów

IN0»0;+\+"RṬS

Wypróbuj online!

Zaoszczędź 2 bajty dzięki @Jonathan Allan.

Wyjaśnienie

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 bajtów

Edycja: Zapisano 5 bajtów dzięki @ 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[]

Wypróbuj online!

Łuska , 16 bajtów

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

Wypróbuj online!

Wyjaśnienie

              Ẋ    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 bajtów

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

Wypróbuj online!

Mathematica, 76 60 58 57 bajtów

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

Wypróbuj na Wolfram Sandbox

Kotlin 1.1, 113 103 bajtów

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

Upiększony

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