Bu soruda, hala egzersiz yaparak kilo vermeye odaklanacağız, ancak hala kilo vermenin birçok yolu var.

Farklı sporlar farklı miktarda kalori yakar.

Örneğin, bir saat boyunca bilardo oynamak 102 kalori yakabilir ^[1] , 15 dakika basketbol oynamak en azından bazı açılardan basketbol oynayarak kilo kaybını kolaylaştıran 119 kaloriyi ^[1] yakabilir .

Kolaylığı tartmanın tam yolu, yakılan kalori miktarını ihtiyaç duyulan zamana bölmektir, bu da bize kolaylık endeksini (EI) verir.

Örneğin, 15 dakika boyunca eskrim 85 kalori yakabilir, bu da 85/15 EI alır.

Size şu biçimde bir liste verilecektir:

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

veya istediğiniz başka bir biçim.

Ardından, en yüksek EI'ye sahip sporları çıkaracaksınız.

TL; DR

Bir tuples [name,value1,value2]çıktısı göz önüne alındığında , en yüksek namenerede value2/value1.

Kısıtlamalar

• Sen olabilir değil sürecinde tamsayı olmayan herhangi bir gerçek sayı üretir.
• Sen olabilir değil yerleşik herhangi kısmını kullanın.

Özellikler (özellikler)

• Sonucu tatmin eden birden fazla ad varsa, bunların boş olmayan alt kümelerini veya herhangi bir öğesini çıktı alabilirsiniz.
• İsim normal /^[a-z]+$/ifadeyle eşleşecektir , yani yalnızca küçük Latin alfabesi standart alfabesinden oluşacaktır.
• Liste boş olmayacak.

Test durumu

Giriş:

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

Çıktı:

basketball

Referanslar

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

Python 2, 51 bayt

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

En büyük oranda girişi bulmak bariz bir şey yapar, ancak önce pay bölmeye bölmeden önce 10 giriş büyük bir bağımlı bağımlı güç ile çarparak şamandıralara karşı yasağı ortadan kaldırır.

Bu katsayının kat bölümünün kat olmayan bölümle aynı farkı gösterecek kadar büyük olduğunu kanıtlayacağım.

İddia: Bir ₁ / b ₁ > bir ₂ / b ₂ , daha sonra, zemin (Na ₁ / b ₁ )> kat (Na ₂ / b ₂ bir N≥b için) ₁ b ₂ .

Korumalı: Bir bu Not ₁ / b ₁ - bir ₂ / b ₂ 1 / b bir katı olan _{, 1} b _{, 2} a, yani ₁ / b ₁ a - ₂ / b ₂ > 0 anlamına gelir

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

Ardından, her iki tarafı N ile çarparak,

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

Bu nedenle, Na yana ₁ / b ₁ ve Na ₂ / b ₂ , ilgili katlar, farklı olan, en azından 1 ile farklılık göstermektedir. ∎

Şimdi, b ₁ b ₂ ürününün , toplam dize uzunluğunun, girdi dize uzunluğundan daha az olan en fazla hane uzunluğuna sahip olduğuna dikkat edin. Giriş 10 bazında N=10**len(`l`)olduğundan, ondan daha fazla hane içeren bir sayı üretmek için uzunluğunun gücüne 10 kullanmak yeterlidir .

JavaScript (ES6), 43 bayt

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

Veya alternatif olarak

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

Bunun için sıralama elbette aşırıya kaçıyor, ancak reduce46 bayt sürecek:

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

MATL , 8 bayt

