Problema:

Il tuo compito è quello di scrivere un programma che accetta come input un'altezza (in metri) e un peso (in chilogrammi) e genera la categoria BMI corrispondente.

BMI è una misura del rapporto tra il tuo peso e la tua altezza. È datato e impreciso per molte persone , ma non importa qui!

L'IMC può essere calcolato usando la seguente equazione:

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

Le categorie saranno definite come segue:

• BMI <18.5: "Sottopeso"

• 18.5 <= BMI <25: "Normale"

• 25 <= BMI: "Sovrappeso"

Per il bene della sfida, sto ignorando tutte le categorie "estreme". Inoltre, poiché alcuni numeri come "25" si collocano tra 2 categorie, ho modificato leggermente i limiti in modo che ci sia una risposta definitiva.

È possibile scrivere una funzione o un programma completo.

Ingresso:

L'input può essere in qualsiasi forma ragionevole. Due numeri (o stringhe), come 2 argomenti separati o come singola stringa. Un array / elenco di 2 numeri, un dizionario con i tasti "peso" e "altezza" ... I valori decimali devono essere supportati. Puoi supporre che l'input sia sempre valido (nessun valore negativo e l'altezza non sarà mai 0).

Produzione:

L'output sarà una stringa contenente i nomi delle categorie senza distinzione tra maiuscole e minuscole . Le stringhe devono corrispondere ai nomi delle categorie esattamente come sopra, ignorando il caso. Può essere inviato allo stdout, restituito (nel caso di una funzione) o scritto su file.

Casi di prova (peso, altezza => risultato):

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)

Ecco alcuni pseudocodici che mostrano un'implementazione di esempio:

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"

Questo è code-golf, quindi vince il minor numero di byte.

(Sì, questo compito è estremamente banale nella maggior parte delle lingue. La maggior parte delle sfide ultimamente sembrano essere più difficili del normale, quindi ho pensato di pubblicarne una più accessibile).

NOTA! Un'ora dopo aver pubblicato questa sfida, ho dovuto modificare leggermente gli intervalli poiché gli intervalli come indicato avevano "buchi", come sottolineato nei commenti. Si prega di consultare le nuove gamme.

Gelatina , 24 byte

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

Provalo online!

Come?

Calcola l'IMC, raddoppia, confronta quello con l'operatore maggiore di con ciascuno dei numeri 37 e 50 (18,5 e 25 raddoppiato), somma gli zero e gli zeri risultanti (producendo 1, 2 o 0 per Normale, Sottopeso e Sovrappeso rispettivamente) e gli indici nell'elenco di stringhe ["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 byte

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

Provalo online!

Confronta con 72 byte:

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

TI-Basic, 58 54 byte

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

Inoltre, per divertimento, ecco una versione più compatta che è più byte:

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

Tutto quello che posso dire è, grazie per aver reso insensibile al maiuscolo / minuscolo;)

PS Inputaccetta input grafico Xe Ysimili aPrompt X,Y

Mathematica, 67 byte

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

Utilizza il fatto che a[b,c][[Sign@d]]restituisce ase è duguale a 0, restituisce bse dè positivo e restituisce cse dè negativo. ⌊...⌋è la Floorfunzione di Mathematica che utilizza i caratteri a tre byte U + 230A e U + 230B. Non sono riuscito a capire come fare meglio di usarlo weightdue volte.

Rubino, 91 77 74 67 byte

Primo tentativo ingenuo:

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

Secondo tentativo con "ispirazione" dalle risposte precedenti:

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

Terzo tentativo:

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

Quarto tentativo:

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

Provalo online!

JavaScript (ES6), 70 67 64 63 byte

Salvato 4B grazie ad 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)

Produzione

"Overweight"

Spiegazione

Questa risposta è piuttosto banale, anche se c'è un trucco intelligente: Underweighted Overweightentrambi finiscono erweight, quindi dobbiamo solo cambiare quei personaggi.

Ho ipotizzato che ciò Normalsignifichi un BMI tra 25 (esclusivo) e 18,5 (incluso). Underweightindica un BMI inferiore a 18.5 e Overweightindica un BMI maggiore o uguale a 25.

C, 81 byte

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

05AB1E , 28 byte

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

Utilizza la codifica CP-1252 . Provalo online!

QBIC , 61 58 byte

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

@Luke ha usato la Forza e ha tagliato due byte. Grazie!

Le regole cambiano salvando un altro byte.

Spiegazione:

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

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

Provalo online!

Python 3, 97 95 byte

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

Programma completo.

Moltiplicare per cinque per salvare un byte. Grazie Jonathan Allan.

Linea per linea:

1. Mappare i due numeri di input dell'utente separati da spazio in ints. Disimballare in a e b.

2. Calcolare

3. Se il bmi è compreso tra 18,6 e 25 inclusi, l'espressione a destra verrà valutata su True. I booleani possono essere 0 o 1 se usati come indici di elenco, quindi otteniamo "Normale" o la stringa costruita nell'indice zero. "erweight" è un suffisso condiviso per le restanti due opzioni, quindi non è necessario ripeterlo. Quindi usiamo il modello [start: stop: step] dell'elenco di Python / slicing di stringhe. c> 18.6 valuterà a 0 o 1 (False o True) e diventerà il nostro inizio. Stop non è indicato, quindi andiamo alla fine del letterale. Il passaggio è 2, quindi prendiamo ogni secondo indice. Se start start restituisce 1, otteniamo "Ov", altrimenti otteniamo "Und". Ad ogni modo, aggiungiamo "erweight" a ciò che abbiamo ottenuto e abbiamo il nostro risultato finale.

