Quel est mon indice de masse corporelle?

21

Problème:

Votre tâche consiste à écrire un programme qui prend en entrée une hauteur (en mètres) et un poids (en kilogrammes), et sort la catégorie d'IMC correspondante.

L'IMC est une mesure du rapport de votre poids à votre taille. C'est daté et inexact pour beaucoup de gens , mais ça n'a pas d'importance ici!

L'IMC peut être calculé à l'aide de l'équation suivante:

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

Les catégories seront définies comme suit:

  • IMC <18,5: «insuffisance pondérale»

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

  • 25 <= IMC: "Surpoids"

Pour relever le défi, j'ignore toutes les catégories «extrêmes». De plus, comme certains nombres comme "25" se situent entre 2 catégories, j'ai légèrement ajusté les limites pour qu'il y ait une réponse définitive.

Vous pouvez écrire soit une fonction, soit un programme complet.

Contribution:

L'entrée peut être sous n'importe quelle forme raisonnable. Deux nombres (ou chaînes), soit sous forme de 2 arguments séparés, soit sous forme de chaîne unique. Un tableau / liste de 2 nombres, un dictionnaire avec les touches "poids" et "hauteur" ... Les valeurs décimales doivent être prises en charge. Vous pouvez supposer que l'entrée sera toujours valide (pas de valeurs négatives et la hauteur ne sera jamais 0).

Sortie:

La sortie sera une chaîne contenant les noms de catégorie insensibles à la casse . Les chaînes doivent correspondre exactement aux noms de catégorie ci-dessus, en ignorant la casse. Il peut être sorti sur la sortie standard, retourné (dans le cas d'une fonction) ou écrit dans un fichier.

Cas de test (poids, taille => résultat):

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)

Voici un pseudocode qui montre un exemple d'implémentation:

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"

Il s'agit de code-golf, donc le plus petit nombre d'octets gagne.

(Oui, cette tâche est extrêmement triviale dans la plupart des langues. La plupart des défis semblent être plus difficiles ces derniers temps que la normale, j'ai donc pensé en publier une plus accessible).


REMARQUE! Une heure après avoir posté ce défi, j'ai dû modifier légèrement les gammes car les gammes comme indiqué avaient des "trous" comme indiqué dans les commentaires. Veuillez voir les nouvelles gammes.

Carcigenicate
la source

Réponses:

9

Gelée , 24 octets

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

Essayez-le en ligne!

Comment?

Calcule l'IMC, le double, compare celui avec l'opérateur supérieur à avec chacun des nombres 37 et 50 (18,5 et 25 doublé), additionne les uns et les zéros résultants (donnant 1, 2 ou 0 pour Normal, Insuffisance pondérale et Surpoids respectivement) et indexe dans la liste des chaînes ["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
la source
1
Sensationnel. Parlez d'obscurcissement. Si c'est du golf, je pense que vous avez un trou en un! Ou 24 ...
Cullub
2
@cullub c'est 24 caractères et 24 octets - Jelly utilise sa propre page de code liée par le mot "octets" dans l'en-tête, mothereff.in compte Unicode je crois.
Jonathan Allan
1
@TheBitByte, oui, jetez un œil au compteur de liens TIO "24 caractères, 24 octets (SBCS)" ou comptez-le à la main en utilisant la page de codes liée aux octets dans l'en-tête.
Jonathan Allan
... comme hex: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 octets

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

Essayez-le en ligne!

Comparé à 72 octets:

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

TI-Basic, 58 54 octets

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

Aussi, pour le plaisir, voici une version plus compacte qui est plus d'octets:

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

Tout ce que je peux dire, c'est merci d'avoir rendu ce cas insensible;)

PS Inputprend l'entrée du graphique dans Xet Ysimilaire àPrompt X,Y

Timtech
la source
De plus, j'ai regardé cela plusieurs fois, et je ne pense pas qu'il y ait moyen d'économiser des octets même si les deux derniers partagent la chaîneERWEIGHT
Timtech
Par curiosité, comment cela aurait-il changé votre réponse si j'avais appliqué la sensibilité à la casse?
Carcigenicate
1
@Carcigenicate Dans TI-Basic, les lettres minuscules ont chacune deux octets. Ainsi, cela aurait considérablement augmenté le nombre d'octets.
Timtech
1
Ah, je vois. C'est étrange.
Carcigenicate
1
@Carcigenicate Il est important de se rappeler que cette version de TI-Basic a été introduite en 1990 comme langage de calculatrice ... personne ne savait que je
jouerais au
6

Mathematica, 67 octets

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

Utilise le fait que a[b,c][[Sign@d]]renvoie asi dest égal à 0, renvoie bsi dest positif et renvoie csi dest négatif. ⌊...⌋est la Floorfonction de Mathematica utilisant les caractères à trois octets U + 230A et U + 230B. Impossible de comprendre comment faire mieux que d'utiliser weightdeux fois.

Greg Martin
la source
3
Surpris Mathematica n'a pas de fonction intégrée pour cela
Daniel
1
il faut aller à la fan fiction pour ça;)
Greg Martin
5

