두 숫자를 입력으로하는 프로그램을 작성하십시오. 첫 번째는 치수의 수입니다-점의 경우 0, 직선의 경우 1, 원의 경우 2, 구의 경우 3입니다. 두 번째 숫자는 개체의 반경이거나 1 차원 인 경우 숫자 자체입니다. 0 치수의 경우 0을 출력합니다. 출력은 객체의 길이 / 영역 / 볼륨입니다.

첫 번째 숫자 n, 두 번째 숫자 r및 출력 을 호출하면 다음 x을 얻습니다.

• n = 0 인 경우 x = 1

• n = 1 인 경우 x = 2 × r

• n = 2 인 경우 x = r ² × π

• N = 3, X = ( ⁴ / ₃ ) × (R) ³ × π

• 그래도 ... 원한다면.

노트:

• 하나 또는 두 개의 숫자가 모두 음수이거나 첫 번째 숫자가 전체가 아닌 경우에는 포함하지 않아도됩니다.

• 프로그램은 파일을 읽지 말아야하며 유일한 입력은이 두 숫자입니다.

• 출력은 숫자 만 사용해야합니다 (예 : "14 * pi"아님). 소수점 이하 두 자리까지 정확해야합니다.

• n = 0의 경우 코드가 더 짧아지면 0을 출력 할 수 있습니다.

• 4 차원 및보다 "차원적인"영역을 포함하는 해답을위한 추가 스왑!

• 그것은의 코드 골프 바이트 승리의 짧은 대답은 이렇게!

예 :

 1 1 -> 2

 2 3 -> 28,27

 3 1 -> 4,19

 3 4,5 -> 381,70

 1 9.379 -> 18.758

 0 48 -> 1

젤리 , 13 바이트 + 추가 스왑

÷2µØP*÷!
ç×*@

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

ØP( 3.141592653589793)로 산출 된 π의 고정 값이 충분히 정확한 한 모든 치수에서 작동합니다 .

어떻게?

÷2µØP*÷! - Link 1: n, r
÷2       - n / 2
  µ      - monadic chain separation
   ØP    - π (3.141592653589793)
     *   - exponentiate: π^(n/2)
       ! - Pi(n/2): Gamma(n/2 + 1)
      ÷  - divide: π^(n/2) / Gamma(n/2 + 1)

ç×*@     - Main link: n, r
ç        - call last link (1) as a dyad: π^(n/2) / Gamma(n/2 + 1)
  *@     - exponentiate with reversed @rguments: r^n
 ×       - multiply: r^n * π^(n/2) / Gamma(n/2 + 1)

Mathematica, 18 바이트, 최대 ~ 168.15 조 치수

