Girdi olarak iki sayı alan bir program yazın. Birincisi boyut sayısıdır - bir nokta için 0, düz bir çizgi için 1, bir daire için 2, bir küre için 3. İkinci sayı, nesnenin yarıçapı veya 1 boyutluysa, sayının kendisidir. 0 boyutlar için çıkış 0. Çıktı, nesnenin uzunluğu / alanı / hacmidir.

İlk numarayı n, ikinci numarayı rve çıktıyı çağırırsak x, şunu elde ederiz:

• n = 0, x = 1 için

• n = 1 için, x = 2 × r

• n = 2 için, x = r ² × π

• n = 3 için, x, = ( ⁴ / ₃ ) x R ³ x π

• ve benzerleri ... eğer istersen.

Notlar:

• Bir veya her iki sayının negatif olduğu veya ilk sayının tam olmadığı durumlarda ele alınmasına gerek yoktur.

• Program herhangi bir dosyadan okumamalıdır ve tek girdi bu iki sayıdır.

• Çıktıda yalnızca rakam kullanılmalıdır (örneğin "14 * pi" değil) ve en az iki ondalık basamağa kadar doğru olmalıdır.

• N = 0'a gelince, kodu kısaltırsa 0 çıktısı alabilirsiniz.

• Hatta 4 ve daha boyutlu "küreleri" kapsayan bir cevap için ekstra yağma!

• Bu kod golf , yani bayt en kısa cevap kazanır!

Örnekler:

 1 1 -> 2

 2 3 -> 28,27

 3 1 -> 4,19

 3 4,5 -> 381,70

 1 9.379 -> 18.758

 0 48 -> 1

Jöle , 13 bayt + ekstra yağma

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

Çevrimiçi deneyin!

ØP( 3.141592653589793) Tarafından verilen sabit π değeri yeterince doğru olduğu sürece herhangi bir boyut için çalışır .

Nasıl?

÷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 bayt, ~ 168,15 trilyon boyuta kadar

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

Anonim işlev. Girdi olarak iki sayı alır ve çıktı olarak hatalı bir sayı döndürür. Herhangi bir sayıda boyutla çalışır. N = 0 1.için çıktılar . Bir n-ball'un Hacmindeki formülü kullanır . Wikipedia'da .

açıklama

