आसानी से वजन कम कैसे करें?

15

इस सवाल में, हम केवल व्यायाम करके अपना वजन कम करने पर ध्यान केंद्रित करेंगे, हालांकि अभी भी वजन कम करने के कई तरीके हैं।

अलग-अलग खेलों में अलग-अलग मात्रा में कैलोरी बर्न होती है।

उदाहरण के लिए, एक घंटे के लिए बिलियर्ड्स खेलने से 102 कैलोरी बर्न हो सकती है [1] , जबकि 15 मिनट के लिए बास्केटबॉल खेलने से पहले से ही 119 कैलोरी बर्न हो सकती है [1] , जो कम से कम कुछ दृष्टिकोणों से बास्केटबॉल को आसानी से खेलकर वजन कम करते हैं।

सुगमता को तौलने का सटीक तरीका है कि आवश्यक समय द्वारा जलाई गई कैलोरी की मात्रा को विभाजित करके, जो हमें सुगमता सूचकांक (ईआई) प्रदान करता है।

उदाहरण के लिए, 15 मिनट के लिए बाड़ लगाने से 85 कैलोरी जल सकती हैं, जिसे 85/15 का ईआई मिलता है।

आपको इस प्रारूप में एक सूची दी जाएगी:

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

या अन्य प्रारूप जो आप चाहते हैं।

फिर, आप उन स्पोर्ट्स को आउटपुट करेंगे जिनमें ईआई सबसे ज्यादा है।

टी एल; डॉ

Tuples [name,value1,value2]output की सूची को देखते हुए सबसे अधिक nameकहाँ value2/value1है।

प्रतिबन्ध

  • आप किसी भी वास्तविक संख्या का उत्पादन नहीं कर सकते हैं जो प्रक्रिया में पूर्णांक नहीं है।
  • आप किसी भी अंश में निर्मित का उपयोग नहीं कर सकते हैं ।

निर्दिष्टीकरण (चश्मा)

  • यदि एक से अधिक नाम हैं जो परिणाम को संतुष्ट करते हैं, तो आप उनमें से किसी भी गैर-रिक्त उपसमूह या उनमें से किसी भी तत्व को आउटपुट कर सकते हैं।
  • नाम रेगेक्स से मेल खाएगा /^[a-z]+$/, जिसका अर्थ है कि इसमें केवल लोअरकेस लैटिन मानक वर्णमाला शामिल होगी।
  • सूची खाली नहीं होगी।

परीक्षण का मामला

इनपुट: 

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

आउटपुट:

basketball

संदर्भ

  1. http://calorielab.com/burned/
code-golf  arithmetic 
— लीक नन
स्रोत
1
क्या यह ठीक है यदि हमारी भाषा में पूर्णांकों को विभाजित करने से डिफ़ॉल्ट रूप से एक भिन्न प्रकार का उत्पादन होता है?
— xnor
1
1. हाँ 2. अंश-निर्मित
— लीक नून
5
— मार्टिन एंडर
4
क्या आपका मतलब है "आसानी से वजन कम कैसे करें?" नहीं "कैसे आसानी से वजन कम करने के लिए?" ..
— पागल
3
@LeakyNun अधिकार .. शीर्षकों पर चुटकुलों के अंदर .. क्योंकि अधिकांश लोग इसे बुरा व्याकरण के रूप में पढ़ते हैं: पी
— पागल

जवाबों:

13

पायथन 2, 51 बाइट्स

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

क्या सबसे बड़े अनुपात के साथ प्रविष्टि खोजने की स्पष्ट बात है, लेकिन फर्श-विभाजन से पहले 10 के एक विशाल इनपुट-निर्भर शक्ति द्वारा अंश को पहले गुणा करके फ्लोट के खिलाफ निषेध को रोक देता है।

मैं साबित करूंगा कि यह गुणांक फर्श-विभाजन को गैर-फर्श विभाजन के समान अंतर बनाने के लिए काफी बड़ा है।

दावा: यदि 1 / b 1 > a 2 / b 2 , तो तल (Na 1 / b 1 )> तल (Na 2 / b 2 ) किसी N≥b 1 b 2 के लिए ।

प्रमाण: ध्यान दें कि 1 / b 1 - a 2 / b 2 1 / b 1 b 2 का गुणक है , इसलिए 1 / b 1 - a 2 / b 2 > 0 का तात्पर्य है

एक 1 / बी 1 - एक 2 / बी 2 b 1 / बी 1 बी 2

फिर, दोनों पक्षों को N से गुणा करें,

ना १ / बी १ - ना २ / बी २ / एन / बी १ बी २ ≥ १

तो, चूंकि Na 1 / b 1 और Na 2 / b 2 कम से कम 1 से भिन्न हैं, इसलिए उनकी संबंधित मंजिलें अलग-अलग हैं। ∎

