W tym pytaniu skupimy się na utracie wagi tylko podczas ćwiczeń, chociaż nadal istnieje wiele sposobów, aby schudnąć.

Różne sporty spalają różną ilość kalorii.

Na przykład gra w bilard przez godzinę może spalić 102 kalorie ^[1] , podczas gdy gra w koszykówkę przez 15 minut może już spalić 119 kalorii ^[1] , które ułatwiają utratę wagi, grając w koszykówkę, przynajmniej z pewnych perspektyw.

Dokładny sposób ważenia łatwości polega na podzieleniu ilości spalonych kalorii przez potrzebny czas, co daje nam wskaźnik łatwości (EI).

Na przykład ogrodzenie przez 15 minut może spalić 85 kalorii, co daje EI 85/15.

Otrzymasz listę w tym formacie:

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

lub inny żądany format.

Następnie wygenerujesz sporty o najwyższym EI.

TL; DR

Biorąc pod uwagę listę [name,value1,value2]wyjściowych krotek, namegdzie value2/value1jest najwyższe.

Ograniczenia

• W tym procesie nie można wygenerować żadnej liczby rzeczywistej, która nie jest liczbą całkowitą.
• Być może nie używać żadnych frakcji wbudowany.

Dane techniczne (specyfikacje)

• Jeśli istnieje więcej niż jedna nazwa, która odpowiada wynikowi, możesz wypisać dowolny niepusty ich podzbiór lub dowolny element.
• Nazwa będzie pasować do wyrażenia regularnego /^[a-z]+$/, co oznacza, że ​​będzie się składać tylko z łacińskiego standardowego alfabetu.
• Lista nie będzie pusta.

Testcase

Wejście:

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

Wynik:

basketball

Bibliografia

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

Python 2, 51 bajtów

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

Czy oczywiste jest znalezienie wpisu o największym współczynniku, ale omija zakaz pływaków, najpierw mnożąc licznik przez ogromną zależną od wejścia moc 10 przed podzieleniem podłogi.

Udowodnię, że ten współczynnik jest wystarczająco duży, aby podział podłogi działał tak samo, jak podział bez podłogi.

Twierdzenie: Jeśli a ₁ / b ₁ > a ₂ / b ₂ , to podłoga (Na ₁ / b ₁ )> podłoga (Na ₂ / b ₂ ) dla dowolnego N≥b ₁ b ₂ .

Dowód: Zauważ, że a ₁ / b ₁ - a ₂ / b ₂ jest wielokrotnością 1 / b ₁ b ₂ , więc a ₁ / b ₁ - a ₂ / b ₂ > 0 oznacza, że

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

Następnie mnożąc obie strony przez N,

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

Tak więc, ponieważ Na ₁ / b ₁ i Na ₂ / b ₂ różnią się co najmniej o 1, ich odpowiednie podłogi są różne. ∎

Teraz zauważ, że iloczyn b ₁ b ₂ ma długość cyfr co najwyżej całkowitą długość cyfr, która jest mniejsza niż długość ciągu wejściowego. Ponieważ wejście znajduje się w podstawie 10, wystarczy użyć 10 do potęgi jego długości, N=10**len(`l`)aby utworzyć liczbę z większą liczbą cyfr niż to, co gwarantuje warunek.

JavaScript (ES6), 43 bajty

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

Lub alternatywnie

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

Sortowanie jest oczywiście przesadne, ale reducezajęłoby 46 bajtów:

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

MATL , 8 bajtów

