在这个问题上，尽管减肥的方法仍然很多，但我们只会专注于通过运动来减肥。

不同的运动会消耗不同量的卡路里。

例如，打台球一个小时可以燃烧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其中where value2/value1最高。

约束条件

• 您可能不会在该过程中产生任何非整数的实数。
• 您不得使用任何内置分数。

规格（规格）

• 如果满足该结果的名称不止一个，则可以输出它们的任何非空子集或它们的任何元素。
• 该名称将与regex匹配/^[a-z]+$/，这意味着它仅由小写的拉丁文标准字母组成。
• 该列表将不会为空。

测试用例

输入：

[["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的依赖于输入的巨大幂来避开对浮点数的禁止。

我将证明该系数足够大，可以使楼层划分的行为与非楼层划分的行为相同。

要求：如果a ₁ / b ₁ > a ₂ / b ₂，则地板为（Na ₁ / B ₁）>地板（钠₂ / B ₂），用于任何N≥b ₁ b ₂。

证明：请注意，a ₁ / b ₁ -a ₂ / b ₂是1 / b ₁ b 的倍数 ₂，因此₁ / b ₁ -a ₂ / b ₂ > 0意味着

一个₁ / B ₁ -一个₂ / B ₂ ≥1 / B ₁ b ₂

然后，将两边都乘以N，

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

所以，因为娜 ₁ / b ₁和Na ₂ / b ₂至少相差1，所以它们各自的底面是不同的。∎

现在，请注意产品b ₁ b _2的位数长度最多为它们的总位数长度，该长度小于输入的字符串长度。由于输入的数字是以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都是整数（DI实际上是的倍数）。

说明

• 主要谓词： 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 62字节

字节数假定为ISO 8859-1编码。

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

输入是每行一项运动，格式为value1 value2 name。输出是最大结果之一（如果有平局，它将给出最大的结果，如果也平局，则将value1在字典上变大name）。

请注意，这是超级慢（对于完全相同的理由，昨天的堆栈交易所停运）。要使其在合理的时间内运行，您可以\b在(0+)（这完全不会影响它处理输入的方式，但会严重限制该正则表达式的回溯）。我已经在下面的测试链接中做到了。

在线尝试！

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字节

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/#&@@#&]&

元组的顺序应为{value1,value2,name}。返回所有最大结果的完整集合。

我通过将分子乘以value1除法前所有s 的LCM来解决分数的使用问题。

R，42 40字节

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

以数据框的形式接受输入，其中的列类型为字符串（也适用于因子），数字，数字。

• %/% 是整数除法。

这是我的第一次提交，请让我知道它是否在规则范围内。

编辑：事实证明您不需要花括号来定义单行功能。

C ++ 14，89个字节

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

取消高尔夫：

[](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字节通过移植@LuisMendo的MATL答案来修正我的divmod方法（请参见其他答案的评论），因此请确保对他进行投票！

输入类似于他的答案：三个分开的列表，是分母的整数列表；提名人的整数列表；以及名称的字符串列表。

在线尝试或验证更多测试用例。

说明：

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字节

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，台球，60,102，篮球，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;

在线尝试！