Dalam pertanyaan ini, kita hanya akan fokus pada penurunan berat badan dengan melakukan olahraga, meskipun masih ada banyak cara untuk menurunkan berat badan.

Olahraga yang berbeda membakar jumlah kalori yang berbeda.

Misalnya, bermain biliar selama satu jam dapat membakar 102 kalori ^[1] , sementara bermain bola basket selama 15 menit sudah dapat membakar 119 kalori ^[1] , yang membuat penurunan berat badan dengan bermain bola basket lebih mudah, setidaknya dari beberapa perspektif.

Cara yang tepat untuk menimbang kemudahan adalah dengan membagi jumlah kalori yang terbakar dengan waktu yang dibutuhkan, yang memberi kita indeks kemudahan (EI).

Misalnya, pagar selama 15 menit dapat membakar 85 kalori, yang mendapat EI 85/15.

Anda akan diberikan daftar dalam format ini:

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

atau format lain yang Anda inginkan.

Kemudian, Anda akan menampilkan olahraga yang memiliki EI tertinggi.

TL; DR

Diberikan daftar tuple [name,value1,value2]output di namemana value2/value1adalah yang tertinggi.

Kendala

• Anda mungkin tidak menghasilkan bilangan real yang tidak bilangan bulat dalam proses.
• Anda tidak boleh menggunakan fraksi built-in.

Spesifikasi (Spesifikasi)

• Jika ada lebih dari satu nama yang memenuhi hasil, Anda dapat menampilkan subset yang tidak kosong atau elemen apa pun dari mereka.
• Nama akan cocok dengan regex /^[a-z]+$/, yang berarti bahwa itu hanya akan terdiri dari huruf latin standar huruf kecil.
• Daftar tidak akan kosong.

Kasus cobaan

Memasukkan:

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

Keluaran:

basketball

Referensi

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]

Apakah hal yang jelas menemukan entri dengan rasio terbesar, tetapi mengesampingkan larangan terhadap pelampung dengan terlebih dahulu mengalikan pembilang dengan kekuatan input-bergantung besar 10 sebelum lantai-membagi.

Saya akan membuktikan koefisien ini cukup besar untuk membuat lantai-divisi bertindak perbedaan yang sama seperti divisi-lantai.

Klaim: Jika a ₁ / b ₁ > a ₂ / b ₂ , maka lantai (Na ₁ / b ₁ )> lantai (Na ₂ / b ₂ ) untuk setiap N≥b ₁ b ₂ .

Bukti: Perhatikan bahwa ₁ / b ₁ - a ₂ / b ₂ adalah kelipatan dari 1 / b ₁ b ₂ , jadi ₁ / b ₁ - a ₂ / b ₂ > 0 menyiratkan bahwa

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

Kemudian, mengalikan kedua sisi dengan N,

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

Jadi, karena Na ₁ / b ₁ dan Na ₂ / b ₂ berbeda setidaknya 1, lantai masing-masing berbeda. ∎

Sekarang, perhatikan bahwa produk b ₁ b ₂ memiliki panjang digit paling banyak dari panjang digit totalnya, yang kurang dari panjang string input. Karena input berada di basis 10, cukup untuk menggunakan 10 pangkat dari panjangnya N=10**len(`l`)untuk menghasilkan angka dengan lebih banyak digit daripada itu, menjamin kondisi.

JavaScript (ES6), 43 byte

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

Atau sebagai alternatif

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

Sortir tentu saja berlebihan untuk ini, tetapi reduceakan mengambil 46 byte:

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

MATL , 8 byte

