In dieser Frage konzentrieren wir uns nur auf das Abnehmen durch Bewegung, obwohl es noch viele Möglichkeiten gibt, Gewicht zu verlieren.

Verschiedene Sportarten verbrauchen unterschiedliche Mengen an Kalorien.

Wenn Sie beispielsweise eine Stunde lang Billard spielen, können 102 Kalorien ^[1] verbraucht werden , während beim 15-minütigen Spielen von Basketball bereits 119 Kalorien ^[1] verbraucht werden , was den Gewichtsverlust durch das Spielen von Basketball zumindest aus bestimmten Perspektiven erleichtert.

Die genaue Methode zum Abwägen der Leichtigkeit besteht darin, die Menge der verbrauchten Kalorien durch die benötigte Zeit zu dividieren. Dies ergibt den Leichtigkeitsindex (EI).

Zum Beispiel kann das Fechten für 15 Minuten 85 Kalorien verbrennen, was einen EI von 85/15 ergibt.

Sie erhalten eine Liste in diesem Format:

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

oder ein anderes Format, das Sie möchten.

Anschließend geben Sie die Sportarten mit dem höchsten EI aus.

TL; DR

Bei einer Liste von Tupeln [name,value1,value2]Ausgabe der , namewo value2/value1die höchsten ist.

Einschränkungen

• Sie dürfen dabei keine reelle Zahl erzeugen, die keine ganze Zahl ist.
• Sie können nicht jede Fraktion Einbau-verwenden.

Spezifikationen (Specs)

• Wenn es mehr als einen Namen gibt, der das Ergebnis erfüllt, können Sie eine beliebige nicht leere Teilmenge oder ein beliebiges Element davon ausgeben.
• Der Name stimmt mit dem regulären Ausdruck überein /^[a-z]+$/, was bedeutet, dass er nur aus lateinischem Standard-Kleinbuchstaben besteht.
• Die Liste wird nicht leer sein.

Testfall

Eingang:

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

Ausgabe:

basketball

Verweise

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]

Ist die offensichtliche Sache, den Eintrag mit dem größten Verhältnis zu finden, umgeht aber das Verbot von Floaten, indem zuerst der Zähler mit einer riesigen eingabeabhängigen Potenz von 10 multipliziert wird, bevor die Unterteilung erfolgt.

Ich werde beweisen, dass dieser Koeffizient groß genug ist, damit die Bodenteilung den gleichen Unterschied macht wie die Nicht-Bodenteilung.

Behauptung: Wenn a ₁ / b ₁ > a ₂ / b ₂ , dann Boden (Na ₁ / b ₁ )> Boden (Na ₂ / b ₂ ) für ein beliebiges N≥b ₁ b ₂ .

Beweis: Beachten Sie, dass a ₁ / b ₁ - a ₂ / b ₂ ein Vielfaches von 1 / b ₁ b _{2 ist} , also impliziert a ₁ / b ₁ - a ₂ / b ₂ > 0 dies

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

Dann multiplizieren beide Seiten mit N,

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

Da sich Na ₁ / b ₁ und Na ₂ / b _{2 also} um mindestens 1 unterscheiden, sind ihre jeweiligen Böden unterschiedlich. ∎

Beachten Sie nun, dass das Produkt b ₁ b ₂ höchstens die gesamte Ziffernlänge hat, die kleiner als die Zeichenfolgenlänge der Eingabe ist. Da sich die Eingabe in der Basis 10 befindet, ist es ausreichend, 10 hoch genug zu setzen N=10**len(`l`), um eine Zahl mit mehr Stellen als der angegebenen zu erzeugen, um die Bedingung zu gewährleisten.

JavaScript (ES6), 43 Byte

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

Oder alternativ

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

Sortieren ist natürlich übertrieben, reducewürde aber 46 Bytes dauern:

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

MATL , 8 Bytes

