16

入力として2つの数値を取るプログラムを作成します。最初の要素は、次元の数です。0は点、1は直線、2は円、3は球です。2番目の数値はオブジェクトの半径、または1次元の場合は数値そのものです。0次元の場合は0を出力します。出力は、オブジェクトの長さ/面積/体積です。

最初の数値n、2番目の数値r、およびoutput を呼び出すと、次のxようになります。

n = 0、x = 1の場合
n = 1の場合、x = 2×r
n = 2の場合、x = r ² ×π
N = 3、X =（⁴ / ₃）×R ³ ×π
など...必要に応じて。

ノート：

一方または両方の数値が負の場合、または最初の数値が完全でない場合は、カバーする必要はありません。
プログラムはどのファイルからも読み取ってはならず、入力はこれら2つの数値のみです。
出力は数字のみを使用する必要があり（「14 * pi」ではない）、少なくとも2桁の10進数まで正確である必要があります。
n = 0の場合、コードを短くする場合は0を出力できます。
4つ以上の次元の「球体」をカバーする回答用の追加のスワッグ！
それはcode-golfなので、バイト単位の最短回答が勝ちです！

例：

 1 1 -> 2

 2 3 -> 28,27

 3 1 -> 4,19

 3 4,5 -> 381,70

 1 9.379 -> 18.758

 0 48 -> 1

code-golf math

— ルドルフ・ジェリン
ソース

2

わーい！投稿で偽のMathJax方程式が大好きです！

— ルドルフジェリン

1

批評家ではありませんが、線がどのように

— 1D

10

@xem中心から所定の距離内にあるすべての点として円を考える

— ルイスMendo

3

数学タイプでは、これらのさまざまな次元の「ボール」を呼び出します。原点からの距離を持つポイントのセットは== r球であり、原点からの距離を持つポイントのセットは<= rボールです。これらは、0ボール=ポイント、1ボール=セグメント、2ボール=ディスク、3ボール=ボール、4ボール、5ボールなどです。（「n-ball = common name」としてリストされています）。

— エリックタワーズ

3

「0次元に対して0を出力」と「n = 0、x = 1に対して」は互いに矛盾します。どちらかを選択してください（または両方が許可されていることを明確にしてください）。

— パエロエベルマン

7

ゼリー、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)

— ジョナサン・アラン
ソース

1

Mathematicaを破ってよくやった！

— CJデニス

おめでとうございます！

— ルドルフジェリン

13

Mathematica、18バイト、最大168.15兆次元

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

匿名関数。入力として2つの数値を受け取り、出力として不正確な数値を返します。任意の数の次元で動作します。出力1.のためにN = 0用途から式超球の体積ウィキペディアに。

説明

我々は、計算πしようとしている^{N / 2} / Γ（N / 2 + 1）・R ^、N、またはN[Pi^(n/2)/Gamma[n/2 + 1] R^n]Mathematicaのです。この場合、#（最初の引数）はnで、#2（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 *)

したがって、元のプログラム。

— LegionMammal978
ソース

いい答え-それは速かった！明確にするために：出力は何桁まで正しいですか？計算可能な次元数は？

— ルドルフジェリン

@RudolfL.Jelínek約5桁の有効数字を出力し、r = 1の場合は168,146,894,169,516までのすべてのnに対して機能します（ただし、数字は少なくなります）。

— LegionMammal978

@ LegionMammal978どの式ですか？私はあなたがそこにガンマ関数を使用しないことをかなり確信しています

— -Angs

@Angs n！= Γ （ n + 1）。

— LegionMammal978

2

ああ、!非整数でも動作します。これにMathematicaを使用することは、ほとんど不正行為のように感じます…:)

— Angs

6

JavaScript（ES6）、45バイト+追加の盗品

ウィキペディアの再帰式は、任意の数の次元で機能するはずです

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

— edc65
ソース

6

R、 75 40 38バイト（および追加の盗品）

まあ、再帰関数ではなくガンマ関数を与えて使用することで、これを打ち負かすことができるようです。

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

Swaglessソリューション、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

— rturnbull
ソース

1

S SSSSSWWWWWAAAAAAAGGGGGGGGGG！

— ルドルフジェリン

5

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 manifestoの式を使用します。 product[n,n-2..1.1]ある二重階乗のためにゼロにカウントされませんハックn==2~~

— gs
ソース

5

JavaScript、61 51 49 43バイト

4次元がないため、0〜3次元がサポートされていますます。

