Tulis program yang menggunakan dua angka sebagai inputnya. Yang pertama adalah jumlah dimensi - 0 untuk titik, 1 untuk garis lurus, 2 untuk lingkaran, 3 untuk bola. Angka kedua adalah jari-jari objek, atau, jika itu 1-dimensi, bilangan itu sendiri. Output 0 untuk 0 dimensi. Outputnya adalah panjang / area / volume objek.

Jika kita memanggil nomor pertama n, yang kedua r, dan hasilnya x, kita dapat:

• untuk n = 0, x = 1

• untuk n = 1, x = 2 × r

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

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

• dan seterusnya ... jika Anda mau.

Catatan:

• Kasus-kasus ketika satu atau kedua angka negatif, atau ketika angka pertama tidak utuh, tidak perlu ditutupi.

• Program tidak boleh membaca dari file apa pun dan satu-satunya input adalah dua angka itu.

• Output harus menggunakan hanya angka (mis. Bukan "14 * pi"), dan harus akurat setidaknya dua digit desimal.

• Sedangkan untuk n = 0, Anda dapat menampilkan 0 jika membuat kode lebih pendek.

• Sombong ekstra untuk jawaban yang mencakup "bola" 4 dimensi dan lebih banyak lagi!

• Ini kode-golf , jadi jawaban tersingkat dalam byte menang!

Contoh:

 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 + tambahan barang curian

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

Cobalah online!

Berfungsi untuk dimensi apa pun, asalkan nilai tetap π yang dihasilkan oleh ØP( 3.141592653589793) cukup akurat.

Bagaimana?

÷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 byte, hingga ~ 168,15 triliun dimensi

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

Fungsi anonim. Mengambil dua angka sebagai input, dan mengembalikan nomor yang tidak eksak sebagai output. Bekerja dengan sejumlah dimensi. Output 1.untuk n = 0. Menggunakan rumus dari Volume n-ball di Wikipedia.

Penjelasan

Kami berusaha menghitung π ^{n / 2} / Γ ( n / 2 + 1) · R ⁿ , atau N[Pi^(n/2)/Gamma[n/2 + 1] R^n]dalam Mathematica. Dalam kasus kami, #(argumen pertama) adalah n dan #2(argumen kedua) adalah R . Ini yang membuat kita N[Pi^(#/2)/Gamma[#/2 + 1] #2^#] &, yang bisa bermain golf sebagai berikut:

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

dan dengan demikian, program asli kami.

JavaScript (ES6), 45 byte + curian ekstra

Formula rekursif dari wikipedia , harus bekerja untuk sejumlah dimensi

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

R, 75 40 38 byte (plus swag ekstra)

Yah, sepertinya saya bisa bermain golf ini dengan menyerah dan menggunakan fungsi gamma daripada fungsi rekursif.

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

Menentukan fungsi anonim untuk menghitung volume suatu njari-jari dimensi - dimensi r.

Beberapa contoh:

1 1 -> 2

0 48 -> 1

2 3 -> 28.27433

3 4.5 -> 381.7035

7 7 -> 3891048

100 3 -> 122051813

Solusi Swagless, 38 34 byte

Untuk beberapa byte lebih sedikit, Anda dapat memiliki fungsi anonim yang hanya berfungsi untuk dimensi 1 hingga 3. Pengembalian numeric(0)untuk n=0, dan NAuntuk n>3. ( numeric(0)adalah vektor numerik dengan panjang 0; NAadalah untuk "tidak tersedia".) Kinerja dinyatakan identik dengan solusi umum di atas.

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

Haskell, 74 65 36 byte + barang curian ekstra

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

Formula rekursif, bekerja untuk semua dimensi yang dapat disajikan dengan tepat sebagai angka floating point presisi ganda tetapi akan berulang tanpa batas untuk dimensi non-integral. Versi lama demi kepentingan posterioritas:

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

Berfungsi untuk semua dimensi. Menggunakan formula dari manifesto tau . product[n,n-2..1.1]adalah hack faktorial ganda yang tidak akan dihitung noln==2

JavaScript, 61 51 49 43 byte

Dimensi 0-3 didukung karena tidak ada dimensi ke-4 .

Terima kasih kepada @Hedi untuk menghemat 7 byte

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

Menciptakan fungsi d. Kemudian naikkan rke ndaya th dan kemudian gandakan dengan angka tergantung pada npenggunaan operator ternary. Output 1untukn=0

Memberikan output ke setidaknya 2 tempat desimal (10+ dp)

Ini cuplikan makanan ringan!

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)

Ini berfungsi hingga 3 dimensi saja. Input dalam urutan terbalik, yaitu:, rlalu n.

Cobalah online!

Pertimbangkan r=3, n=2sebagai contoh.

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 + barang curian ekstra!

Sunting: Disimpan 2 byte berkat @AlexRacer

Fungsi diadik - argumen pertama adalah jumlah dimensi, kedua adalah jari-jari n-ball.

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

