Dans cette question, nous nous concentrerons uniquement sur la perte de poids en faisant de l'exercice, bien qu'il existe encore de nombreuses façons de perdre du poids.

Différents sports brûlent différentes quantités de calories.

Par exemple, jouer au billard pendant une heure peut brûler 102 calories ^[1] , tandis que jouer au basket-ball pendant 15 minutes peut déjà brûler 119 calories ^[1] , ce qui facilite la perte de poids en jouant au basket-ball, du moins à certains égards.

La façon exacte de peser la facilité est de diviser la quantité de calories brûlées par le temps nécessaire, ce qui nous donne l'indice de facilité (IE).

Par exemple, une clôture de 15 minutes peut brûler 85 calories, ce qui donne un IE de 85/15.

Vous recevrez une liste dans ce format:

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

ou tout autre format que vous souhaitez.

Ensuite, vous produirez les sports qui ont le plus haut EI.

TL; DR

Étant donné une liste de tuples [name,value1,value2]sortie l' nameoù value2/value1est le plus élevé.

Contraintes

• Vous ne pouvez pas produire de nombre réel qui n'est pas entier dans le processus.
• Vous ne pouvez pas utiliser de fraction intégrée.

Spécifications (spécifications)

• S'il y a plus d'un nom qui satisfait le résultat, vous pouvez sortir n'importe quel sous-ensemble non vide d'entre eux ou n'importe quel élément d'entre eux.
• Le nom correspondra à l'expression régulière /^[a-z]+$/, ce qui signifie qu'il ne consistera qu'en alphabet latin standard en minuscules.
• La liste ne sera pas vide.

Cas de test

Contribution:

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

Production:

basketball

Les références

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

Python 2, 51 octets

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

Fait la chose évidente de trouver l'entrée avec le plus grand rapport, mais contourne l'interdiction des flotteurs en multipliant d'abord le numérateur par une énorme puissance dépendante de l'entrée de 10 avant de diviser le plancher.

Je prouverai que ce coefficient est assez grand pour que la division par le sol agisse de la même manière que la division non par le sol.

Allégation: si a ₁ / b ₁ > a ₂ / b ₂ , alors étage (Na ₁ / b ₁ )> étage (Na ₂ / b ₂ ) pour tout N≥b ₁ b ₂ .

Preuve: Notez qu'un a ₁ / b ₁ - a ₂ / b ₂ est un multiple de 1 / b ₁ b ₂ , donc a ₁ / b ₁ - a ₂ / b ₂ > 0 implique que

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

Ensuite, en multipliant les deux côtés par N,

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

Ainsi, puisque Na ₁ / b ₁ et Na ₂ / b ₂ diffèrent d'au moins 1, leurs étages respectifs sont distincts. ∎

Maintenant, notez que le produit b ₁ b ₂ a une longueur de chiffres au plus égale à leur longueur totale de chiffres, qui est inférieure à la longueur de chaîne de l'entrée. L'entrée étant en base 10, il suffit d'utiliser 10 à la puissance de sa longueur N=10**len(`l`)pour produire un nombre à plus de chiffres qu'elle, garantissant la condition.

JavaScript (ES6), 43 octets

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

Ou bien

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

Le tri est bien sûr exagéré pour cela, mais reduceprendrait 46 octets:

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

MATL , 8 octets

pG/*&X<)

Tous les nombres calculés sont des valeurs entières. Tout d'abord, le produit des dénominateurs est calculé (il s'agit d'un entier). Ce produit est divisé par chaque dénominateur (ce qui donne également un entier). Chaque résultat est ensuite multiplié par le numérateur correspondant. Cela donne une valeur entière proportionnelle à la fraction d'origine.

Le format d'entrée est: tableau numérique avec dénominateurs, tableau numérique avec numérateurs, tableau de cellules de chaînes avec des noms de sport:

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

S'il y a plusieurs minimiseurs, le premier est émis.

Essayez-le en ligne!

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 octets

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

Demande les heures, puis les calories, puis les noms des activités.

⎕ invite (pour les temps)

(∧/÷⊢)LCM ∧/des temps divisé par ÷les temps ⊢(donc pas de flotteurs)

⎕× invite (pour les calories) et multipliez par eux

(⊢⍳⌈/)en ce que ⊢, obtenir la position ⍳de la valeur maximale⌈/

⎕⊃⍨invite (pour les activités), puis choisissez le n ème.

Exemple d'exécution:

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

Brachylog , 42 octets

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

Essayez-le en ligne!

/ci-dessus est une division entière car les deux J*Det Isont des entiers ( Dest un multiple deI fait).

Explication

• Prédicat 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
  

• Prédicat 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 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

L'entrée est un sport par ligne, avec le format value1 value2 name. La sortie est l'un des résultats maximaux (s'il y a un lien, cela donnera celui avec le plus grandvalue1 et si ceux-ci sont également liés si le plus grand sera lexicographiquement name).

Notez que cela est super lent (pour les mêmes raisons que la panne d'hier Stack Exchange d'hier ). Pour le faire fonctionner dans un délai raisonnable, vous pouvez ajouter un \bdevant le(0+) (ce qui n'affectera pas du tout la façon dont il traite l'entrée mais limite sévèrement le retour en arrière de cette expression régulière). Je l'ai fait dans le lien de test ci-dessous.

Essayez-le en ligne!

Python 2, 55 54 octets

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

Merci à @xnor d'avoir joué au golf sur 1 octet!

Testez-le sur Ideone .

Haskell 72 70 octets

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

Utilisation:

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

Mathematica, 46 octets

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

L'ordre des tuples doit être {value1,value2,name} . Renvoie l'ensemble complet de tous les résultats maximaux.

Je contourne l'utilisation des fractions en multipliant le numérateur par le LCM de tous les value1s avant la division.

R, 42 40 octets

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

Prend l'entrée sous la forme d'un bloc de données avec des types de colonne de chaîne (cela fonctionne également avec des facteurs), numérique, numérique.

• %/% est une division entière.

Ceci est ma première soumission, faites-moi savoir si cela est conforme aux règles.

Modifier: il s'avère que vous n'avez pas besoin des accolades pour définir une fonction sur une ligne.

C ++ 14, 89 octets

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

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

Usage:

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

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

EDIT: Cette solution ne fonctionne pas comme l'a souligné Damien, cela ne résout pas le problème. Je cherche une bonne solution.

VBA Excel, 109 octets

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

Appelez dans une feuille de calcul référençant un tableau d'activités et de paramètres:

05AB1E , 6 7 octets

P¹÷*ZQÏ

+1 octet pour corriger mon approche divmod ( voir ce commentaire sur une autre réponse ) en portant la réponse MATL de @LuisMendo , alors assurez-vous de lui donner un vote positif!

L'entrée est similaire à sa réponse: trois listes séparées, étant une liste entière de dénominateurs; une liste entière de proposants; et une liste de chaînes de noms.

Essayez-le en ligne ou vérifiez d'autres cas de test .

Explication:

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 octets

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

Rubis, 72 octets

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

Je pensais vraiment que ce serait plus court ...

L'entrée provient de STDIN au format name time calories

Eh bien, toute aide pour la raccourcir est appréciée.

Clojure, 63 octets

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

PHP , 98 octets

Utilisé un format d'entrée plus simple que l'exemple, comme ceci:

escrime, 15,85, billard, 60 102, basket-ball, 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;

Essayez-le en ligne!