Pi^(a=.5#)/a!#2^#&

익명의 기능. 두 숫자를 입력으로 취하고 부정확 한 숫자를 출력으로 리턴합니다. 여러 치수에서 작동합니다. n = 0에 1.대한 출력 . Wikipedia 에서 n- 볼의 체적 공식을 사용합니다 .

설명

우리는 π ^{n / 2} / Γ ( n / 2 + 1) · R ⁿ 을 계산하거나 N[Pi^(n/2)/Gamma[n/2 + 1] R^n]Mathematica에서 계산하려고합니다 . 이 경우 #(첫 번째 인수)는 n 이고 #2(두 번째 인수)는 R 입니다. 이렇게 N[Pi^(#/2)/Gamma[#/2 + 1] #2^#] &하면 다음과 같이 골프를 칠 수 있습니다.

N[Pi^(#/2)/Gamma[#/2 + 1] #2^#] &
Pi^(.5#)/Gamma[.5# + 1] #2^# &    (* replace exact with approximate numbers*)
Pi^(.5#)/(.5#)! #2^# &            (* n! == Gamma[n + 1] *)
Pi^(a=.5#)/a! #2^# &              (* replace repeated .5# *)
Pi^(a=.5#)/a!#2^#&                (* remove whitespace *)

따라서 우리의 원래 프로그램.

자바 스크립트 (ES6), 45 바이트 + 추가 스왑

Wikipedia의 재귀 수식은 모든 차원에서 작동해야합니다.

f=(n,r)=>n<2?n?2*r:1:f(n-2,r)*2*Math.PI*r*r/n

R, 75 40 38 바이트 (추가 스왑)

글쎄, 재귀 함수가 아니라 감마 함수를주고 사용함으로써 이것을 골라 내지 못하는 것처럼 보인다.

function(n,r)pi^(n/2)/gamma(n/2+1)*r^n

n반지름 의 차원 초 구면의 부피를 계산하는 익명 함수를 정의합니다 r.

몇 가지 예 :

1 1-> 2

0 48-> 1

2 3-> 28.27433

3 4.5-> 381.7035

7 7-> 3891048

100 3-> 122051813

스왑리스 솔루션, 38 34 바이트

적은 몇 바이트의 경우에만 치수 1 ~ 3로 돌아갑니다 작동하는 익명 함수를 가질 수 numeric(0)에 대한 n=0, 그리고 NA대한을 n>3. ( numeric(0)길이가 0 인 숫자 형 벡터입니다. NA"사용할 수 없음"입니다.) 성능은 위의 일반 솔루션과 동일합니다.

function(n,r)c(1,pi,4/3*pi)[n]*r^n

Haskell, 74 65 36 바이트 + 추가 스왑

0%r=1
1%r=2*r
n%r=2*pi*r^2/n*(n-2)%r

재귀 수식은 배정 밀도 부동 소수점 숫자로 정확하게 표시 될 수 있지만 비 적분 치수에 대해서는 무한 반복됩니다. 구술을위한 구버전 :

n%r=(max 1$1-(-1)**n)*(2*pi)^(floor$n/2)*r**n/product[n,n-2..1.1]

모든 차원에서 작동합니다. tau manifesto 의 공식을 사용합니다 . product[n,n-2..1.1]A는 이중 계승 에 대해 0을 계산하지 않습니다 해킹n==2

자바 스크립트, 61 51 49 43 바이트

4 차원이 없으므로 0-3 차원이 지원됩니다 .

7 바이트를 절약 해 준 @Hedi에게 감사합니다

d=(n,r)=>r**n*(n<2?n+1:Math.PI*(n<3?1:4/3))

함수를 만듭니다 d. 이어서 제기 r받는 n승 다음에 따라 번호를 승산 n삼원 연산자를 사용. 에 1대한 출력n=0

소수점 2 자리 이상 (10 + dp)으로 출력합니다.

다음은 간식 스 니펫입니다.

var N = document.getElementById("n");
var R = document.getElementById("r");
N.value="3";//default
R.value="4.5";//default
d=(n,r)=>r**n*(n<2?n+1:Math.PI*(n<3?1:4/3));
var b = document.getElementById("b");
b.onclick = function() {
  var s = document.getElementById("s");
  var n = document.getElementById("n").value;
  var r = document.getElementById("r").value;
  s.textContent = d(parseFloat(n),parseFloat(r));
}

span {border:1px solid black;padding:10px;font-size:30px;}

Value of n: <input id="n" type="number"></input>
Value of r: <input id="r" type="number"></input><br>
<button id="b">Calculate!</button><br><br><br>
<span id="s">THERE IS NO 4TH DIMENSION</span>

MATL , 17 바이트

3:^[2P4*P/3]*1hi)

이것은 3 차원까지만 작동합니다. 입력은 역순입니다. 즉 r, n.

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

고려 r=3, n=2예를 들어.

3:         % Push array [1 2 3]
           % STACK: [1 2 3]
^          % Take r implicitly, and raise it to [1 2 3] element-wise
           % STACK: [3 9 27]
[2P4*P/3]  % Push array [2 pi 4*pi/3]
           % STACK: [3 9 27], [2 pi 4*pi/3]
*          % Multiply element-wise
           % STACK: [6 28.2743 113.0973]
1h         % Append 1
           % STACK: [6 28.2743 113.0973, 1]
i)         % Input n and use it as modular index into the array. Display implicitly
           % STACK: 28.2743

Java / C / C ++ / C #, 69 67 바이트 + 추가 스왑!

편집 : @AlexRacer 덕분에 2 바이트가 절약되었습니다.

이차원 함수-첫 번째 인수는 차원의 수이고, 두 번째는 n- 볼의 반지름입니다.

float v(int n,float r){return n<1?1:n<2?2*r:6.283f*r*r*v(n-2,r)/n;}

n- 볼의 부피에 대한 재귀 공식 : V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

우와! Java (내 테스트 언어)는 간결한 ?:삼항 구문 덕분에 Scala를 능가 합니다! 이 기능은 머리글의 4 개 언어 모두에서 구문 적으로 정확하며 C (MinGW GCC 5.4.0) 및 C # (VS Ultimate 2016, C # 6.0)으로 테스트했습니다. C ++에서도 작동한다고 가정합니다. 이 함수는 라이브러리와 거의 독립적이므로 유사한 구문을 가진 C와 같은 언어로 작동해야합니다.

Haskell, 52 바이트 탭 들여 쓰기 42 바이트 + 추가 스왑

편집 : @WChargin 덕분에 10 바이트를 절약했습니다.

이진 카레 함수-첫 번째 인수는 차원의 수이고, 두 번째는 n- 볼의 반지름입니다.

v 0 r=1
v 1 r=2*r
v n r=2*pi*r*r*v(n-2)r/n

n- 볼의 부피에 대한 재귀 공식 : V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

이 파일을 별도의 스크립트 파일로 저장 v하고 출력 테스트 기능 ( 예 :)으로 GHCi로 실행하십시오 show (v 3 4.5). 나는 이것을 테스트하지 않았다, 이것이 작동하지 않으면 알려주십시오.

2π에 대한 근사치가 6.2832 인 이전 프로그램이 대체 됨 (탭 들여 쓰기가있는 50 바이트) :

let v 0 r=1
    v 1 r=2*r
    v n r=2*pi*r*r*(v(n-2)r)/n

이것은 다중 라인 모드에서 GHCi와 함께 사용할 수 있습니다 ( 외함은 자체 라인에있는 & :set +m사이에 코드를 사용 하거나 묶음) . 테스터 기능이 필요합니다.:{:}

풀 프로그램 유형의 추론을 사용하는 정적 타이핑이 여기에서 시작되어 Haskell이 Scala보다 훨씬 뛰어나고 Groovy에 접근 할 수는 있지만 일부 문자 반복을 포함하여 삼항식 대신 패턴 일치로 인해 크게 치지 않습니다.

라켓 69 바이트 (추가 스왑)

https://en.wikipedia.org/w/index.php?title=Volume_of_an_n-ball§ion=3#Recursions의 재귀 수식을 사용합니다.

@wchargin의 제안 포함

(define(v d r)(match d[0 1][1(* 2 r)][_(/(* 2 pi r r(v(- d 2)r))d)]))

언 골프 (v = 볼륨, d = 치수, r = 반지름) :

(define(v d r)
  (match d
    [0 1]
    [1 (* 2 r)]
    [_ (/ (*  2   pi   r   r   (v (- d 2) r)  )
          d)]
    ))

테스트 :

(v 1 1)
(v 2 3)
(v 3 1)
(v 3 4.5)
(v 1 9.379)
(v 0 48)

산출:

2
28.274333882308138
4.1887902047863905
381.7035074111599
18.758
1

펄, 63 바이트 + 스왑

@a=1..2;push@a,6.283/$_*@a[$_-2]for 2..($b=<>);say$a[$b]*<>**$b

한 번에 하나씩 두 개의 정수 n과 r을 받아 들인 다음 n- 구의 주어진 반지름 r에 대해 n- 볼륨을 출력합니다. n = 0 일 때, V = 1이고, n = 1 일 때, V = 2r. 모든 추가 치수는 다음 공식으로 계산됩니다.

r ⁿ 은 모든 공식의 반지름 계수이므로 기본 계산에서 제외하고 끝에서만 적용합니다.

2π는 코드에서 6.283으로 근사됩니다.

스칼라, 53 바이트

{import math._;(n,r)=>pow(r,n)*Seq(1,2,Pi,Pi*4/3)(n)}

죄송합니다. 추가 정보가 없습니다 :(

설명:

{                     //define a block, the type of this is the type of the last expression, which is a function
  import math._;        //import everything from math, for pow and pi
  (n,r)=>               //define a function
    pow(r,n)*             //r to the nth power multiplied by
    Seq(1,2,Pi,Pi*4/3)(n) //the nth element of a sequence of 1, 2, Pi and Pi*4/3
}

자바 스크립트 (ES6), 39 바이트, 스왑 없음

(n,r)=>[1,r+r,a=Math.PI*r*r,a*r*4/3][n]

파이썬 3, 76 72 68 바이트 + 추가 스왑!

여분의 장식이있는 재귀 솔루션!
에 0대한 반품n=0

from math import*
f=lambda n,r:n*r*2*(n<2or pi*r/n/n*(f(n-2,r)or 1))

이전 접근 방식 (의 1경우 n=1) :

from math import*
f=lambda n,r:1*(n<1)or r*2*(n<2)or 2*pi*r*r/n*f(n-2,r)

Wikipedia의 재귀 공식 .

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

파이썬 3, 56 바이트 + 추가 스왑!

여분의 장식물로 간단합니다!

from math import*
lambda n,r:pi**(n/2)*r**n/gamma(n/2+1)

표준 공식.

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

스칼라, 81 79 바이트 + 추가 스왑!

편집 : @AlexRacer 덕분에 2 바이트가 절약되었습니다.

이차원 함수-첫 번째 인수는 차원의 수이고, 두 번째는 n- 볼의 반지름입니다.

def v(n:Int,r:Float):Float=if n<1 1 else if n<2 2*r else 6.2832f*r*r*v(n-2,r)/n

n- 볼의 부피에 대한 재귀 공식 : V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

재귀 함수 및 함수 매개 변수 및 자세한 삼항 구문의 반환 유형에 대한 스칼라의 유추 부족은 여기에서 상당히 아 hurt니다.

Groovy, 49 47 바이트 + 추가 스왑!

편집 : @AlexRacer 덕분에 2 바이트가 절약되었습니다.

이차원 함수-첫 번째 인수는 차원의 수이고, 두 번째는 n- 볼의 반지름입니다.

def v(n,r){n<1?1:n<2?2*r:6.2832*r*r*v(n-2,r)/n}

n- 볼의 부피에 대한 재귀 공식 : V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

다이나믹 타이핑 FTW!

내 스칼라와 자바 답변은 동일한 논리를 사용하지만 정적 입력을 사용하면 유형 주석으로 인해 더 많은 바이트 수를 사용합니다. (. 그러나 스칼라와 그루비 return는 Java 및 C와 달리 바이트 수를 도와주는 세미콜론 을 생략 할 수 있습니다. ...

Lithp , 96 자 + 추가 장식

가독성을 위해 2로 줄 바꿈 :

#N,R::((if (< N 2) ((? (!= 0 N) (* 2 R) 1)) ((/ (* (* (* (* (f (- N 2) R) 2)
        3.1416) R) R) N))))

