Trong câu hỏi này, chúng tôi sẽ chỉ tập trung vào việc giảm cân bằng cách tập thể dục, mặc dù vẫn còn nhiều cách để giảm cân.

Các môn thể thao khác nhau đốt cháy lượng calo khác nhau.

Ví dụ, chơi bi-a trong một giờ có thể đốt cháy 102 calo ^[1] , trong khi chơi bóng rổ trong 15 phút đã có thể đốt cháy 119 calo ^[1] , giúp giảm cân bằng cách chơi bóng rổ dễ dàng hơn, ít nhất là từ một số quan điểm.

Cách chính xác để cân nhắc mức độ dễ dàng là bằng cách chia lượng calo bị đốt cháy theo thời gian cần thiết, điều này cho chúng ta chỉ số mức độ dễ dàng (EI).

Ví dụ, đấu kiếm trong 15 phút có thể đốt cháy 85 calo, đạt EI là 85/15.

Bạn sẽ được cung cấp một danh sách theo định dạng này:

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

hoặc định dạng khác mà bạn muốn.

Sau đó, bạn sẽ xuất ra các môn thể thao có EI cao nhất.

TL; DR

Đưa ra một danh sách các bộ [name,value1,value2]dữ liệu đầu ra ở namenơi value2/value1cao nhất.

Những ràng buộc

• Bạn không thể tạo ra bất kỳ số thực nào không phải là số nguyên trong quy trình.
• Bạn không được sử dụng bất kỳ phân số tích hợp nào.

Thông số kỹ thuật (Thông số kỹ thuật)

• Nếu có nhiều hơn một tên thỏa mãn kết quả, bạn có thể xuất bất kỳ tập hợp con không trống nào của chúng hoặc bất kỳ phần tử nào của chúng.
• Tên sẽ phù hợp với regex /^[a-z]+$/, có nghĩa là nó sẽ chỉ bao gồm bảng chữ cái tiêu chuẩn Latin viết thường.
• Danh sách sẽ không trống.

Testcase

Đầu vào:

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

Đầu ra:

basketball

Người giới thiệu

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

Python 2, 51 byte

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

Có phải điều hiển nhiên của việc tìm mục nhập với tỷ lệ lớn nhất, nhưng bỏ qua việc cấm phao bằng cách nhân tử số đầu tiên với công suất phụ thuộc đầu vào lớn là 10 trước khi chia sàn.

Tôi sẽ chứng minh hệ số này đủ lớn để phân chia sàn hoạt động giống như phân chia không sàn.

Yêu cầu: Nếu a ₁ / b ₁ > a ₂ / b ₂ , thì tầng (Na ₁ / b ₁ )> sàn (Na ₂ / b ₂ ) cho bất kỳ N≥b ₁ b ₂ .

Chứng minh: Lưu ý rằng ₁ / b ₁ - a ₂ / b ₂ là bội số của 1 / b ₁ b ₂ , do đó, ₁ / b ₁ - a ₂ / b ₂ > 0 ngụ ý rằng

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

Sau đó, nhân cả hai vế của N,

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

Vì vậy, vì Na ₁ / b ₁ và Na ₂ / b ₂ khác nhau ít nhất 1, nên các tầng tương ứng của chúng là khác biệt. ■

Bây giờ, lưu ý rằng sản phẩm b ₁ b ₂ có độ dài chữ số nhiều nhất là tổng chiều dài chữ số của chúng, nhỏ hơn độ dài chuỗi của đầu vào. Vì đầu vào nằm trong cơ sở 10, nên nó đủ để sử dụng 10 với sức mạnh của chiều dài của nó N=10**len(`l`)để tạo ra một số có nhiều chữ số hơn nó, đảm bảo điều kiện.

JavaScript (ES6), 43 byte

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

Hay cách khác

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

Sắp xếp tất nhiên là quá mức cần thiết cho việc này, nhưng reducesẽ mất 46 byte:

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

TOÁN , 8 byte

