pengantar

Ini adalah log dengan panjang 5:

#####

Saya ingin menumpuk banyak log ini di atas satu sama lain. Cara saya melakukan ini adalah saya menggeser log baru ke atas dari kanan, dan berhenti meluncur ketika ujung kiri atau kanannya sejajar (jangan tanya kenapa). Jika log baru lebih panjang, ia meluncur ke ujung kiri dari log paling atas:

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

Jika lebih pendek, hanya meluncur sampai ujung kanannya rata:

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

Saat saya memasukkan lebih banyak log ke tumpukan, posisi mereka ditentukan oleh log teratas saat ini:

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

Ini terlihat mustahil secara fisik, tetapi mari kita anggap itu berhasil.

Tugas

Input Anda harus berupa daftar bilangan bulat positif yang tidak kosong, yang mewakili panjang log saya. Angka paling kiri adalah log pertama yang saya masukkan ke tumpukan, sehingga berakhir di bagian bawah. Pada contoh di atas, inputnya adalah [5,8,6,2,4,3,6,2]. Output Anda akan, untuk setiap kolom tumpukan yang dihasilkan, jumlah log yang melintasi kolom itu. Pada contoh di atas, output yang benar adalah [2,2,3,3,3,2,4,6,3,3,1,2,2].

Aturan dan penilaian

Input dan output dapat dalam format apa pun yang masuk akal. Output hanya dapat berisi bilangan bulat positif, artinya tidak boleh memiliki leading atau trailing 0s. Aturan kode-golf normal berlaku: Anda dapat menulis program atau fungsi lengkap, jumlah byte terendah menang, dan celah standar dilarang.

Uji kasus

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

-2 byte diminta oleh bantuan dari mil

^{Mungkin ada cara yang lebih cepat menggunakan matematika daripada konstruksi seperti ini?}

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

Cobalah online! atau lihat test-suite .

Bagaimana?

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 byte

IN0»0;+\+"RṬS

Cobalah online!

Disimpan 2 byte berkat @Jonathan Allan.

Penjelasan

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

Sunting: Disimpan 5 byte berkat @ 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[]

Cobalah online!

Sekam , 16 byte

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

Cobalah online!

Penjelasan

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

Cobalah online!

Mathematica, 76 60 58 57 byte

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

Cobalah di 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}}

Yg diperindahkan

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

Uji

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