संकट:

आपका कार्य एक प्रोग्राम लिखना है जो इनपुट को ऊंचाई (मीटर में) और वजन (किलोग्राम में) के रूप में लेता है, और इसी बीएमडब्ल्यू श्रेणी को आउटपुट करता है।

बीएमआई आपकी ऊंचाई के लिए आपके वजन के अनुपात का एक उपाय है। यह कई लोगों के लिए दिनांकित और गलत है , लेकिन यहाँ कोई फर्क नहीं पड़ता!

बीएमआई की गणना निम्नलिखित समीकरण का उपयोग करके की जा सकती है:

BMI = (mass in kilograms) / (height in meters)^2

श्रेणियों को निम्नानुसार परिभाषित किया जाएगा:

बीएमआई <18.5: "अंडरवेट"
18.5 <= बीएमआई <25: "सामान्य"
25 <= बीएमआई: "अधिक वजन"

चुनौती के लिए, मैं सभी "चरम" श्रेणियों को अनदेखा कर रहा हूं। इसके अलावा, चूंकि कुछ संख्याएं जैसे "25" 2 श्रेणियों के बीच बैठती हैं, इसलिए मैंने सीमाओं को थोड़ा समायोजित किया ताकि एक निश्चित उत्तर हो।

आप एक फ़ंक्शन, या एक पूर्ण प्रोग्राम लिख सकते हैं।

इनपुट:

इनपुट किसी भी उचित रूप में हो सकता है। दो नंबर (या तार), या तो 2 अलग-अलग तर्क के रूप में, या एक स्ट्रिंग के रूप में। 2 नंबर की एक सरणी / सूची, "वजन" और "ऊंचाई" कुंजी के साथ एक शब्दकोश ... दशमलव मूल्यों का समर्थन किया जाना चाहिए। आप मान सकते हैं कि इनपुट हमेशा मान्य होगा (कोई नकारात्मक मान नहीं है, और ऊंचाई कभी 0 नहीं होगी)।

आउटपुट:

आउटपुट केस-असंवेदनशील श्रेणी के नामों वाला एक स्ट्रिंग होगा । स्ट्रिंग को मामले की अनदेखी करते हुए ठीक ऊपर की श्रेणी के नामों से मेल खाना चाहिए। यह स्टडआउट के लिए आउटपुट हो सकता है, लौटाया जा सकता है (किसी फ़ंक्शन के मामले में), या फ़ाइल में लिखा जा सकता है।

परीक्षण के मामले (वजन, ऊंचाई => परिणाम):

80, 1 =>   "Overweight"
80, 2 =>   "Normal"
80, 3 =>   "Underweight"

50, 1 =>   "Overweight"
50, 1.5 => "Normal"
50, 2 =>   "Underweight"

Edge Cases:

41, 1.5 => "Underweight" (18.2 BMI)
42, 1.5 => "Normal" (18.667 BMI)

56, 1.5 => "Normal" (24.889 BMI)
57, 1.5 => "Overweight" (25.3 BMI)

73, 2 =>   "Underweight" (18.25 BMI)
74, 2 =>   "Normal" (18.5 BMI)

99, 2 =>  "Normal" (24.75 BMI)
100, 2 => "Overweight" (25 BMI)

यहाँ कुछ छद्मकोश हैं जो एक उदाहरण कार्यान्वयन दिखाता है:

function bmi_category(weight, height):
    var bmi = (weight / (height**2))

    if (bmi < 18.5):
        return "Underweight"

    if (18.5 <= bmi < 25):
        return "Normal"

    if (25 <= bmi):
        return "Overweight"

यह कोड-गोल्फ है, इसलिए सबसे कम संख्या में बाइट्स जीतती हैं।

(हां, अधिकांश भाषाओं में यह कार्य बहुत ही तुच्छ है। अधिकांश चुनौतियां हाल ही में सामान्य से कठिन प्रतीत होती हैं, इसलिए मैंने सोचा कि मैं एक अधिक सुलभ पोस्ट करूंगा)।

ध्यान दें! इस चुनौती को पोस्ट करने के एक घंटे बाद, मुझे श्रेणियों को थोड़ा संशोधित करना पड़ा क्योंकि कहा गया था कि "छेद" के रूप में श्रेणियाँ टिप्पणियों में बताई गई हैं। कृपया नई रेंज देखें।

code-golf math

— Carcigenicate
स्रोत

9

जेली , 24 बाइट्स

÷÷⁹Ḥ“%2‘>Sị“$⁽¿“;ṅẒ“&ċ)»

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

