Problem:

Twoim zadaniem jest napisanie programu, który przyjmuje jako dane wejściowe wysokość (w metrach) i wagę (w kilogramach) i wyświetla odpowiednią kategorię BMI.

BMI jest miarą stosunku masy ciała do wzrostu. Jest przestarzały i niedokładny dla wielu osób , ale to nie ma znaczenia tutaj!

BMI można obliczyć za pomocą następującego równania:

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

Kategorie zostaną zdefiniowane w następujący sposób:

• BMI <18,5: „Niedowaga”

• 18,5 <= BMI <25: „Normalny”

• 25 <= BMI: „Nadwaga”

Ze względu na wyzwanie ignoruję wszystkie kategorie „ekstremalne”. Ponadto, ponieważ niektóre liczby, takie jak „25”, mieszczą się między 2 kategoriami, nieznacznie dostosowałem granice, aby uzyskać jednoznaczną odpowiedź.

Możesz napisać funkcję lub pełny program.

Wkład:

Dane wejściowe mogą mieć dowolną rozsądną formę. Dwie liczby (lub ciągi), albo jako 2 osobne argumenty, albo jako pojedynczy ciąg. Tablica / lista 2 liczb, słownik z klawiszami „waga” i „wzrost” ... Wartości dziesiętne powinny być obsługiwane. Możesz założyć, że dane wejściowe będą zawsze prawidłowe (brak wartości ujemnych, a wysokość nigdy nie będzie wynosić 0).

Wydajność:

Dane wyjściowe będą ciągiem zawierającym nazwy kategorii bez rozróżniania wielkości liter . Ciągi muszą pasować do nazw kategorii dokładnie tak, jak powyżej, ignorując wielkość liter. Może być wyprowadzony na standardowe wyjście, zwrócony (w przypadku funkcji) lub zapisany w pliku.

Przypadki testowe (waga, wzrost => wynik):

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)

Oto pseudokod pokazujący przykładową implementację:

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"

To jest golf golfowy, więc wygrywa najmniejsza liczba bajtów.

(Tak, to zadanie jest niezwykle trywialne w większości języków. Większość wyzwań wydaje się ostatnio trudniejsza niż zwykle, więc pomyślałem, że opublikuję bardziej dostępne).

UWAGA! Godzinę po opublikowaniu tego wyzwania musiałem nieco zmodyfikować zakresy, ponieważ podane zakresy miały „dziury”, jak wskazano w komentarzach. Zobacz nowe zakresy.

Galaretka , 24 bajty

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

Wypróbuj online!

W jaki sposób?

Oblicza BMI, podwaja go, porównuje, że z operatorem większym niż dla każdej z liczb 37 i 50 (18,5 i 25 podwojonych), sumuje otrzymane jedynki i zera (dając 1, 2 lub 0 dla Normalnego, Niedowagi i Nadwagi odpowiednio) i indeksuje do listy ciągów ["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 bajtów

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

Wypróbuj online!

Porównaj z 72 bajtami:

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

TI-Basic, 58 54 bajtów

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

Ponadto, dla zabawy, oto bardziej kompaktowa wersja, która ma więcej bajtów:

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

Wszystko, co mogę powiedzieć, to dziękuję za uczynienie tego bez rozróżniania wielkości liter;)

PS Inputpobiera dane wejściowe z wykresu Xi YpodobnePrompt X,Y

Mathematica, 67 bajtów

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

Wykorzystuje fakt, że a[b,c][[Sign@d]]zwraca, ajeśli djest równe 0, zwraca, bjeśli djest dodatnia, i zwraca, cjeśli djest ujemna. ⌊...⌋to Floorfunkcja Mathematica wykorzystująca trzy bajtowe znaki U + 230A i U + 230B. Nie mogłem wymyślić, jak to zrobić lepiej, niż weightdwa razy.

Ruby, 91 77 74 67 bajtów

Pierwsza naiwna próba:

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

Druga próba z „inspiracją” z poprzednich odpowiedzi:

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

Trzecia próba:

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

Czwarta próba:

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