7バイトを保存してくれた@Hediに感謝

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

関数を作成しますd。次にr、n累乗し、n3項演算子の使用に応じて数値を乗算します。出力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>

スニペットを展開

— クリチキシリソス
ソース

私の投稿されていないソリューションを...たくさん打ち負かしてください。+1！

— ルドルフジェリン

6

なんて馬鹿げた動画…

— 表示名

1

@SargeBorsch少なくともそれは私のポイントを証明しています:)

— Kritixi Lithos

2

@SargeBorsch Haha yup dumb video-0:40- 3 dimensions that behave in the same way and one that behaves in a different wayその時点で、彼は4次元があると言っているようですが、1次元、2次元、3次元はありません！

— レベルリバーセント

1

私はウェブ¯\ _（ツ）_ /¯上にあった最初の結果であった@LevelRiverStまあ

— KritixiのLithos

3

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

— ルイス・メンドー
ソース

2

Java / C / C ++ / C＃、 69 67バイト+追加の盗品！

編集：@AlexRacerのおかげで2バイトを保存しました

二項関数-最初の引数は次元数、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;}

超球の体積のための再帰式：V _N = ^{（2πR ² V _N-2）} /_N

うわあ！簡潔な?:三項構文のおかげで、Java（私のテスト言語）がここでScalaに勝っています！この関数は、見出しの4つの言語すべてで構文的に正しいため、C（MinGW GCC 5.4.0）およびC＃（VS Ultimate 2016、C＃6.0）でテストしました。私はそれがC ++でも動作すると想定していますので、そこに。この関数はほとんどライブラリに依存しないため、同様の構文を持つ任意のCライクな言語で動作するはずです。

— タモグナ・チョウドリー
ソース

うわー！私はJavaの答えを決して受け取らないだろうと思った！了解、ありがとう！そして、ボーナスとして、いくつかの答えを打ち負かし、余分な盗品を得ました！₊₁

— RudolfJelin

n==0短縮することが可能n<1ともn==1にn<2

— AlexRacer

2

Haskell、タブインデント用に52バイト 42バイト+余分な盗品

編集：@WCharginのおかげで10バイト保存

二項カリー関数-最初の引数は次元数、2番目はnボールの半径です。

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

超球の体積のための再帰式：V _N = ^{（2πR ² V _N-2）} /_N

これを別のスクリプトファイルとして保存し、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

これは、GHCiで複数行モードで使用できます（＆の:set +m間でコードを使用または囲む:{:}。エンクロージャーは独自の行にあります。テスター機能が必要です。

全プログラム型推論による静的型付けがここで登場し、HaskellがScalaよりもはるかに優れた結果を出し、Groovyに近づきましたが、文字の繰り返しを伴う3項ではなくパターンマッチのおかげで完全に打ち負かされませんでした。

— タモグナ・チョウドリー
ソース

51直接レイアウトを使用している場合、49あなたは置き換える場合2*piのために6.2832、あなたが再帰呼び出しの周りに括弧を削除した場合47、および：let{v 0 r=1;v 1 r=2*r;v n r=2*pi*r*r*v(n-2)r/n}...

— wchargin

…しかし、より一般的なスコアリングは、別個のスクリプトファイルとして送信することです。ドロップしlet{}、セミコロンをラインフィードに置き換えて、42バイトだけを取得します（末尾の改行なし）。

— wchargin

@WChargin私はHaskellを2日間ずっと学習しているので、ポインタをありがとう。Haskellの演算子と関数の呼び出しの優先順位がわからないため、カッコで注意を

— 怠りました

2

ラケット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

— rnso
ソース

これが正当なものであるかどうかは非常に疑わしい。つまり、バイトカウントで定義をカウントせずに再帰関数を使用している。つまり、67バイトとしてスコアを付けている式は、vバインドされていないため、有効なラケットではありません（他のパラメーターは言うまでもありません）。確かにあなた(define(v d r))もカウントする必要がありますか？これにより、最大82バイトになります…

— -wchargin

…ただしcond、ネストされたif式で置き換えることにより、4バイトを削ることができ、78バイトにを減らすことができます(define(v d r)(if(= d 0)1(if(= d 1)(* 2 r)(*(/(* 2 pi(* r r))d)(v(- d 2)r)))))。

— -wchargin

…そしてa matchを使用してさらに3つを削ります(define(v d r)(match d[0 1][1(* 2 r)][_(*(/(* 2 pi(* r r))d)(v(- d 2)r))]))。

