Problema:

Sua tarefa é escrever um programa que tenha como entrada uma altura (em metros) e peso (em quilogramas) e produza a categoria de IMC correspondente.

O IMC é uma medida da relação entre seu peso e sua altura. É datado e impreciso para muitas pessoas , mas isso não importa aqui!

O IMC pode ser calculado usando a seguinte equação:

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

As categorias serão definidas da seguinte forma:

• IMC <18,5: "Baixo peso"

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

• 25 <= IMC: "Excesso de peso"

Para o desafio, estou ignorando todas as categorias "extremas". Além disso, como alguns números como "25" se situam entre duas categorias, ajustei os limites levemente para que haja uma resposta definitiva.

Você pode escrever uma função ou um programa completo.

Entrada:

A entrada pode estar em qualquer forma razoável. Dois números (ou cadeias), como 2 argumentos separados ou como uma única cadeia. Uma matriz / lista de 2 números, um dicionário com as teclas "peso" e "altura" ... Os valores decimais devem ser suportados. Você pode assumir que a entrada sempre será válida (sem valores negativos e a altura nunca será 0).

Saída:

A saída será uma sequência que contém os nomes de categoria que não diferenciam maiúsculas de minúsculas . As strings devem corresponder aos nomes das categorias exatamente como acima, ignorando maiúsculas e minúsculas. Pode ser enviado para o stdout, retornado (no caso de uma função) ou gravado no arquivo.

Casos de teste (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)

Aqui está um pseudocódigo que mostra um exemplo de implementação:

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"

Isso é código-golfe, então o menor número de bytes vence.

(Sim, essa tarefa é extremamente trivial na maioria dos idiomas. Atualmente, a maioria dos desafios parece ser mais difícil do que o normal, então pensei em publicar um mais acessível).

NOTA! Uma hora depois de postar esse desafio, tive que modificar os intervalos levemente, pois os intervalos declarados tinham "buracos", conforme apontado nos comentários. Por favor, veja os novos intervalos.

Gelatina , 24 bytes

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

Experimente online!

Quão?

Calcula o IMC, dobra-o, compara-o com o operador maior que com cada um dos números 37 e 50 (18,5 e 25 dobrados), soma os números e zeros resultantes (produzindo 1, 2 ou 0 para Normal, Abaixo do peso e Excesso de peso respectivamente) e índices na lista de cadeias ["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]

Experimente online!

Compare com 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

Além disso, por diversão, aqui está uma versão mais compacta com mais bytes:

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

Tudo o que posso dizer é: obrigado por tornar esse caso insensitivo;)

PS Inputleva entrada gráfica Xe Ysemelhante aPrompt X,Y

Mathematica, 67 bytes

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

Usa o fato de a[b,c][[Sign@d]]retornar ase for digual a 0, retornar bse dfor positivo e retornar cse dfor negativo. ⌊...⌋é a Floorfunção do Mathematica usando os caracteres de três bytes U + 230A e U + 230B. Não foi possível descobrir como fazer melhor do que usar weightduas vezes.

Ruby, 91 77 74 67 bytes

Primeira tentativa ingênua:

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

Segunda tentativa com "inspiração" de respostas anteriores:

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

Terceira tentativa:

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

Quarta tentativa:

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

Experimente online!

JavaScript (ES6), 70 67 64 63 bytes

Guardado 4B graças 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)

Saída

"Overweight"

Explicação

Essa resposta é bastante trivial, embora exista um truque inteligente: Underweighte Overweightambas terminam erweight, então só precisamos mudar esses caracteres.

Supus que isso Normalsignifica um IMC entre 25 (exclusivo) e 18,5 (inclusive). Underweightsignifica IMC menor que 18,5 e OverweightIMC maior ou 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’‚Š‰ß î ‚â‰ß’#è

Usa a codificação CP-1252 . Experimente online!

QBIC , 61 58 bytes

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

@Luke usou o Force e cortou dois bytes. Obrigado!

A alteração das regras salvou outro byte.

Explicação:

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

Experimente online!

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 salvar um byte. Obrigado Jonathan Allan.

Linha por linha:

1. Mapeie os dois números de entrada do usuário separados por espaço para ints. Descompacte para a e b.

2. Calcular

3. Se o IMC estiver entre 18,6 e 25, inclusive, a expressão à direita será avaliada como True. Os booleanos podem ser 0 ou 1 quando usados ​​como índices de lista, portanto, obtemos "Normal" ou a string construída no índice zero. "erweight" é um sufixo compartilhado para as duas opções restantes, portanto, não precisa ser repetido. Em seguida, usamos o padrão [start: stop: step] da lista de Python / fatia de strings. c> 18.6 será avaliado em 0 ou 1 (Falso ou Verdadeiro) e se tornará o nosso começo. Stop não é indicado, então vamos para o final do literal. O passo é 2, então pegamos cada segundo índice. Se start start for avaliado como 1, obteremos "Ov", caso contrário, obteremos "Und". De qualquer forma, anexamos "erweight" ao que obtivemos e temos nossa produção final.