Wypróbuj online!

JavaScript (ES6), 70 67 64 63 bajtów

Zaoszczędź 4B dzięki Arnauldowi

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

Stosowanie

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

Wydajność

"Overweight"

Wyjaśnienie

Ta odpowiedź jest dość banalna, choć istnieje jeden sprytny trik: Underweighta Overweightoba kończą się erweight, więc mamy tylko zmienić te znaki.

Zakładam, że Normaloznacza to BMI między 25 (wyłączny) a 18,5 (włącznie). Underweightoznacza BMI mniejsze niż 18,5 i Overweightoznacza BMI większe lub równe 25.

C, 81 bajtów

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

05AB1E , 28 bajtów

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

QBIC , 61 58 bajtów

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

@Luke użył Mocy i odciął dwa bajty. Dzięki!

Zmiana reguł zapisała kolejny bajt.

Wyjaśnienie:

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

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

Wypróbuj online!

Python 3, 97 95 bajtów

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

Pełny program

Pomnóż przez pięć, aby zapisać bajt. Dzięki Jonathan Allan.

Linia po linii:

1. Zamapuj dwie oddzielone spacjami liczby wejściowe użytkownika na ints. Rozpakuj do a i b.

2. Obliczać

3. Jeśli wartość bmi wynosi między 18,6 a 25 włącznie, wyrażenie po prawej stronie będzie miało wartość True. Wartości logiczne mogą mieć wartość 0 lub 1, gdy są używane jako indeksy list, więc otrzymujemy albo „Normalny”, albo skonstruowany ciąg w indeksie zerowym. „waga” to wspólny sufiks pozostałych dwóch opcji, więc nie trzeba go powtarzać. Następnie używamy wzorca [start: stop: step] w krojeniu list / ciągów znaków w języku Python. c> 18,6 oceni na 0 lub 1 (Fałsz lub Prawda) i stanie się naszym początkiem. Stop nie jest wskazany, więc przechodzimy do końca dosłowności. Krok 2, więc bierzemy co drugi indeks. Jeśli start start ma wartość 1, otrzymujemy „Ov”, w przeciwnym razie otrzymujemy „Und”. Tak czy inaczej, dołączamy „wagę” do tego, co otrzymaliśmy i mamy końcowy wynik.

R, 89 84 80 74 bajty

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

Przytakując do odpowiedzi Octave StewieGriffina, tworzy tablicę ciągów, a następnie sumuje wynik BMI < c(18.5,25) i odwołuje się do tablicy w tej pozycji + 1.

Pierwszym argumentem musi być wzrost, a następnie waga; jeśli to nie jest dozwolone, to

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

działa dla 4 kolejnych bajtów.

Clojure, 63 bajty

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

dc , 58 bajtów

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

Pobiera dane wejściowe jako 2 liczby oddzielone spacjami w formacie <mass> <height>. Wysyła ciąg w osobnej linii.

Wypróbuj online!

Wyjaśnienie

Dla celów tego objaśnienia dane wejściowe to 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.

Oktawa, 64 bajty

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

Wypróbuj online

Jest to anonimowa funkcja, która pobiera dwa argumenty wejściowe h(wysokość) iw (ciężar).

Funkcja tworzy tablicę komórek zawierającą tam łańcuchy 'Underweight','Normal','Overweight'i wyświetla numer łańcucha3-sum(2*w/h^2<'%2') .

Tak, ten wygląda trochę dziwnie. Chcemy pierwszy ciąg, jeśliw/h^2<=18.5 , drugi ciąg if (w/h^2 > 18.5) & (w/h^2 < 25)i trzeci ciąg if, jeśli żaden z powyższych warunków nie jest spełniony. Zamiast tworzyć wiele porównań, moglibyśmy po prostu porównać ciąg znaków do :, co zwróciłoby w/h^2 < [18.5, 25]jedną z następujących tablic odpowiednio [1 1], [0 1], [0,0]dla Niedowagi, Normalnej i Nadwagi.

