Die Naismith-Regel hilft dabei, die Zeitspanne für einen Spaziergang oder eine Wanderung zu berechnen, die für die Entfernung und den Aufstieg erforderlich ist.

Bei einer nicht leeren Liste der Höhe an Punkten, die gleichmäßig entlang eines Pfades verteilt sind, und der Gesamtentfernung dieses Pfades in Metern sollten Sie die benötigte Zeit gemäß der Naismith-Regel berechnen.

Naismiths Regel lautet, dass Sie eine Stunde für jeweils fünf Kilometer plus eine zusätzliche Stunde für jeweils 600 Höhenmeter einplanen sollten.

Die Eingabe muss in Metern erfolgen, die garantiert aus nicht negativen ganzen Zahlen bestehen. Die Ausgabe sollte konsistent entweder Stunden oder Minuten (aber nicht beides) sein und gegebenenfalls Dezimalzahlen angeben können (Gleitkommaungenauigkeiten sind in Ordnung). .

Zum Beispiel gegeben:

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

Für die ersten beiden Elemente haben [100, 200]Sie 100 Höhenmeter, das sind 10 Minuten. Wenn [200, 400]Sie 200 Höhenmeter haben, das sind 20 Minuten, [400, 200]steigt nicht an, daher wird keine Zeit dafür hinzugefügt. [200, 700]beträgt 500 Höhenmeter, das sind 50 Minuten, und schließlich [700, 400]geht es nicht aufwärts. Für die Entfernung von fünf Kilometern kommt eine zusätzliche Stunde hinzu. Dies ergibt 140 Minuten oder 2.333 Stunden.

Testfälle

[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

R ,  44  43 42 Bytes

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

Probieren Sie es online!

-1 Byte bei Verwendung pmaxmehrerer anderer Antworten

Nimmt Eingaben als AGeruch und DZustand und gibt die Zeit in Minuten zurück.

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

JavaScript (ES6), 50 Byte

Dank Giuseppes Antwort 1 Byte gespart (dividiert durch 10 am Ende des Prozesses)

Übernimmt die Eingabe als ([altitudes])(distance). Gibt die Zeit in Minuten zurück.

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

Probieren Sie es online!

05AB1E , 15 Bytes

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

Probieren Sie es online!

Gibt die Zeit in Minuten zurück.

Erläuterung

              + # 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) 

Haskell, 47 46 Bytes

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

Gibt die Zeit in Stunden zurück.

Probieren Sie es online!

Python 2, 62 60 Bytes

2 Bytes dank ovs gespart.

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

Probieren Sie es online!

Gibt die Zeit in Minuten zurück.

# 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

Perl 6 ,45 39 37 Bytes

6 Bytes gespart dank Jo King.

2 Bytes gespart dank nwellnhof.

(Dank ihnen beiden sieht das nicht mehr so ​​aus wie meine ursprüngliche Einreichung: -).)

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

Probieren Sie es online!

Das erste Argument ist die Liste mit den Höhen, das zweite Argument ist die Länge der Wanderung.

Das Ganze ist ein WhateverCode. Wenn ein Ausdruck als solcher erkannt wird, ist jeder *ein Argument.

In *.&{sum (.skip Z-$_)Xmax 0}/600nehmen wir also das erste Argument (das erste Vorkommen von *) und verwenden einen Block mit einem methodenähnlichen Konstrukt .&{}. Der Block akzeptiert ein Argument (die Liste), in das er eingeht $_, und .skipdiese Liste ohne das erste Element. Wir subtrahieren das ursprüngliche Array Element für Element mit Z-. Das Zippen wird beendet, sobald die kürzere Liste aufgebraucht ist. Dies ist in Ordnung.

Wir verwenden dann den produktübergreifenden Operator X. list X(op) listErstellt alle möglichen Paare, bei denen das erste Element aus der linken und das zweite aus der rechten Liste stammt, und verwendet den Operator (op)für diese. Das Ergebnis wird als Seq (One-Shot-Liste) zurückgegeben. Die rechte Liste hat jedoch nur ein Element, 0, und tut dies daher * max 0Element für Element. Das stellt sicher, dass wir nur aufsteigende Teile der Wanderung zählen. Dann addieren wir es und dividieren durch 600.

Dann fügen wir hinzu */5e3, wo das *zum zweiten Mal auftritt, und so ist es das zweite Argument, und dividieren es durch 5000. Die Summe ist dann die Zeit in Stunden. (Dies ist effizienter als die Zeit in Minuten, in der wir multiplizieren *müssten und die durch ein Leerzeichen vom WhateverStar getrennt werden müssten *.)

ok , 21 bytes

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

Probieren Sie es online! Missbrauch eines Parsing-Fehlers, bei dem .1.012es sich um das Gleiche handelt wie .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 dank streester .

k , 23 Bytes

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

Probieren Sie es online!

Gelee , 12 Bytes

×.12;I}»0÷⁵S

Probieren Sie es online!

-1 Danke an Herrn Xcoder .

Python 2 , 59 Bytes

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

Probieren Sie es online!

gibt Stunden als Dezimalzahl zurück.

Pyth , 15 Bytes

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

Volles Programm, erwartet den Höhensatz als erstes Argument, Abstand als zweites. Gibt die Zeit in Minuten zurück.

Versuchen Sie es online hier , oder prüfen Sie alle Testfälle auf einmal hier .

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

APL (Dyalog Unicode) , 21 20 18 Bytes

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

Probieren Sie es online!

Herkömmliche Funktion, die Eingaben (von rechts nach links) als 1st ⎕= Höhen / Tiefen, 2nd ⎕= Abstand vornimmt.

Vielen Dank für das @ngn ist ein Assistent ein drei Bytes.

Wie es funktioniert:

.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;

Java 8, 89 Bytes

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;}

Probieren Sie es online aus.

Erläuterung:

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

Japt , 39 Bytes

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

Probieren Sie es online!

Wahrscheinlich kann noch einiges mehr golfen werden.

Stax , 17 Bytes

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

Führen Sie es aus und debuggen Sie es unter staxlang.xyz!

Nimmt alle Eingaben als Float, obwohl dies nur in der entpackten Version ein Byte spart. Wahrscheinlich verbesserungsfähig; Ich kehre gerade zum Codegolf zurück und bin etwas verrostet.

Entpackt (20 Bytes) und Erklärung:

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|++ Funktioniert für integrierte Eingänge für 21 Bytes, die entpackt und noch 17 gepackt sind.