Naismiths Herrschaft

12

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
code-golf  number 
— Okx
quelle
Die Testfallausgaben haben alle minutengenaue Ergebnisse. Ist das beabsichtigt? Sind Eingaben gleich [10], 5125oder [10, 25, 55], 1000gültig und müssen behandelt werden?
— Sundar - Wiedereinsetzung von Monica
@ Sundar Ja, sie sollten.
— Okx
[10, 25, 55], 1000 -> 0.275 OR 16.5
— Khuldraeseth na'Barya

Antworten:

6

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
— Giuseppe
quelle
Sie können 4 weitere Bytes mit pryr :: f (Summe (pmax (0, diff (A)), D * .12) / 10) anstelle von function
— Shayne03
@ Shayne03 das würde diese Antwort technisch in "R + pryr" ändern, was nach den Regeln der Site als eine andere Sprache als Basis R gilt, also werde ich dies so lassen, wie es ist. Vielen Dank für den Vorschlag!
— Giuseppe
Die Erklärung ist wie ein Hügel geformt
— user70585
3

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!

— Arnauld
quelle
2

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)
— Kaldo
quelle
Fast genau das, was ich mir vorgestellt hatte. Der einzige Unterschied, den ich hatte, war ₄12//stattdessen ₄;6//. Also offensichtlich +1 von mir.
— Kevin Cruijssen
2

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
— Triggernometrie
quelle
— OVS
2

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 *.)

— Ramillies
quelle
1
— Jo King
@JoKing, das ist eine gute Verwendung X, danke!
— Ramillies
1
Tatsächlich können wir das Letzte vermeiden, X/indem wir die Summe einfach durch 10 teilen. 39 Bytes
— Jo King
37 Bytes mit WhateverCode und .&{}(gibt Stunden zurück).
— Nwellnhof
2

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!

— zgrep
quelle
{y+/0|1_-':x}..1.012*für 21 Bytes? akku starten mit y.
— Streetster
Tatsächlich! Ich würde eine ähnliche Verbesserung auf den k-Code anwenden, aber der k-Interpreter, den ich habe (2016.08.09), mag es leider nicht, wenn ich den Akku mit irgendetwas in dieser Art starte. :/
— zgrep
1

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
— Sok
quelle
1

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;
— J. Sallé
quelle
Danke für "Wizard" :) Sie müssen den Ausdruck nicht mehrmals kopieren, um ihn zu testen . ,0ist unnötig, das ⍵für den problematischen Test ,604nicht sein sollte604
— ngn
Sehen Sie , das ist , warum Sie ein Zauberer sind. Das mehrmalige Kopieren des Ausdrucks ist völlig meine Schuld, ich habe nur das ⍺und ⍵im alten Code durch ersetzt ⎕und war zu faul, um die tradfn Kopf- / Fußzeile zu setzen. Das ,0bisschen obwohl? Gold.
— J. Sallé
0

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
— Kevin Cruijssen
quelle
0

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.

— Khuldraeseth na'Barya
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.