pG/*&X<)

Tất cả các số được tính là giá trị nguyên. Đầu tiên, tích của mẫu số được tính (đây là số nguyên). Sản phẩm này được chia cho mỗi mẫu số (cũng cung cấp một số nguyên). Mỗi kết quả sau đó được nhân với tử số tương ứng. Điều này cho một giá trị số nguyên tỷ lệ với phân số ban đầu.

Định dạng đầu vào là: mảng số có mẫu số, mảng số có tử số, mảng ô của chuỗi có tên thể thao:

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

Nếu có một vài bộ giảm thiểu thì cái đầu tiên là đầu ra.

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

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

APL Dyalog , 18 byte

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

Nhắc nhở lần, sau đó cho calo, sau đó cho tên hoạt động.

⎕ nhắc nhở (lần)

(∧/÷⊢)LCM ∧/của thời gian chia ÷cho thời gian ⊢(vì vậy không có phao)

⎕× nhắc nhở (cho lượng calo) và nhân với chúng

(⊢⍳⌈/)trong đó ⊢, có được vị trí ⍳của giá trị tối đa⌈/

⎕⊃⍨nhắc nhở (cho các hoạt động), sau đó chọn thứ n .

Chạy ví dụ:

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

Brachylog , 42 byte

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

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

/ở trên là phép chia số nguyên vì cả hai J*Dvà Ilà số nguyên (D là bội số của Ithực tế).

Giải trình

• Vị ngữ chính: 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
  

• Vị ngữ 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]
  

Võng mạc , 64 62 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Đầu vào là một môn thể thao trên mỗi dòng, với định dạng value1 value2 name. Đầu ra là một trong những kết quả tối đa (nếu có một ràng buộc, nó sẽ cho kết quả lớn nhất value1và nếu chúng được buộc cũng như nếu nó sẽ cho kết quả từ vựng lớn hơn name).

Lưu ý rằng điều này là siêu chậm (vì những lý do chính xác giống như ngừng hoạt động Stack Exchange của ngày hôm qua ). Để làm cho nó chạy trong một khoảng thời gian hợp lý, bạn có thể thêm một \bở phía trước(0+) (điều này sẽ không ảnh hưởng đến cách nó xử lý đầu vào nhưng hạn chế nghiêm trọng việc quay lại của biểu thức chính đó). Tôi đã làm điều đó trong liên kết thử nghiệm dưới đây.

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

Python 2, 55 54 byte

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

Cảm ơn @xnor vì đã chơi golf 1 byte!

Kiểm tra nó trên Ideone .

Haskell 72 70 byte

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

Sử dụng :

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

Toán học, 46 byte

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

Thứ tự của các bộ dữ liệu nên là {value1,value2,name} . Trả về tập hợp đầy đủ của tất cả các kết quả tối đa.

Tôi làm việc xung quanh việc sử dụng phân số bằng cách nhân tử số với LCM của tất cả các value1s trước khi chia.

R, 42 40 byte

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

Đưa đầu vào dưới dạng khung dữ liệu với các loại chuỗi của cột (nó cũng hoạt động với các yếu tố), số, số.

• %/% là phép chia số nguyên.

Đây là lần gửi đầu tiên của tôi, hãy cho tôi biết nếu nó nằm trong quy tắc.

Chỉnh sửa: Hóa ra bạn không cần niềng răng để xác định hàm một dòng.

C ++ 14, 89 byte

Hàm Lambda:

[](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];};

Ung dung:

[](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ử dụng:

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

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

EDIT: Giải pháp này không hoạt động như được chỉ ra bởi Damien, điều này không giải quyết được vấn đề. Tôi đang tìm kiếm một bản sửa lỗi tốt.

VBA Excel, 109 byte

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

Gọi vào ô bảng tính tham chiếu một bảng các hoạt động và tham số:

05AB1E , 6 7 byte

P¹÷*ZQÏ

+1 byte để sửa lỗi cách tiếp cận divmod của tôi ( xem nhận xét này về câu trả lời khác ) bằng cách chuyển @LuisMendo câu trả lời MATL của , vì vậy hãy đảm bảo nâng cao anh ấy!

Đầu vào tương tự như câu trả lời của anh ta: ba danh sách riêng biệt, là một danh sách số nguyên của mẫu số; một danh sách số nguyên của những người được đề cử; và một danh sách chuỗi các tên.

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

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 byte

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 byte

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

Tôi thực sự nghĩ rằng điều này sẽ ngắn hơn ...

Đầu vào được lấy từ STDIN theo định dạng name time calories

Oh tốt, bất kỳ trợ giúp để rút ngắn nó được đánh giá cao.

Clojure, 63 byte

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

PHP , 98 byte

Đã sử dụng một định dạng đầu vào đơn giản hơn so với ví dụ, giống như thế này:

đấu kiếm, 15,85, bi-a, 60,102, bóng rổ, 15,119

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

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