¿Cuál es mi índice de masa corporal?

21

Problema:

Su tarea es escribir un programa que tome como entrada una altura (en metros) y un peso (en kilogramos), y genere la categoría de IMC correspondiente.

El IMC es una medida de la relación entre su peso y su altura. Es anticuado e inexacto para muchas personas , ¡pero eso no importa aquí!

El IMC se puede calcular usando la siguiente ecuación:

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

Las categorías se definirán de la siguiente manera:

  • IMC <18.5: "bajo peso"

  • 18.5 <= IMC <25: "Normal"

  • 25 <= IMC: "Sobrepeso"

Por el bien del desafío, estoy ignorando todas las categorías "extremas". Además, dado que algunos números como "25" se ubican entre 2 categorías, ajusté los límites ligeramente para que haya una respuesta definitiva.

Puede escribir una función o un programa completo.

Entrada:

La entrada puede ser de cualquier forma razonable. Dos números (o cadenas), ya sea como 2 argumentos separados, o como una sola cadena. Una matriz / lista de 2 números, un diccionario con las teclas "peso" y "altura" ... Se deben admitir valores decimales. Puede suponer que la entrada siempre será válida (sin valores negativos, y la altura nunca será 0).

Salida:

La salida será una cadena que contiene los nombres de categoría que no distinguen entre mayúsculas y minúsculas . Las cadenas deben coincidir con los nombres de categoría exactamente como se indica arriba, ignorando mayúsculas y minúsculas. Puede enviarse a la salida estándar, devolverse (en el caso de una función) o escribirse en un archivo.

Casos de prueba (peso, altura => resultado):

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)

Aquí hay un pseudocódigo que muestra una implementación de ejemplo:

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"

Este es el código de golf, por lo que gana la menor cantidad de bytes.

(Sí, esta tarea es extremadamente trivial en la mayoría de los idiomas. La mayoría de los desafíos últimamente parecen ser más difíciles de lo normal, así que pensé en publicar uno más accesible).


¡NOTA! Una hora después de publicar este desafío, tuve que modificar ligeramente los rangos ya que los rangos como se indicaron tenían "agujeros" como se señala en los comentarios. Por favor vea las nuevas gamas.

Carcigenicate
fuente

Respuestas:

9

Jalea , 24 bytes

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

Pruébalo en línea!

¿Cómo?

Calcula el IMC, lo duplica, compara eso con el operador mayor que con cada uno de los números 37 y 50 (18.5 y 25 duplicados), suma los ceros y los ceros resultantes (produciendo 1, 2 o 0 para Normal, Bajo peso y Sobrepeso) respectivamente) e índices en la lista de cadenas ["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
Jonathan Allan
fuente
1
Guau. Habla sobre ofuscación. Si esto es golf, ¡creo que tienes un hoyo en uno! O 24 ...
Cullub
2
@cullub tiene 24 caracteres y 24 bytes: Jelly usa su propia página de códigos vinculada por la palabra "bytes" en el encabezado, mothereff.in está contando Unicode, creo.
Jonathan Allan
1
@TheBitByte, sí, eche un vistazo al contador de enlaces TIO "24 caracteres, 24 bytes (SBCS)" o cuéntelo a mano utilizando la página de códigos enlazada por bytes en el encabezado.
Jonathan Allan
... como hechizo:1C 1C 89 AF FE 25 32 FC 3E 53 D8 FE 24 8D 0B FE 3B F0 BD FE 26 E8 29 FB
Jonathan Allan
21

Python , 69 bytes

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

Pruébalo en línea!

Comparar a 72 bytes:

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

TI-Basic, 58 54 bytes

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

Además, por diversión, aquí hay una versión más compacta que tiene más bytes:

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

Todo lo que puedo decir es, gracias por hacer esto insensible a mayúsculas y minúsculas;)

PS Inputtoma entrada de gráfico Xy Ysimilar aPrompt X,Y

