किसी वस्तु के आयतन की गणना

18

आप दिए गए आयामों के आधार पर वस्तुओं की मात्रा निर्धारित कर सकते हैं:

  • एक क्षेत्र का आयतन एकल संख्या, त्रिज्या ( r) का उपयोग करके निर्धारित किया जा सकता है
  • एक सिलेंडर की मात्रा दो संख्याओं, त्रिज्या ( r) और ऊंचाई ( h) का उपयोग करके निर्धारित की जा सकती है
  • एक बॉक्स की मात्रा तीन संख्याओं, लंबाई ( l), चौड़ाई ( w) और ऊंचाई ( h) का उपयोग करके निर्धारित की जा सकती है
  • एक अनियमित त्रिकोणीय पिरामिड की मात्रा को चार संख्याओं, पक्ष की लंबाई ( a, b, c) और ऊंचाई ( h) का उपयोग करके निर्धारित किया जा सकता है ।

निम्नलिखित इनपुटों में से एक दिए गए ऑब्जेक्ट की मात्रा निर्धारित करने के लिए चुनौती है:

  • एक एकल संख्या (r)या (r, 0, 0, 0)=>V = 4/3*pi*r^3
  • दो संख्या (r, h)या (r, h, 0, 0)=>V = pi*r^2*h
  • तीन संख्या (l, w, h)या (l, w, h, 0)=>V = l*w*h
  • चार नंबर (a, b, c, h)=> V = (1/3)*A*h, जहां हेरॉन के सूत्रA द्वारा दिया गया है :A = 1/4*sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))

नियम और स्पष्टीकरण:

  • इनपुट पूर्णांक और / या दशमलव दोनों हो सकता है
  • आप मान सकते हैं कि सभी इनपुट आयाम सकारात्मक होंगे
  • पाई कठिन कोडित है अगर यह करने के लिए सही होने चाहिए: 3.14159।
  • आउटपुट में कम से कम 6 महत्वपूर्ण अंक होने चाहिए, उन संख्याओं को छोड़कर जिन्हें कम अंकों के साथ सटीक रूप से दर्शाया जा सकता है। आप के 3/4रूप में उत्पादन कर सकते हैं 0.75, लेकिन 4/3होना चाहिए 1.33333(अधिक अंक ठीक हैं)
    • त्रुटिपूर्ण मानों को गोल कैसे किया जाए, यह वैकल्पिक है
  • अमान्य इनपुट के लिए व्यवहार अपरिभाषित है
  • आई / ओ के लिए मानक नियम। इनपुट सूची या अलग-अलग तर्क हो सकते हैं

यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा समाधान है।

परीक्षण के मामलों:

calc_vol(4)
ans =  268.082573106329

calc_vol(5.5, 2.23)
ans =  211.923986429533

calc_vol(3.5, 4, 5)
ans =  70

calc_vol(4, 13, 15, 3)
ans =  24

संबंधित, लेकिन अलग ।

code-golf  math  arithmetic  geometry 
— स्टीवी ग्रिफिन
स्रोत
1
क्या प्रश्न में बताए गए क्रम के आयामों का क्रम आवश्यक है?
— मेगो
— Sp3000
@Mego, आप चुन सकते हैं ...
— स्टीवी ग्रिफिन
@StewieGriffin वैरग्स और डायनेमिक रूप से आकार के ऐरे में मिलना मेरी भाषा में एक दर्द है (कम से कम मेरे लिए, एक शुरुआत)। क्या मैं प्रत्येक arg गिनती को संभालने के लिए चार कार्य प्रदान कर सकता हूँ?
— बिल्ली
यदि आवश्यक हो तो आप अंतिम तत्वों को शून्य पर सेट कर सकते हैं। मुझे लगता है कि इसे कवर करना चाहिए? या आप हास्केल उत्तर के रूप में कार्यों को अधिभारित कर सकते हैं। अलग-अलग नामों से आपके अलग-अलग कार्य नहीं हो सकते।
— स्टीवी ग्रिफ़िन

जवाबों:

4

MATL , 57 53 51 44 बाइट्स

3^4*3/YP*GpG1)*YP*GpG0H#)ts2/tb-p*X^3/*XhGn)

इनपुट एक सरणी है जिसमें 1, 2, 3 या 4 नंबर हैं।

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

व्याख्या

