Einführung

Dies ist ein Protokoll der Länge 5:

#####

Ich möchte einen Haufen dieser Protokolle übereinander stapeln. So schiebe ich einen neuen Baumstamm von rechts nach oben und höre auf zu schieben, wenn die linken oder rechten Enden ausgerichtet sind (fragen Sie nicht warum). Wenn das neue Protokoll länger ist, wird es bis zum linken Ende des obersten Protokolls verschoben:

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

Wenn es kürzer ist, wird es nur so lange verschoben, bis die rechten Enden ausgerichtet sind:

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

Wenn ich mehr Stämme in den Stapel schiebe, werden ihre Positionen durch das aktuell oberste Protokoll bestimmt:

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

Das sieht physikalisch unmöglich aus, aber tun wir mal so, als ob es funktioniert.

Die Aufgabe

Ihre Eingabe muss eine nicht leere Liste positiver Ganzzahlen sein, die die Länge meiner Protokolle darstellt. Die am weitesten links stehende Zahl ist das erste Holz, das ich auf den Stapel gelegt habe, sodass es unten landet. Im obigen Beispiel wäre die Eingabe [5,8,6,2,4,3,6,2]. Ihre Ausgabe ist für jede Spalte des resultierenden Stapels die Anzahl der Protokolle, die diese Spalte überschreiten. Im obigen Beispiel wäre die richtige Ausgabe [2,2,3,3,3,2,4,6,3,3,1,2,2].

Regeln und Wertung

Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen. Die Ausgabe kann nur positive Ganzzahlen enthalten, dh sie darf keine führenden oder nachfolgenden 0s enthalten. Es gelten die üblichen Code-Golf-Regeln: Sie können ein vollständiges Programm oder eine Funktion schreiben, die niedrigste Byte-Anzahl gewinnt und Standard-Lücken sind verboten.

Testfälle

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

Jelly ,  18  16 Bytes

-2 Bytes durch Hilfe von Meilen aufgefordert

^{Vielleicht gibt es einen schnelleren Weg, Mathematik zu verwenden, als solche Konstruktionen?}

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

Probieren Sie es online! oder sehen Sie sich die Testsuite an .

Wie?

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]

Jelly , 19 13 Bytes

IN0»0;+\+"RṬS

Probieren Sie es online!

2 Bytes dank @Jonathan Allan gespeichert.

Erläuterung

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

Bearbeiten: 5 Bytes dank @ Mr.Xcoder gespeichert

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

Probieren Sie es online!

Schale , 16 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Mathematica, 76 60 58 57 Bytes

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

Probieren Sie es auf Wolfram Sandbox

Kotlin 1.1, 113 103 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}}

Verschönert

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

Prüfung

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