In questa domanda, ci concentreremo solo sulla perdita di peso facendo esercizio fisico, anche se ci sono ancora molti modi per perdere peso.

Sport diversi bruciano diverse quantità di calorie.

Ad esempio, giocare a biliardo per un'ora può bruciare 102 calorie ^[1] , mentre giocare a basket per 15 minuti può già bruciare 119 calorie ^[1] , il che rende la perdita di peso giocando a basket più facile, almeno da alcune prospettive.

Il modo esatto per valutare la facilità è quello di dividere la quantità di calorie bruciate per il tempo necessario, che ci dà l'indice di facilità (EI).

Ad esempio, la scherma per 15 minuti può bruciare 85 calorie, con un EI di 85/15.

Ti verrà dato un elenco in questo formato:

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

o altro formato che desideri.

Quindi, otterrai gli sport che hanno l'EI più alto.

TL; DR

Dato un elenco di tuple [name,value1,value2]output namedove value2/value1è il più alto.

vincoli

• Si può non produrre qualsiasi numero reale che non è intero nel processo.
• Si può non utilizzare alcun frazione built-in.

Specifiche (specifiche)

• Se esiste più di un nome che soddisfa il risultato, è possibile generare un sottoinsieme non vuoto di essi o qualsiasi elemento di essi.
• Il nome corrisponderà al regex /^[a-z]+$/, il che significa che sarà composto solo da alfabeto standard latino minuscolo.
• L'elenco non sarà vuoto.

testcase

Ingresso:

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

Produzione:

basketball

Riferimenti

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]

Fa la cosa ovvia di trovare l'ingresso con il rapporto più grande, ma elude il divieto di float moltiplicando prima il numeratore per un enorme potere dipendente dall'input di 10 prima di dividere il pavimento.

Dimostrerò che questo coefficiente è abbastanza grande da fare in modo che la divisione del pavimento agisca come la stessa differenza della divisione non.

Reclamo: Se a ₁ / b ₁ > a ₂ / b ₂ , quindi floor (Na ₁ / b ₁ )> floor (Na ₂ / b ₂ ) per qualsiasi N≥b ₁ b ₂ .

Prova: si noti che a ₁ / b ₁ - a ₂ / b ₂ è un multiplo di 1 / b ₁ b ₂ , quindi a ₁ / b ₁ - a ₂ / b ₂ > 0 implica che

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

Quindi, moltiplicando entrambi i lati per N,

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

Quindi, poiché Na ₁ / b ₁ e Na ₂ / b ₂ differiscono di almeno 1, i rispettivi piani sono distinti. ∎

Ora, nota che il prodotto b ₁ b ₂ ha la lunghezza delle cifre al massimo della loro lunghezza totale delle cifre, che è inferiore alla lunghezza della stringa dell'input. Poiché l'ingresso è nella base 10, è sufficiente utilizzare 10 alla potenza della sua lunghezza N=10**len(`l`)per produrre un numero con più cifre di esso, garantendo la condizione.

JavaScript (ES6), 43 byte

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

O in alternativa

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

L'ordinamento è ovviamente eccessivo per questo, ma reducerichiederebbe 46 byte:

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

MATL , 8 byte

pG/*&X<)

Tutti i numeri calcolati sono valori interi. Innanzitutto, viene calcolato il prodotto dei denominatori (questo è un numero intero). Questo prodotto è diviso per ogni denominatore (che fornisce anche un numero intero). Ogni risultato viene quindi moltiplicato per il numeratore corrispondente. Questo dà un valore intero proporzionale alla frazione originale.

Il formato di input è: matrice numerica con denominatori, matrice numerica con numeratori, matrice di celle di stringhe con nomi sportivi:

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

Se ci sono molti minimizzatori viene emesso il primo.

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

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

Richiede i tempi, quindi le calorie, quindi i nomi delle attività.

⎕ prompt (per i tempi)

(∧/÷⊢)LCM ∧/dei tempi diviso per ÷i tempi ⊢(quindi senza galleggianti)

⎕× prompt (per calorie) e moltiplicare per loro

(⊢⍳⌈/)in questo ⊢, ottieni la posizione ⍳del valore massimo⌈/

⎕⊃⍨prompt (per le attività), quindi scegliere il n °.

Esempio di esecuzione:

      ⎕⊃⍨(⊢⍳⌈/)⎕×(∧/÷⊢)⎕
⎕:
      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.

Provalo online!

/sopra è la divisione intera perché entrambi J*De Isono numeri interi (D è un multiplo di Ifatto).

Spiegazione

• Predicato principale: 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
  

• Predicato 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 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

L'input è uno sport per riga, con il formato value1 value2 name. L'output è uno dei risultati massimi (se c'è un pareggio, si otterrà quello con il più grande value1e se anche quelli sono legati se si otterrà il lessicograficamente più grande name).

Si noti che questo è super lento (per gli stessi motivi dell'interruzione di Stack Exchange di ieri ). Per farlo funzionare in un ragionevole lasso di tempo, puoi aggiungere un\b davanti a (0+)(che non influenzerà il modo in cui elabora l'input ma limita fortemente il backtracking di quella regex). L'ho fatto nel link di prova qui sotto.

Provalo online!

Python 2, 55 54 byte

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

Grazie a @xnor per giocare a golf a 1 byte!

Provalo su Ideone .

Haskell 72 70 byte

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

Utilizzo:

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

Mathematica, 46 byte

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

L'ordine delle tuple dovrebbe essere {value1,value2,name}. Restituisce il set completo di tutti i risultati massimi.

Lavoro intorno all'uso delle frazioni moltiplicando il numeratore per il LCM di tutte le value1s prima della divisione.

R, 42 40 byte

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

Accetta input sotto forma di un frame di dati con tipi di stringa di colonne (funziona anche con fattori), numerico, numerico.

• %/% è divisione intera.

Questa è la mia prima presentazione, fammi sapere se rientra nelle regole.

Modifica: risulta che non sono necessarie le parentesi graffe per definire una funzione di una riga.

C ++ 14, 89 byte

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

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

EDIT: Questa soluzione non funziona come sottolineato da Damien, questo non risolve il problema. Sto cercando una bella soluzione.

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

Richiamare nella cella del foglio di calcolo facendo riferimento a una tabella di attività e parametri:

05AB1E , 6 7 byte

P¹÷*ZQÏ

+1 byte per correggere il mio approccio divmod ( vedi questo commento su un'altra risposta ) eseguendo il porting della risposta MATL di @LuisMendo , quindi assicurati di votarlo!

L'input è simile alla sua risposta: tre liste separate, essendo una lista intera di denominatori; un elenco intero di nominatori; e un elenco di stringhe di nomi.

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

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

Rubino, 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

Pensavo davvero che sarebbe stato più breve ...

L'immissione è presa da STDIN nel formato di name time calories

Vabbè, qualsiasi aiuto per accorciarlo è apprezzato.

Clojure, 63 byte

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

PHP , 98 byte

Utilizzato un formato di input più semplice dell'esempio, proprio come questo:

scherma, 15,85, biliardo, 60.102, basket, 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;

Provalo online!