नेस्टेड ifछोरों का उपयोग करने के बजाय , जो बाइट्स के संदर्भ में महंगा है, यह किसी भी इनपुट के लिए चार संभावित परिणामों की गणना करता है, और फिर इनपुट लंबाई के आधार पर उपयुक्त परिणाम चुनता है।

परिणामों की गणना करते समय, भले ही उनमें से केवल एक को वैध होने की आवश्यकता हो, लेकिन अन्य त्रुटियां नहीं दे सकते। उदाहरण के लिए इसका मतलब है कि इनपुट के चौथे तत्व को अनुक्रमित करने की अनुमति नहीं है, क्योंकि इनपुट में चार से कम तत्व हो सकते हैं।

                    % take input implicitly
3^4*3/YP*           % compute a result which is valid for length-1 input:
                    % each entry is raised to 3 and multiplied by 4/3*pi
G                   % push input
pG1)*YP*            % compute a result which is valid for length-2 input:
                    % product of all entries, times first entry, times pi
G                   % push input
p                   % compute a result which is valid for length-3 input:
                    % product of all entries
G                   % push input
0H#)ts2/tb-p*X^3/*  % compute a result which is valid for length-4 input:
                    % shorter version of Heron's formula applied on all
                    % entries except the last, times last entry, divided by 3
Xh                  % collect all results in a cell array
G                   % push input
n)                  % pick appropriate result depending on input length
                    % display implicitly
— लुइस मेंडो
स्रोत
हेरॉन के फॉर्मूले का आप क्या उपयोग कर रहे हैं?
— Addison Crump
@CoolestVeto सेमीपाइरीमीटर वाला। यहाँ
— लुइस मेंडो
अच्छा हुआ @DonMuesli। मैंने इसे MATLAB में "केवल" 34 बाइट्स =) का उपयोग करके प्रबंधित किया
— स्टीवी ग्रिफिन
9

विट्टी, 49 बाइट्स

मुझे लगा कि आपने मुझे एक प्लेट पर सौंप दिया है, लेकिन मुझे काम करने के लिए एक अनसुलझा बग मिला। हालांकि मुझे चोट नहीं लगी।