Rubis, 91 77 74 67 octets

Premier essai naïf:

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

Deuxième essai avec «inspiration» des réponses précédentes:

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

Troisième essai:

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

Quatrième essai:

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

Essayez-le en ligne!

reitermarkus
la source
reitermarkus de homebrew-cask?! Woah, ne m'attendais pas à te voir ici! : o
numbermaniac
1
@numbermaniac, haha, oui, c'est moi! 😂
reitermarkus
5

JavaScript (ES6), 70 67 64 63 octets

Enregistré 4B grâce à 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)

Sortie

"Overweight"

Explication

Cette réponse est assez banale, bien qu'il existe une astuce astucieuse: UnderweightetOverweight deux se terminent erweight, nous n'avons donc qu'à changer ces caractères.

J'ai supposé que cela Normalsignifie un IMC compris entre 25 (exclusif) et 18,5 (inclus). Underweightsignifie un IMC inférieur à 18,5 et Overweightun IMC supérieur ou égal à 25.

Luc
la source
1
Maintenant, la réponse ne contient aucune fonctionnalité ES7 ;-)
ETHproductions
4

C, 81 octets

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

05AB1E , 28 octets

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Adnan
la source
4

QBIC , 61 58 octets

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

@Luke a utilisé la Force et a coupé deux octets. Merci!

Le changement de règles a sauvé un autre octet.

Explication:

::          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
la source
3

Python 2 , 72 octets

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

Essayez-le en ligne!

DJMcMayhem
la source
Comment obtenez-vous les couleurs pour Python? Je ne l'ai jamais compris.
@JackBates C'est juste <!-- language-all: lang-python -->ce que TIO a inséré automatiquement pour moi.
DJMcMayhem
3

Python 3, 97 95 octets

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

Programme complet.

Multipliez par cinq pour enregistrer un octet. Merci Jonathan Allan.

Ligne par ligne:

  1. Mappez les deux numéros d'entrée utilisateur séparés par des espaces en pouces. Déballez vers a et b.

  2. Calculer

  3. Si le bmi est compris entre 18,6 et 25 inclus, l'expression de droite sera évaluée à True. Les booléens peuvent être 0 ou 1 lorsqu'ils sont utilisés comme index de liste, nous obtenons donc "Normal" ou la chaîne construite dans l'index zéro. "erweight" est un suffixe partagé pour les deux options restantes, il n'a donc pas besoin d'être répété. Ensuite, nous utilisons le modèle [start: stop: step] de découpage de liste / chaîne Python. c> 18,6 sera évalué à 0 ou 1 (Faux ou Vrai) et devient notre point de départ. L'arrêt n'est pas indiqué, nous allons donc à la fin du littéral. L'étape est 2 donc nous prenons chaque index sur deux. Si start start est évalué à 1, nous obtenons "Ov", sinon nous obtenons "Und". Quoi qu'il en soit, nous ajoutons "erweight" à ce que nous avons obtenu et nous avons notre sortie finale.

mypetlion
la source
1
Écrivez-le en fonction de 79:def f(h,w):c=h/w/w;print(["UOnvd"[c>18.6::2]+"erweight","Normal"][18.6<=c<=25])
Jonathan Allan
Si vous multipliez par cinq en premier, vous pouvez enregistrer un octet en comparant à 93et 125. Si vous utilisez un lambda, vous devez calculer caux deux endroits mais n'avez pas besoin de nommer la fonction ou d'utiliser print(), donc vous pouvez le faire lambda h,w:["UOnvd"[h/w/w*5>93::2]+"erweight","Normal"][93<=h/w/w*5<=125]pour 73.
Jonathan Allan
... en fait, parce que vous calculez cdeux fois la multiplication par 5 coûte plus cher que ce qu'il économise dans le lambda, donc juste lambda h,w:["UOnvd"[h/w/w>18.6::2]+"erweight","Normal"][18.6<=h/w/w<=25]pour 72
Jonathan Allan
Jonathan Allan Quelqu'un l'a déjà fait comme simple fonction.
mypetlion
Ce n'est pas grave, votre chemin les surpassera: D
Jonathan Allan
3

