नाइस्मिथ का शासन

Question

नाइस्मिथ के नियम , टहलने या वृद्धि के लिए आवश्यक समय की लंबाई बाहर काम करने में मदद करता है दूरी और चढ़ाई दिया।

बिंदुओं पर ऊँचाई की एक गैर-रिक्त सूची को देखते हुए समान रूप से एक पथ और मीटर में उस पथ की कुल दूरी के साथ, आपको Naismith के नियम के अनुसार आवश्यक समय की गणना करनी चाहिए।

नाइस्मिथ का नियम है कि आपको प्रत्येक पांच किलोमीटर के लिए एक घंटे की अनुमति देनी चाहिए, साथ ही प्रत्येक 600 मीटर की चढ़ाई के लिए एक अतिरिक्त घंटे की भी आवश्यकता होगी।

इनपुट को मीटर में लिया जाना चाहिए, जिसमें गैर-नकारात्मक पूर्णांक शामिल हैं, और आउटपुट लगातार घंटे या मिनट (लेकिन दोनों नहीं) होना चाहिए, और दशमलव संख्या देने में सक्षम होना चाहिए जहां लागू हो (अस्थायी बिंदु गलतियाँ ठीक हैं) ।

उदाहरण के लिए, दिया गया:

[100, 200, 400, 200, 700, 400], 5000

पहले दो तत्वों के लिए [100, 200]आपके पास 100 मीटर की चढ़ाई है जो 10 मिनट की है। आपके साथ [200, 400]200 मीटर की चढ़ाई है जो 20 मिनट की है, [400, 200]आरोही नहीं है इसलिए उसके लिए कोई समय नहीं जोड़ा गया है। [200, 700]500 मीटर की चढ़ाई है जो 50 मिनट है, और अंत [700, 400]में आरोही नहीं है। पांच किलोमीटर की दूरी के लिए एक अतिरिक्त घंटा जोड़ा जाता है। यह योग 140 मिनट या 2.333 ... घंटे है।

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

[0, 600] 2500 -> 1.5 OR 90
[100, 200, 300, 0, 100, 200, 300] 10000 -> 2.8333... OR 170
[40, 5, 35] 1000 -> 0.25 OR 15
[604] 5000 -> 1 OR 60
[10, 10, 10] 2000 -> 0.4 OR 24
[10, 25, 55] 1000 -> 0.275 OR 16.5

Comments

परीक्षण मामलों के आउटपुट में पूरे मिनट के परिणाम होते हैं, क्या यह जानबूझकर है? क्या इनपुट [10], 5125या [10, 25, 55], 1000वैध और आवश्यक हैं?

— सूंदर -

@ सूंदर हां, उन्हें चाहिए।

— 14

[10, 25, 55], 1000 -> 0.275 OR 16.5

— खुल्द्रसेठ na'Barya

Answer 1

आर ,  44  43 42 बाइट्स

function(A,D)sum(pmax(0,diff(A)),D*.12)/10

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

pmaxकई अन्य उत्तर के रूप में उपयोग करके -1 बाइट

Aखुशबू और Distance के रूप में इनपुट लेता है , और मिनटों में समय लौटाता है।

function(A,D)                                 # take Ascent and Distance
                        diff(A)               # take successive differences of ascents
                 pmax(0,       )              # get the positive elements of those
                                 D*.12        # multiply distance by 0.12
             sum(               ,     )       # take the sum of all elements
                                       /10    # and divide by 10, returning the result

Comments

आप pryr का उपयोग करके 4 और बाइट्स प्राप्त कर सकते हैं :: f (sum (pmax (0, diff (A)), D * .12) / 10) का उपयोग करने के बजाय फ़ंक्शन

— Shayne03

@ Shayne03 जो तकनीकी रूप से इस उत्तर को "R + pryr" में बदल देगा, जो कि साइट के नियमों पर आधार R की तुलना में एक अलग भाषा के रूप में गिना जाता है, इसलिए मैं इसे इस तरह रखूंगा। फिर भी सुझाव के लिए धन्यवाद!

— ग्यूसेप

स्पष्टीकरण को एक पहाड़ी की तरह आकार दिया गया है

— user70585

Answer 2

जावास्क्रिप्ट (ईएस 6), 50 बाइट्स

Giuseppe के उत्तर के लिए 1 बाइट का धन्यवाद सहेजा (प्रक्रिया के अंत में 10 से भाग)

के रूप में इनपुट लेता है ([altitudes])(distance)। मिनटों में समय लौटाता है।

a=>d=>a.map(p=n=>d-=(x=p-(p=n))<0&&x,d*=.12)&&d/10

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

Answer 3

05AB1E , 15 बाइट्स

¥ʒ0›}OT÷s₄;6//+

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

मिनटों में समय लौटता है।

व्याख्या

              + # sum of ...
¥ʒ0›}OT÷        # the sum of positive deltas of the altitude divided by 10
        s₄;6//  # the distance divided by 83.33333333 (500/6, or the amount of meters per minute) 

Comments

लगभग वही जो मेरे मन में था। मेरे ₄12//बजाय केवल अंतर था ₄;6//। इतना स्पष्ट +1 मुझसे।