더 적은 공간이 필요하도록 파서를 업그레이드해야한다고 생각합니다. 코드 크기는 특히 해당 ((/ (* (* (* (*섹션 에서 잘립니다 .

용법:

% n-circle.lithp
(
    (def f #N,R::((if (< N 2) ((? (!= 0 N) (* 2 R) 1)) ((/ (* (* (* (* (f (- N 2) R) 2) 3.1416) R) R) N)))))
    (print (f 1 1))
    (print (f 2 3))
    (print (f 3 1))
    (print (f 3 4.5))
    (print (f 1 9.379))
    (print (f 0 48))
)

#./run.js n-circle.lithp
2
28.274333882308138
4.1887902047863905
381.7035074111598
18.758
1

몇 바이트를 줄인 Rudolf에게 감사드립니다.

CJam (추가 크레딧이있는 27 바이트)

{1$_[2dP]*<f*\,:)-2%./1+:*}

온라인 테스트 스위트 . 이것은 익명 블록 (함수)으로 d r스택 에서 인수를 취하고 결과를 스택에 남겨 둡니다.

해부

일반적인 n- 차원 공식은 다음과 같이 다시 쓸 수 있습니다.

{            e# Begin block: stack holds d r
  1$_[2dP]*< e#   Build a list which repeats [2 pi] d times and take the first d elements
  f*         e#   Multiply each element of the list by r
  \,:)-2%    e#   Build a list [1 ... d] and take every other element starting at the end
  ./         e#   Pointwise divide. The d/2 elements of the longer list are untouched
  1+:*       e#   Add 1 to ensure the list is non-empty and multiply its elements
}