16

एक प्रोग्राम लिखें जो इसके इनपुट के रूप में दो नंबर लेता है। पहला एक आयामों की संख्या है - एक बिंदु के लिए 0, एक सीधी रेखा के लिए 1, एक वृत्त के लिए 2, एक गोले के लिए 3। दूसरी संख्या वस्तु की त्रिज्या है, या, यदि यह 1-आयामी है, तो संख्या ही। आउटपुट 0 आयामों के लिए। आउटपुट वस्तु की लंबाई / क्षेत्रफल / आयतन है।

यदि हम पहले नंबर n, दूसरे नंबर rऔर आउटपुट को कॉल करते हैं x, तो हमें वह मिलता है:

n = 0, x = 1 के लिए
n = 1, x = 2 × r के लिए
n = 2, x = r ² × x के लिए
n = 3 के लिए, एक्स = ( ⁴ / ₃ ) × आर ³ × π
और इतने पर ... यदि आप चाहते हैं, हालांकि।

टिप्पणियाँ:

मामले जब एक या दोनों संख्याएँ नकारात्मक होती हैं, या जब पहली संख्या पूरी नहीं होती है, तो उन्हें कवर करने की आवश्यकता नहीं होती है।
कार्यक्रम को किसी भी फ़ाइल से नहीं पढ़ा जाना चाहिए और एकमात्र इनपुट वे दो नंबर हैं।
आउटपुट में केवल अंकों (जैसे "14 * पीआई") का उपयोग नहीं किया जाना चाहिए, और कम से कम दो दशमलव अंकों के लिए सटीक होना चाहिए।
N = 0 के लिए, आप 0 को आउटपुट कर सकते हैं यदि यह कोड को छोटा बनाता है।
4 और अधिक-आयामी "क्षेत्रों" को कवर करने वाले उत्तर के लिए अतिरिक्त स्वैग!
यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है!

उदाहरण:

 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

— RudolfJelin
स्रोत

2

वाह! मुझे पोस्टों में झूठे MathJax समीकरण पसंद हैं!

— रुडोल्फजेलिन

1

आलोचना करने के लिए नहीं, लेकिन मैं यह नहीं देखता कि एक पंक्ति को 1d सर्कल कैसे माना जा सकता है ...

— xem

10

@xem सभी बिंदुओं के रूप में एक वृत्त पर विचार करें जो केंद्र से दी गई दूरी के भीतर है

— लुइस मेंडू

3

गणित के प्रकार इन "गेंदों" को विभिन्न आयामों से बुलाएंगे। मूल से दूरी के साथ बिंदुओं का सेट == rगोला है, मूल से दूरी के साथ बिंदुओं का सेट <= rगेंद है। फिर ये हैं 0-बॉल = पॉइंट, 1-बॉल = सेगमेंट, 2-बॉल = डिस्क, 3-बॉल = बॉल, 4-बॉल, 5-बॉल, एट सी। (" n-बॉल = सामान्य नाम" के रूप में सूचीबद्ध )।

— एरिक टावर्स

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

अच्छी तरह से गणितज्ञ की पिटाई के लिए किया गया!

— CJ डेनिस

बधाई हो, आप जीत गए!

— रुडोल्फजेलिन

13

गणितज्ञ, 18 बाइट्स, ~ 168.15 ट्रिलियन आयाम तक

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

अनाम फ़ंक्शन। इनपुट के रूप में दो नंबर लेता है, और आउटपुट के रूप में एक अक्षम संख्या देता है। किसी भी संख्या में आयामों के साथ काम करता है। N = 0. के 1.लिए आउटपुट विकिपीडिया पर n-बॉल के आयतन से सूत्र का उपयोग करता है ।

व्याख्या

हम π गणना करने के लिए प्रयास कर रहे हैं ^{n / 2} / Γ ( एन / 2 + 1) · आर ^एन , या N[Pi^(n/2)/Gamma[n/2 + 1] R^n]Mathematica में। हमारे मामले में, #(पहला तर्क) n है और #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 के बारे में महत्वपूर्ण आंकड़े को आउटपुट, और यह सभी के लिए काम करता n के लिए 168.146.894.169.516 अप करने के लिए आर (कम आंकड़ों के साथ यद्यपि) = 1।

— लेजियम मैमल 978

@ LegionMammal978 कौन सा सूत्र? मैं काफी कुछ आप गामा समारोह का उपयोग नहीं कर रहा हूँ

— 11

@ आंसू n ! = Γ ( n + 1)।

— लीजियनममाल 978 11

2

