Problem:

Ihre Aufgabe ist es, ein Programm zu schreiben, das eine Größe (in Metern) und ein Gewicht (in Kilogramm) als Eingabe verwendet und die entsprechende BMI-Kategorie ausgibt.

Der BMI ist ein Maß für das Verhältnis Ihres Gewichts zu Ihrer Körpergröße. Es ist veraltet und für viele Leute ungenau , aber das spielt hier keine Rolle!

Der BMI kann mit der folgenden Gleichung berechnet werden:

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

Die Kategorien werden wie folgt definiert:

• BMI <18.5: "Untergewicht"

• 18,5 <= BMI <25: "Normal"

• 25 <= BMI: "Übergewicht"

Um der Herausforderung willen ignoriere ich alle "extremen" Kategorien. Da einige Zahlen wie "25" zwischen zwei Kategorien liegen, habe ich die Grenzen leicht angepasst, damit es eine eindeutige Antwort gibt.

Sie können entweder eine Funktion oder ein vollständiges Programm schreiben.

Eingang:

Die Eingabe kann in jeder vernünftigen Form erfolgen. Zwei Zahlen (oder Zeichenfolgen), entweder als zwei separate Argumente oder als einzelne Zeichenfolge. Ein Array / eine Liste mit 2 Zahlen, ein Wörterbuch mit den Tasten "weight" und "height" ... Dezimalwerte sollten unterstützt werden. Sie können davon ausgehen, dass die Eingabe immer gültig ist (keine negativen Werte, und die Höhe wird niemals 0 sein).

Ausgabe:

Die Ausgabe erfolgt als Zeichenfolge mit den Kategorienamen , bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird. Die Zeichenfolgen müssen genau wie oben mit den Kategorienamen übereinstimmen, Groß- und Kleinschreibung wird ignoriert. Es kann auf die Standardausgabe ausgegeben, zurückgegeben (im Falle einer Funktion) oder in eine Datei geschrieben werden.

Testfälle (Gewicht, Größe => Ergebnis):

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)

Hier ist ein Pseudocode, der eine Beispielimplementierung zeigt:

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"

Das ist Code-Golf, also gewinnt die geringste Anzahl von Bytes.

(Ja, diese Aufgabe ist in den meisten Sprachen äußerst trivial. Die meisten Herausforderungen scheinen in letzter Zeit schwieriger als normal zu sein, daher dachte ich, ich würde eine zugänglichere Aufgabe veröffentlichen .)

HINWEIS! Eine Stunde, nachdem ich diese Herausforderung gepostet hatte, musste ich die Bereiche geringfügig ändern, da die angegebenen Bereiche "Löcher" aufwiesen, wie in den Kommentaren ausgeführt. Bitte beachten Sie die neuen Sortimente.

Gelee , 24 Bytes

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

Probieren Sie es online!

Wie?

