Aturan Naismith membantu menentukan waktu yang dibutuhkan untuk berjalan atau mendaki, mengingat jarak dan pendakian.

Diberikan daftar ketinggian kosong pada titik-titik yang ditempatkan secara merata di sepanjang jalur dan total jarak jalur tersebut dalam meter, Anda harus menghitung waktu yang diperlukan sesuai dengan aturan Naismith.

Aturan Naismith adalah bahwa Anda harus mengizinkan satu jam untuk setiap lima kilometer, ditambah satu jam tambahan untuk setiap 600 meter pendakian.

Input harus diambil dalam meter, yang dijamin terdiri dari bilangan bulat non-negatif, dan output harus secara konsisten jam atau menit (tetapi tidak keduanya), dan harus dapat memberikan angka desimal jika berlaku (ketidakakuratan floating point OK) .

Sebagai contoh, diberikan:

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

Untuk dua elemen pertama [100, 200]Anda memiliki 100 meter pendakian yang 10 menit. Dengan [200, 400]Anda memiliki 200 meter pendakian yang 20 menit, [400, 200]tidak naik sehingga tidak ada waktu yang ditambahkan untuk itu. [200, 700]adalah 500 meter pendakian yang 50 menit, dan akhirnya [700, 400]tidak naik. Satu jam tambahan ditambahkan untuk jarak lima kilometer. Ini total 140 menit atau 2.333 ... jam.

Uji Kasus

[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 byte

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

Cobalah online!

-1 byte dengan menggunakan pmaxbeberapa jawaban lainnya

Mengambil input sebagai Aaroma dan Dkecepatan, dan mengembalikan waktu dalam hitungan menit.

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

Disimpan 1 byte berkat jawaban Giuseppe (dibagi 10 pada akhir proses)

Mengambil input sebagai ([altitudes])(distance). Mengembalikan waktu dalam hitungan menit.

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

Cobalah online!

05AB1E , 15 byte

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

Cobalah online!

Mengembalikan waktu dalam hitungan menit.

Penjelasan

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

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

Mengembalikan waktu dalam jam.

Cobalah online!

Python 2, 62 60 bytes

Disimpan 2 byte berkat ovs.

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

Cobalah online!

Mengembalikan waktu dalam hitungan menit.

# 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 byte

6 byte disimpan berkat Jo King.

2 byte disimpan berkat nwellnhof.

(Berkat mereka berdua, ini tidak lagi terlihat seperti kiriman asli saya :—).)

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

Cobalah online!

Argumen pertama adalah daftar dengan elevasi, argumen kedua adalah panjang perjalanan.

Semuanya adalah Kode Apapun. Jika suatu ekspresi dikenali seperti itu, maka masing *- masing adalah satu argumen.

Jadi, di *.&{sum (.skip Z-$_)Xmax 0}/600, kita mengambil argumen pertama (kemunculan pertama *), dan menggunakan blok di atasnya dengan konstruksi seperti metode .&{}. Blok mengambil satu argumen (daftar), yang masuk ke $_, begitu .skipjuga daftar itu tanpa elemen pertama. Kami mengurangi array asli, elemen demi elemen, dari itu, menggunakan Z-. Zip berhenti segera setelah daftar pendek habis, yang OK.

Kami kemudian menggunakan operator lintas produk X. list X(op) listmembuat semua pasangan yang memungkinkan di mana elemen pertama dari daftar kiri dan yang kedua dari kanan, dan menggunakan operator (op)pada mereka. Hasilnya dikembalikan sebagai Seq (daftar sekali pakai). Namun, daftar yang tepat hanya memiliki satu elemen, 0, jadi itu saja * max 0, elemen demi elemen. Itu memastikan bahwa kita hanya menghitung bagian naik dari perjalanan. Lalu kami menambahkannya dan membaginya dengan 600.

Lalu kita tambahkan */5e3, di mana *terjadi untuk yang kedua kalinya, dan jadi itu argumen kedua, dan membaginya dengan 5000. Jumlahnya kemudian menjadi jam dalam jam. (Ini lebih efisien daripada waktu dalam hitungan menit karena kita perlu mengalikan, dan *itu perlu dipisahkan oleh spasi dari WhatsStar *.)

OK , 21 byte

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

Cobalah online! Menyalahgunakan bug parsing di mana .1.012sama dengan .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 terima kasih kepada streester .

k , 23 byte

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

Cobalah online!

Jelly , 12 byte

×.12;I}»0÷⁵S

Cobalah online!

-1 terima kasih kepada Tn . Xcoder .

Python 2 , 59 byte

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

Cobalah online!

mengembalikan jam sebagai desimal.

Pyth , 15 byte

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

Program penuh, mengharapkan set ketinggian sebagai argumen pertama, jarak sebagai argumen kedua. Mengembalikan waktu dalam hitungan menit.

Cobalah online di sini , atau verifikasi semua uji sekaligus di sini .

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 byte

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

Cobalah online!

Fungsi tradisional mengambil input (dari kanan ke kiri) sebagai 1st ⎕= Ketinggian / Kedalaman, 2nd ⎕= Jarak.

Terima kasih kepada @ngn karena menjadi penyihir satu byte tiga.

Bagaimana itu bekerja:

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

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

Cobalah online.

Penjelasan:

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 byte

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

Cobalah online!

Kemungkinan bisa bermain golf sedikit lebih.

Stax , 17 byte

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

Jalankan dan debug di staxlang.xyz!

Mengambil semua input sebagai float, meskipun ini hanya menyimpan satu byte dalam versi yang sudah dibongkar. Kemungkinan tidak bisa diperbaiki; baru saja kembali ke golf kode, saya agak berkarat.

Dibongkar (20 byte) dan penjelasan:

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|++ bekerja untuk input integral untuk 21 byte yang dibongkar dan masih 17 dikemas.