Viết chương trình lấy hai số làm đầu vào. Cái đầu tiên là số thứ nguyên - 0 cho một dấu chấm, 1 cho một đường thẳng, 2 cho một vòng tròn, 3 cho một hình cầu. Số thứ hai là bán kính của đối tượng, hoặc, nếu đó là 1 chiều, chính số đó. Đầu ra 0 cho 0 kích thước. Đầu ra là chiều dài / diện tích / thể tích của đối tượng.

Nếu chúng ta gọi số đầu tiên n, số thứ hai rvà đầu ra x, chúng ta sẽ nhận được:

• cho n = 0, x = 1

• cho n = 1, x = 2 × r

• cho n = 2, x = r ² × π

• cho n = 3, x = ( ⁴ / ₃ ) × r ³ × π

• và v.v ... nếu bạn muốn, mặc dù.

Ghi chú:

• Các trường hợp khi một hoặc cả hai số âm hoặc khi số đầu tiên không toàn bộ, không cần phải được bảo hiểm.

• Chương trình không được đọc từ bất kỳ tập tin nào và đầu vào duy nhất là hai số đó.

• Đầu ra chỉ nên sử dụng các chữ số (ví dụ: "14 * pi") và phải chính xác đến ít nhất hai chữ số thập phân.

• Đối với n = 0, bạn có thể xuất 0 nếu nó làm cho mã ngắn hơn.

• Swag thêm cho một câu trả lời bao gồm cả "hình cầu" 4 chiều và nhiều chiều hơn!

• Đó là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Ví dụ:

 1 1 -> 2

 2 3 -> 28,27

 3 1 -> 4,19

 3 4,5 -> 381,70

 1 9.379 -> 18.758

 0 48 -> 1

Jelly , 13 byte + swag thêm

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

Hãy thử trực tuyến!

Hoạt động cho bất kỳ kích thước nào, miễn là giá trị cố định của π mang lại bởi ØP( 3.141592653589793) là đủ chính xác.

Làm sao?

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

Mathicala, 18 byte, lên tới ~ 168,15 nghìn tỷ

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

Chức năng ẩn danh. Lấy hai số làm đầu vào và trả về một số không chính xác làm đầu ra. Hoạt động với bất kỳ số lượng kích thước. Đầu ra 1.cho n = 0. Sử dụng công thức từ Khối lượng của một quả bóng n trên Wikipedia.

Giải trình

Chúng tôi đang cố gắng để tính π ^{n / 2} / Γ ( n / 2 + 1) · R ⁿ , hoặc N[Pi^(n/2)/Gamma[n/2 + 1] R^n]trong Mathematica. Trong trường hợp của chúng ta,# (số đầu tiên) là n và #2(số thứ hai) là R . Điều này để lại cho chúng tôi N[Pi^(#/2)/Gamma[#/2 + 1] #2^#] &, có thể được chơi golf như sau:

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

và do đó, chương trình ban đầu của chúng tôi.

JavaScript (ES6), 45 byte + swag thêm

Công thức đệ quy từ wikipedia , nên hoạt động với mọi số chiều

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

R, 75 40 38 byte (cộng thêm swag)

Chà, có vẻ như tôi có thể đánh golf nó xuống bằng cách cho vào và sử dụng chức năng gamma thay vì các hàm đệ quy.

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

Xác định một hàm ẩn danh để tính toán khối lượng của một nsiêu mặt phẳng bán kính r.

Vài ví dụ:

1 1 -> 2

0 48 -> 1

2 3 -> 28.27433

3 4,5 -> 381,7035

7 7 -> 3891048

100 3 -> 122051813

Giải pháp Swagless, 38 34 byte

Đối với một vài byte ít hơn, bạn có thể có một chức năng vô danh mà chỉ hoạt động cho kích thước từ 1 tới 3. Returns numeric(0)cho n=0, và NAcho n>3. ( numeric(0)là một vectơ số có độ dài 0; NAdành cho "không khả dụng".) Hiệu suất khác với giải pháp chung ở trên.

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

Haskell, 74 65 36 byte + swag thêm

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

Công thức đệ quy, hoạt động cho tất cả các kích thước có thể được trình bày chính xác dưới dạng số dấu phẩy động chính xác kép nhưng sẽ lặp vô hạn cho các kích thước không tách rời. Phiên bản cũ vì lợi ích của hậu thế:

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

Hoạt động cho tất cả các kích thước. Sử dụng công thức từ bản tuyên ngôn tau . product[n,n-2..1.1]là một hack nhân đôi không được tính không chon==2

JavaScript, 61 51 49 43 byte

Kích thước 0-3 được hỗ trợ vì không có kích thước thứ 4 .

Cảm ơn @Hedi đã lưu 7 byte

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

Tạo chức năng d. Sau đó, đặt ra rcho các nthứ quyền lực và sau đó nhân lên nó với một số tùy thuộc vào nsử dụng ternary nhà khai thác. Đầu ra 1chon=0

Cung cấp đầu ra cho ít nhất 2 vị trí thập phân (10+ dp)

Đây là một đoạn ăn nhẹ!

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 byte

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

Điều này chỉ hoạt động tối đa 3 chiều. Các đầu vào theo thứ tự ngược lại, đó là : r, sau đón .

Hãy thử trực tuyến!

Hãy xem xét r=3, n=2như một ví dụ.

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 byte + swag thêm!

Chỉnh sửa: Đã lưu 2 byte nhờ @AlexRacer

Hàm dyadic - đối số thứ nhất là số thứ nguyên, thứ hai là bán kính của bóng n.

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

Công thức đệ quy cho thể tích của một quả bóng _n : V _n = ^{(2πr 2 V _n-2 )} / _n

