Schreiben Sie ein Programm, das zwei Zahlen als Eingabe verwendet. Die erste ist die Anzahl der Dimensionen - 0 für einen Punkt, 1 für eine gerade Linie, 2 für einen Kreis, 3 für eine Kugel. Die zweite Zahl ist der Radius des Objekts oder, wenn es eindimensional ist, die Zahl selbst. 0 für 0 Dimensionen ausgeben. Die Ausgabe ist die Länge / Fläche / das Volumen des Objekts.

Wenn wir die erste n, die zweite rund die Ausgabe aufrufen x, erhalten wir Folgendes:

• für n = 0 ist x = 1

• für n = 1 ist x = 2 × r

• für n = 2 ist x = r ² × π

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

• und so weiter ... wenn du willst.

Anmerkungen:

• Fälle, in denen eine oder beide Zahlen negativ sind oder die erste Zahl nicht ganz ist, müssen nicht behandelt werden.

• Das Programm darf keine Daten aus einer Datei lesen. Die einzige Eingabe sind diese beiden Zahlen.

• Die Ausgabe sollte nur Ziffern verwenden (z. B. nicht "14 * pi") und auf mindestens zwei Dezimalstellen genau sein.

• Wie für n = 0 können Sie 0 ausgeben, wenn dies den Code kürzer macht.

• Extra Beute für eine Antwort, die sogar 4 und mehr dimensionale "Kugeln" abdeckt!

• Es ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

Beispiele:

 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 Bytes + extra Beute

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

Probieren Sie es online!

Funktioniert für jede Dimension, solange der feste Wert von π, den ØP( 3.141592653589793) liefert, genau genug ist.

Wie?

÷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 Bytes, bis zu 168,15 Billionen Dimensionen

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

Anonyme Funktion. Nimmt zwei Zahlen als Eingabe und gibt eine ungenaue Zahl als Ausgabe zurück. Funktioniert mit beliebig vielen Dimensionen. Ausgaben 1.für n = 0. Verwendet die Formel aus Volumen eines n-Balls in Wikipedia.

Erläuterung

Wir versuchen, π ^{n / 2} / Γ ( n / 2 + 1) · R ⁿ oder N[Pi^(n/2)/Gamma[n/2 + 1] R^n]in Mathematica zu berechnen . In unserem Fall #(erstes Argument) ist n und #2(zweites Argument) ist R . Dies lässt uns mit N[Pi^(#/2)/Gamma[#/2 + 1] #2^#] &, die wie folgt gespielt werden können:

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

und damit unser ursprüngliches Programm.

JavaScript (ES6), 45 Byte + zusätzlicher Swag

Eine rekursive Formel aus Wikipedia sollte für eine beliebige Anzahl von Dimensionen funktionieren

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

R, 75 40 38 Bytes (plus zusätzliche Beute)

Nun, es sieht so aus, als könnte ich Golf spielen, indem ich die Gamma-Funktion anstelle von rekursiven Funktionen verwende.

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

Definiert eine anonyme Funktion zum Berechnen des Volumens einer neindimensionalen Hypersphäre mit Radius r.

Einige Beispiele:

1 1 -> 2

0 48 -> 1

2 3 -> 28,27433

3 4,5 -> 381,7035

7 7 -> 3891048

100 3 -> 122051813

Swagless Lösung, 38 34 Bytes

Für ein paar Bytes weniger können Sie eine anonyme Funktion haben, die nur für die Dimensionen 1 bis 3 funktioniert. Gibt numeric(0)für n=0und NAfür zurück n>3. ( numeric(0)ist ein numerischer Vektor der Länge 0; NAsteht für "nicht verfügbar".) Die Leistung ist ansonsten identisch mit der obigen allgemeinen Lösung.

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

Haskell, 74 65 36 Bytes + zusätzliche Beute

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

Rekursive Formel, funktioniert für alle Bemaßungen, die genau als Gleitkommazahl mit doppelter Genauigkeit dargestellt werden können, bei nicht ganzzahligen Bemaßungen jedoch eine Endlosschleife ausführen. Die alte Version der Nachwelt zuliebe:

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

Funktioniert für alle Dimensionen. Verwendet die Formel aus dem Tau-Manifest . product[n,n-2..1.1]ist ein doppelter faktorieller Hack, für den keine Null gezählt wirdn==2

JavaScript, 61 51 49 43 Bytes

0-3-Dimensionen werden unterstützt, da es keine 4. Dimension gibt .

Vielen Dank an @Hedi für das Speichern von 7 Bytes

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

Erzeugt Funktion d. Erhöht rdann die nPotenz und multipliziert sie mit einer Zahl, abhängig von der nVerwendung von ternären Operatoren. Ausgänge 1fürn=0

Gibt eine Ausgabe mit mindestens 2 Dezimalstellen (10+ dp) aus

Hier ist ein Snack-Schnipsel!

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 Bytes

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

Dies funktioniert nur bis zu 3 Dimensionen. Die Eingänge sind in umgekehrter Reihenfolge, das heißt: r, dann n.

Probieren Sie es online!

Betrachten Sie r=3, n=2als Beispiel.

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 Bytes + zusätzlicher Swag!

Bearbeiten: 2 Bytes dank @AlexRacer gespeichert

Eine dyadische Funktion - das erste Argument ist die Anzahl der Dimensionen, das zweite der Radius der n-Kugel.

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

