Sorun:

Göreviniz, giriş yüksekliği (metre cinsinden) ve ağırlık (kilogram cinsinden) alan ve ilgili BMI kategorisini çıkaran bir program yazmaktır.

BMI , kilonuzun boyunuza olan oranının bir ölçüsüdür. Tarihli ve birçok insan için yanlış , ama bu burada önemli değil!

BMI, aşağıdaki denklem kullanılarak hesaplanabilir:

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

Kategoriler aşağıdaki gibi tanımlanacaktır:

• BMI <18.5: "Düşük Ağırlık"

• 18.5 <= BMI <25: "Normal"

• 25 <= BMI: "Aşırı kilo"

Mücadelenin uğruna, tüm "aşırı" kategorileri görmezden geliyorum. Ayrıca, "25" gibi bazı sayılar 2 kategori arasında oturduğundan, sınırları biraz ayarlayıp kesin bir cevap aldım.

Bir işlev veya tam bir program yazabilirsiniz.

Giriş:

Giriş herhangi bir makul biçimde olabilir. İki sayı (veya dize), 2 ayrı argüman veya tek bir dize olarak. 2 sayıdan oluşan bir dizi / liste, "weight" ve "height" tuşlarına sahip bir sözlük ... Ondalık değerler desteklenmelidir. Girişin her zaman geçerli olacağını varsayabilirsiniz (negatif değer yok ve yükseklik asla 0 olamaz).

Çıktı:

Çıktı büyük / küçük harf duyarlı olmayan kategori adlarını içeren bir dize olacaktır . Karakter dizileri, görmezden gelinme durumuna göre kategori adlarıyla tamamen aynı olmalıdır. Stdout'a gönderilebilir, geri döndürülebilir (bir işlev durumunda) veya dosyaya yazılabilir.

Test Durumları (ağırlık, boy => sonuç):

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)

İşte örnek bir uygulama gösteren bazı sahte kod:

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"

Bu kod golf, yani en az sayıda bayt kazanıyor.

(Evet, bu görev çoğu dilde son derece önemsizdir. Zorlukların çoğu son zamanlarda normalden daha zor gibi görünüyor, bu yüzden daha erişilebilir bir tane göndereceğimi düşündüm).

NOT! Bu zorluğu yayınladıktan bir saat sonra, belirtilen aralıkların yorumlarda belirtildiği gibi "delikler" olduğu için aralıkları biraz değiştirmek zorunda kaldım. Lütfen yeni aralıkları görün.

Jöle , 24 bayt

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

Çevrimiçi deneyin!

Nasıl?

BMI'yi hesaplar, iki katına çıkarır, 37 ve 50 (18.5 ve 25 iki katına çıkmış) sayıların her biriyle operatörden daha büyük olanlarla sonuçlananları karşılaştırır, sonuçtakileri ve sıfırları (Normal, Düşük ve Aşırı Kilo için 1, 2 veya 0 veren) toplar. sırasıyla) ve dizeler listesine endeksler ["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

Python , 69 bayt

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

Çevrimiçi deneyin!

72 byte ile karşılaştır:

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

TI-Basic, 58 54 bayt

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

Ayrıca, eğlence için, işte daha fazla bayt olan daha kompakt bir sürüm:

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

Söyleyebileceğim tek şey, bu davaya duyarsız yaptığınız için teşekkür ederiz;)

PS Inputgrafik girişini alır Xve YbenzerPrompt X,Y

Mathematica, 67 bayt

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

Gerçeğini kullanır a[b,c][[Sign@d]]döner aeğer d, döner 0 eşittir beğer dolumludur ve döner ceğer dnegatiftir. U + 230A ve U + 230B üç baytlık karakterleri kullanarak ⌊...⌋Mathematica'nın Floorişlevidir. weightİki kez kullanmaktan daha iyi nasıl yapılacağını çözemedi.

Ruby, 91 77 74 67 bayt

İlk saf deneme:

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

İkinci cevapları önceki cevaplardan “ilham” ile deneyin:

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

Üçüncü deneme:

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

Dördüncü deneme:

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

Çevrimiçi deneyin!

JavaScript (ES6), 70 67 64 63 bayt

Arnauld sayesinde 4B kurtarıldı

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

kullanım

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

