กฎของไนสมิ ธช่วยในการกำหนดระยะเวลาที่จำเป็นสำหรับการเดินหรือปีนเขาตามระยะทางและทางขึ้น

ให้รายการความสูงที่ไม่เว้นว่าง ณ จุดที่เว้นระยะเท่ากันตามเส้นทางและระยะทางรวมของเส้นทางนั้นเป็นเมตรคุณควรคำนวณเวลาที่จำเป็นตามกฎของไนสมิ ธ

กฎของไนสมิ ธ คือคุณควรอนุญาตหนึ่งชั่วโมงสำหรับทุก ๆ ห้ากิโลเมตรบวกอีกชั่วโมงสำหรับทุก ๆ 600 เมตรของปีน

ข้อมูลนำเข้าต้องใช้หน่วยเป็นเมตรซึ่งรับประกันว่าจะประกอบด้วยจำนวนเต็มไม่เป็นลบและเอาต์พุตควรเป็นชั่วโมงหรือนาทีอย่างสม่ำเสมอ (แต่ไม่ใช่ทั้งคู่) และต้องสามารถให้ตัวเลขทศนิยมที่สามารถใช้งานได้ .

ตัวอย่างเช่นกำหนด:

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

สำหรับสององค์ประกอบแรก[100, 200]คุณมีการขึ้น 100 เมตรซึ่งก็คือ 10 นาที เมื่อ[200, 400]คุณมีการปีนขึ้นไป 200 เมตรซึ่งเป็นเวลา 20 นาที[400, 200]จะไม่ขึ้นไปดังนั้นจึงไม่มีเวลาเพิ่ม [200, 700]คือ 500 เมตรของทางขึ้นซึ่งคือ 50 นาทีและในที่สุดก็[700, 400]ไม่ได้ขึ้น เพิ่มหนึ่งชั่วโมงพิเศษสำหรับระยะทางห้ากิโลเมตร รวมเป็น140นาทีหรือ2.333 ...ชั่วโมง

กรณีทดสอบ

[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 ไบต์

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

ลองออนไลน์!

-1 ไบต์โดยใช้pmaxเป็นคำตอบอื่น ๆ หลายคำตอบ

รับอินพุตเป็นAกลิ่นและDistance และส่งคืนเวลาเป็นนาที

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 ไบต์

บันทึก 1 ไบต์ต้องขอบคุณคำตอบของ Giuseppe (หารด้วย 10 เมื่อสิ้นสุดกระบวนการ)

([altitudes])(distance)จะเข้าเป็น ส่งคืนเวลาเป็นนาที

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

ลองออนไลน์!

05AB1E , 15 ไบต์

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

ลองออนไลน์!

ส่งคืนเวลาเป็นนาที

คำอธิบาย

              + # 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 ไบต์

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

ส่งคืนเวลาเป็นชั่วโมง

ลองออนไลน์!

Python 2, 62 60 ไบต์

บันทึก 2 ไบต์ด้วย ovs

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

ลองออนไลน์!

ส่งคืนเวลาเป็นนาที

# 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

เพิร์ล 6 ,45 39 37 ไบต์

บันทึกไปแล้ว 6 ไบต์ด้วย Jo King

บันทึก 2 ไบต์ด้วย nwellnhof

(ขอขอบคุณพวกเขาทั้งสองสิ่งนี้ไม่เหมือนการส่งต้นฉบับของฉัน: —))

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

ลองออนไลน์!

อาร์กิวเมนต์แรกคือรายการที่มีการยกระดับอาร์กิวเมนต์ที่สองคือความยาวของช่วงระยะการเดินทาง

สิ่งทั้งหมดคือ AnythingCode หากการแสดงออกได้รับการยอมรับเช่นนี้แล้วแต่ละคน*เป็นอาร์กิวเมนต์หนึ่ง