Timtech
fuente
Además, lo he visto varias veces, y no creo que haya ninguna forma de guardar bytes a pesar de que los dos últimos comparten la cadenaERWEIGHT
Timtech
Por curiosidad, ¿cómo habría cambiado tu respuesta si aplicara mayúsculas y minúsculas?
Carcigenique
1
@Carcigenicate En TI-Basic, las letras minúsculas son de dos bytes cada una. Por lo tanto, habría aumentado mucho el recuento de bytes.
Timtech
1
Ah, ya veo. Eso es extraño.
Carcigenicate
1
@Carcigenicate Es importante recordar que esta versión de TI-Basic se introdujo en 1990 como lenguaje de calculadora ... nadie sabía que estaría jugando al golf 27 años después
Timtech
6

Mathematica, 67 bytes

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

Utiliza el hecho de que a[b,c][[Sign@d]]devuelve asi des igual a 0, devuelve bsi des positivo y devuelve csi des negativo. ⌊...⌋es la Floorfunción de Mathematica que usa los caracteres de tres bytes U + 230A y U + 230B. No pude descubrir cómo hacerlo mejor que usar weightdos veces.

Greg Martin
fuente
3
Sorprendido Mathematica no tiene una función incorporada para esto
Daniel
1
tienes que ir al fan fiction para eso;)
Greg Martin
5

Ruby, 91 77 74 67 bytes

Primer intento ingenuo:

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

Segundo intento con "inspiración" de respuestas anteriores:

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

Tercer intento:

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

Cuarto intento:

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

Pruébalo en línea!

reitermarkus
fuente
reitermarkus de homebrew-cask ?! Woah, no esperaba verte aquí! : o
numbermaniac
1
@numbermaniac, jaja, sí, soy yo. 😂
reitermarkus
5

JavaScript (ES6), 70 67 64 63 bytes

Guardado 4B gracias a Arnauld

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

Uso

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

Salida

"Overweight"

Explicación

Esta respuesta es bastante trivial, aunque hay un truco inteligente: Underweighty Overweightambos terminan erweight, por lo que solo tenemos que cambiar esos caracteres.

Supuse que eso Normalsignifica un IMC entre 25 (exclusivo) y 18.5 (inclusive). Underweightsignifica un IMC menor a 18.5 y Overweightsignifica un IMC mayor o igual a 25.

Luke
fuente
1
Ahora la respuesta no contiene ninguna característica de ES7 ;-)
ETHproductions
4

C, 81 bytes

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

QBIC , 61 58 bytes

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

@Luke usó la Fuerza y ​​cortó dos bytes. ¡Gracias!

El cambio de reglas salvó otro byte.

Explicación:

::          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
fuente
3

Python 2 , 72 bytes

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

Pruébalo en línea!

DJMcMayhem
fuente
¿Cómo se obtienen los colores para Python? Nunca lo descubrí.
@JackBates Es justo lo <!-- language-all: lang-python -->que TIO insertó automáticamente para mí.
DJMcMayhem
3

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

Programa completo

Multiplique por cinco para guardar un byte. Gracias Jonathan Allan

Linea por linea:

  1. Asigne los dos números de entrada de usuario separados por espacios a ints. Desempaquete a a y b.

  2. Calcular

  3. Si el IMC está entre 18.6 y 25, inclusive, la expresión de la derecha se evaluará como Verdadero. Los booleanos pueden ser 0 o 1 cuando se usan como índices de lista, por lo que obtenemos "Normal" o la cadena construida en el índice cero. "erweight" es un sufijo compartido para las dos opciones restantes, por lo que no es necesario repetirlo. Luego usamos el patrón [start: stop: step] de la lista de Python / segmentación de cadenas. c> 18.6 se evaluará a 0 o 1 (Falso o Verdadero) y se convierte en nuestro comienzo. Stop no está indicado, así que vamos al final del literal. El paso es 2, así que tomamos cada segundo índice. Si start start se evalúa en 1, obtenemos "Ov", de lo contrario obtenemos "Und". De cualquier manera, agregamos "erweight" a lo que obtuvimos y tenemos nuestro resultado final.

