लॉग के ढेर को मापने

Question

परिचय

यह लंबाई 5 का एक लॉग है:

#####

मैं एक दूसरे के ऊपर इन लॉग का एक गुच्छा ढेर करना चाहता हूं। मैं यह कैसे कर सकता हूं कि मैं दाईं ओर से सबसे ऊपर एक नए लॉग को स्लाइड करता हूं, और जब उनके बाएं या दाएं छोर संरेखित करते हैं (तब क्यों नहीं पूछते हैं) स्लाइड करना बंद करें। यदि नया लॉग लंबा है, तो यह सबसे ऊपरी लॉग के बाईं ओर के सभी मार्ग को स्लाइड करता है:

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

यदि यह छोटा है, तो यह केवल तब तक स्लाइड करता है जब तक कि उनका दाहिना छोर संरेखित न हो जाए:

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

जैसे ही मैं ढेर में अधिक लॉग स्लाइड करता हूं, उनकी स्थिति वर्तमान शीर्ष लॉग द्वारा निर्धारित की जाती है:

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

यह शारीरिक रूप से असंभव दिखता है, लेकिन चलो यह काम करता है का नाटक करते हैं।

काम

आपका इनपुट सकारात्मक पूर्णांकों की एक गैर-रिक्त सूची होगी, जो मेरे लॉग की लंबाई का प्रतिनिधित्व करेगा। सबसे बाईं संख्या पहला लॉग है जिसे मैंने ढेर में रखा है, इसलिए यह नीचे से समाप्त होता है। उपरोक्त उदाहरण में, इनपुट होगा [5,8,6,2,4,3,6,2]। आपका आउटपुट परिणामी ढेर के प्रत्येक कॉलम के लिए होगा, उस कॉलम को पार करने वाले लॉग की संख्या। उपरोक्त उदाहरण में, सही आउटपुट होगा [2,2,3,3,3,2,4,6,3,3,1,2,2]।

नियम और स्कोरिंग

इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं। आउटपुट में केवल धनात्मक पूर्णांक हो सकते हैं, अर्थात इसमें अग्रणी या अनुगामी 0s नहीं होना चाहिए । सामान्य कोड-गोल्फ नियम लागू होते हैं: आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं, सबसे कम बाइट गिनती जीतता है, और मानक कमियां निषिद्ध हैं।

परीक्षण के मामलों

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

Comments

हम इसे आसानी से "काम" कर सकते हैं, यह केवल जमीन पर उन सभी को हवा में ढेर करने के बजाय (उन्हें एक दूसरे के बगल में खिसकाकर) काम करता है।

— जोनाथन एलन

वो आखिरी टेस्ट केस नॉर्वे जैसा दिखता है!

— स्टीवी ग्रिफिन

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

Comments

हम 17 बाइट्स प्राप्त कर सकते हैं यदि हम अपने समाधानों को जोड़ते हैं:IN»0+\0;;"x@€0,1S

— मील

Answer 2

जेली , 19 13 बाइट्स

IN0»0;+\+"RṬS

इसे ऑनलाइन आज़माएं!

@ जोनाथन एलन को 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

Answer 3

पायथन 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[]

इसे ऑनलाइन आज़माएं!

Comments

109 बाइट्स

— मिस्टर एक्सकोडर

Answer 4

भूसी , 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

Answer 5

पर्ल 5 , 64 + 1 ( -a) = 65 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 6

गणितज्ञ, 76 60 58 57 बाइट्स

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

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

Answer 7

कोटलिन 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))
}