Ái chà! Java (ngôn ngữ thử nghiệm của tôi) đánh bại Scala ở đây, nhờ ?:cú pháp tạm thời ngắn gọn ! Hàm này đúng về mặt cú pháp trong cả 4 ngôn ngữ trong tiêu đề và tôi đã thử nghiệm nó với C (MinGW GCC 5.4.0), & C # (VS Ultimate 2016, C # 6.0). Tôi giả sử rằng nó cũng sẽ hoạt động trong C ++. Vì hàm này độc lập với thư viện khá nhiều, nên nó hoạt động trong mọi ngôn ngữ giống như C với cú pháp tương tự.

Haskell, 52 byte cho tab thụt lề 42 byte + swag thêm

Chỉnh sửa: Đã lưu 10 byte nhờ @WChargin

Hàm curled dyadic - đối số đầu tiên là số thứ nguyên, thứ hai là bán kính của bóng n.

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

Công thức đệ quy cho khối lượng của một n-ball: V _n = ^{(2πr 2 V _n-2 )} / _n

Lưu tệp này dưới dạng tệp tập lệnh riêng biệt và chạy với GHCi, với chức năng kiểm tra v đầu ra, ví dụ : show (v 3 4.5). Tôi đã không kiểm tra điều này, xin vui lòng cho tôi biết nếu điều này không hoạt động.

Chương trình cũ với xấp xỉ 6,2832 cho 2π được thay thế (50 byte với thụt tab):

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

Điều này có thể được sử dụng với GHCi ở chế độ đa dòng (sử dụng :set +mhoặc kèm theo mã giữa :{&:} , các vỏ được đặt trên các dòng riêng của chúng. Yêu cầu chức năng của người kiểm tra.

Gõ tĩnh với suy luận kiểu chương trình đầy đủ xuất hiện ở đây, cho phép Haskell làm tốt hơn Scala và tiếp cận Groovy, nhưng không hoàn toàn đánh bại nó nhờ vào khớp mẫu thay vì một câu ba, liên quan đến sự lặp lại của một số ký tự.

Vợt 69 byte (cộng thêm swag)

Sử dụng công thức đệ quy từ https://en.wikipedia.org/w/index.php?title=Volume_of_an_n-ball§ion=3#Recacht

Bao gồm các đề xuất của @wchargein

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

Ungolfed (v = âm lượng, d = kích thước, r = bán kính):

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

Kiểm tra:

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

Đầu ra:

2
28.274333882308138
4.1887902047863905
381.7035074111599
18.758
1

Perl, 63 byte + swag thêm

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

Chấp nhận hai số nguyên n và r, mỗi lần một, sau đó xuất ra thể tích n cho bán kính r cho trước của một hình cầu n. Khi n = 0, V = 1 và khi n = 1, V = 2r. Tất cả các kích thước khác được tính theo công thức sau:

Kể từ khi r ⁿ là hệ số bán kính trong mọi công thức, tôi bỏ nó ra khỏi phép tính cơ bản và chỉ áp dụng nó ở cuối.

2π được tính gần đúng trong mã bằng 6.283.

Scala, 53 byte

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

Xin lỗi, không có thêm swag cho tôi :(

Giải trình:

{                     //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 byte, không có swag

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

Trăn 3, 76 72 68 byte + swag thêm!

Giải pháp đệ quy có thêm swag!
Trả lại 0chon=0

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

Cách tiếp cận cũ ( 1cho 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)

Công thức đệ quy từ Wikipedia .

Hãy thử trực tuyến.

Python 3, 56 byte + swag thêm!

Đơn giản với thêm swag!

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

Công thức chuẩn.

Dùng thử trực tuyến

Scala, 81 79 byte + swag thêm!

Chỉnh sửa: Đã lưu 2 byte nhờ @AlexRacer

Hàm dyadic - đối số thứ nhất là số thứ nguyên, thứ hai là bán kính của bóng 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

Công thức đệ quy cho khối lượng của một n-ball: V _n = ^{(2πr 2 V _n-2 )} / _n

Scala thiếu suy luận kiểu cho các kiểu trả về của hàm đệ quy và tham số hàm và cú pháp ternary dài dòng gây tổn thương khá nhiều ở đây :(

Groovy, 49 47 byte + swag thêm!

Chỉnh sửa: Đã lưu 2 byte nhờ @AlexRacer

Hàm dyadic - đối số thứ nhất là số thứ nguyên, thứ hai là bán kính của bóng n.

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

Công thức đệ quy cho khối lượng của một n-ball: V _n = ^{(2πr 2 V _n-2 )} / _n

Đánh máy động FTW!

Các câu trả lời Scala và Java của tôi sử dụng cùng một logic, nhưng với kiểu gõ tĩnh nên số byte cao hơn do chú thích kiểu :(. Tuy nhiên, Scala và Groovy cho phép tôi bỏ qua returndấu chấm phẩy và dấu chấm phẩy, để giúp đếm byte, không giống như Java / C ...

Tiếng Litva , 96 ký tự + thêm swag

Dòng chia làm 2 để dễ đọc:

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

Suy nghĩ tôi cần nâng cấp trình phân tích cú pháp của mình để yêu cầu ít không gian hơn. Kích thước mã sẽ được cắt giảm độc đáo, đặc biệt là trong đó((/ (* (* (* (* phần .

Sử dụng:

% 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

Cảm ơn Rudolf vì đã cạo một vài byte.

CJam (27 byte có thêm tín dụng)

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

Bộ kiểm tra trực tuyến . Đây là một khối ẩn danh (hàm) có các đối sốd r trên ngăn xếp và để lại kết quả trên ngăn xếp.

Mổ xẻ

Công thức n chiều chung có thể được viết lại thành

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