В этом вопросе мы сосредоточимся только на похудении, выполняя упражнения, хотя есть еще много способов похудеть.

Разные виды спорта сжигают разное количество калорий.

Например, игра в бильярд в течение часа может сжечь 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]выведите namewhere value2/value1.

Ограничения

• Вы не можете производить какие-либо действительные числа, которые не являются целыми числами в процессе.
• Вы не можете использовать любую встроенную дробь.

Технические характеристики (спецификации)

• Если существует более одного имени, которое удовлетворяет результату, вы можете вывести любое непустое их подмножество или любой их элемент.
• Имя будет соответствовать регулярному выражению /^[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 ₂ , то floor (Na ₁ / b ₁ )> floor (Na ₂ / b ₂ ) для любого N≥b ₁ b ₂ .

Доказательство: обратите внимание, что a ₁ / b ₁ - a ₂ / b ₂ кратно 1 / b ₁ b ₂ , поэтому a ₁ / 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 _1, 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

Дьялог АПЛ , 18 байт

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

Запрашивает время, затем калории, затем имена активности.

⎕ подскажите (на раз)

(∧/÷⊢)LCM ∧/времени, деленного ÷на время ⊢(поэтому не плавает)

⎕× подскажите (для калорий) и умножьте на них

(⊢⍳⌈/)в этом ⊢, получить положение ⍳максимального значения⌈/

⎕⊃⍨подскажите (для действий), затем выберите n- й.

Пример выполнения:

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

Брахилог , 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 62 байта

Количество байтов предполагает кодировку ISO 8859-1.

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

Ввод - один вид спорта на строку в формате value1 value2 name . Вывод является одним из максимальных результатов (если есть связь, он даст тот, у которого наибольшее значение, value1и если они также связаны, если лексикографически больше name).

Обратите внимание, что это очень медленно (по тем же причинам, что и вчерашний сбой Stack Exchange ). Чтобы запустить его в разумные сроки, вы можете добавить\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}. Возвращает полный набор всех максимальных результатов.

Я работаю вокруг использования дробей, умножая числитель на LCM всех value1s до деления.

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 ( см. Этот комментарий к другому ответу) ) путем переноса @LuisMendo @LuisMendo на MATL , так что не забудьте его поддержать!

Входные данные аналогичны его ответу: три отдельных списка, представляющих собой целочисленный список знаменателей; целочисленный список номинаторов; и список строк имен.

Попробуйте онлайн или проверьте еще несколько тестов .

Объяснение:

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

Рубин, 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;

Попробуйте онлайн!