소개

이것은 길이가 5 인 로그입니다.

#####

이 통나무를 서로 쌓아 놓고 싶습니다. 이 작업을 수행하는 방법은 새 로그를 오른쪽에서 가장 위쪽으로 밀고 왼쪽 또는 오른쪽 끝이 정렬되면 슬라이딩을 중지합니다 (이유 묻지 않음). 새 로그가 더 길면 맨 위 로그의 왼쪽 끝까지 밉니다.

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

더 짧은 경우 오른쪽 끝이 정렬 될 때까지만 슬라이드됩니다.

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

더 많은 로그를 파일에 밀어 넣으면 해당 위치는 현재 최상위 로그에 의해 결정됩니다.

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

이것은 물리적으로 불가능 해 보이지만 작동한다고 가정 해 봅시다.

작업

귀하의 입력은 내 로그의 길이를 나타내는 비어 있지 않은 양의 정수 목록이어야합니다. 가장 왼쪽의 숫자는 내가 더미에 넣은 첫 번째 로그이므로 맨 아래에 있습니다. 위의 예에서 입력은입니다 [5,8,6,2,4,3,6,2]. 결과 파일의 각 열에 대해 해당 열을 가로 지르는 로그 수가 출력됩니다. 위의 예에서 올바른 출력은입니다 [2,2,3,3,3,2,4,6,3,3,1,2,2].

규칙과 득점

입력 및 출력은 임의의 합리적인 형식 일 수 있습니다. 출력은 양의 정수만 포함 할 수 있습니다. 즉, 선행 또는 후행이 없어야합니다 0. 일반적인 코드 골프 규칙이 적용됩니다. 전체 프로그램 또는 함수를 작성할 수 있으며, 가장 적은 바이트 수로 이기고 표준 허점 은 금지됩니다.

테스트 사례

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

젤리 ,  18  16 바이트

마일의 도움으로 프롬프트 된 -2 바이트

^{어쩌면 이와 같이 구성보다는 수학을 사용하는 더 빠른 방법이 있습니까?}

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

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

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]

젤리 , 19 13 바이트

IN0»0;+\+"RṬS

온라인으로 사용해보십시오!

@Jonathan Allan 덕분에 2 바이트를 절약했습니다.

설명

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

파이썬 (3) , 114 (109) 바이트

편집 : @ Mr.Xcoder 덕분에 5 바이트가 절약되었습니다.

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

온라인으로 사용해보십시오!

껍질 , 16 바이트

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

온라인으로 사용해보십시오!

설명

              Ẋ    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 바이트

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

온라인으로 사용해보십시오!

Mathematica, 76 60 58 57 바이트

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

Wolfram Sandbox에서 사용해보십시오

코 틀린 1.1, 113 103 바이트

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

미화

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

테스트

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