লগের একটি গাদা পরিমাপ

Question

ভূমিকা

এটি দৈর্ঘ্যের লগ 5:

#####

আমি একে অপরের উপরে এই লগের একগুচ্ছ গাদা করতে চাই। আমি এটি কীভাবে করব তা হল ডান দিক থেকে শীর্ষের উপরে একটি নতুন লগটি স্লাইড করা, এবং যখন তাদের বাম বা ডান প্রান্তটি সরে যায় তখন স্লাইডিং বন্ধ করুন (কেন জিজ্ঞাসা করবেন না)। যদি নতুন লগ দীর্ঘ হয়, তবে এটি শীর্ষে লগের বাম প্রান্তে সমস্ত দিক স্লাইড করে:

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

যদি এটি খাটো হয় তবে এটি কেবল ডান প্রান্তে প্রান্তিক হওয়া পর্যন্ত স্লাইড হয়:

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

আমি পুলে আরও লগগুলি স্লাইড করার সাথে সাথে তাদের অবস্থানগুলি বর্তমান শীর্ষতম লগ দ্বারা নির্ধারিত হয়:

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

এটি শারীরিকভাবে অসম্ভব বলে মনে হচ্ছে, তবে আসুন এটি ভান করে tend

কাজটি

আপনার ইনপুটটি আমার লগগুলির দৈর্ঘ্যের প্রতিনিধিত্ব করে ধনাত্মক পূর্ণসংখ্যার একটি খালি খালি তালিকা হবে। বামতম সংখ্যাটি হ'ল প্রথম লগ আমি স্তূপে রেখেছি, তাই এটি নীচে শেষ হয়। উপরের উদাহরণে ইনপুটটি হবে [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]

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 বাইট

সম্পাদনা: @ মিস্টার এক্সকোডারকে 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))
}