Rekursive Formel für das Volumen einer n-Kugel: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Whoa! Java (meine Testsprache) schlägt hier Scala, dank der knappen ?:ternären Syntax! Diese Funktion ist in allen 4 Sprachen der Überschrift syntaktisch korrekt, und ich habe sie mit C (MinGW GCC 5.4.0) und C # (VS Ultimate 2016, C # 6.0) getestet. Ich gehe davon aus, dass es auch in C ++ funktioniert, also dort. Da diese Funktion weitgehend bibliotheksunabhängig ist, sollte sie in jeder C-ähnlichen Sprache mit ähnlicher Syntax funktionieren.

Haskell, 52 Bytes für Tabulatoreinzug 42 Bytes + zusätzlicher Swag

Bearbeiten: 10 Bytes dank @WChargin gespeichert

Eine dyadische Curry-Funktion - das erste Argument ist die Anzahl der Dimensionen, das zweite der Radius der n-Kugel.

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

Rekursive Formel für das Volumen einer n-Kugel: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Speichern Sie diese als separate Skriptdatei und führen Sie sie mit GHCi aus, mit einer Funktion zum Testen der vAusgabe, z.show (v 3 4.5) . Ich habe dies nicht getestet, bitte lassen Sie mich wissen, wenn dies nicht funktioniert.

Altes Programm mit 6.2832-Approximation für 2π ersetzt (50 Bytes mit Tabulatoreinzug):

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

Dies kann mit GHCi im mehrzeiligen Modus verwendet werden (mit :set +m oder Einschließen des Codes zwischen :{& :}, wobei sich die Gehäuse in eigenen Zeilen befinden. Testerfunktion erforderlich.

Hier kommt die statische Eingabe mit vollständiger Programmtyp-Inferenz ins Spiel, die es Haskell ermöglicht, weitaus bessere Ergebnisse als Scala zu erzielen und Groovy näher zu kommen, diese jedoch dank der Musterübereinstimmung anstelle einer ternären Eingabe nicht ganz zu übertreffen, was einige Zeichenwiederholungen mit sich bringt.

Schläger 69 Bytes (plus extra Beute)

Verwendet die rekursive Formel von https://en.wikipedia.org/w/index.php?title=Volume_of_an_n-ball§ion=3#Recursions

Mit Vorschlägen von @wchargin

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

Ungolfed (v = Volumen, d = Abmessungen, r = Radius):

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

Testen:

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

Ausgabe:

2
28.274333882308138
4.1887902047863905
381.7035074111599
18.758
1

Perl, 63 Bytes + zusätzlicher Swag

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

Akzeptiert zwei ganze Zahlen n und r nacheinander und gibt dann das n-Volumen für einen gegebenen Radius r einer n-Kugel aus. Wenn n = 0 ist, ist V = 1 und wenn n = 1 ist, ist V = 2r. Alle weiteren Maße berechnen sich nach folgender Formel:

Seit r ⁿ in jeder Formel der Radiusfaktor ist, lasse ich ihn aus der Basisberechnung heraus und wende ihn nur am Ende an.

2π wird im Code durch 6.283 angenähert.

Scala, 53 Bytes

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

Tut mir leid, kein extra Beute für mich :(

Erläuterung:

{                     //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, kein Swag

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

Python 3, 76 72 68 Bytes + zusätzliche Beute!

Rekursive Lösung mit extra Beute!
Rückgabe 0fürn=0

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

Alter Ansatz ( 1für 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)

Rekursive Formel aus Wikipedia .

Probieren Sie es online aus.

Python 3, 56 Bytes + zusätzlicher Swag!

Einfach mit extra Beute!

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

Standardformel.

Probieren Sie es online aus

Scala, 81 79 Bytes + extra Beute!

Bearbeiten: 2 Bytes dank @AlexRacer gespeichert

Eine dyadische Funktion - das erste Argument ist die Anzahl der Dimensionen, das zweite der Radius der n-Kugel.

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

Rekursive Formel für das Volumen einer n-Kugel: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Die fehlende Typinferenz von Scala für Rückgabetypen von rekursiven Funktionen und Funktionsparametern und die ausführliche ternäre Syntax tun hier einiges weh :(

Groovy, 49 Jahre alt 47 Bytes + zusätzlicher Swag!

Bearbeiten: 2 Bytes dank @AlexRacer gespeichert

Eine dyadische Funktion - das erste Argument ist die Anzahl der Dimensionen, das zweite der Radius der n-Kugel.

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

Rekursive Formel für das Volumen einer n-Kugel: V _n = ^{(2πr 2 V _n-2 )} ⁄ _n

Dynamisches Tippen FTW!

Meine Scala- und Java-Antworten verwenden dieselbe Logik, aber bei statischer Eingabe sind die Byteanzahlen aufgrund von Typanmerkungen höher :(. Bei Scala und Groovy kann ich jedoch returndas Semikolon und weglassen , sodass die Byteanzahl im Gegensatz zu Java / C verbessert wird ...

Lithp , 96 Zeichen + extra Beute

Zeile zweigeteilt zur besseren Lesbarkeit:

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

Ich denke, ich muss meinen Parser aktualisieren, um weniger Speicherplatz zu benötigen. Die Codegröße würde besonders in diesem ((/ (* (* (* (*Bereich deutlich reduziert .

Verwendung:

% 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

Vielen Dank an Rudolf, der ein paar Bytes gespart hat.

CJam (27 Bytes mit extra Guthaben)

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

Online-Testsuite . Dies ist ein anonymer Block (Funktion), der Argumente akzeptiertd r auf dem Stapel entgegennimmt und das Ergebnis auf dem Stapel belässt.

Präparation

Die allgemeine n-dimensionale Formel kann wie folgt umgeschrieben werden

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