문제:

당신의 임무는 높이 (미터)와 무게 (킬로그램)를 입력으로 받아 해당 BMI 범주를 출력하는 프로그램을 작성하는 것입니다.

BMI 는 체중과 키의 비율을 측정 한 것입니다. 그것은 많은 사람들에게 날짜가 있고 부정확 하지만, 여기서는 중요하지 않습니다!

BMI는 다음 방정식을 사용하여 계산할 수 있습니다.

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

범주는 다음과 같이 정의됩니다.

• BMI <18.5 : "언더 웨이트"

• 18.5 <= BMI <25 : "정상"

• 25 <= BMI : "과체중"

도전을 위해, 나는 모든 "극단적 인"카테고리를 무시하고 있습니다. 또한 "25"와 같은 숫자가 두 범주 사이에 있기 때문에 경계를 약간 조정하여 명확한 대답을 얻었습니다.

함수 또는 전체 프로그램을 작성할 수 있습니다.

입력:

입력은 합리적인 형태 일 수 있습니다. 두 개의 개별 인수 또는 단일 문자열로 된 두 개의 숫자 (또는 문자열). "무게"및 "높이"키가있는 사전 인 2 개의 숫자로 구성된 배열 / 목록 ... 10 진수 값이 지원되어야합니다. 입력이 항상 유효하다고 가정 할 수 있습니다 (음수 값이없고 높이가 0이 아님).

산출:

대소 문자를 구분하지 않는 범주 이름이 포함 된 문자열이 출력됩니다 . 문자열은 대소 문자를 무시하고 카테고리 이름과 정확히 일치해야합니다. stdout에 출력하거나, 함수의 경우 리턴하거나 파일에 쓸 수 있습니다.

테스트 사례 (무게, 높이 => 결과) :

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)

예제 구현을 보여주는 의사 코드는 다음과 같습니다.

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"

이것은 코드 골프이므로 가장 적은 수의 바이트가 이깁니다.

(예,이 작업은 대부분의 언어에서 매우 사소한 일입니다. 요즘 대부분의 문제는 평소보다 어렵 기 때문에 더 접근하기 쉬운 것으로 생각했습니다).

노트! 이 챌린지를 게시 한 지 1 시간 후에 언급 한 범위에 "구멍"이 있었기 때문에 범위를 약간 수정해야했습니다. 새로운 범위를 참조하십시오.

젤리 , 24 바이트

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

온라인으로 사용해보십시오!

방법?

BMI를 계산하고, 두 배로 늘리고, 각각의 숫자 37과 50 (18.5와 25가 두 배가 됨)을 가진보다 큰 연산자와 비교 한 결과 1과 0을 합산합니다 (정상, 저체중 및 과체중의 경우 1, 2 또는 0의 수율) ) 및 문자열 목록으로 색인합니다 ["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

파이썬 , 69 바이트

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

온라인으로 사용해보십시오!

72 바이트와 비교 :

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

TI 기본, 58 54 바이트

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

또한 재미를 위해 더 많은 바이트 인 더 컴팩트 한 버전이 있습니다.

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

내가 말할 수있는 것은이 대소 문자를 구분하지 주셔서 감사합니다.)

PS는 Input그래프에 입력 얻어 X과 Y유사한을Prompt X,Y

수학, 67 바이트

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

사실 사용 a[b,c][[Sign@d]]을 반환 a하는 경우는 d, 반환 0에 해당 b하는 경우 d긍정적이며, 반환 c하는 경우 d음을. 3 바이트 문자 U + 230A 및 U + 230B를 사용하는 ⌊...⌋Mathematica의 Floor함수입니다. weight두 번 사용하는 것보다 더 나은 방법을 찾지 못했습니다 .

루비, 91 77 74 67 바이트

첫 순진한 시도 :

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

두 번째 시도는 이전 답변의“영감”으로 시도하십시오.

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

세 번째 시도 :

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

네 번째 시도 :

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 70 67 64 63 바이트

Arnauld 덕분에 4B 절약

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

