ในคำถามนี้เราจะเน้นไปที่การลดน้ำหนักด้วยการออกกำลังกายแม้ว่าจะยังมีอีกหลายวิธีในการลดน้ำหนัก

กีฬาที่แตกต่างกันเผาผลาญแคลอรี่ในปริมาณที่แตกต่างกัน

ตัวอย่างเช่นการเล่นบิลเลียดเป็นเวลาหนึ่งชั่วโมงสามารถเผาผลาญแคลอรี่ได้ 102 ^[1]ในขณะที่เล่นบาสเก็ตบอลเป็นเวลา 15 นาทีสามารถเผาผลาญแคลอรี่ได้ 119 แคลอรี่^[1]ซึ่งทำให้น้ำหนักลดลง

วิธีที่แม่นยำในการชั่งความสะดวกคือการหารปริมาณแคลอรี่ที่เผาผลาญตามเวลาที่ต้องการซึ่งทำให้ดัชนีความง่าย (EI)

ตัวอย่างเช่นการฟันดาบเป็นเวลา 15 นาทีสามารถเผาผลาญ 85 แคลอรี่ซึ่งได้รับ EI 85/15

คุณจะได้รับรายการในรูปแบบนี้:

[["fencing",15,85],["billiards",60,102],["basketball",15,119]]

หรือรูปแบบอื่น ๆ ที่คุณต้องการ

จากนั้นคุณจะแสดงผลกีฬาที่มี EI สูงสุด

TL; DR

รับรายการของสิ่งอันดับ[name,value1,value2]ผลลัพธ์nameที่value2/value1สูงสุด

ข้อ จำกัด

• คุณไม่สามารถสร้างจำนวนจริงใด ๆ ที่ไม่ใช่จำนวนเต็มในกระบวนการ
• คุณไม่สามารถใช้เศษส่วนในตัวได้

ข้อมูลจำเพาะ (Specs)

• หากมีมากกว่าหนึ่งชื่อที่ตอบสนองผลคุณสามารถส่งออกชุดย่อยที่ไม่ว่างเปล่าของพวกเขาหรือองค์ประกอบใด ๆ ของพวกเขา
• ชื่อจะตรงกับ regex /^[a-z]+$/ซึ่งหมายความว่าจะประกอบด้วยตัวอักษรมาตรฐานตัวพิมพ์เล็กละตินเท่านั้น
• รายการจะไม่ว่างเปล่า

TestCase

การป้อนข้อมูล:

[["fencing",15,85],["billiards",60,102],["basketball",15,119]]

เอาท์พุท:

basketball

อ้างอิง

1. http://calorielab.com/burned/

Python 2, 51 ไบต์

lambda l:max((10**len(`l`)*a/b,s)for s,b,a in l)[1]

ทำสิ่งที่ชัดเจนในการค้นหารายการที่มีอัตราส่วนที่ใหญ่ที่สุด แต่หลีกเลี่ยงข้อห้ามต่อการลอยโดยการคูณตัวเศษแรกด้วยกำลังที่ขึ้นอยู่กับอินพุตมากถึง 10 ก่อนการแบ่งพื้น

ฉันจะพิสูจน์ว่าสัมประสิทธิ์นี้มีขนาดใหญ่พอที่จะทำให้การแบ่งพื้นทำหน้าที่แตกต่างเหมือนกับการแบ่งพื้น

การอ้างสิทธิ์:ถ้า₁ / b ₁ > a ₂ / b ₂ดังนั้นพื้น (Na ₁ / b ₁ )> ชั้น (Na ₂ / b ₂ ) สำหรับN≥b ₁ b ₂ใด ๆ

หลักฐาน:โปรดทราบว่า₁ / b ₁ - a ₂ / b ₂คือผลคูณของ 1 / b ₁ b ₂ดังนั้น₁ / b ₁ - a ₂ / b ₂ > 0 หมายความว่า

a ₁ / b ₁ - a ₂ / b ₂ ≥ 1 / b ₁ b ₂

จากนั้นคูณทั้งสองข้างด้วย N

Na ₁ / b ₁ - Na ₂ / b ₂ ≥ N / b ₁ b ₂ ≥ 1