pG/*&X<)

Wszystkie obliczone liczby są liczbami całkowitymi. Najpierw oblicza się iloczyn mianowników (jest to liczba całkowita). Ten produkt jest podzielony przez każdy mianownik (który daje również liczbę całkowitą). Każdy wynik jest następnie mnożony przez odpowiedni licznik. Daje to liczbę całkowitą proporcjonalną do pierwotnego ułamka.

Format wejściowy to: tablica liczbowa z mianownikami, tablica liczbowa z licznikami, tablica komórek ciągów o nazwach sportowych:

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

Jeśli istnieje kilka minimalizatorów, pierwszy jest generowany.

Wypróbuj 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 bajtów

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

Monituje o czasy, następnie o kalorie, a następnie o nazwy działań.

⎕ monit (na czas)

(∧/÷⊢)LCM ∧/czasów podzielonych przez ÷czasy ⊢(więc nie ma pływaków)

⎕× monit (dla kalorii) i pomnóż je

(⊢⍳⌈/)w tym ⊢uzyskaj pozycję ⍳wartości maksymalnej⌈/

⎕⊃⍨monit (dla działań), a następnie wybierz n ty.

Przykładowy przebieg:

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

Brachylog , 42 bajty

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

Wypróbuj online!

/Powyższe dzielenia całkowitego, ponieważ oba J*Di Isą liczbami całkowitymi ( Djest wielokrotnościąI w rzeczywistości).

Wyjaśnienie

• Główny predykat: 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
  

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

Siatkówka , 64 62 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Dane wejściowe to jeden sport na linię, w formacie value1 value2 name. Wyjście jest jednym z maksymalnych wyników (jeśli istnieje remis, daje ten z największym, value1a jeśli te są również powiązane, jeśli daje leksykograficznie większy name).

Pamiętaj, że jest to bardzo wolne (z tych samych powodów, co wczorajsza przerwa w stosie wymiany ). Aby uruchomić go w rozsądnym czasie, możesz dodać \bprzed nim(0+) (co nie wpłynie wcale na sposób, w jaki przetwarza dane wejściowe, ale poważnie ogranicza cofanie wyrażenia regularnego). Zrobiłem to w linku testowym poniżej.

Wypróbuj online!

Python 2, 55 54 bajtów

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

Dzięki @xnor za grę w golfa na 1 bajcie!

Przetestuj na Ideone .

Haskell 72 70 bajtów

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

Stosowanie :

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

Mathematica, 46 bajtów

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

Kolejność krotek powinna być {value1,value2,name}. Zwraca pełny zestaw wszystkich maksymalnych wyników.

Pracuję nad wykorzystaniem ułamków mnożąc licznik przez LCM wszystkich value1s przed podziałem.

R, 42 40 bajtów

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

Pobiera dane wejściowe w postaci ramki danych z kolumnami typu ciąg (działa również z czynnikami), numeryczny, numeryczny.

• %/% jest dzieleniem całkowitym.

To jest moje pierwsze zgłoszenie, daj mi znać, czy jest zgodne z zasadami.

Edycja: Okazuje się, że nawiasy klamrowe nie są potrzebne do zdefiniowania funkcji jednowierszowej.

C ++ 14, 89 bajtów

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

Nie golfowany:

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

Stosowanie:

#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 bajtów

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

EDYCJA: To rozwiązanie nie działa, jak wskazał Damien, to nie rozwiązuje problemu. Szukam dobrej poprawki.

VBA Excel, 109 bajtów

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

Wywołaj w komórce arkusza kalkulacyjnego odwołując się do tabeli działań i parametrów:

05AB1E , 6 7 bajtów

P¹÷*ZQÏ

+1 bajt, aby naprawić błąd w moim podejściu divmod ( patrz ten komentarz do innej odpowiedzi ) przez portowanie @LuisMendo „s Mátl odpowiedź , więc upewnij się, aby go upvote!

Dane wejściowe są podobne do jego odpowiedzi: trzy oddzielne listy, będące całkowitą listą mianowników; całkowita lista nominatorów; i ciąg nazwisk.

Wypróbuj online lub sprawdź więcej przypadków testowych .

Wyjaśnienie:

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 bajtów

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

Rubinowy, 72 bajty

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

Naprawdę myślałem, że to będzie krótsze ...

Dane wejściowe są pobierane ze STDIN w formacie name time calories

No cóż, każda pomoc w skróceniu jest doceniana.

Clojure, 63 bajty

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

PHP , 98 bajtów

Użyłem prostszego formatu wejściowego niż w przykładzie, tak jak poniżej:

ogrodzenie, 15,85, bilard, 60,102, koszykówka, 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;

Wypróbuj online!