ब्रश स्ट्रोक के साथ एक स्काईलाइन को कवर करना

Question

एक गैर-नकारात्मक पूर्णांक क्षितिज की ऊंचाई सूची को देखते हुए, उत्तर दें कि इसे कवर करने के लिए कितने निर्बाध 1-यूनिट-उच्च क्षैतिज ब्रश स्ट्रोक की आवश्यकता होती है।

[1,3,2,1,2,1,5,3,3,4,2], कल्पना के रूप में:

      5    
      5  4 
 3    5334 
 32 2 53342
13212153342

नौ ब्रश स्ट्रोक की जरूरत है:

      1    
      2  3 
 4    5555 
 66 7 88888
99999999999

उदाहरण

[1,3,2,1,2,1,5,3,3,4,2] → 9

[5,8] → 8

[1,1,1,1] → 1

[] → 0

[0,0] → 0

[2] → 2

[2,0,2] → 4

[10,9,8,9] → 11

Comments

रुचि उच्च प्रतिनिधि उपयोगकर्ताओं के लिए: के आधार पर इस के अनुसार यह ।

— शाम

तो, सभी ब्रश स्ट्रोक क्षैतिज हैं?

— tsh

@ सत् शुभ बिंदु। जोड़ा गया।

— प्रवेश

यह कोड कोड नहीं था, लेकिन मेरे पास एक साल पहले एक साक्षात्कार कोड परीक्षण के लिए यह प्रश्न था।

— luizfzs

Answer 1

जावास्क्रिप्ट (Node.js) , 38 बाइट्स

a=>a.map(v=>(n+=v>p&&v-p,p=v),p=n=0)|n

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

बस एक लालची एल्गोरिथ्म जो बाईं से दाईं ओर स्कैन करता है, यदि आवश्यक हो तो केवल लाइनें खींचें और इसे यथासंभव लंबे समय तक खींचें।

धन्यवाद अर्नुल्ड, 2 3 बाइट्स बचाएं

Comments

@ अर्नुलद अच्छा कैच। बिलकुल भूल गया।

— tsh

आपको इसका एहसास कैसे हुआ?

— एडम

@ Adám कुछ नहीं जादू। पहली बार जब मैंने प्रश्न को पढ़ा तो मैं उलझन में था कि कैसे खोजा जाए जब तक मुझे एहसास न हो कि सभी लाइनें केवल क्षैतिज हैं। और फिर यह सूत्र मेरे दिमाग में स्वाभाविक रूप से आया ....

— tsh

जादू उस प्रक्रिया का वर्णन करने के लिए एक अच्छी तरह से फिटिंग शब्द की तरह लगता है।

— 13:

हालांकि यह अब व्यापक रूप से उपयोग किए जाने वाले एल्गोरिथ्म का मूल है, इसे यहां समझाया गया है ।

— आदम

Answer 2

05AB1E ,  8 7  5 बाइट्स

@ Adnan के लिए 2 बाइट्स को सहेजा गया

0š¥þO

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

कैसे?

यह उस एल्गोरिथ्म का उपयोग कर रहा है जो पहली बार @tsh द्वारा पाया गया था । यदि आप इस उत्तर को पसंद करते हैं, तो उनके उत्तर को भी सुनिश्चित करें !

हर बार एक गगनचुंबी इमारत पिछले एक की तुलना में कम या अधिक होती है, इसे बस ब्रशस्ट्रोक का विस्तार करके 'मुफ्त में' चित्रित किया जा सकता है।

उदाहरण के लिए, गगनचुंबी इमारतों $B$ और $C$ नीचे चित्र में लागत कुछ भी नहीं है।

$E$

पहली गगनचुंबी इमारत के लिए, हमें हमेशा उतने ही ब्रशस्ट्रोक की जरूरत होती है, जितनी कि उसमें फर्श होते हैं।

इसे गणित में बदलना:

$$S=h_0+\sum_{i=1}^n \max(h_i-h_{i-1},0)$$

यदि हम सूची में को प्रस्तुत करते हैं, तो इसे सरल बनाया जा सकता है:$0$

$$S=\sum_{i=1}^n \max(h_i-h_{i-1},0)$$