R, 89 84 80 74 byte

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

Con un cenno alla risposta Octave di StewieGriffin, crea una matrice di stringhe, quindi somma il risultato BMI < c(18.5,25)e fa riferimento alla matrice in quella posizione + 1.

Il primo argomento deve essere l'altezza, quindi il peso; se ciò non è consentito, allora

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

funziona per altri 4 byte.

Clojure, 63 byte

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

dc , 58 byte

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

Accetta input come 2 numeri separati da spazio nel formato <mass> <height>. Emette una stringa su una riga separata.

Provalo online!

Spiegazione

Ai fini di questa spiegazione, l'input è 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.

Ottava, 64 byte

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

Provalo online

Questa è una funzione anonima che accetta due argomenti di input, h(altezza) e w(peso).

La funzione crea un array di celle che contiene stringhe 'Underweight','Normal','Overweight'e genera un numero di stringa 3-sum(2*w/h^2<'%2').

Sì, quello sembra un po 'strano. Vogliamo la prima stringa if w/h^2<=18.5, la seconda stringa if (w/h^2 > 18.5) & (w/h^2 < 25)e la terza stringa se nessuna delle condizioni precedenti è vera. Invece di creare un sacco di confronti, potremmo semplicemente confrontare la stringa con:, w/h^2 < [18.5, 25]che restituirebbe uno dei seguenti array rispettivamente [1 1], [0 1], [0,0]per sottopeso, normale e sovrappeso.

[18.5,25]richiede 9 byte, che è molto. Quello che facciamo invece è moltiplicare il BMI per 2 e confrontare il risultato con [37, 50]o '%2'in ASCII. Ciò consente di risparmiare tre byte.

Perl 6 , 59 byte

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

Come funziona

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

Peccato che la stringa erweightdebba essere ripetuta, ma tutte le variazioni che ho provato per evitare che finissero per aumentare il conteggio complessivo dei byte:

• Con sostituzione stringa, 62 byte:

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

• Con interpolazione di stringhe, 67 byte:

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

• Traduzione approssimativa della soluzione Python di 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]

Provalo online!

Spiegazione

Il bit principale che deve essere spiegato è 18.5,25 -lt $b(dove sto sostituendo $bl'IMC che viene calcolato sul posto nel codice). La maggior parte degli operatori in PowerShell, quando viene fornita una matrice sul lato sinistro, restituisce una matrice di elementi che soddisfano il test, invece di restituire un valore booleano. Quindi questo restituirà un array vuoto se $bè inferiore a 18,5, un array contenente solo 18,5 se è nel mezzo e un array contenente sia 18,5 che 25 se è maggiore di 25.

Uso il conteggio degli elementi come indice in un array di stringhe, quindi count 0ottiene element 0che è 'Underweight', ecc.

OCaml, 93 byte

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 byte

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

Provalo online!

Soluzione abbastanza semplice che sfrutta le tecniche altrui per risolverlo.

Grazie @ovs per aver salvato un byte.

alternative

1. 73 byte

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

Ho rifiutato questo perché era troppo simile a un'altra risposta che ho visto.

2. 71 byte

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

Ho rifiutato questo perché, nonostante abbia lavorato su tutti i test nella domanda, ci sono alcuni numeri su cui può fallire perché manca =il <=.

C #, 63 62 61 byte

Salvato 1 byte in più grazie a TheLethalCoder .

Salvato 1 byte grazie all'utente anonimo.

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

Una funzione anonima piuttosto semplice. L'intero trucco sta usando l'operatore ternario per tornare direttamente (omettendo così la returnparola chiave, una coppia di parentesi graffe e una dichiarazione e assegnazione variabili).

Programma completo con casi di test:

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 comune, 89 87 85 84 83 byte

Una funzione:

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

Esempio di utilizzo:

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

Provalo online! (Ho aggiunto la funzione di stampa per vedere l'output in TIO)

Le idee per il miglioramento sono le benvenute.

MATL, 54 45 44 42 byte

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

Provalo su matl.suever.net

Inizia calcolando l'IMC e raddoppiandolo U\E, quindi crea il vettore [37 50]con la stringa letterale '% 2'. Confronta l'IMC con questo vettore e utilizza le istruzioni if ​​per ottenere la risposta, sfruttandole normalcome valore letterale predefinito 17Y0.

Java 8, 61 byte

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

Assegnare a DoubleFunction<DoubleFunction<String>>e chiamare così:

bmi.apply(50).apply(1.5)

dc , 64 byte

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

Provalo online!

Javascript (ES6), 63 byte

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

Esempio

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

Rapido, 97 byte

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

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

Provalo online!

Ispirato da @ Luke's risposta di .

Spiegazione

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

Si decomprime a:

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

Japt ha un input implicito U . Il secondo input è V.

Japt usa il libreria shoco per la compressione delle stringhe. I backtick sono usati per decomprimere le stringhe.

Scorciatoie Unicode utilizzate:

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

PHP , 121 byte

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

Provalo online!

Scala, 124 byte

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 byte

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