— wchargin

素晴らしい提案をありがとう。これらを答えに含めています。

— rnso

@wchargin：式で（v（-d 2）r）を再配置し、既に乗算式にあるため、「（* rr）」ではなく「r r」のみを使用することで、さらに9バイト削減できます。

— rnso

1

Perl、63バイト+余分な盗品

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

2つの整数nとrを一度に1つずつ受け入れ、n球の指定された半径rのnボリュームを出力します。n = 0、V = 1、n = 1の場合、V = 2r。その他のディメンションはすべて、次の式で計算されます。

$Recursive volume formula$

r ⁿはすべての式の半径の係数であるため、基本計算から除外し、最後にのみ適用します。

コードでは、2πは6.283で近似されます。

— ガブリエル・ベナミー
ソース

素敵で再帰的であり、再帰式を表示するために₊₁。

— ルドルフジェリン

1

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
}

— corvus_192
ソース

1

JavaScript（ES6）、39バイト、盗品なし

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

— ニール
ソース

1

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

古いアプローチ（1for 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)

ウィキペディアの再帰式。

オンラインでお試しください。

— パジョンク
ソース

1

Python 3、56バイト+追加の盗品！

余分な盗品で簡単！

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

標準フォーミュラ。

オンラインで試す

— パジョンク
ソース

1

Scala、81 79バイト+追加の盗品！

編集：@AlexRacerのおかげで2バイトを保存しました

二項関数-最初の引数は次元数、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

超球の体積のための再帰式：V _N = ^{（2πR ² V _N-2）} /_N

Scalaには、再帰関数および関数パラメーターの戻り値の型推論と冗長な3項構文の型推論がないため、ここでかなり痛いです:(

— タモグナ・チョウドリー
ソース

1

Groovy、49 47バイト+追加の盗品！

編集：@AlexRacerのおかげで2バイトを保存しました

二項関数-最初の引数は次元数、2番目はnボールの半径です。

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

超球の体積のための再帰式：V _N = ^{（2πR ² V _N-2）} /_N

ダイナミックタイピングFTW！

私のScalaとJavaの回答は同じロジックを使用しますが、静的な型付けでは型注釈によるバイトカウントが高くなります:(ただし、ScalaとGroovy returnでは、セミコロンと...

— タモグナ・チョウドリー
ソース

extra余分なSWAGに！

— ルドルフジェリン

1

Lithp、96文字+余分な盗品

読みやすくするために行を2つに分割：

#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

数バイトを削ってくれたルドルフに感謝します。

— アンドラキス
ソース

1

「3.141592653589793」を「3.1416」に短縮し、11バイトを節約し、それでもルールに適合しますか？

— ルドルフジェリン

1

CJam（追加のクレジットを含む27バイト）

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

オンラインテストスイート。これは引数を取る匿名ブロック（関数）ですd rスタック上の、結果をスタックに残すです。

解剖

一般的なn次元の式は次のように書き換えることができます。

\frac{2^{⌈ \frac{d}{2} ⌉} π^{⌊ \frac{d}{2} ⌋} r^{d}}{d ！ ！}

$\frac{2^{\left\lceil\frac{d}{2}\right\rceil}\pi^{\left\lfloor\frac{d}{2}\right\rfloor} r^d}{d!!}$

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

— ピーター・テイラー
ソース

N次元の円！

ゼリー、13 バイト +余分な盗品

どうやって？

Mathematica、18バイト、最大168.15兆次元

説明

JavaScript（ES6）、45バイト+追加の盗品

R、 75 40 38バイト（および追加の盗品）

Swaglessソリューション、38 34バイト

Haskell、74 65 36バイト+追加の盗品

JavaScript、61 51 49 43バイト

これがスナックスニペットです！

MATL、17バイト

Java / C / C ++ / C＃、 69 67バイト+追加の盗品！

Haskell、タブインデント用に52バイト 42バイト+余分な盗品

ラケット69バイト（および追加の盗品）

Perl、63バイト+余分な盗品

Scala、53バイト

JavaScript（ES6）、39バイト、盗品なし

Pythonの3、76 72 68バイト+余分な盗品！

Python 3、56バイト+追加の盗品！

Scala、81 79バイト+追加の盗品！

Groovy、49 47バイト+追加の盗品！

Lithp、96文字+余分な盗品

CJam（追加のクレジットを含む27バイト）

解剖