टिप्पणी की गई

0š¥þO     # expects a list of non-negative integers  e.g. [10, 9, 8, 9]
0š        # prepend 0 to the list                    -->  [0, 10, 9, 8, 9]
  ¥       # compute deltas                           -->  [10, -1, -1, 1]
   þ      # keep only values made of decimal digits
          # (i.e. without a minus sign)              -->  ["10", "1"]
    O     # sum                                      -->  11

Comments

मुझे लगता 0š¥ʒd}Oहै कि आप एक बाइट बचाता है।

— श्री एक्सकोडर

@ Dobeax-tripedot मैं अपने उत्तर को ठीक उसी तरह संपादित कर रहा था जब मैंने आपकी टिप्पणी देखी थी;)

— अरनॉल्ड

सुंदर व्याख्या।

— एडम

ʒd}साथ बदलने से þआपको दो बाइट्स बचानी चाहिए।

— अदनान

@ अदनान अह, अच्छा। धन्यवाद!

— Arnauld

Answer 3

पायथन 3 , 37 बाइट्स

lambda a:sum(a)-sum(map(min,a[1:],a))

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

_{-5 बाइट्स पायथन 3 पर स्विच करके, सरिएन के लिए धन्यवाद}

---

पायथन 2 , 47 43 42 बाइट्स

lambda a:sum(a)-sum(map(min,a[1:],a[:-1]))

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

Alt:

lambda a:sum(a)-sum(map(min,zip(a[1:],a)))

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

Comments

पायथन 3 में आप [5] को बचाते हुए [: -1] को खोद सकते हैं।

— १

@ सरियन धन्यवाद: डी, ​​मुझे नहीं पता था कि नक्शा अजगर 2 और 3 में अलग है

— TFeld

Answer 4

हास्केल , 32 बाइट्स

(0%)
p%(h:t)=max(h-p)0+h%t
p%_=0

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

लिन के समाधान पर एक सुधार pजो अगले तत्व को देखने के बजाय पिछले तत्व को ट्रैक करता है । यह आधार मामले और पुनरावर्ती कॉल को आह्वान करने की आवश्यकता के बदले कम बनाता है (0%)।

max(h-p)0max h p-pएक ही लंबाई के लिए हो सकता है ।

Answer 5

हास्केल , 35 बाइट्स

f(a:b:c)=max(a-b)0+f(b:c)
f a=sum a

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

f[a]=aअगर मैं भी मामले को संभालने के लिए नहीं था तो लाइन 2 हो सकती है []।

Comments

यहाँ कुछ प्रतियोगिता है ।

— गेहूं जादूगर

Answer 6

के (ओके) , 12 7 बाइट्स

-5 बाइट्स ngn के लिए धन्यवाद!

अरनुल्द के 05AB1E समाधान (और tsh के जावास्क्रिप्ट समाधान) का एक k ( oK ) पोर्ट:

+/0|-':

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

जे , 15 बाइट्स

अर्नुल्ड के 05AB1E समाधान (और tsh के जावास्क्रिप्ट समाधान) का AJ पोर्ट:

1#.0>./2-~/\0,]

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

मेरा भोला समाधान:

जे , 27 बाइट्स

1#.2(1 0-:])\0,@|:@,~1$~"0]

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

Comments