용법

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

산출

"Overweight"

설명

: 하나의 영리한 트릭이있다하지만이 대답은 매우 간단하다 Underweight및 Overweight모두 끝 erweight우리 만 문자를 변경해야하므로.

나는 Normal25 (독점)와 18.5 (포함) 사이의 BMI 를 의미 한다고 가정했습니다 . UnderweightBMI는 18.5 미만의 BMI를 의미하고, Overweight25 이상의 BMI를 의미한다.

C, 81 바이트

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

05AB1E , 28 바이트

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

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

QBIC , 61 58 바이트

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

@Luke는 Force를 사용하여 2 바이트를 잘라 냈습니다. 감사!

규칙 변경으로 다른 바이트가 저장되었습니다.

설명:

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

파이썬 2 , 72 바이트

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

온라인으로 사용해보십시오!

파이썬 3, 97 95 바이트

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

전체 프로그램.

바이트를 저장하려면 5를 곱하십시오. 조나단 앨런에게 감사합니다.

한 줄씩 :

1. 공백으로 구분 된 두 개의 사용자 입력 번호를 int에 맵핑하십시오. a와 b의 포장을 풉니 다.

2. 계산하다

3. bmi가 18.6에서 25 사이 인 경우 오른쪽의 표현식은 True로 평가됩니다. 부울은 목록 인덱스로 사용될 때 0 또는 1이 될 수 있으므로 "Normal"또는 0 인덱스에서 생성 된 문자열을 얻습니다. "erweight"는 나머지 두 옵션의 공유 접미사이므로 반복 할 필요가 없습니다. 그런 다음 Python 목록 / 문자열 슬라이싱의 [start : stop : step] 패턴을 사용합니다. c> 18.6은 0 또는 1 (False 또는 True)로 평가되어 시작이됩니다. 정지는 표시되지 않으므로 리터럴의 끝으로 이동합니다. 단계는 2이므로 매 초마다 인덱스를 가져옵니다. start start가 1로 평가되면 "Ov"가 표시되고 그렇지 않으면 "Und"가 표시됩니다. 어느 쪽이든, 우리는 우리가 얻은 것에 "무게"를 추가하고 최종 결과를 얻습니다.

R, 89 84 80 74 바이트

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

StewieGriffin의 Octave 답변에 끄덕 여서 문자열 배열을 만든 다음 그 결과 BMI < c(18.5,25)+ 1의 배열 을 합산하여 참조합니다.

첫 번째 논증은 키와 몸무게 여야합니다. 그것이 허용되지 않으면

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

4 바이트 더 작동합니다.

클로저, 63 바이트

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

dc , 58 바이트

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

형식에서 공백으로 구분 된 2 개의 숫자로 입력을 <mass> <height>받습니다. 별도의 줄에 문자열을 출력합니다.

온라인으로 사용해보십시오!

설명

이 설명의 목적으로 입력은 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.

옥타브, 64 바이트

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

온라인으로 사용해보십시오

이것은 h(높이)와 w(가중)의 두 가지 입력 인수를 취하는 익명 함수입니다 .

이 함수는 문자열을 포함하는 셀형 배열을 만들고 'Underweight','Normal','Overweight'문자열 번호를 출력합니다 3-sum(2*w/h^2<'%2').

네, 조금 이상해 보입니다. 위의 조건 중 하나라도 해당되지 않으면 첫 번째 문자열 if w/h^2<=18.5, 두 번째 문자열 if (w/h^2 > 18.5) & (w/h^2 < 25)및 세 번째 문자열을 원합니다 . 많은 비교를 생성하는 대신 단순히 문자열을 다음 w/h^2 < [18.5, 25]과 비교할 수 있습니다 . 다음 배열 중 하나를 반환합니다.[1 1], [0 1], [0,0] Underweight, Normal 및 Overweight 각각에 대해 합니다.

[18.5,25]9 바이트가 필요합니다. 대신 BMI에 2를 곱하고 결과를 [37, 50]이나 '%2'ASCII로 비교합니다 . 이렇게하면 3 바이트가 절약됩니다.