Berechnet den BMI, verdoppelt ihn und vergleicht ihn mit dem Größer-als-Operator mit jeder der Zahlen 37 und 50 (18,5 und 25 verdoppelt), summiert die resultierenden Einsen und Nullen (ergibt 1, 2 oder 0 für Normal, Untergewicht und Übergewicht) bzw.) und Indizes in die Liste der Zeichenfolgen ["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 Bytes

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

Probieren Sie es online!

Vergleichen Sie mit 72 Bytes:

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

TI-Basic, 58 54 Bytes

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

Außerdem ist hier zum Spaß eine kompaktere Version mit mehr Bytes:

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

Ich kann nur sagen, danke, dass Sie die Groß- und Kleinschreibung ignoriert haben.

PS Inputnimmt Grapheneingaben an Xund YähneltPrompt X,Y

Mathematica, 67 Bytes

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

Nutzt die Tatsache , dass a[b,c][[Sign@d]]Erträge , awenn dgleich 0 ist , kehrt , bwenn dpositiv ist, und kehrt , cwenn dnegativ ist. ⌊...⌋ist die FloorFunktion von Mathematica, die die Drei-Byte-Zeichen U + 230A und U + 230B verwendet. Konnte nicht herausfinden, wie man es besser macht als weightzweimal.

Ruby, 91 77 74 67 Bytes

Erster naiver Versuch:

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

Zweiter Versuch mit „Inspiration“ aus früheren Antworten:

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

Dritter Versuch:

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

Vierter Versuch:

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

Probieren Sie es online!

JavaScript (ES6), 70 67 64 63 Byte

4B dank Arnauld gerettet

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

Verwendung

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

Ausgabe

"Overweight"

Erläuterung

Diese Antwort ist ziemlich trivial, obwohl es einen cleveren Trick gibt: Underweightund Overweightbeide enden in erweight, also müssen wir nur diese Zeichen ändern.

Ich nahm an, dass Normaldies einen BMI zwischen 25 (exklusiv) und 18,5 (inklusive) bedeutet. Underweightbedeutet einen BMI von weniger als 18,5 und Overweightbedeutet einen BMI von größer oder gleich 25.

C 81 Bytes

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

05AB1E , 28 Bytes

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

QBIC , 61 58 Bytes

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

@Luke benutzte die Kraft und schnitt zwei Bytes ab. Vielen Dank!

Die Regeländerung hat ein weiteres Byte gespeichert.

Erläuterung:

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

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

Probieren Sie es online!

Python 3, 97 bis 95 Bytes

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

Volles Programm.

Mit fünf multiplizieren, um ein Byte zu speichern. Vielen Dank Jonathan Allan.

Zeile für Zeile:

1. Ordnen Sie die zwei durch Leerzeichen getrennten Benutzereingaben den Zeichen ints zu. Auspacken nach a und b.

2. Berechnung

3. Wenn das BMI zwischen 18,6 und einschließlich 25 liegt, wird der Ausdruck auf der rechten Seite mit Wahr bewertet. Boolesche Werte können 0 oder 1 sein, wenn sie als Listenindizes verwendet werden. Daher erhalten wir entweder "Normal" oder die erstellte Zeichenfolge im Nullindex. "erweight" ist ein gemeinsames Suffix für die verbleibenden zwei Optionen, sodass es nicht wiederholt werden muss. Dann verwenden wir das Muster [start: stop: step] des Python-Listen- / String-Slicing. c> 18.6 ergibt entweder 0 oder 1 (False oder True) und wird unser Start. Stopp wird nicht angezeigt, daher gehen wir zum Ende des Buchstabens. Schritt ist 2, also nehmen wir jeden zweiten Index. Wenn start start 1 ergibt, erhalten wir "Ov", andernfalls "Und". In jedem Fall hängen wir "erweight" an das an, was wir haben, und wir haben unsere endgültige Ausgabe.

R, 89 84 80 74 Bytes

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

Wenn Sie auf StewieGriffins Oktavantwort nicken, erstellen Sie ein Array von Zeichenfolgen, summieren dann das Ergebnis BMI < c(18.5,25)und verweisen auf das Array an dieser Position + 1.

Das erste Argument muss Größe sein, dann Gewicht; wenn das nicht erlaubt ist, dann

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

funktioniert für 4 weitere Bytes.

Clojure, 63 Bytes

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

Gleichstrom , 58 Bytes

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

Nimmt die Eingabe als 2 durch Leerzeichen getrennte Zahlen im Format <mass> <height>. Gibt eine Zeichenfolge in einer separaten Zeile aus.

Probieren Sie es online!

Erläuterung

Für die Zwecke dieser Erklärung ist die Eingabe 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.

Oktave, 64 Bytes

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

Probieren Sie es online aus

Dies ist eine anonyme Funktion, die zwei Eingabeargumente h(height) und (height) akzeptiertw (Gewicht) akzeptiert.

Die Funktion erstellt ein Zellenarray, das die Zeichenfolgen enthält 'Underweight','Normal','Overweight', und gibt die Zeichenfolgennummer aus3-sum(2*w/h^2<'%2') .

Ja, das sieht ein bisschen seltsam aus. Wir wollen die erste Zeichenfolge if w/h^2<=18.5, die zweite Zeichenfolge if (w/h^2 > 18.5) & (w/h^2 < 25)und die dritte Zeichenfolge, wenn keine der oben genannten Bedingungen erfüllt ist. Anstatt eine Reihe von Vergleichen zu erstellen, können Sie die Zeichenfolge einfach mit: vergleichen w/h^2 < [18.5, 25], wodurch eines der folgenden Arrays [1 1], [0 1], [0,0]für Untergewicht, Normal und Übergewicht zurückgegeben wird.

[18.5,25]dauert 9 Bytes, was sehr viel ist. Stattdessen multiplizieren wir den BMI mit 2 und vergleichen das Ergebnis mit [37, 50]oder '%2'in ASCII. Das spart drei Bytes.

Perl 6 , 59 Bytes

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

Wie es funktioniert

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

Schade, dass die Zeichenfolge erweightwiederholt werden muss, aber alle Variationen, die ich ausprobiert habe, um dies zu vermeiden, haben die Gesamtanzahl der Bytes erhöht:

• Bei Zeichenfolgensubstitution 62 Bytes:

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

• Bei String-Interpolation 67 Bytes:

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

• Grobe Übersetzung der Python-Lösung von xnor , 65 Byte:

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

PowerShell , 81 Byte

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

Probieren Sie es online!

Erläuterung

Das Hauptbit, das erklärt werden muss, ist 18.5,25 -lt $b(wo ich $bden BMI ersetze, der im Code berechnet wird). Die meisten Operatoren in PowerShell geben bei Angabe eines Arrays auf der linken Seite ein Array von Elementen zurück, die den Test erfüllen, anstatt einen booleschen Wert zurückzugeben. Dies gibt also ein leeres Array zurück, wenn$b es kleiner als 18,5 ist, ein Array, das nur 18,5 enthält, wenn es sich in der Mitte befindet, und ein Array, das sowohl 18,5 als auch 25 enthält, wenn es größer als 25 ist.

Ich verwende die Anzahl der Elemente als Index für ein Array der Zeichenfolgen, also 0erhält count das Element, 0das ist 'Underweight'usw.

OCaml, 93 Bytes

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 Bytes

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

Probieren Sie es online!

Ziemlich einfache Lösung, die die Techniken anderer Leute nutzt, um sie zu lösen.

Vielen Dank an @ovs für das Speichern eines Bytes.

Alternativen

1,73 Bytes

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

Ich lehnte dies ab, da es einer anderen Antwort, die ich sah, zu ähnlich war.

2. 71 Bytes

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

Ich lehnte diese , denn trotz der Arbeit an allen Tests in der Frage, gibt es einige Zahlen es nicht auf , wie es die fehlenden =in der <=.

C #, 63 62 61 Bytes

Dank TheLethalCoder 1 weiteres Byte gespeichert .

1 Byte dank anonymen Benutzers gespeichert.

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

Eine ziemlich unkomplizierte anonyme Funktion. Der ganze Trick besteht darin, den ternären Operator zu verwenden, um direkt zurückzukehrenreturn Schlüsselwort, ein Paar geschweifte Klammern und eine Variablendeklaration und -zuweisung werden ).