कैसे?

बीएमआई की गणना करता है, इसे दोगुना करता है, तुलना करता है कि 37 और 50 (18.5 और 25) संख्याओं में से प्रत्येक के साथ ऑपरेटर की तुलना में अधिक है, परिणामी वाले और शून्य (सामान्य, कम वजन और अधिक वजन के लिए 1, 2, या 0) की रकम देता है। क्रमशः) और अनुक्रमित तार की सूची में ["Normal","Underweight","Overweight"]।

÷÷⁹Ḥ“%2‘>Sị“$⁽¿“;ṅẒ“&ċ)» - Main link: weight, height
÷                        - weight ÷ height
  ⁹                      - right argument, height
 ÷                       - ÷ by height again to get the BMI
   Ḥ                     - double the BMI
    “%2‘                 - list of code page indexes [37,50]
        >                - greater than? (vectorises) - i.e [18.5>bmi, 25>bmi]
         S               - sum -- both:=2 (Underweight), just 50:=1 (Normal) or neither:=0 (Overweight)
          ị              - index into (1-based)
           “$⁽¿“;ṅẒ“&ċ)» - compressed list of strings ["Normal","Underweight","Overweight"]
                         - implicit print

— जोनाथन एलन
स्रोत

1

वाह। मोटापे के बारे में बात करें। यदि यह गोल्फ है, तो मुझे लगता है कि आपको एक छेद मिल गया है! या 24 ...

— कुल्लू

2

@ कुल्लू यह 24 अक्षर और 24 बाइट्स है - जैली इसका उपयोग स्वयं कोड-पेज से करता है जिसे शीर्षक में "बाइट्स" शब्द से जोड़ा गया है, mothereff.in यूनिकोड मैं विश्वास कर रहा है।

— जोनाथन एलन

1

@ TheBitByte, हाँ, TIO लिंक काउंटर "24 चार्ट, 24 बाइट्स (SBCS)" पर एक नज़र डालें या हेडिंग में बाइट्स से जुड़े कोड-पेज का उपयोग करके इसे हाथ से गिनें।

— जोनाथन एलन

... हेक्स के रूप में:1C 1C 89 AF FE 25 32 FC 3E 53 D8 FE 24 8D 0B FE 3B F0 BD FE 26 E8 29 FB

— जोनाथन एलन

21

पायथन , 69 बाइट्स

lambda w,h:["UOnvd"[w/h/h>20::2]+"erweight","Normal"][18.5<=w/h/h<25]

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

72 बाइट्स की तुलना करें:

lambda w,h:"Underweight"*(w/h/h<18.5)or"Normal"*(w/h/h<25)or"Overweight"

— XNOR
स्रोत

10

टीआई-बेसिक, 58 54 बाइट्स

Input 
X/Y²→C
"NORMAL
If 2C≤37
"UNDERWEIGHT
If C≥26
"OVERWEIGHT

इसके अलावा, मज़े के लिए, यहां एक अधिक कॉम्पैक्ट संस्करण है जो अधिक बाइट्स है:

Prompt A,B
sub("UNDERWEIGHTNORMAL      OVERWEIGHT ",sum(A/B²≥{18.5,25})11+1,11

मैं बस इतना कह सकता हूं कि इस मामले को असंवेदनशील बनाने के लिए धन्यवाद;)

PS Inputग्राफ इनपुट को Xऔर इसके Yसमान ले जाता हैPrompt X,Y

— Timtech
स्रोत

इसके अलावा, मैंने इसे कई बार देखा है, और मुझे नहीं लगता कि बाइट्स को बचाने का कोई तरीका है, भले ही पिछले दो भाग स्ट्रिंगERWEIGHT

— टिमटेक

जिज्ञासा से बाहर, अगर मैंने केस-सेंसिटिविटी को लागू किया, तो इससे आपका उत्तर कैसे बदल जाएगा?

— कारजेनियेट विगत

1

@Carcigenicate TI-Basic में, लोअरकेस अक्षर दो बाइट्स हैं। इस प्रकार, यह बाइट की संख्या को बहुत बढ़ा देता है।

— टिमटेक

1

ओह समझा। अजीब है कि।

— कार्निजेन्ट

1

@Carcigenicate यह याद रखना महत्वपूर्ण है कि TI-Basic के इस संस्करण को 1990 में एक कैलकुलेटर भाषा के रूप में पेश किया गया था ... कोई नहीं जानता था कि मैं इसे 27 साल बाद गोल्फ

— करूंगा

6

गणितज्ञ, 67 बाइट्स