pG/*&X<)

Semua angka yang dihitung adalah nilai integer. Pertama, produk dari penyebut dihitung (ini adalah bilangan bulat). Produk ini dibagi oleh masing-masing penyebut (yang memberikan bilangan bulat juga). Setiap hasil kemudian dikalikan dengan pembilang yang sesuai. Ini memberikan nilai integer sebanding dengan fraksi asli.

Format input adalah: susunan numerik dengan penyebut, susunan numerik dengan pembilang, susunan sel string dengan nama olahraga:

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

Jika ada beberapa minimizers yang pertama adalah output.

Cobalah 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

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

Anjurkan waktu, lalu untuk kalori, lalu untuk nama aktivitas.

⎕ prompt (untuk kali)

(∧/÷⊢)LCM ∧/kali dibagi dengan ÷kali ⊢(jadi tidak ada mengapung)

⎕× cepat (untuk kalori) dan kalikan dengan mereka

(⊢⍳⌈/)dalam hal itu ⊢, dapatkan posisi ⍳nilai maksimum⌈/

⎕⊃⍨prompt (untuk kegiatan), kemudian memilih n th.

Contoh dijalankan:

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

Cobalah online!

/di atas adalah pembagian integer karena keduanya J*Ddan Imerupakan integer ( Dsebenarnya merupakan kelipatan I).

Penjelasan

• Predikat utama: 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
  

• Predikat 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

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

Input adalah satu olahraga per baris, dengan format value1 value2 name. Output adalah salah satu hasil maksimal (jika ada dasi itu akan memberikan yang terbesar value1dan jika diikat juga jika akan memberikan leksikografis yang lebih besar name).

Perhatikan bahwa ini adalah sangat lambat (untuk alasan yang sama persis dengan pemadaman Stack Exchange kemarin ). Untuk membuatnya berjalan dalam jumlah waktu yang wajar, Anda dapat menambahkan \bdi depan (0+)(yang tidak akan memengaruhi cara memproses input sama sekali tetapi sangat membatasi pengulangan dari regex itu). Saya sudah melakukannya di tautan tes di bawah ini.

Cobalah online!

Python 2, 55 54 byte

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

Terima kasih kepada @xnor karena bermain golf 1 byte!

Uji di Ideone .

Haskell 72 70 byte

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

Penggunaan:

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

Mathematica, 46 byte

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

Urutan tupel seharusnya {value1,value2,name}. Mengembalikan set lengkap semua hasil maksimal.

Saya mengatasi penggunaan fraksi dengan mengalikan pembilang dengan LCM semua value1sebelum pembagian.

R, 42 40 byte

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

Mengambil input dalam bentuk bingkai data dengan tipe kolom string (juga berfungsi dengan faktor), numerik, numerik.

• %/% adalah pembagian integer.

Ini adalah pengiriman pertama saya, beri tahu saya jika itu sesuai aturan.

Sunting: Ternyata Anda tidak perlu kawat gigi untuk mendefinisikan fungsi satu baris.

C ++ 14, 89 byte

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

Tidak Disatukan:

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

Pemakaian:

#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: Solusi ini tidak berfungsi seperti yang ditunjukkan oleh Damien ini tidak menyelesaikan masalah. Saya mencari perbaikan yang bagus.

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

Meminta sel spreadsheet merujuk pada tabel aktivitas dan parameter:

05AB1E , 6 7 byte

P¹÷*ZQÏ

+1 byte untuk memperbaiki bug pendekatan divmod saya ( lihat komentar ini pada jawaban lain ) dengan port @LuisMendo 's jawaban MATL , jadi pastikan untuk upvote dia!

Masukan serupa dengan jawabannya: tiga daftar yang terpisah, menjadi daftar bilangan penyebut; daftar nominasi integer; dan daftar nama string.

Cobalah online atau verifikasi beberapa kasus uji lagi .

Penjelasan:

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 byte

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

Saya benar-benar berpikir ini akan lebih pendek ...

Input diambil dari STDIN dalam format name time calories

Oh well, bantuan apa pun untuk mempersingkat itu dihargai.

Clojure, 63 byte

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

PHP , 98 byte

Menggunakan format input yang lebih sederhana daripada contohnya, seperti ini:

anggar, 15,85, biliar, 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;

Cobalah online!