R, 89 84 80 74 bytes

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

Com um aceno para a resposta Octave de StewieGriffin, cria uma matriz de seqüências de caracteres e depois soma o resultado de BMI < c(18.5,25) e faz referência à matriz nessa posição + 1.

O primeiro argumento precisa ser altura, depois peso; se isso não for permitido, então

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

funciona para mais 4 bytes.

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

Aceita entrada como 2 números separados por espaço no formato <mass> <height> . Produz uma string em uma linha separada.

Experimente online!

Explicação

Para os fins desta explicação, a entrada é 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.

Oitava, 64 bytes

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

Experimente online

Esta é uma função anônima que recebe dois argumentos de entrada, h(altura) e w(peso).

A função cria uma matriz de células contendo as strings 'Underweight','Normal','Overweight'e gera o número da string 3-sum(2*w/h^2<'%2').

Sim, esse parece um pouco estranho. Queremos a primeira string se w/h^2<=18.5, a segunda string se (w/h^2 > 18.5) & (w/h^2 < 25)e a terceira string se nenhuma das condições acima for verdadeira. Em vez de criar várias comparações, poderíamos simplesmente comparar a string com:, w/h^2 < [18.5, 25]que retornaria uma das seguintes matrizes[1 1], [0 1], [0,0] para Abaixo do Peso, Normal e Acima do Peso, respectivamente.

[18.5,25]leva 9 bytes, o que é muito. O que fazemos é multiplicar o IMC por 2 e comparar o resultado com [37, 50], ou '%2'em ASCII. Isso economiza três bytes.

Perl 6 , 59 bytes

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

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

Pena que a string erweightprecisa ser repetida, mas todas as variações que tentei para evitar isso acabaram aumentando a contagem geral de bytes:

• Com substituição de cadeia, 62 bytes:

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

• Com interpolação de cadeia, 67 bytes:

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

• Tradução aproximada da solução Python do 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]

Experimente online!

Explicação

O principal ponto que precisa ser explicado é 18.5,25 -lt $b(onde eu estou substituindo $bo IMC, que é calculado no lugar no código). A maioria dos operadores do PowerShell, quando recebe uma matriz no lado esquerdo, retorna uma matriz de itens que satisfazem o teste, em vez de retornar um valor booleano. Portanto, isso retornará uma matriz vazia se$b for menor que 18,5, uma matriz contendo apenas 18,5 se estiver no meio e uma matriz contendo 18,5 e 25 se for maior que 25.

Eu uso a contagem dos elementos como um índice em uma matriz de seqüências de caracteres, então a contagem 0obtém o elemento 0que é '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"

Experimente online!

Solução bastante básica que tira proveito das técnicas de outras pessoas para resolvê-lo.

Obrigado @ovs por salvar um byte.

Alternativas

1. 73 bytes

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

Rejeitei isso, pois era muito semelhante a outra resposta que vi.

2. 71 bytes

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

Rejeitei isso porque, apesar de trabalhar em todos os testes da pergunta, existem alguns números em que ele pode falhar, pois está faltando =no <=.

C #, 63 62 61 bytes

Economizou mais 1 byte graças ao TheLethalCoder .

Economizou 1 byte graças ao usuário anônimo.

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

Uma função anônima bem direta. O truque é usar o operador ternário para retornar diretamente (omitindo oreturn palavra chave, um par de chaves e uma declaração e atribuição de variáveis).

Programa completo com casos de teste:

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 comum, 89 87 85 84 83 bytes

Uma função:

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

Exemplo de uso:

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

Experimente online! (Adicionei a função de impressão para ver a saída no TIO)

Idéias para melhoria são bem-vindas.

MATL, 54 45 44 42 bytes

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

Experimente em matl.suever.net

Começa calculando o IMC e dobrando-o U\E, depois cria o vetor [37 50]com a string literal '% 2'. Compara o IMC com esse vetor e usa instruções if para obter a resposta, aproveitando-se normalcomo um literal predefinido 17Y0.

Java 8, 61 bytes

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

Atribua a DoubleFunction<DoubleFunction<String>>e chame assim:

bmi.apply(50).apply(1.5)

dc , 64 bytes

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

Experimente online!

Javascript (ES6), 63 bytes

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

Exemplo

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

Rápido, 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

Experimente online!

Inspirado por @ Luke's resposta de .

Explicação

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

Descomprime para:

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

Japt tem uma entrada implícita U . A segunda entrada é V.

Japt usa o biblioteca shoco para compactação de strings. Backticks são usados ​​para descomprimir seqüências de caracteres.

Atalhos Unicode usados:

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

Experimente 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