ओके: प्रत्येक पूर्व ( ':) सूची से पहले एक अंतर्निहित पहचान तत्व (के 0लिए -) का उपयोग करता है , इसलिए 0,अनावश्यक है। आप { x}इसे एक रचना बनाने के लिए छोड़ सकते हैं :+/0|-':

— ngn

@ng धन्यवाद! जाहिरा तौर पर मैं यह भूल गया हूँ:Some primitive verbs result in a different special-cased initial value: +, *, - and & are provided with 0, 1, 0 or the first element of the sequence, respectively

— इवानोव

Answer 7

हास्केल , 34 32 बाइट्स

लिन द्वारा छंटनी की गई 2 बाइट्स

g x=sum$max 0<$>zipWith(-)x(0:x)

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

तो शुरू करने के लिए हमारे पास है zipWith(-)। यह दो सूचियों को लेता है और उनके जोड़ीदार अंतरों की एक नई सूची तैयार करता है। हम फिर इसके साथ गठबंधन करते हैं xऔर (0:x)। (0:)एक ऐसा कार्य है जो किसी सूची के सामने शून्य को जोड़ता है और इसे जोड़कर zipWith(-)हम सामने वाले शून्य के साथ उस सूची के निरंतर तत्वों के बीच अंतर प्राप्त करते हैं। तब हम सभी नकारात्मक को शून्य में बदल देते हैं (max 0<$>)। यह एक नई सूची बनाता है जहां प्रत्येक तत्व नए स्ट्रोक की संख्या है जिसे प्रत्येक टॉवर पर शुरू किया जाना है। कुल प्राप्त करने के लिए हम इनका योग करते हैं sum।

Comments

g x=sum$max 0<$>zipWith(-)x(0:x)है 32 बाइट्स :)

— लिन

जैसा कि हैsum.zipWith((max 0.).(-))<*>(0:)

— लिन

@Lynn आपके दूसरे वाले को .पहले से अधिक होने के कारण अतिरिक्त कोष्ठक की आवश्यकता है <*>।

— गेहूं जादूगर

Answer 8

जाप , 8 बाइट्स

-2 @ बग्गी से बाइट्स

mîT Õ¸¸è

व्याख्या

mîT Õ¸¸è      Full program. Implicit input U
                e.g. U = [2,0,2]
mîT             Map each item X and repeat T(0) X times
                     U = ["00","","00"]
    Õ           Transpose rows with columns
                     U = ["0 0","0 0"]
     ¸¸         Join using space and then split in space
                     U = ["0","0","0","0"]
        è       Return the count of the truthy values

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

Comments

8 बाइट्स:mîT Õ¸¸è

— झबरा

A.y()वैसे, पैडिंग का अच्छा उपयोग ।

— झबरा

Answer 9

MATL , 8 बाइट्स

0whd3Y%s

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

बहुत @ अरनौलड का एल्गोरिदम। सकारात्मक प्रविष्टियों का uint64चयन करने के बजाय कास्टिंग करके एक बाइट (धन्यवाद @LuisMendo) को बचाया )।

Answer 10

जेली , 5 बाइट्स

मेरे 05AB1E उत्तर का एक पोर्ट , जो खुद @tsh JS उत्तर के समान है ।

ŻI0»S

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

टिप्पणी की गई

ŻI0»S    - main link, expecting a list of non-negative integers  e.g. [10, 9, 8, 9]
Ż        - prepend 0                                             -->  [0, 10, 9, 8, 9]
 I       - compute the deltas                                    -->  [10, -1, -1, 1]
  0»     - compute max(0, v) for each term v                     -->  [10, 0, 0, 1]
    S    - sum                                                   -->  11

Answer 11

जाप , 7 6 बाइट्स

änT fq

कोशिश करो

1 बाइट ने ओलिवर को धन्यवाद दिया।

änT xwT    :Implicit input of integer array
än         :Consecutive differences / Deltas
  T        :  After first prepending 0
    f      :Filter elements by
     q     :  Square root (The square root of a negative being NaN)
           :Implicitly reduce by addition and output

Comments

6 बाइट्स

— ओलिवर

अच्छा लगा, @ ऑलिवर; ऐसा नहीं सोचा होगा।

— झबरा

Answer 12

आर , 30 बाइट्स

sum(pmax(0,diff(c(0,scan()))))

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

@Arnauld सॉल्यूशन का पोर्टिंग जो बदले में @tsh बढ़िया सॉल्यूशन से निकलता है

Answer 13

रेटिना 0.8.2 , 21 बाइट्स

\d+
$*
(1+)(?=,\1)

1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

(1+)(?=,\1)

अगले टॉवर के साथ सभी ओवरलैप्स को हटा दें, जिसे एक नए स्ट्रोक की आवश्यकता नहीं है।

1

शेष स्ट्रोक की गणना करें।

Answer 14

आम लिस्प, 88 87 बाइट्स

(lambda(s)(let((o 0))(dolist(c s)(incf o(max 0 c))(mapl(lambda(y)(decf(car y)c))s))o))