Volles Programm mit Testfällen:

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 Bytes

Eine Funktion:

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

Anwendungsbeispiel:

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

Probieren Sie es online! (Ich habe die Druckfunktion hinzugefügt, um die Ausgabe in TIO zu sehen.)

Verbesserungsvorschläge sind willkommen.

MATL, 54 45 44 42 Bytes

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

Probieren Sie es bei matl.suever.net

Beginnt damit, den BMI zu berechnen und zu verdoppeln U\E, und erstellt dann den Vektor [37 50]mit dem String-Literal '% 2'. Vergleicht den BMI mit diesem Vektor und verwendet if-Anweisungen, um die Antwort zu erhalten. Dabei wird normalein vordefiniertes Literal verwendet 17Y0.

Java 8, 61 Bytes

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

Ordne a zu DoubleFunction<DoubleFunction<String>>und rufe so auf:

bmi.apply(50).apply(1.5)

Gleichstrom , 64 Bytes

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

Probieren Sie es online!

Javascript (ES6), 63 Byte

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

Beispiel

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

Schnell, 97 Bytes

{(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 Bytes

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

Probieren Sie es online!

Inspiriert von der Antwort von @ Luke .

Erläuterung

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

Dekomprimiert zu:

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

Japt hat eine implizite Eingabe U . Die zweite Eingabe ist V.

Japt benutzt das Shoco-Bibliothek zur Komprimierung von Strings. Backticks werden zum Dekomprimieren von Strings verwendet.

Verwendete Unicode-Verknüpfungen:

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

PHP , 121 Bytes

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

Probieren Sie es online!

Scala, 124 Bytes

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 Bytes

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