Giriş

Bu uzunluk 5'in bir günlüğüdür:

#####

Bu kütüklerin bir demetini üst üste koymak istiyorum. Bunu nasıl yapacağım, yeni bir günlüğü sağdan en üstteki günlüğe kaydırmam ve sol veya sağ uçları hizalandığında kaymayı bırakmam (nedenini sorma). Yeni günlük daha uzunsa, en üstteki günlüğün sol ucuna kadar kayar:

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

Daha kısa ise, yalnızca sağ uçları hizalanana kadar kayar:

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

Kazığa daha fazla günlük kaydırdığımda, konumları geçerli en üstteki günlük tarafından belirlenir:

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

Bu fiziksel olarak imkansız görünüyor, ama işe yarıyormuş gibi yapalım.

Görev

Girişiniz, günlüklerimin uzunluklarını temsil eden boş olmayan bir pozitif tamsayı listesi olmalıdır. En soldaki sayı, kazığa koyduğum ilk günlüktür, bu yüzden en altta biter. Yukarıdaki örnekte, girdi olacaktır [5,8,6,2,4,3,6,2]. Çıktınız, elde edilen yığının her bir sütunu için, bu sütunu geçen günlüklerin sayısı olacaktır. Yukarıdaki örnekte, doğru çıktı olacaktır [2,2,3,3,3,2,4,6,3,3,1,2,2].

Kurallar ve puanlama

Giriş ve çıkış herhangi bir makul formatta olabilir. Çıktı yalnızca pozitif tamsayılar içerebilir, yani öndeki veya sondaki s'ler olmamalıdır 0. Normal kod golf kuralları geçerlidir: tam bir program veya işlev yazabilirsiniz, en düşük bayt sayısı kazanır ve standart boşluklar yasaktır.

Test senaryoları

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

Jöle ,  18  16 bayt

-2 yardımıyla tarafından istendiğinde bayt mil

^{Belki de bunun gibi inşaattan ziyade matematiği kullanmanın daha hızlı bir yolu vardır?}

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

Çevrimiçi deneyin! veya test takımına bakın .

Nasıl?

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]

Jöle , 19 13 bayt

IN0»0;+\+"RṬS

Çevrimiçi deneyin!

@Jonathan Allan sayesinde 2 bayt kaydedildi.

açıklama

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 , 114109 bayt

Düzenleme: @ Mr.Xcoder sayesinde 5 bayt tasarruf edildi

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

Çevrimiçi deneyin!

Kabuk , 16 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Mathematica, 76 60 58 57 bayt

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

Wolfram Sandbox'ta deneyin

Kotlin 1.1, 113 103 bayt

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

Beautified

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

Ölçek

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