ดังนั้นใน*.&{sum (.skip Z-$_)Xmax 0}/600เราใช้อาร์กิวเมนต์แรก (คนเกิดขึ้นครั้งแรก*) .&{}และใช้บล็อกในนั้นด้วยวิธีการเช่นการสร้าง บล็อกใช้เวลาหนึ่งอาร์กิวเมนต์ (รายการ) ซึ่งจะเข้าสู่$_ดังนั้น.skipเป็นรายการที่ไม่มีองค์ประกอบแรก Z-เราลบอาร์เรย์เดิมองค์ประกอบโดยองค์ประกอบจากที่ใช้ การซิปจะหยุดทันทีที่รายการที่สั้นลงหมดซึ่งก็โอเค

Xจากนั้นเราจะใช้ประกอบสินค้าข้าม list X(op) listสร้างคู่ที่เป็นไปได้ทั้งหมดที่องค์ประกอบแรกมาจากรายการด้านซ้ายและที่สองจากทางด้านขวาและใช้ผู้ประกอบการ(op)ที่พวกเขา ผลลัพธ์จะถูกส่งคืนเป็น Seq (รายการที่ถ่ายครั้งเดียว) อย่างไรก็ตามรายการที่ถูกต้องมีองค์ประกอบเดียวเท่านั้น 0 ดังนั้นมันจึงเป็น* max 0องค์ประกอบโดยองค์ประกอบ ที่ทำให้แน่ใจว่าเรานับได้เพียงส่วนของการเดินทาง จากนั้นเราบวกมันและหารด้วย 600

จากนั้นเราเพิ่ม*/5e3ที่*เกิดขึ้นเป็นครั้งที่สองและดังนั้นจึงเป็นอาร์กิวเมนต์ที่สองและหารด้วย 5,000 ผลรวมคือเวลาในหน่วยชั่วโมง (สิ่งนี้มีประสิทธิภาพมากกว่าเวลาเป็นนาทีเนื่องจากเราต้องการทวีคูณและสิ่ง*นั้นจะต้องคั่นด้วยช่องว่างจาก AnythingStar *)

ตกลง 21 ไบต์

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

ลองออนไลน์! เหยียดหยามข้อผิดพลาดในการแยกวิเคราะห์ที่เป็นเช่นเดียวกับ.1.012.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 ขอบคุณสตรีม

k , 23 ไบต์

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

ลองออนไลน์!

เยลลี่ 12 ไบต์

×.12;I}»0÷⁵S

ลองออนไลน์!

-1 ขอบคุณที่นาย Xcoder

Python 2 , 59 ไบต์

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

ลองออนไลน์!

ส่งคืนชั่วโมงเป็นทศนิยม

Pyth , 15 ไบต์

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

โปรแกรมเต็มคาดว่าชุดของความสูงเป็นอาร์กิวเมนต์แรกระยะทางเป็นที่สอง ส่งคืนเวลาเป็นนาที

ลองออนไลน์ได้ที่นี่หรือตรวจสอบกรณีทดสอบทั้งหมดในครั้งเดียวที่นี่

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 ไบต์

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

ลองออนไลน์!

ฟังก์ชั่นดั้งเดิมที่รับอินพุต (จากขวาไปซ้าย) เป็น1st ⎕= ความสูง / ความลึก2nd ⎕= ระยะทาง

ขอบคุณ @ngn ที่เป็นตัวช่วยสร้างหนึ่งสามไบต์

มันทำงานอย่างไร:

.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 ไบต์

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

ลองออนไลน์

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

มีแนวโน้มที่จะสามารถเล่นกอล์ฟได้อีกเล็กน้อย

Stax , 17 ไบต์

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

เรียกใช้และแก้ไขปัญหาได้ที่ staxlang.xyz!

รับอินพุตทั้งหมดเป็นแบบลอยแม้ว่าจะเป็นการบันทึกแบบไบต์ในเวอร์ชันที่ไม่มีการแพ็กเท่านั้น น่าจะเป็นไปไม่ได้; ตอนนี้กลับไปที่รหัสกอล์ฟฉันค่อนข้างเป็นสนิม

คลายการแพค (20 ไบต์) และคำอธิบาย:

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|++ ทำงานได้กับอินพุตหนึ่งอินพุทสำหรับ 21 ไบต์และยังคงเต็ม 17