pG/*&X<)

Hesaplanan tüm sayılar tamsayı değerleridir. İlk olarak, paydaların ürünü hesaplanır (bu bir tamsayıdır). Bu ürün her paydaya bölünür (bu da bir tamsayı verir). Her sonuç daha sonra karşılık gelen pay ile çarpılır. Bu, orijinal kesir ile orantılı bir tamsayı değeri verir.

Girdi formatı: paydalarla sayısal dizi, paylarla sayısal dizi, spor adlarına sahip dizelerin hücre dizisi:

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

Birkaç minimizer varsa, birincisi çıkarılır.

Çevrimiçi deneyin!

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 bayt

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

Zamanları, sonra kalorileri, sonra etkinlik adlarını ister.

⎕ istem (zamanlar için)

(∧/÷⊢)LCM ∧/bölünmesiyle kez ÷kez ⊢(bir yüzen böylece)

⎕× istem (kalori için) ve onlarla çarpın

(⊢⍳⌈/)ki ⊢, pozisyon almak ⍳maksimum değerin⌈/

⎕⊃⍨komut istemini (etkinlikler için) seçin, ardından n .

Örnek çalışma:

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

Brachylog , 42 bayt

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

Çevrimiçi deneyin!

/yukarıda tamsayı bölümüdür çünkü ikisi de J*Dve Itamsayıdır ( aslında Dkatlarıdır I).

açıklama

• Ana yüklem: 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
  

• Tahmin 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 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

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

Girdi, her satıra bir biçimdir ve biçimidir value1 value2 name. Çıktı maksimum sonuçlardan biridir (eğer bir kravat varsa en büyük olanı verir value1ve eğer bunlar bağlanırsa sözlükbilimsel olarak daha büyük verirse name).

Bunun süper yavaş olduğuna dikkat edin ( dünkü Stack Exchange kesintisi ile aynı nedenlerle ). Makul bir süre içinde çalışmasını sağlamak için \b, önüne bir ekleyebilirsiniz (0+)(bu, girdiyi işleme biçimini etkilemez, ancak bu normal ifadenin geri izlemesini ciddi şekilde sınırlar). Bunu aşağıdaki test bağlantısında yaptım.

Çevrimiçi deneyin!

Python 2, 55 54 bayt

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

1 bayt golf için @xnor'a teşekkürler!

Ideone üzerinde test edin .

Haskell 72 70 bayt

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

Kullanımı:

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

Mathematica, 46 bayt

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

Tuples sırası olmalıdır {value1,value2,name}. Tüm maksimum sonuçların tam setini döndürür.

Ben value1bölünme önce pay tüm LCM ile pay çarparak kesir kullanımı etrafında çalışır .

R, 42 40 bayt

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

Sayısal, sayısal olmak üzere, sütun türünde dize (faktörlerle de çalışır) bir veri çerçevesi biçiminde girdi alır.

• %/% tamsayı bölümüdür.

Bu benim ilk sunumum, kurallar dahilinde olup olmadığını bana bildirin.

Edit: Bir satırlık fonksiyon tanımlamak için parantez gerekmez.

C ++ 14, 89 bayt

Lambda işlevi:

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

Kullanımı:

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

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

EDIT: Bu çözüm Damien'ın işaret ettiği gibi çalışmaz, bu sorunu çözmez. Güzel bir düzeltme arıyorum.

VBA Excel, 109 bayt

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

Bir aktivite ve parametre tablosuna başvurarak e-tablo hücresine çağırın:

05AB1E , 6 7 bayt

P¹÷*ZQÏ

Divmod yaklaşımımı düzeltmek için +1 bayt ( başka bir yanıt bu yorumu görmek taşıma yoluyla) @LuisMendo 'ın Matl cevabı , bu yüzden onu upvote emin olun!

Girdi cevabına benzer: üç ayrı liste, paydaların bir tamsayı listesi; adayların tam sayı listesi; ve bir dize listesi.

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

Açıklama:

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 Bayt

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

Yakut, 72 bayt

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

Bunun daha kısa olacağını düşündüm ...

Giriş STDIN biçiminde alınır. name time calories

Oh, kısaltmak için herhangi bir yardım takdir.

Clojure, 63 bayt

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

PHP , 98 bayt

Aşağıdaki gibi örnekten daha basit bir giriş biçimi kullanıldı:

eskrim, 15,85, bilardo, 60102, basketbol, ​​15119

$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;

Çevrimiçi deneyin!