[Question]
  [
# Problem:
Your task is to write a program that takes as input a height (in meters) and weight (in kilograms), and outputs the corresponding BMI category.
[BMI](https://en.wikipedia.org/wiki/Body_mass_index) is a measure of the ratio of your weight to your height. [It's dated and inaccurate for many people](https://en.wikipedia.org/wiki/Body_mass_index#Limitations), but that doesn't matter here!
BMI can be calculated using the following equation:
```
BMI = (mass in kilograms) / (height in meters)^2
```
The categories will be defined as follows:
* BMI < 18.5: "Underweight"
* 18.5 <= BMI < 25: "Normal"
* 25 <= BMI: "Overweight"
For the sake of the challenge, I'm ignoring all the "extreme" categories. Also, since some numbers like "25" sit between 2 categories, I adjusted the bounds slightly so there's a definite answer.
You can write either a function, or a full program.
# Input:
Input can be in any reasonable form. Two numbers (or strings), either as 2 separate arguments, or as a single string. An array/list of 2 numbers, a dictionary with "weight" and "height" keys... Decimal values should be supported. You can assume the input will always be valid (no negative values, and height will never be 0).
# Output:
Output will be a string containing the *case-insensitive* category names. The strings must match the category names exactly as above, ignoring case. It can be output to the stdout, returned (in the case of a function), or written to file.
# Test Cases (weight, height => result):
```
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)
```
Here's some pseudocode that shows an example implementation:
```
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"
```
This is code-golf, so the fewest number of bytes wins.
(Yes, this task is ***exceedingly*** trivial in most languages. Most of the challenges lately seem to be harder than normal, so I thought I'd post a more accessible one).
---
NOTE! An hour after I posted this challenge, I had to modify the ranges slightly since the ranges as stated had "holes" as pointed out in the comments. Please see the new ranges.
  
[Answer]
# [Python](https://docs.python.org/2/), 69 bytes
```
lambda w,h:["UOnvd"[w/h/h>20::2]+"erweight","Normal"][18.5<=w/h/h<25]
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQrpNhFa0U6p9XlqIUXa6foZ9hZ2RgZWUUq62UWlSempmeUaKko@SXX5SbmKMUG21ooWdqYwtWZ2NkGvs/Lb8IZIRCZp5CtIaFgZ6BjrGegaaOhimIaQRmWiCYYFFDPVMEE64AxIy14uIsKMrMK1FI0wAaqvkfAA "Python 2 ‚Äì TIO Nexus")
Compare to 72 bytes:
```
lambda w,h:"Underweight"*(w/h/h<18.5)or"Normal"*(w/h/h<25)or"Overweight"
```
[Answer]
# TI-Basic, ~~58~~ 54 bytes
```
Input 
X/Y¬≤‚ÜíC
"NORMAL
If 2C‚â§37
"UNDERWEIGHT
If C‚â•26
"OVERWEIGHT
```
Also, for fun, here's a more compact version that is more bytes:
```
Prompt A,B
sub("UNDERWEIGHTNORMAL      OVERWEIGHT ",sum(A/B¬≤‚â•{18.5,25})11+1,11
```
All I can say is, thank you for making this case-insensitive ;)
P.S. `Input` takes graph input to `X` and `Y` similar to `Prompt X,Y`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 24 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
√∑√∑‚Åπ·∏§‚Äú%2‚Äò>S·ªã‚Äú$‚ÅΩ¬ø‚Äú;·πÖ·∫í‚Äú&ƒã)¬ª
```
**[Try it online!](https://tio.run/nexus/jelly#@394@@Htjxp3Ptyx5FHDHFWjRw0z7IIf7u4GclQeNe49tB/IsH64s/XhrklAltqRbs1Du////29q8N9QzxQA)**
### How?
Calculates the BMI, doubles it, compares that with the greater than operator with each of the numbers 37 and 50 (18.5 and 25 doubled), sums the resulting ones and zeros (yielding 1, 2, or 0 for Normal, Underweight, and Overweight respectively) and indexes into the list of strings `["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
```
[Answer]
# Mathematica, 67 bytes
```
"Normal"["Underweight","Overweight"][[Sign@‚åä(2#/#2^2-37)/13‚åã]]&
```
Uses the fact that `a[b,c][[Sign@d]]` returns `a` if `d` equals 0, returns `b` if `d` is positive, and returns `c` if `d` is negative. `‚åä...‚åã` is Mathematica's `Floor` function using the three-byte characters U+230A and U+230B. Couldn't figure out how to do better than using `weight` twice.
[Answer]
# Ruby, 91 77 74 67 bytes
First naive try:
```
->(w,h){case w/h/h
when 0..18.5
'underweight'
when 18.5..25
'normal'
else
'overweight'
end}
```
Second try with ‚Äùinspiration‚Äú from previous answers:
```
->w,h{["#{(w/=h*h)<18.5?'und':'ov'}erweight",'normal'][(18.5..25)===(w)?1:0]}
```
Third try:
```
->w,h{["#{(w/=h*h)<18.5?'und':'ov'}erweight",'normal'][w>=18.5&&w<25?1:0]}
```
Fourth try:
```
->w,h{18.5<=(w/=h*h)&&w<25?'normal':"#{w<18.5?'und':'ov'}erweight"}
```
[Try it online!](https://tio.run/nexus/ruby#RcrBCoIwHIDxu08xDJzGWtMYiMx8kOVB3Owf2AzTdlCf3ZqHvP34@Jr8tp6ulsAUp5SLPLTnHI4QBYEVCS@w6fpn1eLMP0xWuKXAo1E4w90HL7q3@nGHwV9WKVNGGblQVhLJHZON6c6txpTv/A@OJdVVDUh1aA4tQRDNHkKvcXijhtZV2/4iRJ42av0C "Ruby ‚Äì TIO Nexus")
[Answer]
# JavaScript (ES6), ~~70 67 64~~ 63 bytes
*Saved 4B thanks to Arnauld*
```
a=>b=>(a/=b*b)<25&a>=18.5?"Normal":(a<19?"Und":"Ov")+"erweight"
```
## Usage
```
f=a=>b=>(a/=b*b)<25&a>=18.5?"Normal":(a<19?"Und":"Ov")+"erweight"
f(80)(1)
```
### Output
```
"Overweight"
```
## Explanation
This answer is quite trivial, though there is one clever trick: `Underweight` and `Overweight` both end in `erweight`, so we only have to change those characters.
I assumed that `Normal` means a BMI between 25 (exclusive) and 18.5 (inclusive). `Underweight` means a BMI less than 18.5, and `Overweight` means a BMI greater than or equal to 25.
[Answer]
# C, 81 bytes
```
f(float m,float h){m/=h*h;puts(m<26?m<18.6?"Underweight":"Normal":"Overweight");}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 28 bytes
```
n/¬©37;‚Äπ¬Æ25‚ÄπO‚Äô‚Äö≈†‚Ä∞√ü √Æ√Ç ‚Äö√¢‚Ä∞√ü‚Äô#√®
```
Uses the **CP-1252** encoding. [Try it online!](https://tio.run/nexus/05ab1e#@5@nf2ilsbn1o4adh9YZmQIp/0cNMx81zDq64FHDhsPzFQ6vO9ykAOQfXgTmAyWVD6/4/99Qz5TL1AAA "05AB1E ‚Äì TIO Nexus")
[Answer]
## [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), ~~61~~ 58 bytes
```
::m=a/b^2~m<18.5|?@Und`+@erweight`\~m>=25|?@Ov`+B\?@Normal
```
*@Luke used the Force and chopped off two bytes. Thanks!*
*The rules change saved another byte.*
Explanation:
```
::          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.
```
[Answer]
# [Python 2](https://docs.python.org/2/), 72 bytes
```
lambda a,b:"UNOnovdreemrrawwlee ii gg hh tt"[(18.6<a/b/b)+(a/b/b>25)::3]
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqiQqJNkpRTq55@XX5ZSlJqaW1SUWF6ek5qqkJmpkJ6ukJGhUFKiFK1haKFnZpOon6SfpKmtAabtjEw1rayMY/8XFGXmlWikaVgY6BnoKBjqGWhqcqGKGWERMwaJ/QcA "Python 2 ‚Äì TIO Nexus")
[Answer]
# Python 3, ~~97~~ 95 bytes
```
a,b=map(int,input().split())
a/=b*b*5
print(["UOnvd"[a>93::2]+"erweight","Normal"][93<=a<=125])
```
Full program.
Multiply by five to save a byte. Thanks Jonathan Allan.
Line by line:
1. Map the two space separated user input numbers to ints. Unpack to a and b.
2. Calculate
3. If the bmi is between 18.6 and 25, inclusive, the expression on the right will evaluate to True. Booleans can be 0 or 1 when used as list indexes, so we get either "Normal" or the constructed string in the zero index. "erweight" is a shared suffix for the remaining two options, so it doesn't need to be repeated. Then we use the [start:stop:step] pattern of Python list/string slicing. c>18.6 will evaluate to either 0 or 1 (False or True) and becomes our start. Stop isn't indicated so we go to the end of the literal. Step is 2 so we take every second index. If start start evaluates to 1, we get "Ov", otherwise we get "Und". Either way, we append "erweight" to what we got and we have our final output.
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), 81 bytes
```
param($m,$h)('Underweight','Normal','Overweight')[(18.5,25-lt($m/($h*$h))).Count]
```
[Try it online!](https://tio.run/nexus/powershell#@1@QWJSYq6GSq6OSoamhHpqXklpUnpqZnlGirqPul1@Um5gDZPiXwUU1ozUMLfRMdYxMdXNKgPr0NVQytIB6NTX1nPNL80pi////b2rw31DPFAA "PowerShell ‚Äì TIO Nexus")
## Explanation
The main bit that needs explaining is `18.5,25 -lt $b` (where I'm substituting `$b` for the BMI which is calculated in place in the code). Most operators in PowerShell, when given an array on the left side, return an array of items that satisfy the test, instead of returning a boolean value. So this will return an empty array if `$b` is smaller than 18.5, an array containing only 18.5 if it's in the middle, and an array containing both 18.5 and 25 if it's larger than 25.
I use the count of the elements as an index into an array of the strings, so count `0` gets element `0` which is `'Underweight'`, etc.
[Answer]
## R, ~~89~~ ~~84~~ ~~80~~ 74 bytes
```
f=pryr::f(c('Overweight','Normal','Underweight')[sum(w/h^2<c(18.5,25),1)])
```
With a nod to StewieGriffin's Octave answer, creates an array of strings, then sums the result of `BMI < c(18.5,25)` and references the array at that position + 1.
First argument needs to be height, then weight; if that's not allowed, then
```
f=pryr::f(w,h,c('Overweight','Normal','Underweight')[sum(w/h^2<c(18.5,25),1)])
```
works for 4 more bytes.
[Answer]
## Clojure, 63 bytes
```
#(condp <(/ %(* %2 %2))25"Overweight"18.5"Normal""Underweight")
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 58 bytes
```
Fk[Ov]?2^/d[[Normal]pq][[Und]26]sasb18.5>a25>bn[erweight]p
```
Takes input as 2 space separated numbers in the format `<mass> <height>` . Outputs a string on a separate line.
[Try it online!](https://tio.run/nexus/dc#@x/tXxZrbxSnnxId7ZdflJuYE1tQGBsdHZqXEmtkFhucWJxkaKFnapdoZGqXlBedWlSempmeURJb8P@/hYGC4de8fN3kxOSMVAA "dc ‚Äì TIO Nexus")
### Explanation
For the purposes of this explanation, the input is `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.
```
[Answer]
# Octave, 64 bytes
```
@(w,h){'Underweight','Normal','Overweight'}{3-sum(2*w/h^2<'%2')}
```
[Try it online](https://tio.run/#5pIiW)
This is an anonymous function that takes two input arguments, `h` (height) and `w` (weight).
The function creates a cell array containing there strings `'Underweight','Normal','Overweight'`, and outputs string number `3-sum(2*w/h^2<'%2')`.
Yes, that one looks a bit strange. We want the first string if `w/h^2<=18.5`, the second string if `(w/h^2 > 18.5) & (w/h^2 < 25)` and the third string if none of the above conditions are true. Instead of creating a bunch of comparisons, we could simply compare the string to: `w/h^2 < [18.5, 25]`, which would return one of the following arrays `[1 1], [0 1], [0,0]` for Underweight, Normal and Overweight respectively.
`[18.5,25]` takes 9 bytes, which is a lot. What we do instead, is multiply the BMI by 2, and compare the result with `[37, 50]`, or `'%2'` in ASCII. This saves three bytes.
[Answer]
# [Perl 6](http://perl6.org/), 59 bytes
```
{<Overweight Normal Underweight>[sum 18.5,25 X>$^a/$^b**2]}
```
### How it works
```
{                                                         }  # 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.
```
Too bad the string `erweight` has to be repeated, but all variations I tried in order to avoid that ended up increasing the overall byte count:
* With string substitution, 62 bytes:
```
{<Ov_ Normal Und_>[sum 18.5,25 X>$^a/$^b**2].&{S/_/erweight/}}
```
* With string interpolation, 67 bytes:
```
{$_='erweight';("Ov$_","Normal","Und$_")[sum 18.5,25 X>$^a/$^b**2]}
```
* Rough translation of [xnor's Python solution](https://codegolf.stackexchange.com/a/109338/14880), 65 bytes:
```
{$_=$^a/$^b**2;25>$_>=18.5??"Normal"!!<Und Ov>[$_>19]~"erweight"}
```
[Answer]
# 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"
```
[Answer]
# Python, ~~75~~ 74 bytes
```
lambda h,w:18.5<=w/h/h<=25and"normal"or["ov","und"][25>w/h/h]+"erwe‚Äå‚Äãight"
```
[Try it online!](https://tio.run/nexus/python3#NclLCoAgFADAqzzeqo9UCkVEnsRaGGkKZmEfj2@rZjsaOEzJyX1ZJRgSB/RH2KVDq4H2VTvyWJuiYCNnLSh3KYHHiwQfv@IsWPf/XKIKUdnN3JjOYP2d6axvCM3z9AE)
Fairly basic solution that takes advantage of other people's techniques for solving it.
Thanks @ovs for saving a byte.
## Alternatives
### 1. 73 bytes
```
lambda h,w:"normal"if 18.5<=w/h/h<=25 else"uonvd"[25<w/h/h::2]+"erweight"
```
I rejected this as it was too similar to another answer I saw.
### 2. 71 bytes
```
lambda h,w:"normal"if 18.5<w/h/h<25 else"uonvd"[25<w/h/h::2]+"erweight"
```
I rejected this because, despite working on all the tests in the question, there are some numbers it can fail on as it's missing the `=` in the `<=`.
[Answer]
# C#, 63 62 61 bytes
*Saved 1 more byte thanks to [TheLethalCoder](https://codegolf.stackexchange.com/users/38550/thelethalcoder).*
*Saved 1 byte thanks to anonymous user.*
```
w=>h=>w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight";
```
A pretty straightforward anonymous function. The whole trick is using the ternary operator to return directly (thus omitting the `return` keyword, a pair of curly braces and a variable declaration and assignment).
Full program with test cases:
```
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"
    }
}
```
[Answer]
# Common Lisp, ~~89~~ ~~87~~ ~~85~~ ~~84~~ 83 bytes
A function:
```
(lambda(w h)(if(< #1=(/ w(* h h))18.5)'underweight(if(< #1#25)'normal'overweight)))
```
### Example of usage:
```
((lambda(w h)(if(< #1=(/ w(* h h))18.5)'underweight(if(< #1#25)'normal'overweight)))150 2)
```
[Try it online!](https://tio.run/##NYtLCoAgEECvMuCimRaVQdCiDmNpKZiJWR7f3Lh9n92ax@eMPhgXEa24NikwgSY0By7A@Io9JGxBF0Z87iZqXidVSMqcOtaKjYW7O1zCNvdXLZVjGmAkyvkH "Common Lisp ‚Äì Try It Online")
(I added printing function to see output in TIO)
Ideas for improvement are welcomed.
[Answer]
# MATL, ~~54~~ ~~45~~ ~~44~~ 42 bytes
```
U/E'%2'<sqt?q?'ov'}'und']'erweight'h}x17Y0
```
[Try it at matl.io](https://matl.io/?code=U%2FE%27%252%27%3Csqt%3Fq%3F%27ov%27%7D%27und%27%5D%27erweight%27h%7Dx17Y0&inputs=3%0A80&version=19.8.0)
Starts off by calculating the BMI and doubling it `U\E`, then creates the vector `[37 50]` with the string literal '%2'. Compares the BMI to this vector and uses if statements to get the answer, taking advantage of `normal` as a predefined literal `17Y0`.
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 25 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
¬≤/¬ø}»ØE¬ø¬©S‚Äò·ªå·∏É·∫ã…† ·∏≤·∫á ·πÅ·∫ì·∫ã…†‚ÄòOi
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSVDMiVCMiUyRiVDMiVCRiU3RCVDOCVBRkUlQzIlQkYlQzIlQTlTJUUyJTgwJTk4JUUxJUJCJThDJUUxJUI4JTgzJUUxJUJBJThCJUM5JUEwJTIwJUUxJUI4JUIyJUUxJUJBJTg3JTIwJUUxJUI5JTgxJUUxJUJBJTkzJUUxJUJBJThCJUM5JUEwJUUyJTgwJTk4T2kmZm9vdGVyPSZpbnB1dD0xJTJDJTIwODAlMjAlM0QlM0UlMjAlMjAlMjAlMjJPdmVyd2VpZ2h0JTIyJTBBMiUyQyUyMDgwJTIwJTNEJTNFJTIwJTIwJTIwJTIyTm9ybWFsJTIyJTBBMyUyQyUyMDgwJTIwJTNEJTNFJTIwJTIwJTIwJTIyVW5kZXJ3ZWlnaHQlMjImZmxhZ3M9QyVFMSVCOSVBQw==)
#### Explanation
```
¬≤/...¬©S...i  # Implicit input
¬≤/           # Divide the weight by the height squared
  ...        # Compressed numeric list [18.5, 25]
     ¬©       # Vectorised lesser than or equal to
      S      # Sum the list to get an integer from 0 to 2
             # (0=overweight, 1=normal, 2=underweight)
       ...i  # Index into compressed list of strings
             # ["Overweight", "Normal", "Underweight"]
             # Implicit output
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 57 bytes
```
{((,"Normal"),("Ov";"Und"),\:"erweight")3!("%2"%2)'x%y*y}
```
[Try it online!](https://ngn.codeberg.page/k#eJx1kN1LwzAUxd/vX5HdMpO40jVts3YZU1F8yIMKBd8COlhXBT9gk+kQ97cvJt2Xm5CXe87vnhzuRH0zFuLt+/R19II8ZHg3xwHev43tYBRW08/quX76QJ62GLYT+zj9ai9OFz8AXSjikAgyPCOE2MUN7PSk0Ztsp6WNZvO3MMh/UpweyV9nkyJ3kvdTrsd1Ra5Gs2qmADKxXd3FCBNFlJDLG80hSw7ind3r5R4A2TtCJFlUFH1PyHwL7DS3kIzSJiRPjzf2VaSn8uzgYM5vbOj31/5ekbzxRbw+y98a3jcAWokHfXGyZPo8pNg1BjllrUCrWD2OpvWcCPsN04OSqw5LhoGiPECXaKgGKBXroEE7lFzYcUnMJKIRpRh6YgVoZ4vc)
[Answer]
# Java 8, 61 bytes
```
w->h->w/h/h<18.5?"Underweight":w/h/h<25?"Normal":"Overweight"
```
Assign to a `DoubleFunction<DoubleFunction<String>>` and call thusly:
```
bmi.apply(50).apply(1.5)
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 64 bytes
```
[erweight][[Und]PszPq]su[[Normal]Pq]sn9k?d*/d18.5>ud25>n[Ov]PszP
```
[Try it online!](https://tio.run/nexus/dc#@x@dWlSempmeURIbHR2alxIbUFwVUBhbXBod7ZdflJuYEwvi5Vlm26do6acYWuiZ2pWmGJna5UX7l4HV/v9vYaBgyAUA "dc ‚Äì TIO Nexus")
[Answer]
## Javascript (ES6), 63 bytes
```
(m,h)=>(w="erweight",b=m/h/h)<18.5?"Und"+w:b<25?"Normal":"Ov"+w
```
Example
```
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));
```
[Answer]
# PHP, 69 68/85 bytes
If you want it to be more as a program,
```
$a=$args;$b=$a[0]/($a[1]*$a[1]);echo$b>=18.5&&$b<25?normal:($b<18.5?und:ov).erweight; // 85
$b=$k/($h*$h);echo$b>=18.5&&$b<25?normal:($b<18.5?und:ov).erweight; // 68
$b=$k/pow($h,2);echo$b>=18.5&&$b<25?normal:($b<18.5?und:ov).erweight; // 69
```
You can test with `$k=80; $h=1;`. I had three choices, via `$args`, like this or as defined values (`K`&`H`). I choose the middle as most fair.
[Answer]
# Swift, 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"}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 46 bytes
```
/=V¬≤U<25¬©U¬®18¬Ω?`NŽ¬µl`:¬∫U<19?`U˜`:"Ov")+`€¬≥ight
```
[Try it online!](https://tio.run/nexus/japt#AT8AwP//Lz1WwrJVPDI1wqlVwqgxOMK9P2BOwo7CtWxgOsK6VTwxOT9gVcKYYDoiT3YiKStgwoDCs2lnaHT//zUwLDI "Japt ‚Äì TIO Nexus")
Inspired by @Luke's [answer](https://codegolf.stackexchange.com/a/109322/61613).
### Explanation
```
/=V¬≤U<25¬©U¬®18¬Ω?`N≈Ω¬µl`:¬∫U<19?`UÀú`:"Ov")+`‚Ç¨¬≥ight  
```
Decompresses to :
```
U=U/V**2,U<25&&U>18.5?"Normal":(U<19?"Und":"Ov")+"erweight"
```
Japt has an implicit input `U`. The second input is `V`.
Japt uses the [shoco library](http://ed-von-schleck.github.io/shoco/) for string compression. Backticks are used to decompress strings. 
Unicode shortcuts used:
```
¬≤ : **2
¬© : &&
¬® : >=
¬Ω : .5
¬∫ : ((
```
]