R, 89 84 80 74 octets

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

Avec un clin d'œil à la réponse Octave de StewieGriffin, crée un tableau de chaînes, puis additionne le résultat BMI < c(18.5,25)et référence le tableau à cette position + 1.

Le premier argument doit être la taille, puis le poids; si ce n'est pas permis, alors

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

fonctionne pour 4 octets de plus.

BLT
la source
2

Clojure, 63 octets

#(condp <(/ %(* %2 %2))25"Overweight"18.5"Normal""Underweight")
NikoNyrh
la source
Zut. Comme toujours, c'est une version plus courte de ce à quoi je pensais.
Carcigenicate
2

dc , 58 octets

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

Prend l'entrée sous forme de 2 nombres séparés par des espaces dans le format <mass> <height>. Génère une chaîne sur une ligne distincte.

Essayez-le en ligne!

Explication

Aux fins de cette explication, l'entrée est 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
la source
2

Octave, 64 octets

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

Essayez-le en ligne

Il s'agit d'une fonction anonyme qui prend deux arguments d'entrée, h(hauteur) et w(poids).

La fonction crée un tableau de cellules contenant ses chaînes 'Underweight','Normal','Overweight'et affiche le numéro de chaîne3-sum(2*w/h^2<'%2') .

Oui, celui-là a l'air un peu étrange. Nous voulons la première chaîne if w/h^2<=18.5, la deuxième chaîne if (w/h^2 > 18.5) & (w/h^2 < 25)et la troisième chaîne si aucune des conditions ci-dessus n'est vraie. Au lieu de créer un tas de comparaisons, nous pourrions simplement comparer la chaîne à:, w/h^2 < [18.5, 25]qui retournerait l'un des tableaux suivants[1 1], [0 1], [0,0] pour Underweight, Normal et Overweight respectivement.

[18.5,25]prend 9 octets, ce qui est beaucoup. À la place, nous multiplions l'IMC par 2 et comparons le résultat avec [37, 50]ou '%2'en ASCII. Cela économise trois octets.

Stewie Griffin
la source
2

Perl 6 , 59 octets

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

Comment ça marche

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

Dommage que la chaîne erweightdoive être répétée, mais toutes les variations que j'ai essayées afin d'éviter cela ont fini par augmenter le nombre d'octets global:

  • Avec substitution de chaîne, 62 octets:

    {<Ov_ Normal Und_>[sum 18.5,25 X>$^a/$^b**2].&{S/_/erweight/}}
  • Avec interpolation de chaîne, 67 octets:

    {$_='erweight';("Ov$_","Normal","Und$_")[sum 18.5,25 X>$^a/$^b**2]}
  • Traduction approximative de la solution Python de xnor , 65 octets:

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

PowerShell , 81 octets

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

Essayez-le en ligne!

Explication

Le bit principal qui doit être expliqué est 18.5,25 -lt $b(où je remplace $bl'IMC qui est calculé en place dans le code). La plupart des opérateurs dans PowerShell, lorsqu'ils reçoivent un tableau sur le côté gauche, retournent un tableau d'éléments qui satisfont le test, au lieu de renvoyer une valeur booléenne. Donc, cela retournera un tableau vide si$b est inférieur à 18,5, un tableau contenant seulement 18,5 s'il se trouve au milieu et un tableau contenant à la fois 18,5 et 25 s'il est supérieur à 25.

J'utilise le nombre d'éléments comme index dans un tableau de chaînes, donc nombre 0obtient l'élément 0qui est 'Underweight', etc.

briantiste
la source
2

OCaml, 93 octets

let b w h=if w/.h/.h<18.5 then"underweight"else if w/.h/.h>=25.0 then"overweight"else"normal"
reitermarkus
la source
Non, c'est une fonction.
reitermarkus
2

Python, 75 74 octets

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

Essayez-le en ligne!

Solution assez basique qui tire parti des techniques des autres pour la résoudre.

Merci @ovs d'avoir enregistré un octet.

Alternatives

1. 73 octets

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

J'ai rejeté cela car c'était trop similaire à une autre réponse que j'ai vue.

2. 71 octets

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

J'ai rejeté cela parce que, malgré tous les tests de la question, il peut y avoir des chiffres sur lesquels il peut échouer car il manque le =dans le <=.


la source
Vous n'avez pas besoin d'espace entre 25et else- mais de toute façon, l'utilisation du court-circuit and/or(comme l'a commenté @ovs) est plus courte.
FlipTack
@FlipTack: concernant l'espace entre 25 et else, vous avez certainement faire besoin avec certains ( la plupart?) Des interprètes (y compris CPython, IIRC). Si vous l'écrivez en tant que 25else, le 25eest interprété comme le début d'un littéral numérique de notation scientifique, et l'interprète recule alors lorsqu'il n'y a pas de chiffres suivants.
Mac
2