ดังนั้นเนื่องจาก Na ₁ / b ₁และ Na ₂ / b ₂ต่างกันอย่างน้อย 1 ชั้นจึงมีความแตกต่างกัน ∎

ตอนนี้โปรดทราบว่าผลิตภัณฑ์ b ₁ b ₂มีความยาวหลักที่ความยาวรวมสูงสุดซึ่งน้อยกว่าความยาวสตริงของอินพุต เนื่องจากอินพุตอยู่ในฐาน 10 จึงพอเพียงที่จะใช้ 10 ต่อกำลังของความยาวของมันN=10**len(`l`)เพื่อสร้างตัวเลขที่มีตัวเลขมากกว่าตัวเลขรับประกันถึงเงื่อนไข

JavaScript (ES6), 43 ไบต์

a=>a.sort(([p,q,r],[s,t,u])=>q*u-r*t)[0][0]

หรืออีกวิธีหนึ่ง

a=>a.sort((v,w)=>v[1]*w[2]-v[2]*w[1])[0][0]

การเรียงลำดับเป็นสิ่งที่มากเกินไปสำหรับสิ่งนี้ แต่reduceจะใช้เวลา 46 ไบต์:

a=>a.reduce((v,w)=>v[1]*w[2]-v[2]*w[1]?v:w)[0]

MATL , 8 ไบต์