mypetlion
fuente
1
Escríbelo como una función para 79:def f(h,w):c=h/w/w;print(["UOnvd"[c>18.6::2]+"erweight","Normal"][18.6<=c<=25])
Jonathan Allan
Si multiplica por cinco primero, puede guardar un byte comparando con 93y 125. Si usa una lambda, tiene que calcular cen ambos lugares, pero no necesita nombrar la función o el uso print(), también puede hacerlo lambda h,w:["UOnvd"[h/w/w*5>93::2]+"erweight","Normal"][93<=h/w/w*5<=125]para 73.
Jonathan Allan
... en realidad porque calcularás el cdoble de la multiplicación por 5 cuesta más de lo que ahorra en el lambda, así que solo lambda h,w:["UOnvd"[h/w/w>18.6::2]+"erweight","Normal"][18.6<=h/w/w<=25]por 72
Jonathan Allan
Jonathan Allan Alguien ya lo hizo como una función.
mypetlion
Está bien, tu camino los superará: D
Jonathan Allan
3

R, 89 84 80 74 bytes

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

Con un guiño a la respuesta Octave de StewieGriffin, crea una matriz de cadenas, luego suma el resultado BMI < c(18.5,25)y hace referencia a la matriz en esa posición + 1.

El primer argumento debe ser la altura, luego el peso; si eso no está permitido, entonces

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

funciona para 4 bytes más.

BLT
fuente
2

Clojure, 63 bytes

#(condp <(/ %(* %2 %2))25"Overweight"18.5"Normal""Underweight")
NikoNyrh
fuente
Maldita sea. Como siempre, esta es una versión más corta de lo que estaba pensando.
Carcigenicate
2

dc , 58 bytes

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

Toma la entrada como 2 números separados por espacios en el formato <mass> <height>. Emite una cadena en una línea separada.

Pruébalo en línea!

Explicación

A los fines de esta explicación, la entrada es 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.
R. Kap
fuente
2

Octava, 64 bytes

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

Pruébalo en línea

Esta es una función anónima que toma dos argumentos de entrada, h (altura) y w(peso).

La función crea una matriz de celdas que contiene sus cadenas 'Underweight','Normal','Overweight' y genera un número de cadena 3-sum(2*w/h^2<'%2').

Sí, ese se ve un poco extraño. Queremos la primera cadena if w/h^2<=18.5, la segunda cadena if (w/h^2 > 18.5) & (w/h^2 < 25)y la tercera cadena if ninguna de las condiciones anteriores es verdadera. En lugar de crear un montón de comparaciones, podríamos simplemente comparar la cadena con:, w/h^2 < [18.5, 25]lo que devolvería una de las siguientes matrices[1 1], [0 1], [0,0] para Underweight, Normal y Overweight respectivamente.

[18.5,25]toma 9 bytes, que es mucho. En cambio, lo que hacemos es multiplicar el IMC por 2 y comparar el resultado con [37, 50]o '%2'en ASCII. Esto ahorra tres bytes.

Stewie Griffin
fuente
2

Perl 6 , 59 bytes

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

Cómo funciona

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

Lástima que la cadena erweightdeba repetirse, pero todas las variaciones que intenté para evitar eso terminaron aumentando el recuento de bytes general:

  • Con sustitución de cadena, 62 bytes:

    {<Ov_ Normal Und_>[sum 18.5,25 X>$^a/$^b**2].&{S/_/erweight/}}
  • Con interpolación de cadenas, 67 bytes:

    {$_='erweight';("Ov$_","Normal","Und$_")[sum 18.5,25 X>$^a/$^b**2]}
  • Traducción aproximada de la solución Python de xnor , 65 bytes:

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

PowerShell , 81 bytes

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

Pruébalo en línea!

Explicación

El bit principal que necesita explicación es 18.5,25 -lt $b(donde estoy sustituyendo $bel IMC que se calcula en el lugar en el código). La mayoría de los operadores en PowerShell, cuando reciben una matriz en el lado izquierdo, devuelven una matriz de elementos que satisfacen la prueba, en lugar de devolver un valor booleano. Entonces esto devolverá una matriz vacía si$b es menor que 18.5, una matriz que contiene solo 18.5 si está en el medio y una matriz que contiene 18.5 y 25 si es mayor que 25.

Utilizo el recuento de los elementos como un índice en una matriz de cadenas, por lo que count 0obtiene el elemento 0que es 'Underweight', etc.

briantista
fuente
2

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"
reitermarkus
fuente
No, esta es una función.
reitermarkus
2

Python, 75 74 bytes

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

Pruébalo en línea!

Solución bastante básica que aprovecha las técnicas de otras personas para resolverlo.