C #, 63 62 61 octets

Enregistré 1 octet de plus grâce à TheLethalCoder .

Enregistré 1 octet grâce à un utilisateur anonyme.

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

Une fonction anonyme assez simple. L'astuce consiste à utiliser l'opérateur ternaire pour retourner directement (omettant ainsireturn mot clé, une paire d'accolades et une déclaration et une affectation de variable).

Programme complet avec cas de 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"
    }
}
adrianmp
la source
2

Lisp commun, 89 87 85 84 83 octets

Une fonction:

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

Exemple d'utilisation:

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

Essayez-le en ligne! (J'ai ajouté la fonction d'impression pour voir la sortie dans TIO)

Les idées d'amélioration sont les bienvenues.


la source
2

MATL, 54 45 44 42 octets

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

Essayez-le sur matl.suever.net

Commence par calculer l'IMC et le doubler U\E, puis crée le vecteur [37 50]avec la chaîne littérale «% 2». Compare l'IMC à ce vecteur et utilise les instructions if pour obtenir la réponse, en tirant parti d' normalun littéral prédéfini 17Y0.

B. Mehta
la source
Vous pouvez remplacer [BC]UQavec '%2'et enregistrer 2 octets.
sundar
1

Java 8, 61 octets

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

Attribuez à a DoubleFunction<DoubleFunction<String>>et appelez ainsi:

bmi.apply(50).apply(1.5)
David Conrad
la source
Vous pouvez épargner un octet en réutilisant 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 finalImpossible d'assigner à W.
David Conrad
1
Oh ... j'ai vérifié avec des trucs en ligne comme int w = ... , h = ... ; System.out.println((w/=h*h)<18.5?"Underweight":w<25?"Normal":"Overweight"), désolé :)
Olivier Grégoire
@ OlivierGrégoire Aucun problème. Je souhaite que Java l'autorise.
David Conrad
1

dc , 64 octets

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

Essayez-le en ligne!

Mitchell Spector
la source
Dang it! Me battre juste de quelques secondes. J'étais sur le point de poster le mien, jusqu'à ce que je voie cela. Quoi qu'il en soit, voici une autre réponse de 64 octets: 3k[Overweight]??2^/dsp[[Normal]][[Underweight]]sasb25>blp18.5>ap.
R. Kap
@ R.Kap Vous pouvez réellement obtenir le vôtre pour être un octet plus court que le mien en omettant l'un des points d'interrogation.
Mitchell Spector
Oh ouais, j'ai oublié que je pouvais faire ça. Vous pouvez le publier comme le vôtre si vous le souhaitez.
R. Kap
Non, ça va - allez-y et postez-le vous-même, c'est votre solution. (Vous pouvez me créditer un octet si vous le souhaitez.)
Mitchell Spector
Au fait, j'ai pu le réduire à 58 octets. :)
R. Kap
1

Javascript (ES6), 63 octets

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

Exemple

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

Jan
la source
1

Swift, 97 octets

{(w:Float,h)->String in return 18.5<=w/h/h&&w/h/h<25 ?"normal":"\(w/h/h>25 ?"ov":"und")erweight"}
reitermarkus
la source
1

Japt , 46 octets

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

Essayez-le en ligne!

Inspiré par @ Luke's réponse de .

Explication

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

Décompresse pour:

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

Japt a une entrée implicite U. La deuxième entrée estV .

Japt utilise la bibliothèque shoco pour la compression de chaînes. Les backticks sont utilisés pour décompresser les chaînes.

Raccourcis Unicode utilisés:

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

PHP , 121 octets

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

Essayez-le en ligne!

Tom291
la source
1

Scala, 124 octets

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
la source