ओह, !गैर-अभिन्न के लिए भी काम करता है। इसके लिए गणितज्ञ का उपयोग करना लगभग धोखा जैसा लगता है ... :)

— Angs

6

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स + अतिरिक्त स्वैग

विकिपीडिया से पुनरावर्ती सूत्र , आयाम के किसी भी संख्या के लिए काम करना चाहिए

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

— edc65
स्रोत

6

आर, 75 40 38 बाइट्स (अतिरिक्त अतिरिक्त स्वाग)

ठीक है, ऐसा लगता है कि मैं पुनरावर्ती कार्यों के बजाय गामा फ़ंक्शन का उपयोग करके इसे नीचे गोल्फ कर सकता हूं।

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

nत्रिज्या के एक आयामी हाइपरस्फियर की मात्रा की गणना करने के लिए एक अनाम फ़ंक्शन को परिभाषित करता है r।

कुछ उदाहरण:

१ १ -> २

० ४। -> १

२ ३ -> २ 3.२33४३३

3 4.5 -> 381.7035

7 -> ३ 7 ९ १०४9

100 3 -> 122051813

स्वैगलेस सॉल्यूशन, 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

₊₁ SSSSSWWWWAAAAAAAAGGGGGGGGG के लिए!

— रुडोल्फजेलिन

5

हास्केल, 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]

सभी आयामों के लिए काम करता है। ताओ घोषणा पत्र से सूत्र का उपयोग करता है । product[n,n-2..1.1]एक डबल फैक्टोरियल हैक है जो शून्य की गणना नहीं करेगाn==2

— Angs
स्रोत

5

जावास्क्रिप्ट, 61 51 49 43 बाइट्स

0-3 आयामों का समर्थन किया जाता है क्योंकि कोई 4 आयाम नहीं है ।

7 बाइट्स बचाने के लिए @Hedi को धन्यवाद

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

कार्य करता है d। फिर उठाती rको nवें शक्ति और उसके बाद के आधार पर एक संख्या के साथ पलता यह nत्रिगुट ऑपरेटर का उपयोग करके। आउटपुट 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

@ सर्जबॉर्श कम से कम यह मेरी बात को साबित करता है :)

— क्रिटिक्स लिथोस

2

@SargeBorsch Haha yup dumb वीडियो - 0:40 3 dimensions that behave in the same way and one that behaves in a different way- इस बिंदु पर वह कह रहा है कि 4 आयाम है, लेकिन कोई 1st, 2nd या 3rd नहीं है!

— लेवल रिवर सेंट

1

