Nesta questão, focaremos apenas a perda de peso fazendo exercícios, embora ainda haja muitas maneiras de perder peso.

Esportes diferentes queimam diferentes quantidades de calorias.

Por exemplo, jogar bilhar por uma hora pode queimar 102 calorias ^[1] , enquanto jogar basquete por 15 minutos já pode queimar 119 calorias ^[1] , o que facilita a perda de peso jogando basquete, pelo menos de algumas perspectivas.

A maneira exata de avaliar a facilidade é dividir a quantidade de calorias queimadas pelo tempo necessário, o que nos fornece o índice de facilidade (IE).

Por exemplo, cercar por 15 minutos pode queimar 85 calorias, o que gera um IE de 85/15.

Você receberá uma lista neste formato:

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

ou outro formato que você deseja.

Em seguida, você exibirá os esportes com maior IE.

TL; DR

Dada uma lista de tuplas [name,value1,value2]de saída name, onde value2/value1é o mais alto.

Restrições

• Você não pode produzir nenhum número real que não seja um número inteiro no processo.
• Você não pode usar nenhuma fração incorporada.

Especificações (Especificações)

• Se houver mais de um nome que satisfaça o resultado, você poderá gerar qualquer subconjunto não vazio deles ou qualquer elemento deles.
• O nome corresponderá ao regex /^[a-z]+$/, o que significa que ele consistirá apenas em alfabeto latino padrão em minúsculas.
• A lista não estará vazia.

Caso de teste

Entrada:

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

Resultado:

basketball

Referências

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]

Faz o óbvio de encontrar a entrada com a maior proporção, mas evita a proibição de carros alegóricos, primeiro multiplicando o numerador por uma enorme potência dependente de entrada de 10 antes da divisão do piso.

Vou provar que esse coeficiente é grande o suficiente para fazer com que a divisão de piso atue a mesma diferença que a divisão sem piso.

Reivindicação: Se a ₁ / b ₁ > a ₂ / b ₂ , então andar (Na ₁ / b ₁ )> andar (Na ₂ / b ₂ ) para qualquer N≥b ₁ b ₂ .

Prova: Observe que a ₁ / b ₁ - a ₂ / b ₂ é um múltiplo de 1 / b ₁ b ₂ , então a ₁ / b ₁ - a ₂ / b ₂ > 0 implica que

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

Então, multiplicando os dois lados por N,

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

Portanto, como Na ₁ / b ₁ e Na ₂ / b ₂ diferem em pelo menos 1, seus respectivos pisos são distintos. ∎

Agora, observe que o produto b ₁ b ₂ tem comprimento de dígito no máximo seu comprimento total, que é menor que o comprimento da string da entrada. Como a entrada está na base 10, basta usar 10 com a potência de seu comprimento N=10**len(`l`)para produzir um número com mais dígitos que ele, garantindo a condição.

JavaScript (ES6), 43 bytes

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

Ou alternativamente

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

A classificação é obviamente um exagero para isso, mas reducelevaria 46 bytes:

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

MATL , 8 bytes

pG/*&X<)

Todos os números calculados são valores inteiros. Primeiro, o produto dos denominadores é calculado (este é um número inteiro). Este produto é dividido por cada denominador (que também fornece um número inteiro). Cada resultado é então multiplicado pelo numerador correspondente. Isso fornece um valor inteiro proporcional à fração original.

O formato de entrada é: matriz numérica com denominadores, matriz numérica com numeradores, matriz de células de cadeias com nomes de esporte:

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

Se houver vários minimizadores, o primeiro é emitido.

Experimente online!

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 horários, calorias e nomes de atividades.

⎕ prompt (por vezes)

(∧/÷⊢)LCM ∧/dos tempos divididos pelos ÷tempos ⊢(portanto, não flutua)

⎕× prompt (para calorias) e multiplique por eles

(⊢⍳⌈/)nisso ⊢, obtenha a posição ⍳do valor máximo⌈/

⎕⊃⍨prompt (para atividades) e escolha o n .

Exemplo de execução:

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

Braquilog , 42 bytes

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

Experimente online!

/acima é a divisão inteira porque ambos J*De Isão inteiros ( Dé um múltiplo de Ifato).

Explicação

• 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

A contagem de bytes assume a codificação ISO 8859-1.

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

A entrada é um esporte por linha, com o formato value1 value2 name. A saída é um dos resultados máximos (se houver um empate, ele dará o que value1tiver maior e, se esses também estiverem empatados, se o lexicograficamente for maior name).

Observe que isso é super lento (exatamente pelos mesmos motivos que a interrupção do Stack Exchange de ontem ). Para executá-lo em um período de tempo razoável, você pode adicionar um \bna frente do (0+)(que não afeta a maneira como processa a entrada, mas limita severamente o retorno do regex). Eu fiz isso no link de teste abaixo.

Experimente online!

Python 2, 55 54 bytes

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

Graças a @xnor por jogar fora um byte!

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

A ordem das tuplas deve ser {value1,value2,name} . Retorna o conjunto completo de todos os resultados máximos.

Eu trabalho em torno do uso de frações multiplicando o numerador pelo LCM de todos os value1s antes da divisão.

R, 42 40 bytes

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

Recebe entrada na forma de um quadro de dados com tipos de coluna de sequência (também funciona com fatores), numérico, numérico.

• %/% é a divisão inteira.

Esta é a minha primeira submissão, deixe-me saber se está dentro das regras.

Editar: Acontece que você não precisa de chaves para definir uma função de uma linha.

C ++ 14, 89 bytes

Função 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];};

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

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

Edição: Esta solução não funciona como apontado por Damien isso não resolve o problema. Estou procurando uma boa solução.

Excel VBA, 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

Chame na célula da planilha referenciando uma tabela de atividades e parâmetros:

05AB1E , 6 7 bytes

P¹÷*ZQÏ

1 byte para bugfix minha abordagem DIVMOD ( veja este comentário em outra resposta ) por portar @LuisMendo resposta MATL 's , por isso, certifique-se de upvote-lo!

A entrada é semelhante à sua resposta: três listas separadas, sendo uma lista inteira de denominadores; uma lista inteira de nominadores; e uma lista de cadeias de nomes.

Experimente online ou verifique mais alguns casos de teste .

Explicação:

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

Eu realmente pensei que isso seria mais curto ...

A entrada é retirada do STDIN no formato de name time calories

Bem, qualquer ajuda para encurtá-lo é apreciada.

Clojure, 63 bytes

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

PHP , 98 bytes

Utilizou um formato de entrada mais simples que o exemplo, assim:

esgrima, 15,85, bilhar, 60.102, basquete, 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;

Experimente online!