अब, ध्यान दें कि उत्पाद b 1 b 2 की उनकी कुल अंक लंबाई में अंक लंबाई है, जो इनपुट की स्ट्रिंग लंबाई से कम है। चूंकि इनपुट बेस 10 में है, इसलिए इसकी लंबाई 10 की शक्ति का उपयोग करने के लिए पर्याप्त है, इससे N=10**len(`l`)अधिक अंक के साथ संख्या का उत्पादन करने के लिए, शर्त की गारंटी देता है।

— XNOR
स्रोत
9इसके बजाय कोई भी अवसर जैसे काम हो सकता है 10?
— लिन
2
@ लियन दुर्भाग्य से, यह विशाल इनपुट की तरह विफल रहता है [('y', 10**296+1, 1), ('x', 10**296, 1)]।
— xnor
8

जावास्क्रिप्ट (ईएस 6), 43 बाइट्स

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

या वैकल्पिक रूप से

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

इसके लिए सॉर्ट ओवरकिल है, लेकिन reduce46 बाइट्स लेंगे:

a=>a.reduce((v,w)=>v[1]*w[2]-v[2]*w[1]?v:w)[0]
— नील
स्रोत
7

MATL , 8 बाइट्स

pG/*&X<)

सभी संगणित संख्या पूर्णांक मान हैं। सबसे पहले, हर के उत्पाद की गणना की जाती है (यह एक पूर्णांक है)। यह उत्पाद प्रत्येक भाजक (जो एक पूर्णांक भी देता है) द्वारा विभाजित है। प्रत्येक परिणाम को फिर इसी अंश से गुणा किया जाता है। यह एक पूर्णांक मान मूल अंश के आनुपातिक देता है।

इनपुट प्रारूप है: हर के साथ संख्यात्मक सरणी, संख्यात्मक के साथ संख्यात्मक सरणी, खेल के नाम के साथ तार की सेल सरणी:

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

यदि कई न्यूनतम हैं तो पहला आउटपुट है।

इसे ऑनलाइन आज़माएं!

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
— लुइस मेंडो
स्रोत
5

दिल्लोग एपीएल , 18 बाइट्स

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

समय के लिए संकेत, फिर कैलोरी के लिए, फिर गतिविधि के नाम के लिए।

⎕ शीघ्र (समय के लिए)

(∧/÷⊢)∧/समय का LCM समय से विभाजित होता ÷है ⊢(इसलिए कोई तैरता नहीं)

⎕× शीघ्र (कैलोरी के लिए) और उनके द्वारा गुणा करें

(⊢⍳⌈/)उस में ⊢, ⍳अधिकतम मूल्य की स्थिति प्राप्त करें⌈/

⎕⊃⍨प्रॉम्प्ट (गतिविधियों के लिए), फिर एन चुनें वें चुनें।

उदाहरण रन:

      ⎕⊃⍨(⊢⍳⌈/)⎕×(∧/÷⊢)⎕
⎕:
      15 60 15
⎕:
      85 102 119
⎕:
      'fencing' 'billiards' 'basketball'
basketball
— एडम
स्रोत
4

ब्रेकीलॉग , 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

/ऊपर पूर्णांक विभाजन है क्योंकि दोनों पूर्णांक हैं J*Dऔर I( वास्तव में Dएक से अधिक I) हैं।

व्याख्या

  • मुख्य विधेय: 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

  • 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]
— Fatalize
स्रोत
3

रेटिना , 64 62 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

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

इनपुट प्रति प्रारूप एक खेल है, प्रारूप के साथ value1 value2 name। आउटपुट अधिकतम परिणामों में से एक है (यदि कोई टाई है तो यह सबसे बड़े के साथ देगा value1और यदि वे बंधे हुए हैं तो लेक्सिकोग्राफिक रूप से बड़ा होगा name)।

ध्यान दें कि यह सुपर स्लो है ( कल के स्टैक एक्सचेंज आउटेज के समान सटीक कारणों के लिए )। इसे उचित समय में चलाने के लिए, आप इसमें एक \bसामने जोड़ सकते हैं (0+)(जो उस तरीके को प्रभावित नहीं करेगा जो इनपुट को बिल्कुल संसाधित करता है लेकिन गंभीर रूप से उस regex की सीमा को सीमित कर देता है)। मैंने नीचे दिए गए परीक्षण लिंक में किया है।

इसे ऑनलाइन आज़माएं!

— मार्टिन एंडर
स्रोत
3

पायथन 2, 55 54 बाइट्स

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

1 बाइट को बंद करने के लिए @xnor को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
अच्छा! मैं भूल गया कि sortedदो-इनपुट तुलनित्र फ़ंक्शन ले सकता है, मैं एक साथ हैक करने जा रहा था।
— xnor
लगता है जैसे यह अनपैक करने के लिए छोटा है lambda(a,b,c),(d,e,f):b*f-c*e।
— xnor
@ एक्सनॉर नीट! मुझे नहीं पता था कि आप ऐसा कर सकते हैं।
— डेनिस
2

हास्केल 72 70 बाइट्स

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

उपयोग: 

main=putStr$(fst.minimumBy(%))[("fencing",(15,85)),("billiards",(60,102)),("basketball",(15,119))]
— डेमियन
स्रोत
1

मैथेमेटिका, 46 बाइट्स

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

टुपल्स का क्रम होना चाहिए {value1,value2,name} । सभी अधिकतम परिणामों का पूरा सेट लौटाता है।

मैं value1डिवीजन से पहले सभी एस के एलसीएम द्वारा अंश को गुणा करके अंशों के उपयोग के आसपास काम करता हूं ।

— मार्टिन एंडर
स्रोत
1

आर, 42 40 बाइट्स

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

स्तंभ प्रकार के स्ट्रिंग के साथ डेटा फ़्रेम के रूप में इनपुट लेता है (यह कारकों के साथ भी काम करता है), संख्यात्मक, संख्यात्मक।

  • %/% पूर्णांक विभाजन है।

यह मेरा पहला सबमिशन है, मुझे बताएं कि क्या यह नियमों के भीतर है।

संपादित करें: पता चलता है कि आपको एक-पंक्ति फ़ंक्शन को परिभाषित करने के लिए ब्रेसिज़ की आवश्यकता नहीं है।

— अज़ोर अहै
स्रोत
क्या यह गलत उत्तर दे सकता है यदि दो समान अनुपात एक ही पूर्णांक में विभाजित होते हैं, जैसे 7 / 3,9 / 4?
— नील
मेरी समझ यह है कि यदि वे एक ही पूर्णांक में विभाजित होते हैं, तो आप उनमें से किसी को भी आउटपुट कर सकते हैं, यह डेटा फ्रेम में पहला आउटपुट देगा।
— अज़ोर अहई
1

सी ++ 14, 89 बाइट्स

लंबोतरा समारोह:

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

उपयोग:

#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);
}
— अलेक्जेंडर रेवो
स्रोत
1

हास्केल, 46 बाइट्स

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

संपादित करें: यह समाधान डेमियन द्वारा बताए गए अनुसार काम नहीं करता है इससे समस्या हल नहीं होती है। मैं एक अच्छा तय खोज रहा हूँ।

— villou24
स्रोत
1
s(_,(x,y))=divMod y xछोटा है
— डेमियन
1
s(n,(x,y))=(divMod y x,n) g=snd.maximum.map sभी ..
— डेमियन
2
लेकिन यह समस्या को हल नहीं करता divMod a b < divMod c dहै क्योंकि इसके बराबर नहीं है a/b < c/d। divMod 19 4 < divMod 55 12लेकिन19/4 > 55/12
— डेमियन
Mmmh वास्तव में मेरे समाधान काफी गरीब है ... मैं अच्छा तय के बारे में सोचेंगे, धन्यवाद!
— विलाउ
1

VBA एक्सेल, 109 बाइट्स

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

स्प्रेडशीट सेल में शामिल गतिविधियों और मापदंडों की एक तालिका देखें:

यहाँ छवि विवरण दर्ज करें

— Joffan
स्रोत
1

05AB1E , 6 7 बाइट्स

P¹÷*ZQÏ

+1 बाइट मेरे दिव्योदक दृष्टिकोण को खराब करने के लिए ( अन्य उत्तर पर इस टिप्पणी को देखें ) @LuisMendo के MATL उत्तर को पोर्ट करके , इसलिए उसे सुनिश्चित करें!

इनपुट उनके उत्तर के समान है: तीन अलग-अलग सूची, भाजक की पूर्णांक-सूची होने के नाते; नामांकितों की एक पूर्णांक-सूची; और नामों की एक स्ट्रिंग-सूची।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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)
— केविन क्रूज़सेन
स्रोत
0

जावा 8, 128 बाइट्स

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();}
— user902383
स्रोत
0

रूबी, 72 बाइट्स

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

मैं वास्तव में सोचा था कि यह छोटा होगा ...

के प्रारूप में इनपुट STDIN से लिया गया है name time calories

ओह ठीक है, किसी भी मदद के लिए यह सराहना की है छोटा।

— Elenian
स्रोत
0

क्लोजर, 63 बाइट्स

#((last(sort(fn[[x a b][y c d]](-(* b c)(* a d)))%))0)
— NikoNyrh
स्रोत
0

PHP , 98 बाइट्स

उदाहरण की तुलना में सरल इनपुट प्रारूप का उपयोग किया, जैसे:

तलवारबाजी, 15,85, बिलियर्ड्स, 60,102, बास्केटबॉल, 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;

इसे ऑनलाइन आज़माएं!

— XMark
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.