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.

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

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"

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

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.

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!

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.

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’‚Š‰ß î ‚â‰ß’#è

Utiliza la codificación CP-1252 . Pruébalo en línea!

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.

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!

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.

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.

Clojure, 63 bytes

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

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.

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.

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

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.

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"

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

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

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.

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.

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)

dc , 64 bytes

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

Pruébalo en línea!

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

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

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
º : ((

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!

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