Çıktı

"Overweight"

açıklama

: Bir akıllı hile var olmasına rağmen bu cevap, oldukça önemsiz Underweightve Overweighther iki uç erweightbiz yalnızca bu karakterleri değiştirmek zorunda.

Bunun Normal25 (özel) ve 18.5 (dahil) arasında bir BMI anlamına geldiğini varsaydım . Underweight18,5'ten küçük bir BMI Overweightanlamına gelir ve 25'ten büyük veya 25'e eşit olan bir BMI anlamına gelir.

C, 81 bayt

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

05AB1E , 28 bayt

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

QBIC , 61 58 bayt

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

@ Luke, Kuvvet'i kullandı ve iki baytı kesti. Teşekkürler!

Kural değişikliği başka bir bayt kaydetti.

Açıklama:

::          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.

Python 2,72 bayt

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

Çevrimiçi deneyin!

Python 3, 97 95 bayt

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

Tam program

Bir baytı kaydetmek için beş ile çarpın. Teşekkürler Jonathan Allan.

Satır satır:

1. İki boşlukla ayrılmış kullanıcı giriş numaralarını ints ile eşleyin. A ve b paketinden çıkarın.

2. Hesaplamak

3. Eğer bmi 18.6 ile 25 arasındaysa, kapsayıcı ise, sağdaki ifade Doğru olarak değerlendirilecektir. Boolean'lar liste indeksleri olarak kullanıldığında 0 veya 1 olabilir, bu yüzden "Normal" veya sıfır dizinde oluşturulmuş dizgeyi alırız. "erweight", kalan iki seçenek için paylaşılan bir sonektir, bu yüzden tekrarlanması gerekmez. Daha sonra Python list / string stringing [start: stop: step] desenini kullanırız. c> 18.6 0 veya 1 (Yanlış veya Doğru) olarak değerlendirecek ve bizim başımıza gelecektir. Dur belirtilmez, bu yüzden değişmezin sonuna gideriz. Adım 2'dir, bu yüzden her ikinci dizine geçiyoruz. Eğer start start 1 olarak değerlendirilirse "Ov", aksi halde "Und" alırız. Her iki durumda da, sahip olduklarımıza "erweight" ekliyoruz ve son çıktımız var.

R, 89 84 80 74 bayt

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

StewieGriffin'in Octave cevabına bir selam vererek, bir dizi dizi oluşturur, ardından sonucu toplar BMI < c(18.5,25)ve + 1 konumundaki bu pozisyona başvurur .

İlk argüman boy, sonra ağırlık olmalıdır; eğer buna izin verilmediyse

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

4 bayt daha çalışır.

Clojure, 63 bayt

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

dc , 58 bayt

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

Girdiyi biçiminde 2 boşluk ile ayrılmış sayılar olarak alır. <mass> <height> . Ayrı bir satıra bir dize çıkarır.

Çevrimiçi deneyin!

açıklama

Bu açıklama amacıyla giriş 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.

Oktav, 64 bayt

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

Çevrimiçi deneyin

Bu, iki giriş bağımsız değişkeni h(ad) ve w(ağırlık) alan adsız bir işlevdir .

İşlev, orada dizeleri içeren bir hücre dizisi yaratır 'Underweight','Normal','Overweight've dize numarası verir 3-sum(2*w/h^2<'%2').

Evet, bu biraz garip görünüyor. Birinci dizgiyi istersek, w/h^2<=18.5ikinci dizgiyi if (w/h^2 > 18.5) & (w/h^2 < 25), üçüncü dizgiyi yukarıdaki koşullardan hiçbiri doğru değilse istiyoruz. Bir grup karşılaştırma yapmak yerine, diziyi şu şekilde karşılaştırabiliriz: w/h^2 < [18.5, 25]bu [1 1], [0 1], [0,0]sırasıyla sırasıyla Düşük, Normal ve Fazla Ağırlık için aşağıdaki dizilerden birini döndürür .

[18.5,25]9 bayt, ki bu çok fazla. Bunun yerine ne yaparsak, çarpın 2 oranında BMI ve ile karşılaştırmak [37, 50]veya '%2'ASCII. Bu üç bayt kaydeder.

Perl 6 , 59 bayt

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

Nasıl çalışır

