इस पहाड़ को कैसे जलाया जाता है? 🔥

Question

एक पर्वत को रेखाखंडों के एक समूह के रूप में परिभाषित किया जाता है, जिसका पहला बिंदु निर्देशांक है (0,a)जहां a > 0, और जिसका अंतिम बिंदु समन्वय है (b,0), जहां b > 0। सभी मध्यवर्ती बिंदुओं में एक y-निर्देशांक (निर्देशांक) सख्ती से अधिक से अधिक होता है। आपको x-निर्देशांक (abscissa) के आरोही क्रम में छाँटे गए पर्वत पर अंक दिए जाते हैं। ध्यान दें कि दो बिंदुओं में एक ही एक्स-समन्वय हो सकता है, जो पहाड़ के एक ऊर्ध्वाधर खंड का निर्माण करता है। यदि आपको एक ही एक्स-समन्वय के साथ दो अंक दिए जाते हैं, तो उन्हें उस क्रम में जोड़ा जाना चाहिए, जो वे दिए गए हैं। इसके अलावा, पहाड़ के क्षैतिज खंड हो सकते हैं ये क्षैतिज खंड नहीं जलाए जाते हैं, चाहे कुछ भी हो। सभी निर्देशांक nonnegative पूर्णांक हैं।

प्रश्न: पहाड़ की कुल लंबाई क्या है जो सूर्य को मानते हुए, पर्वत के दाईं ओर स्थित प्रकाश का एक अनंत ऊर्ध्वाधर विमान है? इस संख्या को गोल करने की आवश्यकता नहीं है, लेकिन अगर यह गोल है, तो कम से कम चार दशमलव स्थानों को शामिल करें। मैंने एक तस्वीर शामिल की है: यहां, जो लाइनें बोल्ड की गई हैं, वे उन खंडों का प्रतिनिधित्व करती हैं जो जलाए जाते हैं। ध्यान दें कि इनपुट में P, Q से पहले दिखाई देता है (PQ एक वर्टिकल लाइन सेगमेंट है) इसलिए पिछला बिंदु P से जुड़ा है और Q से नहीं।

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

परीक्षण का मामला:

(0,3000)
(500, 3500)
(2500, 1000)
(5000,5000)
(9000,2000)
(9000,3500)
(10200,0)

Output: 6200.0000

यहां दो लिट-अप सेगमेंट हैं, जैसा कि इस चित्र में दिखाया गया है: पहले वाले की लंबाई 5000/2 = 2500 है और दूसरे की लंबाई 3700 है।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

Comments