Rumus rekursif untuk volume bola-n: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Wah! Java (bahasa pengujian saya) mengalahkan Scala di sini, berkat ?:sintaks ternary yang singkat ! Fungsi ini secara sintaksis benar dalam semua 4 bahasa dalam tajuk, dan saya telah mengujinya dengan C (MinGW GCC 5.4.0), & C # (VS Ultimate 2016, C # 6.0). Saya berasumsi bahwa itu akan bekerja di C ++ juga, jadi di sana. Karena fungsi ini cukup banyak perpustakaan-independen, itu harus berfungsi dalam bahasa C-like dengan sintaksis yang sama.

Haskell, 52 byte untuk tab indentasi 42 byte + swag ekstra

Sunting: Disimpan 10 byte berkat @WChargin

Fungsi kari diad - argumen pertama adalah jumlah dimensi, kedua adalah jari-jari bola-n.

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

Rumus rekursif untuk volume bola-n: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Simpan ini sebagai file skrip terpisah dan jalankan dengan GHCi, dengan fungsi untuk menguji voutput, misalnya,show (v 3 4.5) ,. Saya tidak menguji ini, tolong beri tahu saya jika ini tidak berhasil.

Program lama dengan perkiraan 6.2832 untuk 2π diganti (50 byte dengan indentasi tab):

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

Ini dapat digunakan dengan GHCi dalam mode multiline (menggunakan :set +matau melampirkan kode antara :{&:} , enklosur berada di jalurnya sendiri. Fungsi tester diperlukan.

Pengetikan statis dengan inferensi tipe program lengkap mulai berlaku di sini, memungkinkan Haskell untuk melakukan jauh lebih baik daripada Scala, dan mendekati Groovy, tetapi tidak cukup mengalahkannya berkat kecocokan pola dan bukan ternary, yang melibatkan beberapa pengulangan karakter.

Racket 69 byte (ditambah barang curian ekstra)

Menggunakan rumus rekursif dari https://en.wikipedia.org/w/index.php?title=Volume_of_an_n-ball§ion=3#Recursions

Termasuk saran oleh @wchargin

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

Tidak digabungkan (v = volume, d = dimensi, r = jari-jari):

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

Pengujian:

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

Keluaran:

2
28.274333882308138
4.1887902047863905
381.7035074111599
18.758
1

Perl, 63 byte + tambahan barang curian

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

Menerima dua bilangan bulat n dan r, satu per satu, lalu mengeluarkan volume-n untuk jari-jari r dari bola-n yang diberikan. Ketika n = 0, V = 1, dan ketika n = 1, V = 2r. Semua dimensi selanjutnya dihitung dengan rumus berikut:

Sejak r ⁿ adalah faktor jari-jari dalam setiap rumus, saya meninggalkannya dari perhitungan dasar dan hanya menerapkannya di akhir.

2π diperkirakan dalam kode dengan 6.283.

Scala, 53 byte

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

Maaf, tidak ada barang curian tambahan untuk saya :(

Penjelasan:

{                     //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, tidak ada barang curian

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

Python 3, 76 72 68 byte + barang curian ekstra!

Solusi rekursif dengan barang curian ekstra!
Pengembalian 0untukn=0

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

Pendekatan lama ( 1untuk 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)

Formula rekursif dari Wikipedia .

Cobalah online.

Python 3, 56 byte + barang curian ekstra!

Mudah dengan barang curian ekstra!

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

Formula standar.

Cobalah online

Scala, 81 79 byte + barang curian ekstra!

Sunting: Disimpan 2 byte berkat @AlexRacer

Fungsi diadik - argumen pertama adalah jumlah dimensi, kedua adalah jari-jari n-ball.

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

Rumus rekursif untuk volume bola-n: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Kurangnya inferensi tipe Scala untuk tipe kembali fungsi rekursif dan parameter fungsi dan sintaks ternary verbose agak menyakitkan di sini :(

Groovy, 49 47 byte + barang curian ekstra!

Sunting: Disimpan 2 byte berkat @AlexRacer

Fungsi diadik - argumen pertama adalah jumlah dimensi, kedua adalah jari-jari n-ball.

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

Rumus rekursif untuk volume bola-n: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Mengetik Dinamis FTW!

Scala dan Java saya menjawab menggunakan logika yang sama, tetapi dengan pengetikan statis jumlah byte yang lebih tinggi karena mengetik anotasi :(. Namun, Scala dan Groovy memungkinkan saya untuk menghilangkan returndan titik koma, sehingga membantu jumlah byte, tidak seperti Java / C ...

Lithp , 96 karakter + barang curian ekstra

Garis terbagi 2 untuk dibaca:

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

Berpikir saya perlu memutakhirkan parser saya untuk membutuhkan lebih sedikit ruang Ukuran kode akan dikurangi dengan baik, terutama di ((/ (* (* (* (*bagian itu.

Pemakaian:

% 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

Terima kasih kepada Rudolf karena telah memangkas beberapa byte.

CJam (27 byte dengan kredit ekstra)

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

Test suite online . Ini adalah blok anonim (fungsi) yang mengambil argumen d rdi stack dan meninggalkan hasilnya di stack.

Pembedahan

Rumus n-dimensi umum dapat ditulis ulang sebagai

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