{                                                         }  # 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.

Dizenin erweighttekrarlanması gerekiyor, ancak genel bayt sayısının artmasını engellemek için denedim.

• Dize değiştirme ile, 62 bayt:

  {<Ov_ Normal Und_>[sum 18.5,25 X>$^a/$^b**2].&{S/_/erweight/}}

• Dize enterpolasyonu ile 67 bayt:

  {$_='erweight';("Ov$_","Normal","Und$_")[sum 18.5,25 X>$^a/$^b**2]}

• Xnor'ın Python çözümünün kaba çevirisi , 65 bayt:

  {$_=$^a/$^b**2;25>$_>=18.5??"Normal"!!<Und Ov>[$_>19]~"erweight"}

PowerShell , 81 bayt

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

Çevrimiçi deneyin!

açıklama

Açıklanması gereken asıl şey 18.5,25 -lt $b( $bkodda yer alan BMI yerine kullanıyorum). PowerShell'deki çoğu operatör, sol tarafta bir dizi verildiğinde, bir boolean değeri döndürmek yerine testi karşılayan bir öğe dizisi döndürür. Yani bu boş bir dizi döndürürse$b 18,5'ten küçükse bir dizi, ortadaysa sadece 18,5 içeren bir dizi ve 25'ten büyükse hem 18,5 hem de 25 içeren bir dizi .

Sayım yüzden, dizelerden oluşan bir diziye bir endeks olarak elementlerin sayısını kullanmak 0elemanını alır 0olduğunu 'Underweight'vs.

OCaml, 93 bayt

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

Python, 75 74 bayt

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

Çevrimiçi deneyin!

Diğer insanların çözme tekniklerinden yararlanan oldukça basit bir çözüm.

Bayt kaydettiğiniz için teşekkürler @ovs.

Alternatifler

1. 73 bayt

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

Gördüğüm başka bir cevaba çok benzer olduğu için bunu reddettim.

2. 71 bayt

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

Bunu reddettim, çünkü sorudaki tüm testler üzerinde çalışmaya rağmen, =içinde eksik olduğu için üzerinde başarısız olabilecek bazı numaralar var <=.

C #, 63 62 61 bayt

TheLethalCoder sayesinde 1 bayt daha kaydedildi .

Anonim kullanıcı sayesinde 1 bayt kaydedildi.

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

Oldukça basit bir isimsiz fonksiyon. Tüm hile, doğrudan dönmek için üçlü işleci kullanıyor (bu nedenlereturn anahtar kelimeyi, bir çift kaşlı ayracı ve değişken bir bildirimi ve atamayı ).

Test vakaları ile tam program:

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"
    }
}

Ortak Lisp, 89 87 85 84 83 bayt

Bir işlev:

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

Kullanım örneği:

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

Çevrimiçi deneyin! (Çıktıyı TIO'da görmek için yazdırma işlevi ekledim)

İyileştirme fikirleri memnuniyetle karşılanmaktadır.

MATL, 54 45 44 42 bayt

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

Matl.suever.net adresinde deneyin

BMI'yi hesaplayarak ve ikiye katlayarak başlar U\E, ardından vektör [37 50]ifadesini '% 2' dizgesiyle oluşturur . BMI'yi bu vektörle karşılaştırır ve cevap almak için if ifadelerini normalönceden tanımlanmış bir hazır bilgi olarak yararlanarak kullanır 17Y0.

Java 8, 61 bayt

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

A ata DoubleFunction<DoubleFunction<String>>ve bu şekilde çağır:

bmi.apply(50).apply(1.5)

dc , 64 bayt

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

Çevrimiçi deneyin!

Javascript (ES6), 63 bayt

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

Örnek

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

Swift, 97 bayt

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

Japt , 46 bayt

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

Çevrimiçi deneyin!

@ Luke'dan ilham aldı cevabından .

açıklama

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

Dekompresanlar:

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

Japt'in gizli bir girişi var U. İkinci girişV .

Japt shoco kütüphanesini kullanıyor string sıkıştırma için . Geri tepmeler dizeleri açmak için kullanılır.

Kullanılan Unicode kısayolları:

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

PHP , 121 bayt

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

Çevrimiçi deneyin!

Scala, 124 bayt

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}

REXX, 113 bayt

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