Gracias @ovs por guardar un byte.

Alternativas

1. 73 bytes

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

Rechacé esto porque era demasiado similar a otra respuesta que vi.

2. 71 bytes

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

Rechacé esto porque, a pesar de trabajar en todas las pruebas en la pregunta, hay algunos números en los que puede fallar, ya que faltan =en el <=.


fuente
No necesita el espacio entre 25y else, pero de todos modos, el uso de cortocircuito and/or(como comentó @ovs) es más corto.
FlipTack
@FlipTack: con respecto al espacio entre 25y else, definitivamente lo necesita con algunos (¿la mayoría?) Intérpretes (incluidos CPython, IIRC). Si lo escribe como 25else, 25ese interpreta como el comienzo de un literal numérico de notación científica, y el intérprete luego interrumpe cuando no hay dígitos siguientes.
Mac
2

C #, 63 62 61 bytes

Ahorró 1 byte más gracias a TheLethalCoder .

Guardado 1 byte gracias a un usuario anónimo.

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

Una función anónima bastante sencilla. Todo el truco es usar el operador ternario para regresar directamente (omitiendo así elreturn palabra clave, un par de llaves y una declaración y asignación variable).

Programa completo con casos de prueba:

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
fuente
2

Lisp común, 89 87 85 84 83 bytes

Una función:

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

Ejemplo de uso:

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

Pruébalo en línea! (Agregué la función de impresión para ver la salida en TIO)

Ideas de mejora son bienvenidas.


fuente
2

MATL, 54 45 44 42 bytes

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

Pruébalo en matl.suever.net

Comienza calculando el IMC y duplicándolo U\E, luego crea el vector [37 50]con la cadena literal '% 2'. Compara el IMC con este vector y usa declaraciones if para obtener la respuesta, aprovechando normalcomo un literal predefinido 17Y0.

B. Mehta
fuente
Puede reemplazar [BC]UQcon '%2'y guardar 2 bytes.
sundar - Restablecer Monica
1

Java 8, 61 bytes

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

Asignar a a DoubleFunction<DoubleFunction<String>>y llamar así:

bmi.apply(50).apply(1.5)
David Conrad
fuente
Se puede prescindir de un byte reutilizando w: w->h->(w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight".
Olivier Grégoire
@ OlivierGrégoire Nope :( Error: local variables referenced from a lambda expression must be final or effectively finalNo se puede asignar a w.
David Conrad
1
Oh ... Lo revisé con cosas en línea como int w = ... , h = ... ; System.out.println((w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight"), lo siento :)
Olivier Grégoire
@ OlivierGrégoire No hay problema. Desearía que Java lo permitiera.
David Conrad
1

dc , 64 bytes

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

Pruébalo en línea!

Mitchell Spector
fuente
Dang it! Solo golpéame por unos segundos. Estaba a punto de publicar el mío, hasta que vi esto. De todas formas, aquí es otra respuesta de 64 bytes: 3k[Overweight]??2^/dsp[[Normal]][[Underweight]]sasb25>blp18.5>ap.
R. Kap
@ R.Kap En realidad, puede hacer que el suyo sea un byte más corto que el mío omitiendo uno de los signos de interrogación.
Mitchell Spector
Oh sí, olvidé que podía hacer eso. Puede publicar eso como propio si lo desea.
R. Kap
No, está bien, adelante y publíquelo usted mismo, es su solución. (Puede acreditarme un byte si lo desea)
Mitchell Spector,
Por cierto, pude reducirlo a 58 bytes. :)
R. Kap
1

Javascript (ES6), 63 bytes

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

Ejemplo

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

ene
fuente
1

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"}
reitermarkus
fuente
1

Japt , 46 bytes

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

Pruébalo en línea!

Inspirado por @ Luke's respuesta de .

Explicación

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

Descomprime a:

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

Japt tiene una entrada implícita U. La segunda entrada esV .

Japt usa la biblioteca shoco para la compresión de cadenas. Los backticks se usan para descomprimir cadenas.

Accesos directos Unicode utilizados:

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

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":"")));}

Pruébalo en línea!

Tom291
fuente
1

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}
Roman Gräf
fuente
1

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
idrougge
fuente