lmN
3^43/*P*
2^*P*
**
v:++2/uV3\[V}-]V3\*12/^v*3/

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

स्पष्टीकरण, एक समय में एक पंक्ति:

lmN
l   Get the length of the stack.
 m  Go to the line index specified by the top item of the stack (the length).
  N Output as a number.

3^43/*P*
3^
          Put to the power of 3.
  43/*    Multiply by 4/3.
      P*  Multiply by π

2^*P*
2^     Put to the second power.
  *    Multiply the top two items.
   P*  Multiply by π

**
**     Multiply the top three items of the stack.

v:++2/uV3\[V}-]V3\*12/^v*3/
v                            Save the top item as a temp variable.
 :                           Duplicate the stack.
  ++                         Sum the top three values.
    2/                       Divide by two.
      u                      Flatten the top stack to the second to top.
       V                     Capture the top item of the stack (semiperimeter) 
                             as a permanent variable.
        3\[   ]              Do the stuff in the brackets 3 times.
           V}-               Subtract the semiperimeter by each item.
               V             Push the global var again.
                3\*          Multiply the top 4 items.
                   12/^      Square root.
                       v*    Multiply by the temp var (the depth)
                         3/  Divide by three.

इनपुट को कमांड लाइन की दलीलों के रूप में सटीक उलटा स्वीकार किया जाता है क्योंकि वे प्रश्न में दिखाई देते हैं, जिसमें कोई पीछे नहीं रहने वाला शून्य होता है।

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

एक तरफ के रूप में, यहां कुछ ऐसा है जो वर्तमान में विकास में है।

Java w / Vitsy पैकेज

ध्यान दें कि यह पैकेज कार्य प्रगति पर है; यह केवल यह दिखाने के लिए है कि यह भविष्य में कैसे काम करेगा (इसके लिए दस्तावेज अभी तक अपलोड नहीं किया गया है) और यह गोल्फ नहीं है , और शाब्दिक अनुवाद है:

import com.VTC.vitsy;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;

public class Volume {
    public static void main(String[] args) {
        Vitsy vitsyObj = new Vitsy(false, true);
        vitsyObj.addMethod(new Vitsy.Method() {
            public void execute() {
                vitsyObj.pushStackLength();
                vitsyObj.callMethod();
                vitsyObj.outputTopAsNum();
            }
        });
        vitsyObj.addMethod(new Vitsy.Method() {
            public void execute() {
                vitsyObj.push(new BigDecimal(3));
                vitsyObj.powerTopTwo();
                vitsyObj.push(new BigDecimal(4));
                vitsyObj.push(new BigDecimal(3));
                vitsyObj.divideTopTwo();
                vitsyObj.multiplyTopTwo();
                vitsyObj.pushpi();
                vitsyObj.multiplyTopTwo();
            }
        });
        vitsyObj.addMethod(new Vitsy.Method() {
            public void execute() {
                vitsyObj.push(new BigDecimal(2));
                vitsyObj.powerTopTwo();
                vitsyObj.multiplyTopTwo();
                vitsyObj.pushpi();
                vitsyObj.multiplyTopTwo();
            }
        });
        vitsyObj.addMethod(new Vitsy.Method() {
            public void execute() {
                vitsyObj.multiplyTopTwo();
                vitsyObj.multiplyTopTwo();
            }
        });
        vitsyObj.addMethod(new Vitsy.Method() {
            public void execute() {
                vitsyObj.tempVar();
                vitsyObj.cloneStack();
                vitsyObj.addTopTwo();
                vitsyObj.addTopTwo();
                vitsyObj.push(new BigDecimal(2));
                vitsyObj.divideTopTwo();
                vitsyObj.flatten();
                vitsyObj.globalVar();
                vitsyObj.push(new BigDecimal(3));
                vitsyObj.repeat(new Vitsy.Block() {
                    public void execute() {
                        vitsyObj.globalVar();
                        vitsyObj.rotateRight();
                        vitsyObj.subtract();
                    }
                });
                vitsyObj.globalVar();
                vitsyObj.push(new BigDecimal(3));
                vitsyObj.repeat(new Vitsy.Block() {
                    public void execute() {
                        vitsyObj.multiplyTopTwo();
                    }
                });
                vitsyObj.push(new BigDecimal(1));
                vitsyObj.push(new BigDecimal(2));
                vitsyObj.divideTopTwo();
                vitsyObj.powerTopTwo();
                vitsyObj.tempVar();
                vitsyObj.multiplyTopTwo();
                vitsyObj.push(new BigDecimal(3));
                vitsyObj.divideTopTwo();
            }
        });
        vitsyObj.run(new ArrayList(Arrays.asList(args)));
    }
}
— एडिसन क्रम्प
स्रोत
1
निश्चित रूप से नौकरी के लिए सही उपकरण
— मेगो
5

सी, 100 97 बाइट्स

#define z(a,b,c,d) d?d*sqrt(4*a*a*b*b-pow(a*a+b*b-c*c,2))/12:c?a*b*c:3.14159*(b?a*a*b:4/3.*a*a*a)

1 संपादित करें: अनावश्यक दशमलव हटा दें ., धन्यवाद इमिबिज़िस!

— जोश
स्रोत
2
4./3.बस नहीं हो सकता 4/3.? और कर सकते हैं 2.और 12.बस हो 2और 12?
— user253751
आप बिल्कुल सही हैं। धन्यवाद!
— जोश
4

जावास्क्रिप्ट ईएस 6, 129 126 125 116 114 90 बाइट्स

एक अद्भुत सूत्र के साथ बहुत सारे बाइट्स (9) की बचत की, स्टीवी ग्रिफिन के लिए धन्यवाद! चूंकि इनपुट नॉनजरो होना चाहिए, variable?एक परिभाषित-जांच के लिए पर्याप्त होगा।

with(Math){(a,b,c,h,Z=a*a)=>h?sqrt(4*Z*b*b-(D=Z+b*b-c*c)*D)/4:c?a*b*c:b?PI*Z*b:4/3*PI*Z*a}

इसका परीक्षण करो!

with(Math){Q = (a,b,c,h,Z=a*a)=>h?sqrt(4*Z*b*b-(D=Z+b*b-c*c)*D)/4:c?a*b*c:b?PI*Z*b:4/3*PI*Z*a}
console.log = x => o.innerHTML += x + "<br>";

testCases = [[4], [5.5, 2.23], [3.5, 4, 5], [4, 13, 15, 3]];
redo = _ => (o.innerHTML = "", testCases.forEach(A => console.log(`<tr><td>[${A.join(", ")}]` + "</td><td> => </td><td>" + Q.apply(window, A) + "</td></tr>")));
redo();
b.onclick = _ => {testCases.push(i.value.split(",").map(Number)); redo();}
*{font-family:Consolas,monospace;}td{padding:0 10px;}
<input id=i><button id=b>Add testcase</button><hr><table id=o></table>
स्निपेट का विस्तार करें

— कोनोर ओ ब्रायन
स्रोत
5
गणित के साथ? वैध लगता है।
— Addison Crump
Chrome 48 पर यह त्रुटियां Uncaught SyntaxError: Unexpected token =(का उल्लेख करते हुए Z=a*a)
— पैट्रिक रॉबर्ट्स
@PatrickRoberts फ़ायरफ़ॉक्स का उपयोग करें। यह लैम्ब्डा के अंदर डिफ़ॉल्ट मापदंडों के लिए अनुमति देता है।
— कोनर ओ'ब्रायन
मैं काम करने के लिए 4-arg संस्करण प्राप्त करने के लिए प्रतीत नहीं कर सकता ... और आप कभी भी उस मूल्य का उपयोग नहीं करते हैं h, जो थोड़ा सा निरीक्षण करता है।
— नील
@ नील हुह, सच। मुझे उस सूत्र को फिर से देखने की आवश्यकता होगी, स्टीवी ने अपनी टिप्पणी को हटा दिया ...
— कॉनर ओ'ब्रायन
3

हास्केल, 114 109 107 101 99 बाइट्स

v[r]=4/3*pi*r^3
v[r,h]=pi*r^2*h
v[x,y,z]=x*y*z
v[a,b,c,h]=h/12*sqrt(4*a^2*b^2-(a^2+b^2-c^2)^2)

संख्याओं की एक सूची लेता है और एक मात्रा लौटाता है। जैसे बुलाओ

v[7]

एक क्षेत्र के लिए, आदि समारोह किसी भी प्रकार के लिए बहुरूपी है जो लागू करता है sqrt (इसलिए, मूल रूप से Floatया Double)।

यह संक्षिप्तता के लिए किसी भी प्रतियोगिता को जीतने वाला नहीं है। लेकिन ध्यान दें कि यह कितना पठनीय है। यहां तक ​​कि अगर आप वास्तव में हास्केल को नहीं जानते हैं, तो आप बता सकते हैं कि यह काफी आसानी से क्या करता है। हास्केल का पैटर्न मिलान वाक्यविन्यास अजीब कार्यों को परिभाषित करना वास्तव में आसान बनाता है जो इनपुट के आकार के आधार पर कुछ पूरी तरह से अलग करते हैं।

— MathematicalOrchid
स्रोत
1
(1/3)*(1/4)*h,,, क्यों नहीं h/12? आपको बहुत सारे बाइट्स बचाता है!
— स्टीवी ग्रिफिन
1
इसके अलावा, हेरॉन के eq का संस्करण जो कॉनर का उपयोग करता है, वह बहुत छोटा लगता है।
— स्टीवी ग्रिफिन
@StewieGriffin जाहिरा तौर पर हाँ। : -}
— MathematicalOrchid
हास्केल केवल इन्फिक्स गणित के लिए पठनीय है, जो मुझे पठनीय नहीं लगता है। तो फिर तुम में मिल .और #और $और यह मेथेमेटिका सूप हो जाता है।
— बिल्ली
3

पॉवरशेल, 165 161 बाइट्स

param($a,$b,$c,$h)((($h/12)*[math]::Sqrt(($a+$b+$c)*(-$a+$b+$c)*($a-$b+$c)*($a+$b-$c))),(($a*$b*$c),((($p=[math]::PI)*$b*$a*$a),($p*$a*$a*$a*4/3))[!$b])[!$c])[!$h]

इसलिए ... कई ... डॉलर ... (161 अक्षरों में से 31 $कोड के 19.25% के लिए हैं ...), लेकिन, स्ट्यू ग्रिफिन के लिए 4 बाइट्स धन्यवाद!

हम चार इनपुट में लेते हैं, और फिर उत्तरोत्तर क्रम में छद्म-टर्नरी बयानों में उनके आधार पर अनुक्रमित करते हैं। जैसे, बाहर का (..., ...)[!$h]परीक्षण कि क्या चौथा इनपुट मौजूद है। यदि ऐसा है, तो !$hइच्छाशक्ति बराबर 0और पहली छमाही को निष्पादित किया जाता है (एक अनियमित त्रिकोणीय पिरामिड की मात्रा)। अन्यथा, !$hसाथ $h = $null(के रूप में यह अप्रारंभीकृत है) के बराबर होगा 1, तो यह दूसरी छमाही है, जो अपने आप में एक छद्म त्रिगुट पर आधारित है को जाता है[!$c] और इतने पर।

यह संभावित रूप से इष्टतम के करीब है, क्योंकि माना जाता है कि छोटे फार्मूला (जैसे) Cʀɪᴇɴ O'B close उपयोग कर रहा है, वास्तव में 2 बाइट्स लंबे समय तक PowerShell में एक ^ऑपरेटर की कमी के लिए धन्यवाद ... एकमात्र वास्तविक बचत (1/3)*(1/4)*A*$hगोल्फिंग से आती है A*$h/12, और $pलंबी [math]::PIकॉल के बजाय युगल बाइट को बचाने के लिए बाद में सेटिंग ।

— AdmBorkBork
स्रोत
1

गंभीरता से, 65 59 55 बाइट्स

`kd@;Σ½╗"╜-"£Mπ╜*√*3@/``kπ``ª*╦*``3;(^/4*╦*`k,;lD(E@i(ƒ

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

व्याख्या

यह एक डोज है। मैं स्पष्टीकरण को कई भागों में तोड़ने जा रहा हूँ।

मुख्य भाग:

`...``...``...``...`k,;lD(E@i(ƒ
`...``...``...``...`k            push 4 functions to a list
                     ,;lD        push input, len(input)-1
                         (E      get the function at index len(input)-1
                           @i(   flatten the input list
                              ƒ  execute the function

समारोह 0:

3;(^/4*╦*
3;(^       push 3, r^3
    /      divide (r^3/3)
     4*    multiply by 4 (4/3*r^3)
       ╦*  multiply by pi (4/3*pi*r^3)

समारोह 1:

ª*╦*
ª     r^2
 *    multiply by h (r^2*h)
  ╦*  multiply by pi (pi*r^2*h)

समारोह 2:

kπ  listify, product (l*w*h)

समारोह 3 (21 बाइट्स; लगभग आधे कार्यक्रम की लंबाई!)

kd@;Σ½╗"╜-"£Mπ╜*√*3@/
kd@                    listify, dequeue h, bring [a,b,c] back on top
   ;Σ½                       dupe, sum, half (semiperimeter)
      ╗                push to register 0
       "╜-"£M          map: push s, subtract (s-x for x in (a,b,c))
             π         product
              ╜*√      multiply by s, sqrt (Heron's formula for area of the base)
                 *3@/  multiply by h, divide by 3 (1/3*A*h)
— मीगो
स्रोत
1

मतलाब, 78 बाइट्स

@(a,b,c,d)pi*a^2*(4/3*a*~b+b*~c)+a*b*c*~d+d/12*(4*a^2*b^2-(a^2+b^2-c^2)^2)^.5;

काफी यकीन है कि यह इस से कम नहीं मिल सकता है। ~b, ~cऔर ~d, 0यदि प्रत्येक आयाम गैर-शून्य है। शून्य आयाम वाला एक सूत्र सिर्फ शून्य देगा। इस तरह, प्रत्येक सूत्र को संक्षेप में प्रस्तुत किया जा सकता है। नहीं ifऔर नहींelse आवश्यकता है।

इसे इस तरह से कॉल करें (या इसे ऑनलाइन यहां आज़माएं ):

g=@(a,b,c,d)pi*a^2*(4/3*a*~b+b*~c)+a*b*c*~d+d/12*(4*a^2*b^2-(a^2+b^2-c^2)^2)^.5;

g(4,0,0,0)
ans =  268.082573106329

g(5.5,2.23,0,0)
ans =  211.923986429533

g(3.5,4,5,0)
ans =  70

g(4,13,15,3)
ans =  24
— स्टीवी ग्रिफिन
स्रोत
1
चर का एक पागलपन :-) हाँ, यह किसी भी आगे छोटा करने के लिए मुश्किल लगता है
— लुइस मेंडो
शायद इसे ऑनलाइन आज़माने के लिए एक लिंक जोड़ें? ideone.com/6VZF9z
— लुइस
0

अजगर 3 2, 127 119 116 बाइट्स

किसी को क्रेडिट और गोल्फ के साथ उनकी मदद के लिए Mego । इसका श्रेय C also O'Bʀɪᴇɴ और जोश को भी जाता है रूप में मैं इस एक के लिए उनके जवाब के कुछ हिस्सों को उधार लिया।

def v(a,b,c,d):z=a*a;P=3.14159;print filter(int,[max(0,(4*z*b*b-(z+b*b-c*c)**2))**.5*d/12,a*b*c,P*z*b,P*z*a*4/3])[0]

Ungolfed:

def v(a, b, c, d):
    z = a*a
    p = 3.14159
    s = filter(int,[max(0,(4*z*b*b-(z+b*b-c*c)**2))**.5*d/12,a*b*c,P*z*b,P*z*a*4/3])
    print s[0]
— Sherlock9
स्रोत
और अधिक गढ़ा: def v(a,b,c,d):z=a*a;p=355/113;return[x for x in[(4*z*b*b-(z+b*b-c*c)**2)**.5*d/12,a*b*c,p*z*b,p*z*a*4/3]if x][0]इनपुट संभालने के साथ गद्देदार है 0।
— केवल
इसके अलावा, यदि आप इसके बजाय अजगर 2 का उपयोग करते हैं, तो आप कर सकते हैंdef v(a,b,c,d):z=a*a;P=3.14159;return filter(int,[(4*z*b*b-(z+b*b-c*c)**2)**.5*d/12,a*b*c,P*z*b,P*z*a*4/3])[0]
— ASCII- केवल
0

गणितज्ञ, 114 (103)

शुद्ध कार्य: 114

Which[(l=Length@{##})<2,4.Pi/3#1^3,l<3,#1^2.Pi#2,l<4,#1#2#3,l<5,(4#1^2#2^2-(#1^2+#2^2-#3^2)^2)^.5#4/12]~Quiet~All&

Ungolfed:

fun = Which[
  (l = Length@{##}) < 2,
    4. Pi/3 #1^3,
  l < 3,
    #1^2 Pi #2, 
  l < 4,
    #1 #2 #3, 
  l < 5,
    (4 #1^2 #2^2 - (#1^2 + #2^2 - #3^2)^2)^.5 #4/12
]~Quiet~All &

उपयोग:

fun[4]
268.083
fun[5.5, 2.23]
211.924
fun[3.5, 4, 5]
70.
fun[4, 13, 15, 3]
24.

यदि नामित कार्यों की अनुमति है: 103

f[r_]:=4.Pi/3r^3
f[r_,h_]:=r^2.Pi h
f[l_,w_,h_]:=l w h
f[a_,b_,c_,h_]:=(4a^2b^2-(a^2+b^2-c^2)^2)^.5h/12

उपयोग:

f[4]
268.083
f[5.5, 2.23]
211.924
f[3.5, 4, 5]
70.
f[4, 13, 15, 3]
24.
— shrx
स्रोत
1
#1==#, मुझे लगता है Quiet[x_]:=Quiet[x,All]और I (एक मैक पर Alt-P) विस्तारित ASCII में फिट बैठता है।
— कैलक्यूलेटरफलाइन
आप को बदल नहीं सकता #1 #2 #3के साथ 1##? मत भूलना#==#1
— कैलक्यूलेटर
0

फैक्टर, 783 बाइट्स

खैर, यह हमेशा के लिए ले लिया।

USING: arrays combinators io kernel locals math math.constants math.functions quotations.private sequences sequences.generalizations prettyprint ;
: 1explode ( a -- x y ) dup first swap 1 tail ;
: 3explode ( a -- b c d ) 1explode 1explode 1explode drop ;
: spr ( r -- i ) first 3 ^ 4 3 / pi * swap * ;
: cyl ( r -- i ) 1explode 1explode drop 2 ^ pi swap * * ; : cub ( v -- i ) 1 [ * ] reduce ;
: A ( x a -- b d ) reverse dup dup dup 0 [ + ] reduce -rot 3explode neg + + -rot 3explode - + 3array swap 3explode + - 1array append 1 [ * ] reduce sqrt .25 swap * ;
: ilt ( a -- b c  ) V{ } clone-like dup pop swap A 1 3 / swap pick * * ;
: volume ( v -- e ) dup length { { [ 1 = ] [ spr ] } { [ 2 = ] [ cyl ] } { [ 3 = ] [ cub ] } { [ 4 = ] [ ilt ] } [ "bad length" throw ] } cond print ;

पुकारते हैं { array of numbers } volume।

— बिल्ली
स्रोत
@StewieGriffin: PI कार्यों के नामों को छोटा करना भूल गया। हालांकि ज्यादा मदद नहीं करेगा।
— बिल्ली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.