pG/*&X<)

ตัวเลขที่คำนวณทั้งหมดเป็นค่าจำนวนเต็ม ขั้นแรกให้คำนวณผลคูณของตัวส่วน (นี่คือจำนวนเต็ม) ผลิตภัณฑ์นี้หารด้วยตัวส่วนแต่ละตัว (ซึ่งให้จำนวนเต็มด้วย) ผลลัพธ์แต่ละรายการจะถูกคูณด้วยตัวเศษที่เกี่ยวข้อง สิ่งนี้จะให้ค่าจำนวนเต็มตามสัดส่วนกับเศษส่วนดั้งเดิม

รูปแบบการป้อนข้อมูลคือ: อาร์เรย์ตัวเลขพร้อมตัวส่วน, อาร์เรย์ตัวเลขพร้อมตัวนับ, อาร์เรย์เซลล์ของสตริงที่มีชื่อกีฬา:

[85, 102, 119]
[15, 60, 15]
{'fencing', 'billiards', 'basketball'}

หากมีตัวย่อหลายตัวตัวแรกคือเอาต์พุต

ลองออนไลน์!

p     % Take first input. Compute the product of its entries
G/    % Divide by first input element-wise
*     % Take second input. Multiply by previous array element-wise
&X<   % Argmax
)     % Take third input. Index into it using previous result. Display

Dyalog APL ขนาด 18 ไบต์

⎕⊃⍨(⊢⍳⌈/)⎕×(∧/÷⊢)⎕

พร้อมท์สำหรับเวลาจากนั้นสำหรับแคลอรี่จากนั้นสำหรับชื่อกิจกรรม

⎕ พรอมต์ (ครั้ง)

(∧/÷⊢)LCM ∧/คูณด้วยจำนวน÷ครั้ง⊢(ดังนั้นจึงไม่มีการลอย)

⎕× พรอมต์ (สำหรับแคลอรี่) และคูณด้วยพวกเขา

(⊢⍳⌈/)ในนั้น⊢รับตำแหน่ง⍳ของค่าสูงสุด⌈/

⎕⊃⍨พรอมต์ (สำหรับกิจกรรม) จากนั้นเลือกลำดับที่n

ตัวอย่างการเรียกใช้:

      ⎕⊃⍨(⊢⍳⌈/)⎕×(∧/÷⊢)⎕
⎕:
      15 60 15
⎕:
      85 102 119
⎕:
      'fencing' 'billiards' 'basketball'
basketball

Brachylogขนาด 42 ไบต์

:{bh.}a*g:?z:2aott.
[D:[S:I:J]]tt:D*:I/:S.

ลองออนไลน์!

/ด้านบนคือการหารจำนวนเต็มเพราะทั้งคู่J*DและIเป็นจำนวนเต็ม (Dเป็นIจริง)

คำอธิบาย

• ภาคแสดงหลัก: Input = [["string":mins:cals]:...]

  :{bh.}a*                Multiply all mins in the Input together
          g:?z            Zip that number with the Input
              :2a         Apply predicate 2 to that zipped list
                 ott.     Sort the list of lists on the values of the first element of
                            sublists, Output is the string of the last sublist
  

• คำกริยาที่ 1:

  [D:[S:I:J]]             Input = [D:[S:I:J]]
             tt:D*        Multiply J by D
                  :I/     Divide the result by I
                     :S.  Output = [That number:S]
  

เรติน่า64ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

\d+
$*
%`\G1
0
1
:$_:
Ts`0p¶`0_`:.+?:
+`(0+) \1
@$1 
O`
!`\w+$

value1 value2 nameการป้อนข้อมูลเป็นหนึ่งในกีฬาต่อบรรทัดที่มีรูปแบบ ผลลัพธ์เป็นผลลัพธ์สูงสุดอย่างใดอย่างหนึ่ง (หากมีการเสมอกันมันจะให้ผลลัพธ์ที่มีขนาดใหญ่ที่สุดvalue1และหากมีการผูกเช่นกันหากจะให้ขนาดใหญ่กว่าพจนานุกรมname )

ทราบว่านี้เป็นซุปเปอร์ช้า (ด้วยเหตุผลเดียวกันกับเมื่อวานนี้กองแลกเปลี่ยนดับ ) เพื่อให้ทำงานในระยะเวลาที่เหมาะสมคุณสามารถเพิ่ม\bหน้า(0+)(ซึ่งจะไม่ส่งผลกระทบต่อวิธีการดำเนินการอินพุตเลย แต่ จำกัด backtracking ของ regex อย่างรุนแรง) ฉันได้ทำไปแล้วในลิงค์ทดสอบด้านล่าง

ลองออนไลน์!

Python 2, 55 54 ไบต์

lambda x:sorted(x,lambda(S,N,D),(s,n,d):N*d-n*D)[0][0]

ขอบคุณ @xnor สำหรับการเล่นกอล์ฟ 1 ไบต์!

ทดสอบบนIdeone

Haskell 72 70 bytes

import Data.List
(n,(x,y))%(m,(a,b))=compare(x*b)$y*a
fst.minimumBy(%)

การใช้งาน:

main=putStr$(fst.minimumBy(%))[("fencing",(15,85)),("billiards",(60,102)),("basketball",(15,119))]

Mathematica ขนาด 46 ไบต์

Last/@MaximalBy[#,g=LCM@@First/@#;g#2/#&@@#&]&

คำสั่งของ tuples {value1,value2,name}ที่ควรจะเป็น ส่งคืนชุดเต็มของผลลัพธ์สูงสุดทั้งหมด

ฉันหลีกเลี่ยงการใช้เศษส่วนโดยการคูณตัวเศษด้วย LCM ของทุกvalue1ส่วนก่อนหาร

R, 42 40 ไบต์

function(v)v[which.max(v[,3]%/%v[,2]),1]

รับอินพุตในรูปแบบของกรอบข้อมูลที่มีประเภทคอลัมน์ของสตริง (มันยังทำงานได้กับปัจจัย), ตัวเลข, ตัวเลข

• %/% เป็นการหารจำนวนเต็ม

นี่คือการส่งครั้งแรกของฉันแจ้งให้เราทราบว่าเป็นไปตามกฎหรือไม่

แก้ไข:ปรากฎว่าคุณไม่จำเป็นต้องจัดฟันเพื่อกำหนดฟังก์ชั่นหนึ่งบรรทัด

C ++ 14, 89 ไบต์

ฟังก์ชั่นแลมบ์ดา:

[](auto s,int*a,int*b,int l){int r=--l;while(l--)r=b[l]*a[r]>a[l]*b[r]?l:r;return s[r];};

Ungolfed:

[](auto s,int*a,int*b,int l)
{
  int r = --l;
  while(l--)
    r = b[l] * a[r] > a[l] * b[r] ? l : r;
  return s[r];
};

การใช้งาน:

#include <iostream>

int main()
{
  const char* s[] = {"fencing", "billiards", "basketball"};
  int a[] = {15,60,15};
  int b[] = {85,102,119};
  std::cout << [](auto s,int*a,int*b,int l){int r=--l;while(l--)r=b[l]*a[r]>a[l]*b[r]?l:r;return s[r];}(s,a,b,3);
}

Haskell, 46 ไบต์

s(n,(x,y))=(divMod y x,n)
g =snd.maximum.map s

แก้ไข:วิธีนี้ไม่ได้ผลตามที่ดาเมียนชี้ให้เห็นซึ่งไม่สามารถแก้ปัญหาได้ ฉันกำลังค้นหาการแก้ไขที่ดี

VBA Excel, 109 ไบต์

Function A(B)
R=1
For I=2 To B.Rows.Count
If B(R,2)*B(I,3)>B(I,2)*B(R,3) Then R=I
Next
A=B(R,1)
End Function

เรียกใช้ในเซลล์สเปรดชีตที่อ้างอิงถึงตารางกิจกรรมและพารามิเตอร์:

05AB1E , 6 7 ไบต์

P¹÷*ZQÏ

1 ไบต์เพื่อแก้ไขข้อผิดพลาดวิธี divmod ของฉัน ( ดูความคิดเห็นนี้ในคำตอบอื่น ) โดย porting @LuisMendo 's คำตอบ MATLเพื่อให้แน่ใจว่าจะ upvote เขา!

ข้อมูลมีความคล้ายคลึงกับคำตอบของเขา: สามรายการที่แยกกันเป็นรายการจำนวนเต็มของตัวส่วน; รายการจำนวนเต็มของผู้เสนอชื่อ; และรายการสตริงของชื่อ

ลองออนไลน์หรือตรวจสอบกรณีทดสอบเพิ่มเติมตรวจสอบกรณีทดสอบบางมากขึ้น

คำอธิบาย:

P       # Take the product of the (implicit) input-list of denominators
        #  i.e. [85,102,119] → 1031730
 ¹÷     # (Integer)-divide it by each of the denominators of the first input-list
        #  i.e. 1031730 / [85,102,119] → [12138,10115,8670]
   *    # Multiply each (at the same positions) by the (implicit) input-list of nominators
        #  i.e. [12138,10115,8670] * [15,60,15] → [182070,606900,130050]
    Z   # Get the maximum of this list (without popping the list itself)
        #  i.e. [182070,606900,130050] → [182070,606900,130050] and 606900
     Q  # Check which values are equal to this maximum
        #  i.e. [182070,606900,130050] and 606900 → [0,1,0]
      Ï # Only leave the strings of the (implicit) input-list of names at the truthy indices
        #  i.e. ["fencing","billiards","basketball"] and [0,1,0] → ["billiards"]
        # (after which the result is output implicitly)

Java 8, 128 Bytes

String f(List<Object[]>l){return l.stream().max((x,y)->(int)x[2]*1000/(int)x[1]-(int)y[2]*1000/(int)y[1]).get()[0].toString();}

Ruby, 72 ไบต์

e=0;while gets;n=$_.split;f=eval n[2]+"/"+n[1];m,e=n[0],f if f>e;end;p m

ฉันคิดว่ามันจะสั้นกว่านี้ ...

อินพุตถูกนำมาจาก STDIN ในรูปแบบของ name time calories

โอ้ดีความช่วยเหลือใด ๆ ที่จะย่อให้มันสั้นลง

Clojure, 63 ไบต์

#((last(sort(fn[[x a b][y c d]](-(* b c)(* a d)))%))0)

PHP , 98 ไบต์

ใช้รูปแบบอินพุตที่ง่ายกว่าตัวอย่างเช่นนี้:

ฟันดาบ 15,85, บิลเลียด, 60102, บาสเกตบอล, 15119

$s=explode(",",$argn);for($x=0;$s[$x];$x+=3){if($y<$e=$s[$x+2]/$s[$x+1]){$y=$e;$z=$s[$x];}}echo$z;

ลองออนไลน์!