@LevelRiverSt खैर वह पहला परिणाम था जब मैं वेब पर था (\ _ (ツ) _ /

— i

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

जावा / C / C ++ / सी #, ६ ९ ६ बाइट्स + अतिरिक्त स्वैग!

संपादित करें: @AlexRacer के लिए 2 बाइट्स सहेजे गए

एक डायडिक फ़ंक्शन - पहला तर्क आयामों की संख्या है, दूसरा एन-बॉल की त्रिज्या है।

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

एक n गेंद की मात्रा के लिए पुनरावर्ती सूत्र: वी _एन = ^{(2πr ² वी _n-2 )} / _n

वाह! जावा (मेरी परीक्षा की भाषा) यहाँ स्काला को हरा देता है, धन्यवाद ?:ट्रिनरी सिंटैक्स के लिए! यह फ़ंक्शन शीर्षलेख में सभी 4 भाषाओं में वाक्यविन्यास रूप से सही है, और मैंने इसे C (MINGW GCC 5.4.0), और C # (VS अंतिम 2016, C # 6.0) के साथ परीक्षण किया है। मैं मान रहा हूं कि यह C ++ में भी काम करेगा, इसलिए वहां। चूंकि यह फ़ंक्शन बहुत अधिक पुस्तकालय-स्वतंत्र है, इसलिए इसे समान सिंटैक्स के साथ किसी भी सी-लाइक भाषा में काम करना चाहिए।

— तमोग्ना चौधरी
स्रोत

वाह! मैंने सोचा कि मुझे कभी जावा उत्तर नहीं मिलेगा! मिल गया धन्यवाद! और, एक बोनस के रूप में, इसने कुछ उत्तरों को हरा दिया और अतिरिक्त स्वाग प्राप्त किया! J

— रुडोल्फजेलिन

n==0को n<1और भी छोटा किया जा सकता n==1हैn<2

— AlexRacer

2

हास्केल, टैब इंडेंट 42 बाइट्स + अतिरिक्त स्वाग के लिए 52 बाइट्स

संपादित करें: सहेजे गए 10 बाइट्स @Chargin के लिए धन्यवाद

एक डायडिक करी फ़ंक्शन - पहला तर्क आयामों की संख्या है, दूसरा एन-बॉल की त्रिज्या है।

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

एक n गेंद की मात्रा के लिए पुनरावर्ती सूत्र: वी _एन = ^{(2πr ² वी _n-2 )} / _n

इसे अलग स्क्रिप्ट फ़ाइल के रूप में सहेजें और vआउटपुट के लिए परीक्षण के लिए एक फ़ंक्शन के साथ GHCi के साथ चलाएं , जैसे 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है या के बीच कोड enclosing :{और :}, बाड़ों अपने स्वयं के तर्ज पर किया जा रहा है। परीक्षक समारोह की आवश्यकता है।

फुल-प्रोग्राम टाइप इंट्रैक्शन के साथ स्टेटिक टाइपिंग यहाँ खेल में आती है, जिससे हास्केल स्केला से कहीं बेहतर कर सकते हैं, और ग्रूवी से संपर्क कर सकते हैं, लेकिन एक टर्नरी के बजाय पैटर्न मैच की बदौलत काफी पिटाई हो रही है, जिसमें कुछ चरित्र हनन शामिल है।

— तमोग्ना चौधरी
स्रोत

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 बाइट्स (बिना नई रेखा के पीछे) प्राप्त करने के लिए लाइनफीड्स के साथ बदलें।

— वचर्जिन

@Chargin मैं पूरे 2 दिनों के लिए हास्केल सीख रहा हूं, इसलिए संकेत के लिए धन्यवाद। मैं कोष्ठक के साथ सावधानी के पक्ष में मिटा दिया, क्योंकि मैं हास्केल में ऑपरेटर बनाम फ़ंक्शन कॉल की पूर्वता के बारे में निश्चित नहीं हूं

— तमोग्ना चौधरी

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एक्सप्रेशन्स की जगह , आपको 78 बाइट्स के साथ नीचे लाते हैं (define(v d r)(if(= d 0)1(if(= d 1)(* 2 r)(*(/(* 2 pi(* r r))d)(v(- d 2)r)))))।

— वचर्जिन

… और matchपाने के लिए एक का उपयोग करके तीन और बंद दाढ़ी (define(v d r)(match d[0 1][1(* 2 r)][_(*(/(* 2 pi(* r r))d)(v(- d 2)r))]))।

— 1

महान सुझावों के लिए धन्यवाद। मैं उत्तर में इन सहित हूँ।

— nn

@wchargin: मैं सूत्र में (v (- d 2) r) रिपॉजिट करके 9 और बाइट्स कम कर सकता हूं और केवल "r (" rr) के बजाय "r" का उपयोग कर सकता हूं क्योंकि यह पहले से ही गुणा फॉर्मूला में है।

— rnso

1

पर्ल, 63 बाइट्स + अतिरिक्त स्वैग

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

दो पूर्णांक n और r को स्वीकार करता है, एक बार में, फिर n-sp क्षेत्र के दिए गए त्रिज्या r के लिए n- आयतन को आउटपुट करता है। जब n = 0, V = 1, और जब n = 1, V = 2r। सभी अन्य आयामों की गणना निम्न सूत्र द्वारा की जाती है:

$पुनरावर्ती मात्रा सूत्र$

चूंकि आर ^एन हर सूत्र में त्रिज्या का कारक है, मैं इसे आधार गणना से बाहर छोड़ता हूँ और केवल इसे अंत में लागू करता हूँ।

2 6.283 के कोड में सन्निकट है।

— गेब्रियल बेनामी
स्रोत

अच्छा और पुनरावर्ती, और पुनरावर्ती सूत्र दिखाने के लिए,।

— रुडोल्फजेलिन

1

स्काला, 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

जावास्क्रिप्ट (ईएस 6), 39 बाइट्स, कोई स्वैग नहीं

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

— नील
स्रोत

1

पायथन 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))

पुराना तरीका (के 1लिए 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)

से पुनरावर्ती सूत्र विकिपीडिया ।

इसे ऑनलाइन आज़माएं।

— pajonk
स्रोत

1

पायथन 3, 56 बाइट्स + अतिरिक्त स्वैग!

अतिरिक्त स्वैग के साथ सीधा!

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

मानक सूत्र।

इसे ऑनलाइन आज़माएं

— pajonk
स्रोत

1

स्काला, 81 79 बाइट्स + अतिरिक्त स्वैग!