संकेत: जब एक खंड की लंबाई का पता चलता है, तो तीन बिंदुओं पर विचार करने की आवश्यकता है: दो समापन बिंदु, और वह बिंदु जो इसे "अवरुद्ध" कर रहा है (दूसरी तस्वीर में, यह (9000,3500) जो लंबाई निर्धारित करता है 3-4-5 खंड। मुख्य खंड पर दो बिंदु होने दें (x1, y1)और (x2,y2)वह बिंदु जो "अवरुद्ध" है वह है (x3, y3)। मान लें कि y2 <y3 <= y1 है। तब खंड की लंबाई है ((y1 - y3)/(y1 - y2))*sqrt((x1 - x2)^2 + (y1 - y2)^2)। यह अनिवार्य रूप से है। दूरी सूत्र, खंड के अंश जो वास्तव में प्रयोग किया जाता है से गुणा।

— धांधली

क्या पहाड़ क्षैतिज हो सकता है?

— user202729

हां, पहाड़ पर क्षैतिज खंड हो सकते हैं। हालाँकि यह किसी बिंदु पर 0 पर जाएगा।

— धांधली

लेकिन क्या उन्हें जलाया जाना चाहिए?

— user202729

उन्हें जलाया नहीं जाता। प्रकाश, पूरी तरह से क्षैतिज होने के कारण, केवल उनके समानांतर चल सकता है और कभी भी उन पर प्रहार नहीं कर सकता है। मैंने इसे स्पष्ट करने के लिए समस्या का संपादन किया।

— धांधली

Answer 1

पायथन 2 ,  134 131 128 124 120 120 117 109  107 बाइट्स

p=input();s=0
for X,Y in p[1:]:x,y=p.pop(0);n=y-max(zip(*p)[1]);s+=n*(1+((X-x)/(y-Y))**2)**.5*(n>0)
print s

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

Tuples की सूची के रूप में इनपुट लेता है / अस्थायी बिंदुओं की दो-तत्व सूची।

व्याख्या

हम मूल रूप से ग्राफ़ में बिंदुओं के जोड़े के माध्यम से पुनरावृत्ति करते हैं, और यदि , तो हम गणना करते हैं कि प्रकाश के लिए लाइन कितनी उजागर होती है। जोड़ी बिंदु पुनरावृत्ति अगले बिंदु, को प्राप्त करने के लिए लूप के साथ किया जाता है, वर्तमान बिंदु को पुनः प्राप्त करने के लिए हर बार सूची में पहला तत्व पॉपिंग ।$y_1 > y_2$for$(x_2, y_2)$$(x_1, y_1)$

गणित - रेखाखंड का कौन सा भाग प्रकाश के संपर्क में आता है?

आज्ञा देना वर्तमान बिंदु के निर्देशांक हैं। आज्ञा दें वर्तमान बिंदु के बाद एक बिंदु की अधिकतम ऊंचाई हो (वर्तमान बिंदु के बाद स्थानीय मैक्सिमा) और अगले बिंदु के निर्देशांक हों। सूर्य, संपर्क में आने वाली लंबाई की गणना करने के लिए , हमें को ढूंढना चाहिए , जैसा कि चित्र में दिखाया गया है। स्वाभाविक रूप से, यदि , खंड प्रकाश के लिए बिल्कुल भी उजागर नहीं है।$(x_1, y_1)$$y_{max}$$(x_2, y_2)$$L$$x_3$$y_1 \le y_{max}$

गठित त्रिकोण में, लंबाई का लाइन खंड आधार के समानांतर है, लंबाई , इसलिए तीनों कोण हैं। इसलिए, समानता (मामले कोण-कोण) के मौलिक सिद्धांत से , हम उस । इसलिए, । फिर, हम पायथागॉरियन प्रमेय को लागू कर सकते हैं:$x_3$$x_2 - x_1$$\frac{x_3}{x_2 - x_1} = \frac{y_1-y_{max}}{y_1}$$x_3 = \frac{(y_1-y_{max})(x_2 - x_1)}{y_1}$

$$L = \sqrt{(y_1-y_{max})^2+x_3^2}$$

दो सूत्रों से जुड़कर, हम निम्नलिखित अभिव्यक्ति पर आते हैं, जो इस दृष्टिकोण का मूल है:

एल=

$$L = \sqrt{(y_1-y_{max})^2+\left(\frac{(y_1-y_{max})(x_2 - x_1)}{y_1}\right)^2}$$ $$L = \sqrt{(y_1-y_{max})^2\left(1+\frac{(x_2 - x_1)^2}{y_1^2}\right)}$$

कोड - यह कैसे काम करता है?

p=input();s=0                             # Assign p and s to the input and 0 respectively.
for X,Y in p[1:]:                         # For each point (X, Y) in p with the first
                                          # element removed, do:
    x,y=p.pop(0)                          # Assign (x, y) to the first element of p and
                                          # remove them from the list. This basically
                                          # gets the coordinates of the previous point.
    n=y-max(zip(*p)[1])                   # Assign n to the maximum height after the
                                          # current one, subtracted from y.
    s+=n*(1+((X-x)/(y-Y))**2)**.5         # Add the result of the formula above to s.
                                 *(n>0)   # But make it null if n < 0 (if y is not the
                                          # local maxima of this part of the graph).
print s                                   # Output the result, s.

बदलाव का

• धीरे-धीरे गोल्फ उद्देश्यों के लिए सूत्र को अनुकूलित किया।

• FlipTack के लिए 1 बाइट का धन्यवाद सहेजा गया ।

• अनावश्यक स्थिति को हटाकर 2 बाइट्स को सहेजा गया है y>Y, क्योंकि यदि वर्तमान बिंदु से घटाए जाने के बाद Y -coordinate की स्थानीय अधिकतम सीमा yसकारात्मक है, तो वह स्थिति बेमानी है। हालांकि यह दुर्भाग्य से फ्लिपकैक के गोल्फ को अमान्य कर देता है।

• एल्गोरिथ्म को थोड़ा बदलकर 3 बाइट्स सहेजे गए: एक काउंटर चर होने के बजाय, इसे बढ़ाना और सूची पूंछना, हम प्रत्येक पुनरावृत्ति पर पहला तत्व निकालते हैं।

• सहेजे गए 8 बाइट्स ओव्स के लिए धन्यवाद ; (x,y),(X,Y)एक list.pop()तकनीक के साथ लूप की स्थिति में बदलाव ।

• सहेजे गए 2 बाइट्स के लिए धन्यवाद अर्जन जोहान्सन (सूत्र थोड़ा अनुकूलित)।

Answer 2

जावास्क्रिप्ट, 97 बाइट्स

a=>a.reduceRight(([p,q,l=0,t=0],[x,y])=>[x,y,y>t?(y-t)/(s=y-q)*Math.hypot(x-p,s)+l:l,y>t?y:t])[2]

f=a=>a.reduceRight(([p,q,l=0,t=0],[x,y])=>[x,y,y>t?(y-t)/(s=y-q)*Math.hypot(x-p,s)+l:l,y>t?y:t])[2];
t=[[0, 3000], [500, 3500], [2500, 1000], [5000, 5000], [9000, 2000], [9000, 3500], [10200, 0]];
console.log(f(t));

(5 बाइट्स सहेजे जा सकते हैं, यदि इनपुट का उलटा संस्करण लेना वैध माना जाता है।)

Answer 3

एपीएल + विन, 48 बाइट्स

+/((h*2)+(((h←-2-/⌈\m)÷-2-/m←⌽⎕)×(⌽-2-/⎕))*2)*.5

Y निर्देशांक की सूची के बाद x निर्देशांक की सूची के लिए संकेत

व्याख्या

h←-2-/⌈\m difference between successive vertical maxima viewed from the right (1)

-2-/m←⌽⎕ vertical difference between points (2)

⌽-2-/⎕ horizontal difference between points (3)

जलाई हुई दूरियाँ = h और जलाई हुई क्षैतिज दूरियाँ (3) * (1) / (2) हैं। बाकी पाइथागोरस है।

Comments

चाहेंगे +/.5*⍨(h*2)+×⍨((h←-2-/⌈\m)÷-2-/m←⌽⎕)×⌽-2-/⎕काम करते हैं?

— क्रिकटी लिथोस

दुर्भाग्य से मेरे पुराने एपीएल + विन संस्करण में ⍨ऑपरेटर नहीं है, इसलिए मैं यह नहीं कह सकता

— ग्राहम

@Cows यह Dyalog Unicode (v13) के पुराने संस्करण में प्रयास करने का प्रबंधन करता है और आपका सुझाव काम करता है

— ग्राहम

Answer 4

स्विफ्ट , 190 बाइट्स

import Foundation
func f(a:[(Double,Double)]){var t=0.0,h=t,l=(t,t)
a.reversed().map{n in if l.0>=n.0&&n.1>l.1{t+=max((n.1-h)/(n.1-l.1)*hypot(n.0-l.0,n.1-l.1),0)
h=max(n.1,h)}
l=n}
print(t)}

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

व्याख्या

import Foundation                  // Import hypot() function
func f(a:[(Double,Double)]){       // Main function
  var t=0.0,h=0.0,l=(0.0,0.0)      // Initialize variables
  a.reversed().map{n in            // For every vertex in the list (from right to left):
    if l.0>=n.0&&n.1>l.1{          //   If the line from the last vertex goes uphill:
      t+=max((n.1-h)/(n.1-l.1)     //     Add the fraction of the line that's above the
        *hypot(n.0-l.0,n.1-l.1),0) //     highest seen point times the length of the line
                                   //     to the total
      h=max(n.1,h)}                //     Update the highest seen point
    l=n}                           //   Update the last seen point
  print(t)}                        // Print the total

Answer 5

पायथन 2 , 122 120 बाइट्स

k=input()[::-1]
m=r=0
for(a,b),(c,d)in zip(k,k[1:]):
 if d>m:r+=(b>=m or(m-b)/(d-b))*((a-c)**2+(b-d)**2)**.5;m=d
print r

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

Comments

चूँकि हमें x मानों की सूची और y मानों की सूची दो इनपुटों के रूप में लेने की अनुमति है, मुझे पूरा यकीन है कि हम इसकी आवश्यकता को हटाते हुए, रिवर्स में सह-निर्देशांक की एक सूची ले सकते हैं [::-1]।

— जोनाथन एलन

Answer 6

पायथन 2 , 89 बाइट्स

M=t=0
for x,y in input()[::-1]:
 if y>M:t+=(y-M)*abs((x-X)/(y-Y)+1j);M=y
 X,Y=x,y
print t

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

झांकियों के जोड़े की सूची में ले जाता है। ओवर्स के समाधान के आधार पर ।

Comments

सोचें कि हम एक रिवर्स सूची ले सकते हैं (हमें अलग-अलग सूचियों के रूप में x और y लेने की अनुमति है), ताकि आप ड्रॉप कर सकें [::-1]।

— जोनाथन एलन

Answer 7

एपीएल (Dyalog यूनिकोड) , 31 बाइट्स ^SBCS

ग्राहम के सूत्र का उपयोग करता है ।

अनाम उपसर्ग फ़ंक्शन सही तर्क के रूप में डेटा का 2 × n मैट्रिक्स ले रहा है। पहली पंक्ति में दाईं से बाईं ओर x-मान होते हैं, और दूसरी पंक्ति में संबंधित y-मान होते हैं।

{+/.5*⍨(×⍨2-/⌈\2⌷⍵)×1+×⍨÷⌿2-/⍵}

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

{... } अनाम लंबोदर जहां ⍵तर्क है:

 2-/⍵ डेल्टास (लिट्युज़ पेयर वाइज माइनस-रिडक्शन)

 ÷⌿ ^Δx ⁄ ( _y (lit. वर्टिकल डिवीजन रिडक्शन)

 ×⍨ वर्गाकार (lit. गुणा गुणन सेल्फी)

 1+ उसमें एक जोड़ा गया

 (… )× उस के साथ निम्नलिखित गुणा करें:

  2⌷⍵ तर्क की दूसरी पंक्ति (y मान)

  ⌈\ अधिकतम चलाना (उच्चतम ऊंचाई अब तक मिली, दाईं ओर से जा रही है)

  2-/ का डेल्टा (जलाया हुआ जोड़ीदार घटा-घटा)

  ×⍨ वर्गाकार (lit. गुणा गुणन सेल्फी)

 .5*⍨वर्गमूल (lit. को बढ़ाएं कि एक आधा की शक्ति)

 +/ योग

Answer 8

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

ṀÐƤḊ_⁸«©0×⁹I¤÷⁸I¤,®²S½S

बाईं ओर y मानों की सूची और दाईं ओर संबंधित x मानों की सूची के अनुसार एक डायडिक लिंक (जैसा कि टिप्पणियों में ओपी द्वारा स्पष्ट रूप से अनुमति दी गई है)

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

कैसे?

जलाया जाने वाला (ढलान वाला) खंड का अंश वही अंश है जो अगर एक लंबवत गिरता है तो जलाया जाएगा। ध्यान दें कि चौराहे पर ढलान की लंबाई का मूल्यांकन करने के लिए होता है, जिस तरह से गणना की गई ऊँचाई नकारात्मक हो सकती है (नीचे दी गई ढलान की रन-लंबाई में भी ऋणात्मक द्वारा विभाजित नकारात्मक के रूप में गणना की जाती है)।

ṀÐƤḊ_⁸«©0×⁹I¤÷⁸I¤,®²S½S - Link:list, yValues; list, xValues
 ÐƤ                     - for suffixes of the yValues:       e.g. [ 3000, 3500, 1000, 5000, 2000, 3500,    0]
Ṁ                       -   maximum                               [ 5000, 5000, 5000, 5000, 3500, 3500,    0]
   Ḋ                    - dequeue                                 [ 5000, 5000, 5000, 3500, 3500,    0]
     ⁸                  - chain's left argument, yValues          [ 3000, 3500, 1000, 5000, 2000, 3500,    0]
    _                   - subtract                                [ 2000, 1500, 4000,-1500, 1500,-3500,    0]
        0               - literal zero
      «                 - minimum (vectorises)                    [    0,    0,    0,-1500,    0,-3500,    0]
       ©                - copy to the register for later
            ¤           - nilad followed by link(s) as a nilad:
          ⁹             -   chain's right argument, xValues  e.g. [    0,  500, 2500, 5000, 9000, 9000, 10200]
           I            -   incremental differences               [  500, 2000, 2500, 4000,    0, 1200]
         ×              - multiply (vectorises)                   [    0,    0,    0,-6000000, 0,-4200000, 0]
                ¤       - nilad followed by link(s) as a nilad:
              ⁸         -   chain's left argument, yValues        [ 3000, 3500, 1000, 5000, 2000, 3500,    0]
               I        -   incremental differences               [  500,-2500, 4000,-3000, 1500,-3500]
             ÷          - divide (vectorises)                     [    0,    0,    0, 2000,    0, 1200,    0]
                  ®     - recall from the register                [    0,    0,    0,-1500,    0,-3500,    0]
                 ,      - pair (i.e. lit slope [runs, rises])     [[0, 0, 0,    2000, 0,    1200, 0], [0, 0, 0,   -1500, 0,    -3500, 0]]
                   ²    - square (vectorises)                     [[0, 0, 0, 4000000, 0, 1440000, 0], [0, 0, 0, 2250000, 0, 12250000, 0]]            
                    S   - sum (vectorises)                        [  0,   0,   0, 6250000,   0, 13690000,   0]
                     ½  - square root (vectorises)                [0.0, 0.0, 0.0,  2500.0, 0.0,   3700.0, 0.0]
                      S - sum                                     6200.0

---

25 बाइट मोनैडिक संस्करण [x,y]सह- निर्देशकों की सूची ले रहा है :

ṀÐƤḊ_«0
Z©Ṫµ®FI×Ç÷I,DzS½S

इसको आजमाओ।

Comments

इनपुट मूल्यों की दो सूचियां हो सकती हैं। मैंने कुछ समय पहले ओपी से पूछा है और उन्होंने कहा कि यह ठीक है ।

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

मुझे ऐसा लगता है कि बहुत सारे ⁸एस और ⁹एस हैं।

— जोनाथन एलन

Answer 9

कोटलिन , 178 बाइट्स

fun L(h:List<List<Double>>)=with(h.zip(h.drop(1))){mapIndexed{i,(a,b)->val t=a[1]-drop(i).map{(_,y)->y[1]}.max()!!;if(t>0)t*Math.hypot(1.0,(a[0]-b[0])/(a[1]-b[1]))else .0}.sum()}

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

परीक्षण भाग बहुत अधिक नहीं है :)