Reguła Naismitha pomaga ustalić czas potrzebny na spacer lub wędrówkę, biorąc pod uwagę odległość i wzniesienie.

Biorąc pod uwagę niepustą listę wysokości w punktach równomiernie rozmieszczonych wzdłuż ścieżki i całkowitą odległość tej ścieżki w metrach, należy obliczyć czas potrzebny zgodnie z regułą Naismitha.

Zasadą Naismitha jest to, że należy pozwolić na jedną godzinę na każde pięć kilometrów, plus dodatkową godzinę na każde 600 metrów wejścia.

Dane wejściowe muszą być pobierane w metrach, co gwarantuje, że składać się będzie z nieujemnych liczb całkowitych, a dane wyjściowe powinny konsekwentnie być godzinami lub minutami (ale nie obydwoma) i muszą być w stanie podać liczby dziesiętne w stosownych przypadkach (niedokładności zmiennoprzecinkowe są OK) .

Na przykład biorąc pod uwagę:

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

Dla pierwszych dwóch elementów [100, 200]masz 100 metrów wynurzania, czyli 10 minut. Gdy [200, 400]masz 200 metrów wznoszenia, czyli 20 minut, [400, 200]nie rośnie, więc nie dodajesz na to czasu. [200, 700]ma 500 metrów wejścia, czyli 50 minut i wreszcie [700, 400]nie wznosi się. Dodano dodatkową godzinę na dystansie pięciu kilometrów. Łącznie wynosi 140 minut lub 2,333 ... godzin.

Przypadki testowe

[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 bajtów

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

Wypróbuj online!

-1 bajt przy użyciu pmaxwielu innych odpowiedzi

Pobiera dane wejściowe jako Azapach i Distnienie i zwraca czas w minutach.

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 bajtów

Zapisano 1 bajt dzięki odpowiedzi Giuseppe (dzielenie przez 10 na końcu procesu)

Pobiera dane wejściowe jako ([altitudes])(distance) . Zwraca czas w minutach.

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

Wypróbuj online!

05AB1E , 15 bajtów

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

Wypróbuj online!

Zwraca czas w minutach.

Wyjaśnienie

              + # 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 bajtów

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

Zwraca czas w godzinach.

Wypróbuj online!

Python 2, 62 60 bajtów

Zaoszczędzono 2 bajty dzięki ovs.

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

Wypróbuj online!

Zwraca czas w minutach.

# 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 bajtów

6 bajtów zaoszczędzonych dzięki Jo Kingowi.

2 bajty zapisane dzięki nwellnhof.

(Dzięki obojgu nie wygląda to już tak jak moje oryginalne zgłoszenie :—).)

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

Wypróbuj online!

Pierwszy argument to lista z wysokościami, drugi argument to długość wędrówki.

Całość jest kodem WhthingCode. Jeśli wyrażenie zostanie uznane za takie, to każdy z nich *jest jednym argumentem.

Tak więc, *.&{sum (.skip Z-$_)Xmax 0}/600bierzemy pierwszy argument (pierwsze wystąpienie *) i używamy na nim bloku z konstrukcją podobną do metody .&{}. Blok przyjmuje jeden argument (listę), który wchodzi w skład $_, podobnie jak .skipta lista bez pierwszego elementu. Odejmujemy od tego oryginalną tablicę, element po elemencie, za pomocą Z-. Kompresowanie zatrzymuje się, gdy tylko krótsza lista zostanie wyczerpana, co jest w porządku.

Następnie korzystamy z operatora wielu produktów X. list X(op) listtworzy wszystkie możliwe pary, w których pierwszy element jest z lewej listy, a drugi z prawej i używa (op)na nich operatora . Wynik jest zwracany jako Seq (lista jednorazowa). Jednak właściwa lista ma tylko jeden element, 0, więc po prostu tak * max 0, element po elemencie. Dzięki temu liczymy tylko rosnące części wędrówki. Następnie sumujemy i dzielimy przez 600.

Następnie dodajemy */5e3, gdzie *występuje po raz drugi, a więc jest to drugi argument i dzielimy go przez 5000. Suma jest wtedy czasem w godzinach. (Jest to bardziej wydajne niż czas w minutach, ponieważ musielibyśmy się pomnożyć, a *należałoby je oddzielić spacją od WhthingStar *.)

ok , 21 bajtów

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

Wypróbuj online! Nadużywanie błędu analizowania, gdzie .1.012jest to samo, co .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 dzięki streester .

k , 23 bajty

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

Wypróbuj online!

Galaretka , 12 bajtów

×.12;I}»0÷⁵S

Wypróbuj online!

-1 dzięki Mr. Xcoder .

Python 2 , 59 bajtów

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

Wypróbuj online!

zwraca godziny w postaci dziesiętnej.

Pyth , 15 bajtów

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

Pełny program oczekuje zestawu wysokości jako pierwszego argumentu, odległości jako drugiego. Zwraca czas w minutach.

Spróbuj go online tutaj , lub sprawdzić wszystkie przypadki testowe od razu tutaj .

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 bajtów

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

Wypróbuj online!

Tradycyjna funkcja przyjmująca dane wejściowe (od prawej do lewej) jako 1st ⎕= Wysokość / Głębokość, 2nd ⎕= Odległość.

Dzięki @ngn do bycia czarodziejem jeden trzy bajty.

Jak to działa:

.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 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Prawdopodobnie można grać w golfa nieco więcej.

Stax , 17 bajtów

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

Uruchom i debuguj na staxlang.xyz!

Pobiera wszystkie dane wejściowe jako liczby zmiennoprzecinkowe, chociaż oszczędza to bajt tylko w wersji bez rozpakowania. Prawdopodobnie poprawialne; właśnie wracam do golfa z kodem, jestem trochę zardzewiały.

Rozpakowane (20 bajtów) i objaśnienie:

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|++ działa na integralne wejścia dla 21 bajtów rozpakowanych i nadal 17 zapakowanych.