펄 6 , 59 바이트

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

작동 원리

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

문자열 erweight을 너무 나쁘게 반복해야하지만 전체 바이트 수를 늘리는 것을 피하기 위해 시도한 모든 변형이 있습니다.

• 문자열 대체, 62 바이트 :

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

• 문자열 보간으로 67 바이트 :

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

• xnor의 Python 솔루션의 대략적인 번역 , 65 바이트 :

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

PowerShell , 81 바이트

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

온라인으로 사용해보십시오!

설명

설명해야 할 주요 비트는 18.5,25 -lt $b( $b코드에서 계산되는 BMI를 대체 하는 곳)입니다. PowerShell의 대부분의 연산자는 왼쪽에 배열이 제공되면 부울 값을 반환하는 대신 테스트를 만족시키는 항목 배열을 반환합니다. 따라서 이것은 빈 배열을 반환합니다.$b 18.5보다 작은 , 중간에 있으면 18.5 만 포함하는 배열, 25보다 큰 경우 18.5와 25를 모두 포함하는 배열을 반환합니다.

카운트하므로 I는 문자열의 배열의 인덱스로서 요소 수를 이용 0소자 얻는다 0인 'Underweight'등

OCaml, 93 바이트

let b w h=if w/.h/.h<18.5 then"underweight"else if w/.h/.h>=25.0 then"overweight"else"normal"

파이썬, 75 74 바이트

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

온라인으로 사용해보십시오!

다른 사람들이 해결하는 기술을 활용하는 상당히 기본적인 솔루션입니다.

바이트를 저장해 준 @ovs에게 감사합니다.

대안

1. 73 바이트

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

내가 본 다른 답변과 너무 비슷하여 이것을 거부했습니다.

2. 71 바이트

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

질문의 모든 테스트를 수행했지만에에서 누락되어 실패 할 수있는 숫자가 있기 때문에 이것을 거부 =했습니다 <=.

C #, 63 62 61 바이트

TheLethalCoder 덕분에 1 바이트를 더 절약했습니다 .

익명 사용자 덕분에 1 바이트를 절약했습니다.

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

매우 간단한 익명 함수입니다. 전체 트릭은 삼항 연산자를 사용하여 직접 반환합니다 (따라서 return키워드, 중괄호 쌍 및 변수 선언 및 할당 생략 ).

테스트 케이스가 포함 된 전체 프로그램 :

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

공통 리스프, 89 87 85 84 83 바이트

기능 :

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

사용 예 :

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

온라인으로 사용해보십시오! (TIO에서 출력을 볼 수있는 인쇄 기능을 추가했습니다)

개선을위한 아이디어를 환영합니다.

MATL, 54 45 44 42 바이트

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

matl.suever.net에서 사용해보십시오

BMI를 계산하고 배가하여 U\E시작한 다음 [37 50]문자열 리터럴 '% 2'로 벡터를 만듭니다 . BMI를이 벡터와 비교하고 if 문을 사용 normal하여 미리 정의 된 리터럴로 활용하여 답을 얻습니다 17Y0.

자바 8, 61 바이트

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

에 할당하고 다음 DoubleFunction<DoubleFunction<String>>과 같이 호출 하십시오 .

bmi.apply(50).apply(1.5)

dc , 64 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 63 바이트

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

예

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

스위프트, 97 바이트

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

apt , 46 바이트

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

온라인으로 사용해보십시오!

@Luke의 답변에서 영감을 얻었습니다 .

설명

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

압축 해제 :

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

Japt에는 암시 적 입력이 U있습니다. 두 번째 입력은 V입니다.

Japt는 문자열 압축을 위해 shoco 라이브러리 를 사용합니다 . 백틱은 문자열을 압축 해제하는 데 사용됩니다.

사용되는 유니 코드 단축키 :

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

PHP , 121 바이트

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

온라인으로 사용해보십시오!

스칼라, 124 바이트

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 바이트

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