— केविन क्रूज़सेन

Answer 4

हास्केल, 47 46 बाइट्स

d#l@(_:t)=d/5e3+sum(max 0<$>zipWith(-)t l)/600

समय को घंटों में लौटाता है।

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

Answer 5

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

2 बाइट्स ओव्स के लिए धन्यवाद।

lambda e,d:sum((a-b)*(a>b)for a,b in zip(e[1:],e))*.1+d*.012

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

मिनटों में समय लौटता है।

# add all increasing slope differences together
sum(
    # multiply the difference by 0 if a<b, else by 1
    (a-b)*(a>b)
                # create a list of pairs by index, like [(1,0), (2,1) ...(n, n-1)]
                # then interate thru the pairs where a is the higher indexed item and b is the lower indexed item
                for a,b in zip(e[1:],e)
    )
    # * 60 minutes / 600 meters == .1 min/m
    *.1 
    # 60 minutes / 5000 meters = .012 min/m
    +d*.012

Comments

60 बाइट्स

— ovs

Answer 6

पर्ल 6 ,45 39 37 बाइट्स

6 बाइट्स ने जो राजा को धन्यवाद दिया।

2 बाइट्स ने nwellnhof के लिए धन्यवाद बचाया।

(उन दोनों के लिए धन्यवाद, यह अब मेरे मूल सबमिशन की तरह कुछ भी नहीं दिखता है:

*.&{sum (.skip Z-$_)Xmax 0}/600+*/5e3

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

पहला तर्क ऊंचाई के साथ सूची है, दूसरा तर्क ट्रेक की लंबाई है।

पूरी बात जो कुछ भी है। यदि एक अभिव्यक्ति को इस तरह से मान्यता दी जाती है, तो प्रत्येक *एक तर्क है।

तो, में *.&{sum (.skip Z-$_)Xmax 0}/600, हम पहले तर्क (पहली घटना *) लेते हैं , और इस पर एक ब्लॉक का उपयोग करते हैं विधि-जैसे निर्माण के साथ .&{}। ब्लॉक एक तर्क (सूची) लेता है, जो कि अंदर जाता है $_, इसलिए .skipवह सूची पहले तत्व के बिना है। हम मूल सरणी, तत्व से तत्व, उस से, का उपयोग करके घटाते हैं Z-। छोटी सूची समाप्त होते ही ज़िप बंद हो जाता है, जो ठीक है।

हम तो क्रॉस उत्पाद ऑपरेटर का उपयोग करते हैं X। list X(op) listसभी संभव जोड़े बनाता है जहां पहला तत्व बाईं सूची से है और दूसरा दाएं से है, और (op)उन पर ऑपरेटर का उपयोग करता है। परिणाम एक Seq (एक-शॉट सूची) के रूप में वापस आ जाता है। हालांकि, सही सूची में केवल एक तत्व है, 0, इसलिए यह बस * max 0तत्व से तत्व करता है। यह सुनिश्चित करता है कि हम केवल ट्रेक के आरोही भागों की गिनती करें। फिर हम इसे जोड़ते हैं और 600 से विभाजित करते हैं।

फिर हम जोड़ते हैं */5e3, जहां *दूसरी बार होता है, और इसलिए यह दूसरा तर्क है, और इसे 5000 से विभाजित करें। योग तब घंटों में समय है। (यह मिनटों में समय की तुलना में अधिक कुशल है, क्योंकि हमें गुणा करने की आवश्यकता होगी, और जो *कुछ भी एक पथ से अलग करने की आवश्यकता होगी *।)

Comments

42 बाइट्स का उपयोगX

— जो किंग

@JoKing, यह एक अच्छा उपयोग है X, धन्यवाद!

— रामलीज 21

वास्तव में, हम X/केवल 10. 39 बाइट्स

— जो किंग

37 बाइट्स जो कुछ भी कोड का उपयोग कर और .&{}(घंटे देता है)।

— nwellnhof

Answer 7

ठीक , 21 बाइट्स

{y+/0|1_-':x}..1.012*

इसे ऑनलाइन आज़माएं! एक पार्सिंग बग का दुरुपयोग करना जहां .1.012के समान है .1 .012।

              .1.012* /a = [0.1 * input[0], 0.012 * input[1]]
{           }.        /function(x=a[0], y=a[1])
      1_-':x          /  a = subtract pairs of elements from x
    0|                /  a = max(a, 0) w/ implicit map
 y+/                  /  y + sum(a)

-1 स्टार्टर के लिए धन्यवाद ।

के , 23 बाइट्स

{.1*(.12*y)++/0|1_-':x}

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

Comments

{y+/0|1_-':x}..1.012*21 बाइट्स के लिए? संचायक के साथ शुरू करें y।

— सड़कपर

वास्तव में! मैं k कोड के लिए एक समान वृद्धि लागू करूंगा, लेकिन दुर्भाग्यवश k दुभाषिया जो मेरे पास है (2016.08.09) मुझे यह पसंद नहीं है कि मैं उस फैशन में कुछ के साथ संचायक को शुरू करूं। :/

— zgrep

Answer 8

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

×.12;I}»0÷⁵S

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

-1 श्री एक्सकोडर का धन्यवाद ।

Comments

×.12काम नहीं करता है?

— श्री Xcoder

@ Mr.Xcoder यह करता है, मैं जल्दी में था।

— आउटगॉल्फ

Answer 9

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

lambda a,d:d/5e3+sum(max(0,y-x)/6e2for x,y in zip(a,a[1:]))

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

एक दशमलव के रूप में घंटे देता है।

Answer 10

अजगर , 15 बाइट्स

c+*E.12s>#0.+QT

पूर्ण कार्यक्रम, पहले तर्क के रूप में ऊंचाइयों के सेट की उम्मीद करता है, दूसरे के रूप में दूरी। मिनटों में समय लौटाता है।

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

c+*E.12s>#0.+QT   Implicit: Q=input 1, E=input 2
           .+Q    Take the differences between each height point
        >#0       Filter to remove negative values
       s          Take the sum
  *E.12           Multiply the distance by 0.12
 +                Add the two previous results
c             T   Divide the above by 10, implicit print

Answer 11

एपीएल (डायलॉग यूनिकोड) , 21 20 18 बाइट्स

.1×.12⊥⎕,-+/0⌊2-/⎕

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

पारंपरिक फ़ंक्शन इनपुट (दाएं से बाएं) के रूप में 1st ⎕= हाइट्स / गहराई, 2nd ⎕= दूरी।

एक तीन बाइट्स एक जादूगर होने के लिए @ngn के लिए धन्यवाद ।

यह काम किस प्रकार करता है:

.1×.12⊥⎕,-+/0⌊2-/⎕ ⍝ Function;
                 ⎕ ⍝ Append 0 to the heights vector;
              2-/  ⍝ Pairwise (2) differences (-/);
            0⌊     ⍝ Minimum between 0 and the vector's elements;
          +/       ⍝ Sum (yields the negated total height);
         -         ⍝ Subtract from;
   .12⊥⎕,          ⍝ Distance × 0.12;
.1×                ⍝ And divide by 10;

Comments

"विज़ार्ड" के लिए धन्यवाद :) आपको इसे परीक्षण करने के लिए अभिव्यक्ति को कई बार कॉपी करने की ज़रूरत नहीं है, इसे एक ट्रेडफ़न में डालें ; ,0अनावश्यक है, ⍵समस्याग्रस्त परीक्षण के लिए ,604, नहीं604

— ngn

देखें, कि तुम क्यों एक जादूगर हो। कई बार भाग की अभिव्यक्ति की नकल करना पूरी तरह से मेरी गलती है, मैंने अभी ⍺और ⍵पुराने कोड को बदल दिया है और ⎕ट्रेडफ़न हेडर / फ़ूटर को लगाने के लिए बहुत आलसी था। ,0बिट हालांकि? सोना।

— जे। सेले

Answer 12

जावा 8, 89 बाइट्स

a->n->{int s=0,p=0,i=a.length;for(;i-->0;p=a[i])s+=(p=p-a[i])>0?p:0;return s/10+n/500*6;}

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

स्पष्टीकरण:

a->n->{                   // Method with integer-array and integer parameter and integer return-type
  int s=0,                //  Sum-integers, starting at 0
      p=0,                //  Previous integer, starting at 0
  i=a.length;for(;i-->0;  //  Loop `i` backwards over the array
                 ;        //    After every iteration:
                  p=a[i]) //     Set `p` to the current value for the next iteration
    s+=(p=p-a[i])>0?      //   If the previous minus current item is larger than 0:
         p                //    Add that difference to the sum `s`
        :                 //   Else:
         0;               //    Leave the sum the same
   return s/10            //  Return the sum integer-divided by 10
          +n/500*6;}      //  Plus the second input divided by 500 and then multiplied by 6

Answer 13

जाप , 39 बाइट्स

0oUl)x@W=UgXÄ -UgX)g ¥É?0:W/#ɘ} +V/(#Ǵ0

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

शायद थोड़ा और अधिक गोल्फ हो सकता है।

Answer 14

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

ü;█y☼òΓ▀ßîP<<╪⌠öß

भागो और इसे staxlang.xyz पर डीबग करें!

सभी इनपुट्स को फ्लोट्स के रूप में लेता है, हालांकि यह केवल अनपैक्ड संस्करण में एक बाइट बचाता है। बिलकुल अनुचित; बस अब कोड गोल्फ में लौट रहा हूं, मैं कुछ कठोर हूं।

अनपैक्ड (20 बाइट्स) और स्पष्टीकरण:

0!012*s:-{0>f{A/m|++
0!012*                  Float literal and multiplication for distance
      s                 Swap top two stack values (altitudes to the top)
       :-               List of deltas
         {0>f           Filter: keep only positive changes
             {A_m       Map: divide all ascents by 10
                 |++    Add these times to that for horizontal travel
                        Implicit print

0!012*s:-{0>f{A_:m|++ 21 बाइट्स के लिए अभिन्न इनपुट के लिए काम करता है और अभी भी 17 पैक।