"Normal"["Underweight","Overweight"][[Sign@⌊(2#/#2^2-37)/13⌋]]&

इस तथ्य का उपयोग करता है कि अगर a[b,c][[Sign@d]]रिटर्न 0 के बराबर है, तो रिटर्न अगर सकारात्मक है, और रिटर्न अगर नकारात्मक है। तीन-बाइट अक्षर U + 230A और U + 230B का उपयोग करके मैथेमेटिका का कार्य है। दो बार के उपयोग से बेहतर करने के लिए यह पता नहीं लगा सका ।adbdcd⌊...⌋Floorweight

— ग्रेग मार्टिन
स्रोत

3

आश्चर्यचकित गणितज्ञ के पास इसके लिए कोई अंतर्निहित नहीं है

— डैनियल

1

आपको उसके लिए फैन फिक्शन में जाना होगा ;)

— ग्रेग मार्टिन

5

रूबी, 91 77 74 67 बाइट्स

पहली भोली कोशिश:

->(w,h){case w/h/h
when 0..18.5
'underweight'
when 18.5..25
'normal'
else
'overweight'
end}

पिछले उत्तरों से "प्रेरणा" के साथ दूसरा प्रयास करें:

->w,h{["#{(w/=h*h)<18.5?'und':'ov'}erweight",'normal'][(18.5..25)===(w)?1:0]}

तीसरा प्रयास:

->w,h{["#{(w/=h*h)<18.5?'und':'ov'}erweight",'normal'][w>=18.5&&w<25?1:0]}

चौथा प्रयास:

->w,h{18.5<=(w/=h*h)&&w<25?'normal':"#{w<18.5?'und':'ov'}erweight"}

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

— reitermarkus
स्रोत

homebrew-cask से रीइक्टर्माटस ?! वाह, तुम्हें यहाँ देखने की उम्मीद नहीं थी! : ओ

— संख्यामान

1

@numbermaniac, हाहा, हाँ, यह मैं हूँ! 😂

— रीटमर्स्कस

5

जावास्क्रिप्ट (ईएस 6), 70 67 64 63 बाइट्स

4B को Arnauld के लिए धन्यवाद दिया

a=>b=>(a/=b*b)<25&a>=18.5?"Normal":(a<19?"Und":"Ov")+"erweight"

प्रयोग

f=a=>b=>(a/=b*b)<25&a>=18.5?"Normal":(a<19?"Und":"Ov")+"erweight"
f(80)(1)

उत्पादन

"Overweight"

व्याख्या

यह उत्तर काफी तुच्छ है, हालांकि एक चतुर चाल है: Underweightऔर Overweightदोनों में अंत होता है erweight, इसलिए हमें केवल उन पात्रों को बदलना होगा।

मैंने माना कि Normal25 (अनन्य) और 18.5 (समावेशी) के बीच बीएमआई का मतलब है। Underweightमतलब बीएमआई 18.5 से कम है, और Overweightइसका मतलब बीएमआई 25 से अधिक या उसके बराबर है।

— ल्यूक
स्रोत

1

अब उत्तर में कोई ES7 विशेषताएं नहीं हैं ;-)

— ETHproductions

4

सी, 81 बाइट्स

f(float m,float h){m/=h*h;puts(m<26?m<18.6?"Underweight":"Normal":"Overweight");}

— Steadybox
स्रोत

4

05AB1E , 28 बाइट्स

n/©37;‹®25‹O’‚Š‰ß îÂ ‚â‰ß’#è

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

4

QBIC , 61 58 बाइट्स

::m=a/b^2~m<18.5|?@Und`+@erweight`\~m>=25|?@Ov`+B\?@Normal

@ ल्यूक ने फोर्स का इस्तेमाल किया और दो बाइट्स काट दिए। धन्यवाद!

नियमों में बदलाव ने एक और बाइट को बचाया।

स्पष्टीकरण:

::          gets weight and height as a and b
m=a/b^2     Calculates BMI
~m<18.5|    If BMI < 18.5 then
?@Und`      Print the string literal 'Und' (which is now A$)
+@erweight` and the string literal 'erweight'  (which is now B$)
\~m>=25|    else if the BMI is greater than or equal to 25
?@Ov`+B     Print 'Ov' and B$ ('erweight')
\?@Normal   Else, if we're here, BMI is normal.

— steenbergh
स्रोत

3

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

lambda a,b:"UNOnovdreemrrawwlee ii gg hh tt"[(18.6<a/b/b)+(a/b/b>25)::3]

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

— DJMcMayhem
स्रोत

आप पायथन के लिए रंग कैसे प्राप्त करते हैं? मैंने कभी इसका पता नहीं लगाया।

@JackBates यह सिर्फ वह है जो TIO स्वचालित रूप से मेरे लिए डाला गया है।

— DJMcMayhem

3

पायथन 3, 97 95 बाइट्स

a,b=map(int,input().split())
a/=b*b*5
print(["UOnvd"[a>93::2]+"erweight","Normal"][93<=a<=125])

पूरा कार्यक्रम।

एक बाइट को बचाने के लिए पांच से गुणा करें। धन्यवाद जोनाथन एलन।

पंक्ति दर पंक्ति:

दो अलग-अलग उपयोगकर्ता इनपुट नंबर को अंतरिक्ष में मैप करें। ए और बी को अनपैक करें।
गणना
यदि बीएमआई 18.6 और 25 के बीच है, तो समावेशी, दाईं ओर की अभिव्यक्ति True का मूल्यांकन करेगी। बूलियन 0 या 1 हो सकता है जब सूची सूचकांक के रूप में उपयोग किया जाता है, इसलिए हम या तो "सामान्य" या शून्य सूचकांक में निर्मित स्ट्रिंग प्राप्त करते हैं। "इरवेट" शेष दो विकल्पों के लिए एक साझा प्रत्यय है, इसलिए इसे दोहराने की आवश्यकता नहीं है। तब हम पायथन लिस्ट / स्ट्रिंग स्लाइसिंग के [स्टार्ट: स्टॉप: स्टेप] पैटर्न का उपयोग करते हैं। c> 18.6 या तो 0 या 1 (गलत या सत्य) का मूल्यांकन करेगा और हमारी शुरुआत बन जाएगा। स्टॉप का संकेत नहीं है, इसलिए हम शाब्दिक के अंत में जाते हैं। चरण 2 है इसलिए हम हर दूसरे सूचकांक को लेते हैं। यदि स्टार्ट स्टार्ट 1 का मूल्यांकन करता है, तो हमें "ओव" मिलता है, अन्यथा हमें "अंडर" मिलता है। किसी भी तरह, हम "एरवेट" को जोड़ते हैं जो हमें मिला और हमारे पास हमारा अंतिम आउटपुट है।

— mypetlion
स्रोत

1

इसे 79 के लिए एक समारोह के रूप में लिखें:def f(h,w):c=h/w/w;print(["UOnvd"[c>18.6::2]+"erweight","Normal"][18.6<=c<=25])

— जोनाथन एलन

यदि आप पहले पांच से गुणा करते हैं 93और आप एक बाइट को और से तुलना करके बचा सकते हैं 125। यदि आप एक लैम्ब्डा का उपयोग करते हैं, तो आपको cदोनों स्थानों पर गणना करनी होगी, लेकिन फ़ंक्शन या उपयोग को नाम देने की आवश्यकता नहीं है print(), इसलिए lambda h,w:["UOnvd"[h/w/w*5>93::2]+"erweight","Normal"][93<=h/w/w*5<=125]73 के लिए कर सकते हैं।

— जोनाथन एलन

... वास्तव में क्योंकि आप cदो बार 5 से गुणा लागत की गणना करेंगे यह लंबोदर में बचाता है, इसलिए सिर्फ lambda h,w:["UOnvd"[h/w/w>18.6::2]+"erweight","Normal"][18.6<=h/w/w<=25]72 के लिए

— जोनाथन एलन

जोनाथन एलन किसी ने पहले से ही इसे केवल एक समारोह के रूप में किया था।

— मैपिलेयन

यह ठीक है, आपका रास्ता उन्हें गोल्फ से बाहर कर देगा: डी

— जोनाथन एलन

3

आर, 89 ९ 89४ 80 74 बाइट्स

f=pryr::f(c('Overweight','Normal','Underweight')[sum(w/h^2<c(18.5,25),1)])

StewieGriffin के ऑक्टेव उत्तर के लिए एक संकेत के साथ, स्ट्रिंग्स की एक सरणी बनाता है, फिर परिणाम का वर्णन करता है BMI < c(18.5,25)और उस स्थिति + 1 पर सरणी को संदर्भित करता है।

पहले तर्क को ऊंचाई चाहिए, फिर वजन; अगर यह अनुमति नहीं है, तो

f=pryr::f(w,h,c('Overweight','Normal','Underweight')[sum(w/h^2<c(18.5,25),1)])

4 और बाइट्स के लिए काम करता है।

— बीएलटी
स्रोत

2

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

#(condp <(/ %(* %2 %2))25"Overweight"18.5"Normal""Underweight")

— NikoNyrh
स्रोत

अरे नहीं। हमेशा की तरह, यह एक छोटा संस्करण है जो मैं सोच रहा था।

— कैरिजनेट

2

डीसी , 58 बाइट्स

Fk[Ov]?2^/d[[Normal]pq][[Und]26]sasb18.5>a25>bn[erweight]p

प्रारूप में 2 अलग-अलग संख्याओं के रूप में इनपुट लेता है <mass> <height>। एक अलग लाइन पर एक स्ट्रिंग आउटपुट करता है।

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

व्याख्या

इस स्पष्टीकरण के प्रयोजनों के लिए, इनपुट है 80 1।

Fk                                                         # Set decimal precision to `16`.
  [Ov]                                                     # Push the string "Ov" onto the main stack.
                                                           # Main Stack: [[Ov]]
      ?2^/d                                                # Take and evaluate input, squaring the 2nd one, and the dividing by the first one by the 2nd. Then duplicate the result.
                                                           # Main Stack: [[Ov],80.000000000000000,80.000000000000000]
           [[Normal]pq][[Und]26]sasb                       # Push and store the executable macros "[Normal]pq" and "[Und]26" on registers "a" and "b", respectively.
                                                           # Main Stack: [[Ov],80.000000000000000,80.000000000000000], reg. a: [[[Normal]pq]], reg. b: [[[Und]26]]
                                    18.5>a25>b             # Push, "18.5" onto stack, and then pop top 2 values. If "18.5 > (top of stack)", then execute the macro on top of reg. "a", which in turn pushes the string "Und" onto the main stack followed by the number 26.
                                                           # The "26" will automatically prompt the next comparison to not execute the macro on top of reg. "b", regardless of the value on top of the main stack.
                                                           # Otherwise, if "18.5 <= (top of stack) < 25", then execute "b"s macro, which in turn pushes the string "Normal" onto the main stack, outputs it, then quits the program.
                                                           # In this case, Main stack: [[Ov]], reg. a: [[[Normal]pq]], reg. b: [[[Und]26]]
                                              n[erweight]p # If "Normal" has not been output, only then will the program get to this point. Here, it will output whatever string, either "Und" or "Ov", on top of the main stack, followed by "erweight" and a new line.

— आर। कप
स्रोत

2

ऑक्टेव, 64 बाइट्स

@(w,h){'Underweight','Normal','Overweight'}{3-sum(2*w/h^2<'%2')}

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

यह एक अनाम फ़ंक्शन है जो दो इनपुट तर्क लेता है, h(ऊंचाई) और w(वजन)।

फ़ंक्शन एक सेल सरणी बनाता है जिसमें तार होते हैं 'Underweight','Normal','Overweight', और स्ट्रिंग संख्या को आउटपुट करता है 3-sum(2*w/h^2<'%2')।

हाँ, यह एक अजीब सा लग रहा है। हम पहली स्ट्रिंग चाहते हैं यदि w/h^2<=18.5, दूसरी स्ट्रिंग अगर (w/h^2 > 18.5) & (w/h^2 < 25)और तीसरी स्ट्रिंग यदि उपरोक्त शर्तों में से कोई भी सत्य नहीं है। तुलनाओं का एक गुच्छा बनाने के बजाय, हम बस स्ट्रिंग की तुलना कर सकते हैं: w/h^2 < [18.5, 25]जो [1 1], [0 1], [0,0]क्रमशः निम्न वजन, सामान्य और अधिक वजन के लिए निम्न सरणियों में से एक को लौटाएगा ।

[18.5,25]9 बाइट्स लेता है, जो बहुत कुछ है। क्या हम बजाय करते हैं, गुणा 2 से बीएमआई है, और साथ परिणाम की तुलना [37, 50], या '%2'ASCII में। इससे तीन बाइट्स बचती हैं।

— स्टीवी ग्रिफिन
स्रोत

2

पर्ल 6 , 59 बाइट्स

{<Overweight Normal Underweight>[sum 18.5,25 X>$^a/$^b**2]}

यह काम किस प्रकार करता है

{                                                         }  # A lambda.
                                               $^a/$^b**2    # Compute BMI from arguments.
                                     18.5,25 X>              # Compare against endpoints.
                                 sum                         # Add the two booleans together.
 <Overweight Normal Underweight>[                        ]   # Index into hard-coded list.

स्ट्रिंग erweightको बार-बार खराब करना पड़ता है, लेकिन इससे बचने के लिए मैंने जो भी कोशिशें कीं, उन सभी बदलावों से बचने के लिए मैंने कुल मिलाकर बाइट की गिनती को बढ़ाया।

स्ट्रिंग प्रतिस्थापन के साथ, 62 बाइट्स:
```
{<Ov_ Normal Und_>[sum 18.5,25 X>$^a/$^b**2].&{S/_/erweight/}}
```
स्ट्रिंग प्रक्षेप के साथ, 67 बाइट्स:
```
{$_='erweight';("Ov$_","Normal","Und$_")[sum 18.5,25 X>$^a/$^b**2]}
```
Xnor के पायथन सॉल्यूशन का कठिन अनुवाद , 65 बाइट्स:
```
{$_=$^a/$^b**2;25>$_>=18.5??"Normal"!!<Und Ov>[$_>19]~"erweight"}
```

— SMLS
स्रोत

2

पॉवरशेल , 81 बाइट्स

param($m,$h)('Underweight','Normal','Overweight')[(18.5,25-lt($m/($h*$h))).Count]

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

व्याख्या

मुख्य बिट की व्याख्या करने की आवश्यकता है 18.5,25 -lt $b(जहां मैं प्रतिस्थापित कर रहा हूं$b बीएमआई के लिए जो कोड में जगह की गणना करता है)। पॉवरशेल में अधिकांश ऑपरेटर, जब बाईं ओर एक सरणी दी जाती है, तो बूलियन मान वापस करने के बजाय, उन मदों की एक सरणी लौटाते हैं जो परीक्षण को संतुष्ट करते हैं। तो यह एक खाली सरणी लौटाएगा यदि$b 18.5 से छोटा है, एक सरणी केवल 18.5 से युक्त है यदि यह बीच में है, और एक सरणी जिसमें 18.5 और 25 दोनों हैं, यदि यह 25 से बड़ा है।

मैं तत्वों की गिनती को स्ट्रिंग्स के एक सरणी में एक सूचकांक के रूप में उपयोग करता हूं, इसलिए गणना 0को तत्व मिलता है 0जो कि है 'Underweight', आदि।

— briantist
स्रोत

2

OCaml, 93 बाइट्स

let b w h=if w/.h/.h<18.5 then"underweight"else if w/.h/.h>=25.0 then"overweight"else"normal"

— reitermarkus
स्रोत

नहीं, यह एक फ़ंक्शन है।

— रीव वाटरमार्क

2

पायथन, 75 74 बाइट्स

lambda h,w:18.5<=w/h/h<=25and"normal"or["ov","und"][25>w/h/h]+"erwe‌ight"

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

काफी हद तक बुनियादी समाधान जो इसे हल करने के लिए अन्य लोगों की तकनीकों का लाभ उठाता है।

एक बाइट को बचाने के लिए @ovs धन्यवाद।

वैकल्पिक

1. 73 बाइट्स

lambda h,w:"normal"if 18.5<=w/h/h<=25 else"uonvd"[25<w/h/h::2]+"erweight"

मैंने इसे अस्वीकार कर दिया क्योंकि यह मेरे द्वारा देखे गए दूसरे उत्तर के समान था।

2. 71 बाइट्स

lambda h,w:"normal"if 18.5<w/h/h<25 else"uonvd"[25<w/h/h::2]+"erweight"

मैंने इसे अस्वीकार कर दिया, क्योंकि प्रश्न में सभी परीक्षणों पर काम करने के बावजूद, कुछ संख्याएँ हैं जो इसमें विफल हो सकती हैं जैसे कि यह गायब =है <=।

आपको बीच 25- बीच में स्थान की आवश्यकता नहीं है, elseलेकिन वैसे भी, शॉर्ट सर्किटिंग का उपयोग करके and/or(जैसा कि @ovs ने टिप्पणी की है) छोटा है।

— पलटें

@FlipTack: के बीच की जगह के बारे में 25और else, आप निश्चित रूप से करना चाहिए कि कुछ (? सबसे) (CPython, IIRC सहित) दुभाषिए के साथ। यदि आप इसे लिखते हैं 25else, तो 25eवैज्ञानिक-संकेतन संख्यात्मक शाब्दिक की शुरुआत के रूप में व्याख्या की जाती है, और दुभाषिया तब बाऊल करता है जब निम्न अंक नहीं होते हैं।

— मैक

2

सी #, 63 62 61 बाइट्स

TheLethalCoder को 1 और बाइट धन्यवाद दिया ।

अनाम उपयोगकर्ता के लिए 1 बाइट का धन्यवाद सहेजा गया।

w=>h=>w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight";

एक बहुत ही सरल अनाम फ़ंक्शन। पूरी चाल सीधे करने के लिए टर्नरी ऑपरेटर का उपयोग कर रही है (इस तरह से चूक कर रही हैreturn कीवर्ड , घुंघराले ब्रेस की एक जोड़ी और एक चर घोषणा और असाइनमेंट)।

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

class BodyMassIndex
{
    static void Main()
    {
        Func<double, Func<double, string>> f =
        w=>h=>w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight";

        // test cases:
        Console.WriteLine(f(80)(1));  // "Overweight"
        Console.WriteLine(f(80)(2));  // "Normal"
        Console.WriteLine(f(80)(3));  // "Underweight"
        Console.WriteLine(f(50)(1));  // "Overweight"
        Console.WriteLine(f(50)(1.5));  // "Normal"
        Console.WriteLine(f(50)(2));  // "Underweight"
    }
}

— adrianmp
स्रोत

2

आम लिस्प, 89 87 85 84 83 बाइट्स

एक समारोह:

(lambda(w h)(if(< #1=(/ w(* h h))18.5)'underweight(if(< #1#25)'normal'overweight)))

उपयोग का उदाहरण:

((lambda(w h)(if(< #1=(/ w(* h h))18.5)'underweight(if(< #1#25)'normal'overweight)))150 2)

इसे ऑनलाइन आज़माएं! (TIO में आउटपुट देखने के लिए मैंने प्रिंटिंग फंक्शन जोड़ा)

सुधार के विचारों का स्वागत किया जाता है।

2

MATL, 54 45 44 42 बाइट्स

U/E'%2'<sqt?q?'ov'}'und']'erweight'h}x17Y0

इसे matl.suever.net पर आज़माएं

बीएमआई की गणना करके और इसे दोगुना करने से शुरू होता है U\E, फिर [37 50]स्ट्रिंग शाब्दिक '% 2' के साथ वेक्टर बनाता है । इस सदिश के लिए बीएमआई की तुलना करता है और normalपूर्वनिर्धारित शाब्दिक के रूप में लाभ उठाते हुए उत्तर प्राप्त करने के लिए उपयोग करता है 17Y0।

— बी मेहता ने
स्रोत

आप बदल सकते हैं [BC]UQके साथ '%2'और 2 बाइट्स सहेजें।

— सूंदर - १ica:

1

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

w->h->w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight"

इस प्रकार निर्दिष्ट करें DoubleFunction<DoubleFunction<String>>और कॉल करें:

bmi.apply(50).apply(1.5)

— डेविड कोनराड
स्रोत

आप पुन w: उपयोग करके एक बाइट को छोड़ सकते हैं w->h->(w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight":।

— ओलिवियर ग्राईगोइरे

@ ओलिवियरग्रैगोयर नोप :( Error: local variables referenced from a lambda expression must be final or effectively finalडब्ल्यू को असाइन नहीं किया जा सकता है।

— डेविड कॉनरैड

1

ओह ... मैंने जैसे अंतर्निर्मित सामान के साथ जाँच की int w = ... , h = ... ; System.out.println((w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight"), क्षमा करें :)

— ओलिवियर ग्रेजायर 23

@ OlivierGrégoire कोई समस्या नहीं है। काश जावा इसकी अनुमति देता।

— डेविड कॉनरेड

1

डीसी , 64 बाइट्स

[erweight][[Und]PszPq]su[[Normal]Pq]sn9k?d*/d18.5>ud25>n[Ov]PszP

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

— मिशेल स्पेक्टर
स्रोत

धत तेरे की! बस मुझे कुछ सेकंड के लिए हराया। मैं अपना पोस्ट करने वाला था, जब तक मैंने यह नहीं देखा। वैसे भी, यहाँ एक और 64 बाइट का जवाब है 3k[Overweight]??2^/dsp[[Normal]][[Underweight]]sasb25>blp18.5>ap:।

— आर। कप

@ R.Kap तुम वास्तव में तुम्हारा एक बाइट हो सकता है एक प्रश्न के निशान को छोड़ कर मेरी तुलना में छोटा हो।

— मिशेल स्पेक्टर

अरे हाँ, मैं भूल गया कि मैं ऐसा कर सकता हूँ। यदि आप चाहें तो आप इसे अपने रूप में पोस्ट कर सकते हैं।

— आर। कप

नहीं, यह ठीक है - आगे बढ़ो और इसे स्वयं पोस्ट करें, यह आपका समाधान है। (आप चाहें तो एक बाइट के लिए मुझे श्रेय दे सकते हैं।)

— मिशेल स्पेक्टर

वैसे, मैं इसे 58 बाइट्स तक लाने में सक्षम था। :)

— आर। कप

1

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

(m,h)=>(w="erweight",b=m/h/h)<18.5?"Und"+w:b<25?"Normal":"Ov"+w

उदाहरण

f=(m,h)=>(w="erweight",b=m/h/h)<18.5?"Und"+w:b<25?"Normal":"Ov"+w

console.log(f(80, 1));
console.log(f(80, 2));
console.log(f(80, 3));

स्निपेट का विस्तार करें

— जनवरी
स्रोत

1

स्विफ्ट, 97 बाइट्स

{(w:Float,h)->String in return 18.5<=w/h/h&&w/h/h<25 ?"normal":"\(w/h/h>25 ?"ov":"und")erweight"}

— reitermarkus
स्रोत

1

जाप , 46 बाइट्स

/=V²U<25©U¨18½?`NŽµl`:ºU<19?`U˜`:"Ov")+`€³ight

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

@ ल्यूक के जवाब से प्रेरित ।

व्याख्या

/=V²U<25©U¨18½?`NŽµl`:ºU<19?`U˜`:"Ov")+`€³ight

नीचे करने के लिए:

U=U/V**2,U<25&&U>18.5?"Normal":(U<19?"Und":"Ov")+"erweight"

जाप में एक निहित इनपुट है U। दूसरा इनपुट हैV ।

Japt शोको लाइब्रेरी का उपयोग करता है स्ट्रिंग संपीड़न के लिए । बैकटिक्स का उपयोग स्ट्रिंग्स को डिकम्प्रेस करने के लिए किया जाता है।

यूनिकोड शॉर्टकट का उपयोग किया जाता है:

² : **2
© : &&
¨ : >=
½ : .5
º : ((

— ओलिवर
स्रोत

1

PHP , 121 बाइट्स

function f($a,$b){$i=$a/($b*$b);$x = 18.5;print ($i<$x?"Underweight":($i>=$x&&$i<25?"Normal":($i>=25?"Overweight":"")));}

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

— Tom291
स्रोत

1

स्काला, 124 बाइट्स

val x="erweight"
def b(i:Float,a:Float):Any=i/a/a match{case z if(z<18.5)=>"Und"+x
case z if(z<25)=>"Normal"
case z=>"Ov"+x}

— रोमन ग्रैफ़
स्रोत

1

आरएक्सएक्सएक्स, 113 बाइट्स

arg m h
b=m/h**2
e=erweight
select
  when b<18.5 then say 'UND'e
  when b>=25 then say 'OV'e
  otherwise say Normal
end

— idrougge
स्रोत

REXX अब TIO पर है!

— आदम

मेरा बॉडी मास इंडेक्स क्या है?

संकट:

इनपुट:

आउटपुट:

परीक्षण के मामले (वजन, ऊंचाई => परिणाम):

जेली , 24 बाइट्स

कैसे?

पायथन , 69 बाइट्स

टीआई-बेसिक, 58 54 बाइट्स

गणितज्ञ, 67 बाइट्स

रूबी, 91 77 74 67 बाइट्स

जावास्क्रिप्ट (ईएस 6), 70 67 64 63 बाइट्स

प्रयोग

उत्पादन

व्याख्या

सी, 81 बाइट्स

05AB1E , 28 बाइट्स

QBIC , 61 58 बाइट्स

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

पायथन 3, 97 95 बाइट्स

आर, 89 ९ 89४ 80 74 बाइट्स

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

डीसी , 58 बाइट्स

व्याख्या

ऑक्टेव, 64 बाइट्स

पर्ल 6 , 59 बाइट्स

यह काम किस प्रकार करता है

पॉवरशेल , 81 बाइट्स

व्याख्या

OCaml, 93 बाइट्स

पायथन, 75 74 बाइट्स

वैकल्पिक

1. 73 बाइट्स

2. 71 बाइट्स

सी #, 63 62 61 बाइट्स

आम लिस्प, 89 87 85 84 83 बाइट्स

उपयोग का उदाहरण:

MATL, 54 45 44 42 बाइट्स

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

डीसी , 64 बाइट्स

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

स्विफ्ट, 97 बाइट्स

जाप , 46 बाइट्स

व्याख्या

PHP , 121 बाइट्स

स्काला, 124 बाइट्स

आरएक्सएक्सएक्स, 113 बाइट्स