En esta pregunta, solo nos enfocaremos en perder peso haciendo ejercicio, aunque todavía hay muchas maneras de perder peso.

Diferentes deportes queman diferentes cantidades de calorías.

Por ejemplo, jugar al billar durante una hora puede quemar 102 calorías ^[1] , mientras que jugar al baloncesto durante 15 minutos ya puede quemar 119 calorías ^[1] , lo que facilita la pérdida de peso jugando al baloncesto, al menos desde algunas perspectivas.

La forma exacta de sopesar la facilidad es dividiendo la cantidad de calorías quemadas por el tiempo necesario, lo que nos da el índice de facilidad (EI).

Por ejemplo, la esgrima durante 15 minutos puede quemar 85 calorías, lo que obtiene un EI de 85/15.

Se le dará una lista en este formato:

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

u otro formato que desee.

Luego, emitirá los deportes que tienen la IE más alta.

TL; DR

Dada una lista de tuplas de [name,value1,value2]salida, namedonde value2/value1es el más alto.

Restricciones

• Es posible que no se produce ningún número real que no es entero en el proceso.
• Es posible que no utilice cualquier fracción incorporada.

Especificaciones (especificaciones)

• Si hay más de un nombre que satisfaga el resultado, puede generar cualquier subconjunto no vacío de ellos o cualquier elemento de ellos.
• El nombre coincidirá con la expresión regular /^[a-z]+$/, lo que significa que solo consistirá en minúsculas alfabeto latino estándar.
• La lista no estará vacía.

Caso de prueba

Entrada:

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

Salida:

basketball

Referencias

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

Python 2, 51 bytes

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

Hace lo obvio de encontrar la entrada con la mayor proporción, pero evita la prohibición de flotadores al multiplicar primero el numerador por una enorme potencia de 10 dependiente de la entrada antes de dividir el piso.

Demostraré que este coeficiente es lo suficientemente grande como para hacer que la división de piso actúe como la misma diferencia que la división sin piso.

Reclamación: Si a ₁ / b ₁ > a ₂ / b ₂ , entonces floor (Na ₁ / b ₁ )> floor (Na ₂ / b ₂ ) para cualquier N≥b ₁ b ₂ .

Prueba: Tenga en cuenta que a ₁ / b ₁ - a ₂ / b ₂ es un múltiplo de 1 / b ₁ b ₂ , por lo que a ₁ / b ₁ - a ₂ / b ₂ > 0 implica que

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

Luego, multiplicando ambos lados por N,

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

Entonces, desde Na ₁ / b ₁ y Na ₂ / b ₂ difieren en al menos 1, sus respectivos pisos son distintos. ∎

Ahora, tenga en cuenta que el producto b ₁ b ₂ tiene una longitud de dígitos como máximo su longitud total de dígitos, que es menor que la longitud de la cadena de la entrada. Como la entrada está en la base 10, es suficiente usar 10 a la potencia de su longitud N=10**len(`l`)para producir un número con más dígitos que él, garantizando la condición.

JavaScript (ES6), 43 bytes

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

O alternativamente

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

Por supuesto, ordenar es excesivo para esto, pero reducetomaría 46 bytes:

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

MATL , 8 bytes

pG/*&X<)

Todos los números calculados son valores enteros. Primero, se calcula el producto de los denominadores (este es un número entero). Este producto se divide por cada denominador (que también da un número entero). Cada resultado se multiplica por el numerador correspondiente. Esto da un valor entero proporcional a la fracción original.

El formato de entrada es: matriz numérica con denominadores, matriz numérica con numeradores, matriz de celdas de cadenas con nombres deportivos:

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

Si hay varios minimizadores, se genera el primero.

Pruébalo en línea!

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 bytes

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

Solicita tiempos, luego calorías, luego nombres de actividades.

⎕ aviso (para veces)

(∧/÷⊢) LCM ∧/ de los tiempos dividido por ÷los tiempos ⊢(por lo que no hay flotadores)

⎕× preguntar (por calorías) y multiplicar por ellas

(⊢⍳⌈/) en eso ⊢ , obtenga la posición ⍳del valor máximo⌈/

⎕⊃⍨ mensaje (para actividades), luego elija el n º.

Ejemplo de ejecución:

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

Brachylog , 42 bytes

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

Pruébalo en línea!

/arriba es la división entera porque ambos J*Dy Ison enteros (D es un múltiplo deI hecho).

Explicación

• Predicado principal: 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
  

• Predicado 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]
  

Retina , 64 62 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

La entrada es un deporte por línea, con el formato value1 value2 name. La producción es uno de los resultados máximos (si hay un empate, dará el que tenga el más grande value1y si esos están empatados también si dará el lexicográfico más grande name).

Tenga en cuenta que esto es muy lento (exactamente por las mismas razones que la interrupción de Stack Exchange de ayer ). Para que se ejecute en un período de tiempo razonable, puede agregar un \ben frente de(0+) (que no afectará la forma en que procesa la entrada en absoluto, pero limita severamente el retroceso de esa expresión regular). Lo hice en el siguiente enlace de prueba.

Pruébalo en línea!

Python 2, 55 54 bytes

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

¡Gracias a @xnor por jugar golf en 1 byte!

Pruébelo en Ideone .

Haskell 72 70 bytes

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

Uso:

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

Mathematica, 46 bytes

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

El orden de las tuplas debe ser {value1,value2,name} . Devuelve el conjunto completo de todos los resultados máximos.

Trabajo alrededor del uso de fracciones multiplicando el numerador por el MCM de todos los value1s antes de la división.

R, 42 40 bytes

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

Toma datos en forma de un marco de datos con tipos de columna de cadena (también funciona con factores), numérico, numérico.

• %/% es la división entera.

Esta es mi primera presentación, avíseme si está dentro de las reglas.

Editar: Resulta que no necesita las llaves para definir una función de una línea.

C ++ 14, 89 bytes

Función 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];};

Sin golf:

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

Uso:

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

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

EDITAR: Esta solución no funciona como lo señaló Damien, esto no resuelve el problema. Estoy buscando una buena solución.

VBA Excel, 109 bytes

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

Invoque en una celda de hoja de cálculo que haga referencia a una tabla de actividades y parámetros:

05AB1E , 6 7 bytes

P¹÷*ZQÏ

+1 byte para corregir mi enfoque divmod ( vea este comentario en otra respuesta ) al portar la respuesta MATL de @LuisMendo , ¡así que asegúrese de votarlo!

La entrada es similar a su respuesta: tres listas separadas, siendo una lista entera de denominadores; una lista entera de nominadores; y una lista de cadenas de nombres.

Pruébalo en línea o verifique algunos casos de prueba más .

Explicación:

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 bytes

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

Realmente pensé que esto sería más corto ...

La entrada se toma de STDIN en el formato de name time calories

Bueno, cualquier ayuda para acortarlo es apreciada.

Clojure, 63 bytes

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

PHP , 98 bytes

Usó un formato de entrada más simple que el ejemplo, así:

esgrima, 15,85, billar, 60,102, baloncesto, 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;

Pruébalo en línea!