गैर न्यूनतम किया गया

(lambda (skyline)
  (let ((output 0))
    (dolist (current-skyscraper-height skyline)
      (incf output (max 0 current-skyscraper-height))
      (mapl (lambda (skyscraper)
              (decf (car skyscraper) current-skyscraper-height))
            skyline))
    output)))

झसे आज़माओ

जब एक टॉवर को चित्रित किया जाता है, तो यह ऊँचाई के बराबर कई ब्रशस्ट्रोक लेता है। ये ब्रशस्ट्रोक सभी निम्नलिखित लोगों के लिए अनुवाद करते हैं, जो अन्य सभी टावरों (और खुद से, लेकिन यह कोई फर्क नहीं पड़ता) से वर्तमान टॉवर की ऊंचाई को घटाकर यहां इंगित किया गया है। यदि एक निम्न टॉवर छोटा होता है, तो इसे एक नकारात्मक संख्या में धकेल दिया जाएगा, और यह नकारात्मक संख्या बाद में उन टावरों से घटा दी जाएगी जो अनुसरण करते हैं (ब्रशस्ट्रोक का संकेत देते हैं जो पिछले टॉवर से अगले वाले तक अनुवादित नहीं किए जा सकते)। यह वास्तव में पिछले सभी सहित सभी टॉवर ऊंचाइयों से संख्या घटाता है, लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि हम पिछले वाले को फिर से नहीं देखते हैं।

Comments

PPCG में आपका स्वागत है। क्या आप संभवतः सत्यापन में आसानी के लिए ऑनलाइन परीक्षण वातावरण का लिंक प्रदान कर सकते हैं?

— जोनाथन फ्रेच

हाँ बिल्कुल। rextester.com/TKBU14782 जवाब जल्द ही अपडेट किया जाएगा

— चार्लीम

बहुत बढ़िया। एक अच्छा, पहली पोस्ट के लिए +1। मज़ा गोल्फ है।

— जोनाथन फ्रीच

Answer 15

05AB1E , 13 10 बाइट्स

Z>Lε@γPO}O

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Z            # Get the maximum of the (implicit) input-list
 >           # Increase it by 1 (if the list only contains 0s)
  L          # Create a list in the range [1, max]
   ε         # Map each value to:
    @        #  Check if this value is >= for each value in the (implicit) input
     γ       #  Split into chunks of adjacent equal digits
      P      #  Take the product of each inner list
       O     #  Take the sum
        }O   # And after the map: take the sum (which is output implicitly)

Answer 16

ध्वज के साथ सी # (विजुअल सी # इंटरएक्टिव कंपाइलर)/u:System.Math , 47 बाइट्स

n=>n.Select((a,i)=>i<1?a:Max(a-n[i-1],0)).Sum()

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

पुराने संस्करण, ध्वज के साथ /u:System.Math, 63 बाइट्स

n=>n.Aggregate((0,0),(a,b)=>(a.Item1+Max(0,b-a.Item2),b)).Item1

मुझे ऐसा लगता है कि यह समाधान पहले वाले की तुलना में अधिक सुरुचिपूर्ण है। यह एक दो-मूल्य के साथ एक प्रारंभिक मूल्य के रूप में टपल के माध्यम से जाता है, मूल्यों को उठाता है, और इससे पहले मूल्य को ट्यूपल के दूसरे भाग में संग्रहीत करता है।

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

Answer 17

पायथ, 8 बाइट्स

s>#0.++0

अभी तक @ टीश के अद्भुत जवाब का एक और बंदरगाह । 0 प्रीपेंडेड ( , अनुगामी क्यू अनुमान के साथ) इनपुट के डेल्टास (। +) के sसकारात्मक मानों का योग ( ) लेता है ।>#0+0Q

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

स्ट्रिंग शामिल होने की विधि, 10 बाइट्स

यह वह समाधान था जो मैंने अन्य उत्तरों को ब्राउज़ करने से पहले लिखा था।

lcj.t+d*LN

परीक्षण सूट।