संपादित करें: @AlexRacer के लिए 2 बाइट्स सहेजे गए

एक डायडिक फ़ंक्शन - पहला तर्क आयामों की संख्या है, दूसरा एन-बॉल की त्रिज्या है।

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

एक n गेंद की मात्रा के लिए पुनरावर्ती सूत्र: वी _एन = ^{(2πr ² वी _n-2 )} /_n

स्केला की कमी प्रकार प्रतिक्षेप कार्यों और समारोह मापदंडों और क्रिया टर्नरी सिंटैक्स की वापसी के लिए आक्षेप की काफी यहाँ चोट लगी है :(

— तमोग्ना चौधरी
स्रोत

1

ग्रूवी, 49 47 बाइट्स + अतिरिक्त स्वैग!

संपादित करें: @AlexRacer के लिए 2 बाइट्स सहेजे गए

एक डायडिक फ़ंक्शन - पहला तर्क आयामों की संख्या है, दूसरा एन-बॉल की त्रिज्या है।

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

एक n गेंद की मात्रा के लिए पुनरावर्ती सूत्र: वी _एन = ^{(2πr ² वी _n-2 )} / _n

गतिशील टाइपिंग FTW!

मेरा स्काला और जावा उत्तर एक ही तर्क का उपयोग करते हैं, लेकिन स्थैतिक टाइपिंग के कारण टाइपिंग एनोटेशन के कारण इतनी अधिक बाइट गिनती होती है :( हालांकि, स्काला और ग्रूवी मुझे returnऔर अर्धविराम को छोड़ने की अनुमति देते हैं , जिससे जावा / सी के विपरीत, बाइट गिनती में मदद मिलती है। ...

— तमोग्ना चौधरी
स्रोत

अतिरिक्त SWAG के लिए SW!

— रुडोल्फजेलिन

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

रुडोल्फ के लिए धन्यवाद कुछ बाइट्स बंद करने के लिए।

— Andrakis
स्रोत

1

11 बाइट्स को बचाने और अभी भी नियमों में फिट " 3.141592653589793" से " " को छोटा करने के बारे में क्या 3.1416?

— रुडोल्फजेलिन

1

CJam (अतिरिक्त ऋण के साथ 27 बाइट्स)

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

ऑनलाइन टेस्ट सूट । यह एक अनाम ब्लॉक (फ़ंक्शन) है जो तर्क लेता हैd r स्टैक पर और स्टैक पर परिणाम छोड़ता है।

विच्छेदन

सामान्य एन-आयामी सूत्र के रूप में फिर से लिखा जा सकता है

\frac{2^{⌈ \frac{घ}{2} ⌉} π^{⌊ \frac{घ}{2} ⌋} {आर}^{घ}}{घ!!}

$\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
}

— पीटर टेलर
स्रोत

एन-आयामी सर्किलों!

जेली , 13 बाइट्स + अतिरिक्त स्वैग

कैसे?

गणितज्ञ, 18 बाइट्स, ~ 168.15 ट्रिलियन आयाम तक

व्याख्या

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स + अतिरिक्त स्वैग

आर, 75 40 38 बाइट्स (अतिरिक्त अतिरिक्त स्वाग)

स्वैगलेस सॉल्यूशन, 38 34 बाइट्स

हास्केल, 74 65 36 बाइट्स + अतिरिक्त स्वैग

जावास्क्रिप्ट, 61 51 49 43 बाइट्स

यहाँ एक स्नैक स्निपेट है!

MATL , 17 बाइट्स

जावा / C / C ++ / सी #, ६ ९ ६ बाइट्स + अतिरिक्त स्वैग!

हास्केल, टैब इंडेंट 42 बाइट्स + अतिरिक्त स्वाग के लिए 52 बाइट्स

रैकेट 69 बाइट्स (अतिरिक्त अतिरिक्त स्वाग)

पर्ल, 63 बाइट्स + अतिरिक्त स्वैग

स्काला, 53 बाइट्स

जावास्क्रिप्ट (ईएस 6), 39 बाइट्स, कोई स्वैग नहीं

पायथन 3, 76 72 68 बाइट्स + अतिरिक्त स्वैग!

पायथन 3, 56 बाइट्स + अतिरिक्त स्वैग!

स्काला, 81 79 बाइट्स + अतिरिक्त स्वैग!

ग्रूवी, 49 47 बाइट्स + अतिरिक्त स्वैग!

Lithp , 96 अक्षर + अतिरिक्त

CJam (अतिरिक्त ऋण के साथ 27 बाइट्स)

विच्छेदन