pG/*&X<)

Alle berechneten Zahlen sind ganzzahlige Werte. Zuerst wird das Produkt der Nenner berechnet (dies ist eine ganze Zahl). Dieses Produkt wird durch jeden Nenner geteilt (was auch eine ganze Zahl ergibt). Jedes Ergebnis wird dann mit dem entsprechenden Zähler multipliziert. Dies ergibt einen ganzzahligen Wert proportional zum ursprünglichen Bruch.

Das Eingabeformat ist: numerisches Array mit Nennern, numerisches Array mit Zählern, Zellenarray von Zeichenfolgen mit Sportnamen:

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

Bei mehreren Minimierern wird der erste ausgegeben.

Probieren Sie es 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

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

Fordert nach Zeiten, dann nach Kalorien und dann nach Aktivitätsnamen auf.

⎕ prompt (für Zeiten)

(∧/÷⊢)LCM ∧/der Zeit geteilt durch ÷die Zeit⊢ (also keine Flöße)

⎕× prompt (für Kalorien) und mit ihnen multiplizieren

(⊢⍳⌈/)dadurch ⊢erhalten die Position ⍳des Maximalwerts⌈/

⎕⊃⍨Eingabeaufforderung (für Aktivitäten), und wählen Sie dann die n ten .

Beispiellauf:

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

Probieren Sie es online!

/oben ist die Ganzzahldivision, weil beide J*Dund Iganze Zahlen sind ( Dist ein Vielfaches vonI tatsächlich).

Erläuterung

• Hauptprädikat: 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ädikat 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

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Die Eingabe ist eine Sportart pro Zeile mit dem Format value1 value2 name. Die Ausgabe ist eines der maximalen Ergebnisse (wenn es einen Gleichstand gibt, gibt es den mit dem größten value1und wenn diese gleich sind, gibt es den lexikografisch größerenname ).

Beachten Sie, dass dies Super langsam (für die genauen gleichen Gründen wie Stack - Exchange - Ausfall von gestern ). Damit es in angemessener Zeit ausgeführt wird, können Sie ein \bvor dem hinzufügen(0+) (was sich nicht auf die Art und Weise auswirkt, in der es die Eingabe verarbeitet, aber das Zurückverfolgen dieses regulären Ausdrucks stark einschränkt). Ich habe das im Testlink unten gemacht.

Probieren Sie es online!

Python 2, 55 54 Bytes

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

Vielen Dank an @xnor für das Golfen ab 1 Byte!

Teste es auf Ideone .

Haskell 72 70 Bytes

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

Verwendung :

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

Mathematica, 46 Bytes

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

Die Reihenfolge der Tupel sollte sein {value1,value2,name}. Gibt den vollständigen Satz aller maximalen Ergebnisse zurück.

Ich arbeite um die Verwendung von Brüchen herum, indem ich den Zähler value1vor der Division mit dem LCM aller s multipliziere .

R, 42 - 40 Bytes

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

Nimmt Eingaben in Form eines Datenrahmens mit den Spaltentypen String (funktioniert auch mit Faktoren), numerisch und numerisch vor.

• %/% ist eine Ganzzahldivision.

Dies ist meine erste Einreichung, lass es mich wissen, wenn es innerhalb der Regeln ist.

Bearbeiten: Es stellt sich heraus, dass Sie keine geschweiften Klammern benötigen, um eine einzeilige Funktion zu definieren.

C ++ 14, 89 Bytes

Lambda-Funktion:

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

Verwendung:

#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

BEARBEITEN: Diese Lösung funktioniert nicht, wie von Damien hervorgehoben, dies löst das Problem nicht. Ich suche eine nette Lösung.

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

Rufen Sie in der Tabellenzelle eine Tabelle mit Aktivitäten und Parametern auf:

05AB1E , 6 7 Bytes

P¹÷*ZQÏ

+1 Byte, um meinen divmod-Ansatz zu verbessern ( siehe diesen Kommentar zu einer anderen Antwort ), indem die MATL - Antwort von @LuisMendo portiert wird also sicher, dass Sie ihn unterstützen!

Die Eingabe ist ähnlich wie bei seiner Antwort: Drei getrennte Listen, wobei es sich um eine ganzzahlige Liste von Nennern handelt. eine ganzzahlige Liste von Nominatoren; und eine String-Liste von Namen.

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

Erläuterung:

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

Ich dachte wirklich, das wäre kürzer ...

Die Eingabe erfolgt von STDIN im Format von name time calories

Na ja, jede Hilfe, um es zu verkürzen, wird geschätzt.

Clojure, 63 Bytes

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

PHP , 98 Bytes

Verwendete ein einfacheres Eingabeformat als das folgende Beispiel:

Fechten, 15,85, Billard, 60,102, Basketball, 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;

Probieren Sie es online!