[18.5,25]zajmuje 9 bajtów, co jest dużo. Zamiast tego mnożymy BMI przez 2 i porównujemy wynik z [37, 50]lub '%2'w ASCII. To oszczędza trzy bajty.

Perl 6 , 59 bajtów

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

Jak to działa

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

Szkoda, że ​​ciąg erweightmusi być powtórzony, ale wszystkie odmiany, które próbowałem, aby tego uniknąć, spowodowały zwiększenie ogólnej liczby bajtów:

• Z podstawieniem łańcucha 62 bajty:

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

• Z interpolacją ciągów, 67 bajtów:

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

• Z grubsza tłumaczenie rozwiązania xnor w języku Python , 65 bajtów:

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

PowerShell , 81 bajtów

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

Wypróbuj online!

Wyjaśnienie

Najważniejszy bit, który wymaga wyjaśnienia, to 18.5,25 -lt $b(gdzie zastępuję $bBMI, który jest obliczany na miejscu w kodzie). Większość operatorów w PowerShell, gdy otrzymuje tablicę po lewej stronie, zwraca tablicę elementów, które spełniają test, zamiast zwracać wartość logiczną. To zwróci pustą tablicę if$b jest mniejsza niż 18,5, tablicę zawierającą tylko 18,5, jeśli jest w środku, i tablicę zawierającą zarówno 18,5, jak i 25, jeśli jest większa niż 25.

Liczenia elementów używam jako indeksu w tablicy ciągów, więc count 0pobiera element, 0który jest 'Underweight'itd.

OCaml, 93 bajty

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 bajtów

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

Wypróbuj online!

Dość podstawowe rozwiązanie, które wykorzystuje techniki rozwiązywania problemów innych osób.

Dzięki @ovs za zapisanie bajtu.

Alternatywy

1. 73 bajty

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

Odrzuciłem to, ponieważ było zbyt podobne do innej odpowiedzi, którą widziałem.

2. 71 bajtów

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

Odrzuciłem to, ponieważ pomimo pracy nad wszystkimi testami w pytaniu, istnieją pewne liczby, na których może się nie powieść, ponieważ brakuje =w nim <=.

C #, 63 62 61 bajtów

Zaoszczędził jeszcze 1 bajt dzięki TheLethalCoder .

Zapisano 1 bajt dzięki anonimowemu użytkownikowi.

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

Dość prosta anonimowa funkcja. Cała sztuczka polega na użyciu operatora trójskładnikowego do bezpośredniego powrotu (pomijając returnsłowo kluczowe, parę nawiasów klamrowych oraz zmienną deklarację i przypisanie).

Pełny program z przypadkami testowymi:

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

Common Lisp, 89 87 85 84 83 bajtów

Funkcja:

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

Przykład użycia:

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

Wypróbuj online! (Dodałem funkcję drukowania, aby zobaczyć wyjście w TIO)

Pomysły na ulepszenia są mile widziane.

MATL, 54 45 44 42 bajtów

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

Wypróbuj na matl.suever.net

Zaczyna się od obliczenia BMI i podwojenia go U\E, a następnie tworzy wektor [37 50]z literałem „% 2”. Porównuje BMI do tego wektora i używa instrukcji if, aby uzyskać odpowiedź, wykorzystując normaljako predefiniowany literał 17Y0.

Java 8, 61 bajtów

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

Przypisz do DoubleFunction<DoubleFunction<String>>i wywołaj w ten sposób:

bmi.apply(50).apply(1.5)

dc , 64 bajty

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

Wypróbuj online!

JavaScript (ES6), 63 bajty

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

Przykład

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

Szybki, 97 bajtów

{(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 bajtów

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

Wypróbuj online!

Zainspirowany @ Łukasza odpowiedź .

Wyjaśnienie

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

Dekompresuje do:

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

Japt ma niejawny wkład U. Drugie wejście to V.

Japt używa biblioteki shoco do kompresji ciągów. Wsteczne są używane do dekompresji ciągów.

Zastosowane skróty Unicode:

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

PHP , 121 bajtów

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

Wypróbuj online!

Scala, 124 bajty

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 bajtów

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