lcj.t+d*LNQ   Implicit: Q=eval(input()), b=<newline>, N=<quote mark>
              Trailing Q inferred
        L Q   Map each element of Q...
       * N    ... to N repeated that many times
     +b       Prepend a newline
   .t         Transpose, padding with spaces
  j           Join on newlines
 c            Split on whitespace
l             Take the length, implicit print

Answer 18

क्लोजर, 50 बाइट्स

#((reduce(fn[[s n]i][(+(max(- i n)0)s)i])[0 0]%)0)

इसे ऑनलाइन आज़माएं! (यह कुछ भी क्यों नहीं प्रिंट करता है?)

#( ; begin anonymous function
    (reduce
        (fn [[s n] i] ; internal anonymous reducing function, destructures accumulator argument into a sum and the previous item
            [(+ (max (- i n) 0) s ; the sum part of the accumulator becomes the previous sum plus the larger of zero and the difference between the current number and the last one, which is how many new strokes need to be started at this point
            i]) ; ...and the previous item part becomes the current item
        [0 0] ; the initial value of the accumulator gives no strokes yet, and nothing for them to cover yet
        %) ; reduce over the argument to the function
    0) ; and get the sum element of the last value of the accumulator.

Comments

PPCG में आपका स्वागत है! मुझे क्लोजर के बारे में कुछ भी पता नहीं है, लेकिन एक त्वरित खोज से पता चलता है कि आपको लूप के लिए आलसी का मूल्यांकन करने की आवश्यकता होगी। इसे ऑनलाइन आज़माएं! (टिप: आप अपने उत्तर को ऑटो-स्वरूप करने के लिए लिंक बटन का उपयोग कर सकते हैं)। आशा है कि आप चारों ओर चिपकेंगे और कुछ मज़ा करेंगे!

— जो किंग

Answer 19

जावा (JDK) , 57 बाइट्स

a->{int s=0,p=0;for(int x:a)s-=(x>p?p:x)-(p=x);return s;}

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

टीश का जावास्क्रिप्ट उत्तर का एक और पोर्ट । इसलिए सुनिश्चित करें कि आपने उन्हें अपडाउन किया है।

ध्यान दें कि मैंने जोड़ के बजाय घटाव का उपयोग किया था क्योंकि इसने मुझे (p=x)उसी कथन में सही ऑपरेंड के रूप में लिखने की अनुमति दी थी ।

Answer 20

MATL , 15 14 13 बाइट्स

ts:<~"@Y'x]vs

इनपुट एक स्तंभ वेक्टर है, जो ;विभाजक के रूप में उपयोग करता है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

t       % Implicit input: column vector. Duplicate
s       % Sum
:       % Range from 1 to that. Gives a row vector
<~      % Greater or equal? Element-wise with broadcast
"       % For each column
  @     %   Push current columnn
  Y'    %   Run-length encoding. Gives vector of values (0, 1) and vector of lengths
  x     %   Delete vector of lengths
]       % End
v       % Vertically concatenate. May give an empty array
s       % Sum. Implicit display

Answer 21

पर्ल 5, 21 बाइट्स

$\+=$_>$'&&$_-$';//}{

TIO

किस तरह

• -p+ }{+ $\चाल
• //खाली स्ट्रिंग से मेल खाता है ताकि अगली पंक्ति के लिए पोस्टमैच $'में पिछली पंक्ति होगी
• $\+=$_>$'&&$_-$'करंट लाइन और पिछले के बीच अंतर जमा करने के लिए अगर करंट पूर्व से अधिक है, (यह भी लिखा जा सकता है $\+=$_-$' if$_>$', लेकिन पर्ल $\+=$_-$'if$_>$'समान नहीं है)

Answer 22

स्टैक्स , 8 बाइट्स

Φ┐Γ╟φφ.╨

इसे चलाएं और डीबग करें

Tsh के जावास्क्रिप्ट समाधान से व्यापक रूप से उपयोग किए गए दृष्टिकोण का उपयोग करता है।

Answer 23

वोल्फ्राम भाषा (गणितज्ञ) , 34 बाइट्स

के एक बंदरगाह @Arnauld के समाधान ।

Tr@Select[{##,0}-{0,##},#>0&]&@@#&

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