编写一个以两个数字为输入的程序。第一个是尺寸数-0代表点，1代表直线，2代表圆，3代表球体。第二个数字是对象的半径，如果是一维，则是数字本身。输出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.。使用维基百科上n球体积的公式。

说明

我们试图计算π ^{ñ / 2} / Γ（Ñ / 2 + 1）· [R ^Ñ，或N[Pi^(n/2)/Gamma[n/2 + 1] R^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 *)

因此，我们的原始程序。

JavaScript（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字节（加上额外的赃物）

好吧，看起来我可以通过放弃并使用gamma函数而不是递归函数来解决这个问题。

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宣言中的公式。 product[n,n-2..1.1]是一种双重析因骇客，对于n==2

JavaScript，61 51 49 43字节

支持0-3尺寸，因为没有第4尺寸。

感谢@Hedi节省了7个字节

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 _Ñ = ^{（2πR 2 V _N-2 ）} / _Ñ

哇！由于简洁的?:三元语法，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 _Ñ = ^{（2πR 2 V _N-2 ）} / _Ñ

将此另存为单独的脚本文件，并与GHCi一起运行，并带有用于测试v输出的功能，例如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

可以在多行模式下:set +m将其与GHCi一起使用（在:{＆之间使用代码或将代码括起来:}，外壳在自己的行上。需要测试仪功能。

具有全程序类型推断功能的静态类型在这里发挥了作用，它使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

Perl，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。

Scala，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
}

JavaScript（ES6），39个字节，无赃物

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

Python 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的递归公式。

在线尝试。

Python 3，56个字节+额外赃物！

直截了当加上额外的赃物！

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

标准公式。

在线尝试

Scala，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 _Ñ = ^{（2πR 2 V _N-2 ）} / _Ñ

Scala缺乏对递归函数和函数参数的返回类型以及冗长的三进制语法的类型推断，这在这里很痛苦：(

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 _Ñ = ^{（2πR 2 V _N-2 ）} / _Ñ

动态打字FTW！

我Scala和Java的答案，使用相同的逻辑，但静态类型如此高字节计数由于类型标注:(。然而，Scala和Groovy的让我省略return和分号，这样有利于字节数，不同的Java / C ...

Lithp，96个字符+额外赃物

为了便于阅读，将行分成两部分：

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