Π ^{n / 2} / Γ ( n / 2 + 1) · R ⁿ veya N[Pi^(n/2)/Gamma[n/2 + 1] R^n]Mathematica'da hesaplamaya çalışıyoruz . Bizim durumumuzda, #(ilk argüman) n ve #2(ikinci argüman) R'dir . Bu bizi N[Pi^(#/2)/Gamma[#/2 + 1] #2^#] &aşağıdaki gibi golf oynayabilen bırakır :

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

ve böylece orijinal programımız.

JavaScript (ES6), 45 bayt + ekstra yağma

Wikipedia'dan özyinelemeli formül, herhangi bir boyut boyutu için çalışmalıdır

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

R, 75 40 38 bayt (artı ekstra yağma)

Görünüşe göre, tekrarlayan fonksiyonlar yerine gama fonksiyonunu vererek ve kullanarak golf oynayabilirim.

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

nYarıçapın boyutsal bir hiper küresinin hacmini hesaplamak için anonim bir işlevi tanımlar r.

Bazı örnekler:

1 1 -> 2

0 48 -> 1

2 3 -> 28.27433

3 4.5 -> 381.7035

7 7 -> 3891048

100 3 -> 122051813

Swagless çözümü, 38 34 bayt

Az birkaç bayt, yalnızca boyutları için 1 ila 3 İade çalışan isimsiz bir işleve sahip olabilir numeric(0)için n=0, ve NAiçin n>3. ( numeric(0)0 uzunluğundaki sayısal bir vektördür; NA"mevcut değil" içindir.) Aksi takdirde, yukarıdaki genel çözüm ile aynıdır.

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

Haskell, 74 65 36 bayt + ekstra yağma

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

Özyinelemeli formül, tam olarak çift kesinlikli kayar nokta sayısı olarak sunulabilen, ancak tümleşik olmayan boyutlar için sonsuz döngü yapacak tüm boyutlar için çalışır. Posteriorluk uğruna eski versiyon:

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

Tüm boyutlar için çalışır. Tau manifesto'daki formülü kullanır . product[n,n-2..1.1]için sıfır saymayacak bir çift ​​faktörlü kesmekn==2

JavaScript, 61 51 49 43 bayt

0-3 boyut desteklenir, çünkü 4. boyut yoktur .

@Hedi'ye 7 bayt kaydettiği için teşekkürler

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

İşlev oluşturur d. Sonra yükseltir riçin ninci güç ve daha sonra bağlı bir sayı ile çarpar onu nüçlü operatörleri kullanarak. çıktılar1 içinn=0

En az 2 ondalık basamağa çıktı verir (10+ dp)

İşte bir aperatif snippet'i!

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 bayt

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

Bu yalnızca 3 boyuta kadar çalışır. Girişler ters sıradadır, yani:, rsonra n.

Çevrimiçi deneyin!

Göz önünde r=3, n=2bir örnek olarak.

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 bayt + ekstra yağma!

Düzenleme: @AlexRacer sayesinde 2 bayt kaydedildi

Bir ikili fonksiyon - ilk argüman boyut sayısı, ikincisi n-top yarıçapıdır.

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

Bir n-topun hacmi için özyinelemeli formül: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Oha! Java (test dilim) Scala'yı burada yeniyor,?: üçlü sözdizimi ! Bu işlev, başlıktaki 4 dilde de sözdizimsel olarak doğrudur ve C (MinGW GCC 5.4.0), & C # (VS Ultimate 2016, C # 6.0) ile test ettim. Ben de orada C ++ 'da çalışacağını varsayıyorum. Bu işlev hemen hemen kütüphaneden bağımsız olduğu için benzer sözdizimine sahip C benzeri bir dilde çalışmalıdır.

Haskell, sekme girintisi için 52 bayt 42 bayt + ekstra yağma

Düzenleme: @WChargin sayesinde 10 bayt kaydedildi

Bir ikili kavisli fonksiyon - ilk argüman boyut sayısı, ikincisi n-top yarıçapıdır.

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

Bir n-topun hacmi için özyinelemeli formül: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Bunu ayrı bir komut dosyası olarak kaydedin ve GHCi ile test etme işleviyle çalıştırın v örneğin çıkış için,show (v 3 4.5) . Bunu test etmedim, lütfen bunun işe yaramadığını bildirin.

Değiştirilen 2π için 6.2832 yaklaşık eski program (sekme girintili 50 bayt):

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

Bu çoklu-hatlı modunda GHCi kullanılabilir (kullanarak :set +mya arasında kodu çevreleyen :{ve:} , muhafazalar kendi satırlarındadır.

Tam program tipi çıkarım ile statik yazım burada devreye girerek Haskell'in Scala'dan çok daha iyi yapmasına ve Groovy'ye yaklaşmasına izin veriyor, ancak bazı karakter tekrarlarını içeren bir üçlü yerine desen eşleşmesi sayesinde onu tam olarak yenmiyor.

Raket 69 bayt (artı ekstra yağma)

Kaynağından özyinelemeli formül kullanır Https://en.wikipedia.org/w/index.php?title=Volume_of_an_n-ball§ion=3#Recursions adresinden

@Wchargin tarafından önerilenler dahil

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

Kurtulmamış (v = hacim, d = boyutlar, r = yarıçap):

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

Test yapmak:

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

Çıktı:

2
28.274333882308138
4.1887902047863905
381.7035074111599
18.758
1

Perl, 63 bayt + ekstra yağma

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

Her seferinde bir tane olmak üzere iki n ve r tamsayısını kabul eder, ardından bir n-küresinin verilen yarıçapı r için n-hacmi verir. N = 0 olduğunda, V = 1 ve n = 1 olduğunda, V = 2r. Diğer tüm boyutlar aşağıdaki formülle hesaplanır:

R ^n'den beri radius en faktör her formülde, ben taban hesaplama dışarı bırakın ve sadece sonunda uygulayın.

2π kodda 6.283 ile yaklaştırılmıştır.

Scala, 53 bayt

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

Üzgünüm, benim için fazladan yağma yok :(

Açıklama:

{                     //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 bayt, yağma yok

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

Python 3, 76 72 68 bayt + ekstra yağma!

Ekstra yağma ile özyinelemeli çözüm!
İade 0içinn=0

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

Eski yaklaşım ( 1için 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'dan özyinelemeli formül .

Çevrimiçi deneyin.

Python 3, 56 bayt + ekstra yağma!

Ekstra yağma ile anlaşılır!

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

Standart formül.

Çevrimiçi deneyin

Scala, 81 79 bayt + ekstra yağma!

Düzenleme: @AlexRacer sayesinde 2 bayt kaydedildi

Bir ikili fonksiyon - ilk argüman boyut sayısı, ikincisi n-top yarıçapıdır.

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

Bir n-topun hacmi için özyinelemeli formül: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Scala'nın tekrarlayan fonksiyonların ve fonksiyon parametrelerinin dönüş tipleri için tip çıkarım eksikliği ve ayrıntılı üçlü sözdizimi burada biraz acıyor :(

Harika, 49 47 bayt + ekstra yağma!

Düzenleme: @AlexRacer sayesinde 2 bayt kaydedildi

Bir ikili fonksiyon - ilk argüman boyut sayısı, ikincisi n-top yarıçapıdır.

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

Bir n-topun hacmi için özyinelemeli formül: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Dinamik Yazma FTW!

Scala ve Java yanıtlarım aynı mantığı kullanıyor, ancak statik yazım ile tür ek açıklamaları nedeniyle çok daha yüksek bayt sayımı var :(. Ancak, Scala ve Groovy, returnve noktalı virgül atlamama izin veriyor , bu nedenle Java / C'nin aksine bayt sayımına yardımcı oluyor ...

Lithp , 96 karakter + ekstra yağma

Okunabilirlik için 2'ye bölünmüş çizgi:

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

Daha az yer kaplaması için ayrıştırıcımı yükseltmem gerektiğini düşünüyorum. Kod boyutu güzelce kesilir, özellikle de((/ (* (* (* (* bölümde .

Kullanımı:

% 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

Birkaç bayt tıraş ettiği için Rudolf'a teşekkürler.

CJam (ekstra kredili 27 bayt)

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

Çevrimiçi test paketi . Bu, argüman alan anonim bir bloktur (işlev)d r yığında alan ve sonucu yığında bırakan .

teşrih

Genel n-boyutlu formül şu şekilde yeniden yazılabilir:

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