Giới thiệu

Đây là nhật ký có độ dài 5:

#####

Tôi muốn chồng một đống các bản ghi này lên nhau. Cách tôi làm điều này là tôi trượt một bản ghi mới lên trên cùng trên cùng từ bên phải và dừng trượt khi kết thúc bên trái hoặc bên phải của chúng thẳng hàng (đừng hỏi tại sao). Nếu nhật ký mới dài hơn, nó sẽ trượt hết về phía bên trái của nhật ký trên cùng:

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

Nếu nó ngắn hơn, nó chỉ trượt cho đến khi kết thúc bên phải của chúng thẳng hàng:

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

Khi tôi trượt thêm các bản ghi vào đống, vị trí của chúng được xác định bởi nhật ký trên cùng hiện tại:

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

Điều này có vẻ không thể, nhưng hãy giả vờ nó hoạt động.

Nhiệm vụ

Đầu vào của bạn sẽ là một danh sách không có các số nguyên dương, biểu thị độ dài của nhật ký của tôi. Số ngoài cùng bên trái là nhật ký đầu tiên tôi đặt vào cọc, vì vậy nó kết thúc ở phía dưới. Trong ví dụ trên, đầu vào sẽ là [5,8,6,2,4,3,6,2]. Đầu ra của bạn sẽ là, cho mỗi cột của cọc kết quả, số lượng các bản ghi vượt qua cột đó. Trong ví dụ trên, đầu ra chính xác sẽ là [2,2,3,3,3,2,4,6,3,3,1,2,2].

Quy tắc và tính điểm

Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý. Đầu ra chỉ có thể chứa các số nguyên dương, tức là nó không được có 0s dẫn đầu hoặc dấu . Quy tắc golf-code thông thường được áp dụng: bạn có thể viết một chương trình đầy đủ hoặc một hàm, số byte thấp nhất sẽ thắng và các lỗ hổng tiêu chuẩn bị cấm.

Các trường hợp thử nghiệm

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

Thạch ,  18  16 byte

-2 byte thúc đẩy bởi sự giúp đỡ từ dặm

^{Có lẽ có một cách nhanh hơn sử dụng toán học hơn là xây dựng như thế này?}

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

Hãy thử trực tuyến! hoặc xem bộ thử nghiệm .

Làm sao?

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]

Thạch , 19 13 byte

IN0»0;+\+"RṬS

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ @Jonathan Allan.

Giải trình

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

Chỉnh sửa: Đã lưu 5 byte nhờ @ 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[]

Hãy thử trực tuyến!

Husk , 16 byte

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

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Toán học, 76 60 58 57 byte

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

Dùng thử trên 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}}

Làm đẹp

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

Kiểm tra

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