Quy tắc của Naismith giúp tìm ra khoảng thời gian cần thiết cho việc đi bộ hoặc đi bộ, với khoảng cách và đi lên.

Đưa ra một danh sách không trống về độ cao tại các điểm cách đều nhau dọc theo một con đường và tổng khoảng cách của con đường đó tính bằng mét, bạn nên tính thời gian cần thiết theo quy tắc của Naismith.

Quy tắc của Naismith là bạn nên cho phép một giờ cho mỗi năm km, cộng thêm một giờ cho mỗi 600 mét đi lên.

Đầu vào phải được lấy theo mét, được đảm bảo bao gồm các số nguyên không âm và đầu ra phải luôn là giờ hoặc phút (nhưng không phải cả hai) và phải có thể đưa ra số thập phân khi áp dụng (độ chính xác của dấu phẩy động là OK) .

Ví dụ: đã cho:

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

Đối với hai yếu tố đầu tiên, [100, 200]bạn có 100 mét đi lên là 10 phút. Với [200, 400]bạn có 200 mét đi lên là 20 phút, [400, 200]không tăng dần nên không có thêm thời gian cho việc đó. [200, 700]là 500 mét đi lên trong 50 phút và cuối cùng [700, 400]không tăng lên. Thêm một giờ được thêm cho khoảng cách năm km. Tổng cộng là 140 phút hoặc 2.333 ... giờ.

Các trường hợp thử nghiệm

[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

Hãy thử trực tuyến!

-1 byte bằng cách sử dụng pmaxnhư nhiều câu trả lời khác làm

Lấy đầu vào là Amùi hương và Distance, và trả về thời gian tính bằng phút.

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

Đã lưu 1 byte nhờ câu trả lời của Giuseppe (chia cho 10 ở cuối quá trình)

Đưa đầu vào là ([altitudes])(distance). Trả về thời gian tính bằng phút.

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

Hãy thử trực tuyến!

05AB1E , 15 byte

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

Hãy thử trực tuyến!

Trả về thời gian tính bằng phút.

Giải trình

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

Trả về thời gian tính bằng giờ.

Hãy thử trực tuyến!

Python 2, 62 60 byte

Lưu được 2 byte nhờ vào ovs.

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

Hãy thử trực tuyến!

Trả về thời gian tính bằng phút.

# 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 được lưu nhờ Jo King.

2 byte được lưu nhờ vào nwellnhof.

(Cảm ơn cả hai, điều này không còn giống với bài dự thi ban đầu của tôi: Wap).)

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

Hãy thử trực tuyến!

Đối số đầu tiên là danh sách có độ cao, đối số thứ hai là độ dài của trek.

Toàn bộ điều là một AnyCode. Nếu một biểu thức được nhận dạng như vậy, thì mỗi biểu thức *là một đối số.

Vì vậy, trong *.&{sum (.skip Z-$_)Xmax 0}/600, chúng ta lấy đối số đầu tiên (lần xuất hiện đầu tiên của *) và sử dụng một khối trên nó với cấu trúc giống như phương thức .&{}. Khối nhận một đối số (danh sách), đi vào$_ , vì vậy .skipdanh sách đó không có phần tử đầu tiên. Chúng tôi trừ mảng ban đầu, từng phần tử, từ đó, sử dụng Z-. Nén dừng ngay khi danh sách ngắn hơn đã hết, không sao cả.

Chúng tôi sau đó sử dụng các nhà điều hành sản phẩm chéo X.list X(op) listtạo tất cả các cặp có thể trong đó phần tử đầu tiên nằm trong danh sách bên trái và phần thứ hai từ bên phải và sử dụng toán tử (op)trên chúng. Kết quả được trả về dưới dạng Seq (danh sách một lần bắn). Tuy nhiên, danh sách bên phải chỉ có một phần tử, 0, vì vậy nó chỉ làm * max 0, phần tử theo phần tử. Điều đó chắc chắn rằng chúng tôi chỉ tính các phần tăng dần của trek. Sau đó, chúng tôi thêm nó và chia cho 600.

Sau đó, chúng tôi thêm vào */5e3, nơi *xảy ra lần thứ hai và do đó, đó là đối số thứ hai và chia cho 5000. Tổng sau đó là thời gian tính bằng giờ. (Điều này hiệu quả hơn thời gian tính bằng phút vì chúng ta cần nhân lên và *sẽ cần phải được phân tách bằng khoảng trắng từ Anystar *.)

oK , 21 byte

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

Hãy thử trực tuyến! Lạm dụng một lỗi phân tích cú pháp .1.012giống như .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 nhờ vào streester .

k , 23 byte

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

Hãy thử trực tuyến!

Thạch , 12 byte

×.12;I}»0÷⁵S

Hãy thử trực tuyến!

-1 cảm ơn ông Xcoder .

Python 2 , 59 byte

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

Hãy thử trực tuyến!

trả về giờ dưới dạng thập phân.

Bình thường , 15 byte

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

Chương trình đầy đủ, dự kiến ​​tập hợp các độ cao là đối số thứ nhất, khoảng cách là thứ hai. Trả về thời gian tính bằng phút.

Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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-/⎕

Hãy thử trực tuyến!

Hàm truyền thống lấy đầu vào (từ phải sang trái) as 1st ⎕= Heights / Depths, 2nd ⎕= distance.

Cảm ơn @ngn vì đã là một thuật sĩ một ba byte.

Làm thế nào nó hoạt động:

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

Hãy thử trực tuyến.

Giải trình:

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

Hãy thử trực tuyến!

Có khả năng có thể được chơi golf hơn một chút.

Stax , 17 byte

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

Chạy và gỡ lỗi nó tại staxlang.xyz!

Lấy tất cả các đầu vào dưới dạng float, mặc dù điều này chỉ lưu một byte trong phiên bản chưa giải nén. Có khả năng ứng biến; vừa mới trở lại chơi golf mã, tôi hơi gỉ.

Giải nén (20 byte) và giải thích:

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|++ hoạt động cho các đầu vào tích hợp cho 21 byte được giải nén và vẫn còn 17 gói.