क्रिसमस के लिए आपको कितना वर्तमान मिला?


32

हां, कितना , कितने नहीं ...

जैसा कि हम सभी जानते हैं, एक बड़ा वर्तमान एक छोटे से कहीं बेहतर है। इसलिए, प्रस्तुत का मूल्य हमेशा कुल मात्रा में मापा जाना चाहिए, न कि उपहारों की संख्या, वजन, या यहां तक ​​कि संयुक्त मूल्य।

जैसा कि इसे प्रस्तुत किए जाने वाले उपहारों की मात्रा की तुलना करना है, आप एक लंबी स्क्रिप्ट नहीं चाहते हैं जो आसानी से क्रिसमस पार्टी में दूसरों द्वारा देखी और पढ़ी जाए। इसलिए आपको अपनी स्क्रिप्ट में बाइट्स की संख्या न्यूनतम रखने की आवश्यकता है।

आपका कार्य सरल है: एक प्रोग्राम बनाएं जो किसी उपयुक्त प्रारूप पर इनपुट के रूप में आयामों की एक सूची लेता है, और आपके प्रस्तुत की संयुक्त मात्रा को आउटपुट करता है। प्रत्येक वर्तमान का आयाम या तो तीन संख्याओं का एक समूह होगा, या एकल संख्या। यदि इनपुट तीन नंबर ( L, W, H) है, तो वर्तमान आयामों का घनाभ है L x W x H। यदि यह एकल संख्या ( R) है, तो वर्तमान त्रिज्या का एक क्षेत्र है R

नियम:

  • यह या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन हो सकता है
  • इनपुट किसी भी सुविधाजनक प्रारूप में हो सकता है
    • यदि वांछनीय है, तो एक क्षेत्र को दो शून्य के बाद एक संख्या द्वारा दर्शाया जा सकता है
    • एक घनाभ के पास हमेशा सभी गैर-शून्य आयाम होंगे।
  • आउटपुट एक एकल दशमलव संख्या होना चाहिए
    • अतिरिक्त आउटपुट को तब तक स्वीकार किया जाता है जब तक यह स्पष्ट न हो कि उत्तर क्या है
    • दशमलव बिंदु के बाद आउटपुट में कम से कम दो अंक होने चाहिए
    • यदि मानक 1000 से बड़ा है तो आउटपुट मानक रूप / वैज्ञानिक संकेतन में हो सकता है।
    • यदि आपकी भाषा में पीआई-स्थिरांक नहीं है, तो उत्तर 9999.99 तक सटीक होना चाहिए।

उदाहरण:

((1,4,3),(2,2,2),(3),(4,4,4))
197.0973    // (1*4*3 + 2*2*2 + 4/3*pi*3^3 + 4*4*4)

(5)
523.5988

(5,0,0)
523.5988

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

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

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


3
किसी भी महिला को उन मज़ेदार बेलनाकार बक्से में से एक में टोपी नहीं मिलती है ?
मैनटवर्क

2
@manatwork, नहीं, सभी महिलाओं को गेंदबाज टोपी मिलेंगी, और आप आसानी से उन लोगों को एक गोले में फिट कर सकते हैं = पी
स्टीवी ग्रिफिन

1
मुझे लगता है (5)कि सिर्फ आंशिक उदाहरण है और हमारे कोड को केवल संभालना है ((5))
12

2
यदि हमारी पसंद की भाषा में पीआई स्थिर नहीं है, तो कितनी सटीकता की आवश्यकता है?
डेनिस

1
@manatwork, + और * तब तक ठीक हैं जब तक कि वे आपके द्वारा उपयोग की जाने वाली भाषा में जोड़ और गुणा (या अन्य संचालन) का मतलब नहीं करते हैं।
स्टू ग्रिफिन

जवाबों:


10

जेली , 19 18 बाइट्स

Zµ*3×1420÷339Ḣo@PS

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

दुर्भाग्य से, जेली एक नहीं है π लगातार अभी तक, और vectorizer तैरता ठीक से संभाल नहीं है।

इन मुद्दों को दूर करने के लिए, 4 these / 3 से गुणा करने के बजाय , हम 1420 से गुणा करते हैं और 339 से विभाजित करते हैं । के बाद से 1420 ÷ 339 = ४.१,८८,७९,०५६ ... और 4π / 3 = ४.१,८८,७९,०२० ... , इस लिए पर्याप्त रूप से नियमों का पालन करने के लिए सटीक है।

जेली का नवीनतम संस्करण 14 बाइट्स में बेहतर सटीकता के साथ इस कार्य को पूरा कर सकता है ।

Zµ*3×240°Ḣo@PS

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

यह काम किस प्रकार करता है

Zµ*3×1420÷339Ḣo@PS  Left argument: A, e.g., [[1, 2, 3], [4, 0, 0]]

Z                   Zip A; turn A into [[1, 4], [2, 0], [3, 0]].
 µ                  Begin a new, monadic chain with zip(A) as left argument.
  *3                Cube all involved numbers.
    ×1420           Multiply all involved numbers by 1420.
         ÷339       Divide all involved numbers by 339.
                    This calculates [[4.19, 268.08], [33.51, 0], [113.10, 0]]
             Ḣ      Head; retrieve the first array.
                    This yields [4.19, 268.08].
                P   Take the product across the columns of zip(A).
                    This yields [6, 0].
              o@    Apply logical OR with swapped argument order to the results.
                    This replaces zeroes in the product with the corresponding
                    results from the left, yielding [6, 268.08].
                 S  Compute the sum of the resulting numbers.

इसके ×240°बजाय गैर-प्रतिस्पर्धात्मक संस्करण का उपयोग करता है ×1420÷339, जो 240 से गुणा करता है और उत्पादों को रेडियंस में परिवर्तित करता है।


9

हास्केल, 40 बाइट्स

q[x]=4/3*pi*x^^3
q x=product x
sum.map q

प्रयोग उदाहरण: sum.map q $ [[1,4,3],[2,2,2],[3],[4,4,4]]-> 197.09733552923254

यह कैसे काम करता है: इनपुट सूची के प्रत्येक तत्व के लिए: यदि इसके पास एक भी तत्व है x, जो गोला के आयतन की गणना करता है, तो अन्य को लें product। इसे जोड़ो।


1
क्या बाइट्स गिनने का यह तरीका आम तौर पर मान्य है? मैंने कहा होगा p=sum.map q(और फिर pसंख्याओं की सूची की सूची का उपयोग करने के लिए कहा गया )
लीफ विलर्ट्स

1
@LeifWillerts: मेटा पर एक हालिया विषय है जो वैश्विक कार्यों पर रिले करने वाले अनाम कार्यों की अनुमति देता है। sum.map qएक अनाम फ़ंक्शन है जो निर्भर करता है q, इसलिए मुझे लगता है कि यह ठीक है।
nimi

9

पायथ, 19 18 बाइट्स

sm|*Fd*.tC\ð7^hd3Q

1 बाइट डेनिस के लिए धन्यवाद

प्रदर्शन

इनपुट प्रारूप सूची की सूची है:

[[1,4,3],[2,2,2],[3,0,0],[4,4,4]]

यह बस घन मात्रा की गणना करने के लिए आयामों को एक साथ गुणा करता है। यदि वह शून्य पर आता है, तो यह गोलाकार आयतन की गणना करता है।

क्षेत्र स्थिर, 4/3*piरेडियन में 240 डिग्री के रूप में गणना की जाती है। .t ... 7एक इनपुट को रेडियन में डिग्री में परिवर्तित करता है, और C\ðकोड पॉइंट की गणना करता है ð, जो कि 240 है।


7

पायथन 2, 86 70 बाइट्स

lambda i:sum(x[0]*x[1]*x[2]if len(x)>1 else x[0]**3*4.18879for x in i)

मुझे आपकी बाइट गिनती 86 के रूप में मिलती है , आपको कैसे मिला?
13

इसके अतिरिक्त, आप पाई को केवल मैन्युअल रूप से डालकर बाइट्स को बचा सकते हैं, आप 3.14159265358979323ब्रेक अप करने के लिए भी उपयोग कर सकते हैं
wnnmaw

@wnnmaw मैं आयात को गिनना भूल गया।
TFeld

मेरा मानना ​​है कि पीआई के लिए आपका हार्डकोडेड मूल्य थोडा हटकर है :)
wnnmaw

4
@wnnmaw यह पाई नहीं है; यह 4Pi / 3 है।
डेनिस

5

गणितज्ञ, 34 बाइट्स

Tr[1.##&@@@(#/.{r_}:>{4r^3/3Pi})]&

एक अनाम फ़ंक्शन जो लंबाई की नेस्टेड सूची लेता है और वॉल्यूम को वास्तविक संख्या के रूप में वापस करता है।

हम पहले एकल मान को उसी क्षेत्र के आयतन से बदलते हैं /.{r_}:>{4r^3/3Pi}। फिर हम प्रत्येक सूची की सामग्री के साथ गुणा करते हैं 1.##&@@@। अंत में हम इस योग की गणना वेक्टर के ट्रेस के रूप में करते हैं Tr[...]


5

जावास्क्रिप्ट (ईएस 6), 56

l=>l.map(([x,y,z])=>t+=y?x*y*z:x*x*x*4/3*Math.PI,t=0)&&t

अधिक समझदार .reduce संस्करण 1 बाइट लंबा है

l=>l.reduce((t,[x,y,z])=>t+(y?x*y*z:x*x*x*4/3*Math.PI),0)

के 4.11879स्थान पर उपयोग करके आप बाइट्स के एक जोड़े को बचा सकते हैं 4/3*Math.PI, क्योंकि यह अर्हता प्राप्त करने के लिए पर्याप्त सटीक होना चाहिए।
ETHproductions

@ETHproductions हाँ, लेकिन In case your language doesn't have a Pi-constant,और मेरी भाषा में एक PI स्थिर है, इसलिए मुझे नहीं पता कि क्या यह योग्य है
edc65

5

पायथन, 49 बाइट्स

lambda l:sum(a*b*c or a**3*4.18879for a,b,c in l)

के रूप में क्षेत्रों के प्रतिनिधित्व का उपयोग करता है (a,0,0)। क्यूबॉइड के रूप में माना जाता है, इसमें वॉल्यूम 0 होता है, इस मामले में इसके बजाय गोलाकार मात्रा का उपयोग किया जाता है। मुझे स्पष्ट नहीं है कि निरंतरता कितनी सटीक होनी चाहिए, इसलिए मुझे आशा है कि यह पर्याप्त है।


4

MATL , 20 बाइट्स

it!ptbw~)3^4*3/XT*hs

इनपुट प्रारूप एक मैट्रिक्स है जिसमें प्रत्येक पंक्ति एक घन या एक क्षेत्र का वर्णन करती है। एक गोले को उस पंक्ति में केवल पहले नंबर से परिभाषित किया जाता है; अन्य दो संख्याएँ शून्य हैं। तो चुनौती से पहला उदाहरण होगा:

[1 4 3; 2 2 2; 3 0 0; 4 4 4]

यह भाषा की वर्तमान रिलीज़ 2.0.2 का उपयोग करता है , जो इस चुनौती से पहले है।

उदाहरण:

>> matl it!ptbw~)3^4*3/XT*hs
> [1 4 3; 2 2 2; 3 0 0; 4 4 4]
197.0973355292326

>> matl it!ptbw~)3^4*3/XT*hs
> [5 0 0]
523.5987755982989

स्पष्टीकरण:

i             % input matrix
t!            % duplicate and transpose: each object is now a column
p             % product of elements in each column
t             % duplicate                                               
b             % bubble up top-third element in stack                              
w             % swap top two elements in stack                                  
~             % logical 'not'. This gives logical index of speheres                 
)             % reference () indexing. This is a logical-linear index to get sphere radii
3^4*3/XT*     % formula for volume of spehere; element-wise operations
h             % horizontal concatenation                                
s             % sum                

3

प्रोलॉग, 115 100 बाइट्स

कोड:

[]*0.
[[L,W,H]|T]*V:-W=0,X is 4*pi*L^3/3,T*Y,V is X+Y;X is L*W*H,T*Y,V is X+Y.
p(L):-L*V,write(V).

व्याख्या की:

[]*0.
[[L,W,H]|T]*V:-W=0,                           % When 2nd dimension is 0
                  X is 4*pi*L^3/3,            % Calc volume of sphere
                  T*Y,                        % Recurse over list
                  V is X+Y                    % Sum volumes
                  ;                           % When we have a cube
                  X is L*W*H,                 % Calc cube volume
                  T*Y                         % Recurse over list
                  V is X+Y.                   % Sum volumes
p(L):-L*V,                                    % Get combined volume of list of lists
      write(V).                               % Print volume

उदाहरण:

p([[1,4,3],[2,2,2],[3,0,0],[4,4,4]]).
197.09733552923257

p([[5,0,0]]).
523.5987755982989

इसे यहाँ ऑनलाइन आज़माएँ

संपादित करें: एक डाईडिक विधेय को परिभाषित करके 15 बाइट्स बचाए गए।


3

पर्ल, 52 47 बाइट्स

s/,/*/g||s@$@**3*4.18879@,$\+=eval for/\S+/g}{

46 + 1 के लिए -p(यह आम बात है; मुझे बताएं कि क्या यह यहां अलग है और मैं अपडेट करूंगा)

उपयोग: एक फ़ाइल में डाल दिया और echo 1,4,3 2,2,2 3 4,4,4 | perl -p x.pl

टिप्पणियों के साथ:

s/,/*/g                # x,y,z becomes x*y*z
||                     # if that fails,
s@$@**3*1420/339@      # x becomes x**3 * 1420/339
,                      # 
$\+=eval               # evaluate the expression and accumulate
for/\S+/g              # iterate groups of non-whitespace
}{                     # -p adds while(<>){...}continue{print}; resets $_

अपडेट 47 इस ट्रिक का उपयोग करके कुछ बाइट्स बचाने के लिए @ डेनिस के लिए धन्यवाद ।


s/,/*/g||s@$@**3*4.18879@,$\+=eval for/\S+/g;}{कुछ बाइट्स बचाता है।
डेनिस

@ डेनिस धन्यवाद! मैंने $ \ _ के साथ पहले प्रयास किया लेकिन $_लागत को अधिक से अधिक रीसेट करना। फिर भी स्पष्ट नहीं है कि $_नए ब्लॉक में रीसेट क्यों किया जाता है, हालांकि .. $_ब्लॉक-लोकल है while(<>){}?
केनी

हां, $_वर्तमान क्षेत्र का डिफ़ॉल्ट चर है। END ब्लॉक में, यह अपरिभाषित है।
डेनिस

2

सीजेएम, 24 21 बाइट्स

q~{3*)4P*3/*+3<:*}%:+

इसका परीक्षण यहां करें।

व्याख्या

q~       e# Read and evaluate input.
{        e# Map this block over the list of presents...
  3*     e#   Repeat the list of lengths 3 times. This will expand cuboids to 9 elements
         e#   and spheres to three copies of the radius.
  )      e#   Pull off the last element.
  4P*3/* e#   Multiply by 4 pi / 3.
  +      e#   Add it back to the list of lengths.
  3<     e#   Truncate to 3 elements. This is a no-op for spheres, which now have three
         e#   elements [r r 4*pi/3*r] but discards everything we've done to cuboids, such
         e#   that they're reduced to their three side lengths again.
  :*     e#   Multiply the three numbers in the list.
}%
:+       e# Sum all the individual volumes.

2

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

($args|%{($_,((,$_*3)+4.18879))[$_.count-eq1]-join'*'})-join'+'|iex

यहां कुछ काला जादू हो रहा है। मैं इसके माध्यम से आसानी से चलने की कोशिश करूँगा।

हम पहले अपना इनपुट लेते हैं, जैसे कि व्यक्तिगत कॉमा-सीमांकित सरणियों की अपेक्षा की जाती है (1,4,3) (2,2,2) (3) (4,4,4), और पाइप को एक लूप में |%{}

लूप के अंदर, हम पहले जांचते हैं कि क्या हम $_जिस विशेष सरणी पर विचार कर रहे हैं, उसके पास केवल एक ही आइटम है और इसका उपयोग उस सरणी में अनुक्रमित करने के लिए किया जा सकता है (अनिवार्य रूप से छोटा / यदि निर्माण हो)। यदि यह एक से अधिक आइटम है, तो (1,4,3)इनपुट के रूप में मान लें , हम पहले आधे भाग को निष्पादित करते हैं, जो कि सरणी के माध्यम से बाहर थूकना है $_, जैसे कि (1,4,3)। अन्यथा, हम तत्व के साथ तीन बार एक नया गतिशील सरणी बनाते हैं (,$_*3)और 4/3 * पाई के सन्निकटन से निपटते हैं। इनपुट के लिए (3), इसका परिणाम (3,3,3,4.18879)आउटपुट होगा।

हां, PowerShell में एक पीआई कंटीन्यू है, जिसे .NET कॉल के माध्यम से एक्सेस किया जाता है [math]::PI, लेकिन यह अधिक लंबा है और मैं इसका उपयोग नहीं करना चाहता। : p

भले ही, हम उस उत्पादन सरणी को तारांकन के माध्यम से -join'*', इसलिए "1*4*3"। एक बार जब हम पूरी तरह से लूप के माध्यम से हो जाते हैं, तो हमारे पास अब स्ट्रिंग्स का एक संग्रह होता है। हम -join'+'उन सभी को एक साथ जोड़ते हैं, और iexपरिणाम की गणना करने के लिए अभिव्यक्ति।

ओह।


1

रूबी, 58 वर्ण

->b{b.reduce(0){|t,s|a,b,c=*s;t+(c ?a*b*c :a**3*4.18879)}}

नमूना रन:

2.1.5 :001 ->b{b.reduce(0){|t,s|a,b,c=*s;t+(c ?a*b*c :a**3*4.18879)}}[[[1,4,3],[2,2,2],[3],[4,4,4]]]
 => 197.09733

रूबी, 50 अक्षर

सुधार विचार बेशर्मी से edc65 के जावास्क्रिप्ट जवाब से चुराया गया है ।

->b{t=0;b.map{|a,b,c|t+=c ?a*b*c :a**3*4.18879};t}

नमूना रन:

2.1.5 :001 > ->b{t=0;b.map{|a,b,c|t+=c ?a*b*c :a**3*4.18879};t}[[[1,4,3],[2,2,2],[3],[4,4,4]]]
 => 197.09733

1

जाप, 27 22 बाइट्स

N®r*1 ª4/3*M.P*Zg ³} x

अंतरिक्ष-पृथक सरणियों के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

N®   r*1 ª 4/3*M.P*Zg ³  } x
NmZ{Zr*1 ||4/3*M.P*Zg p3 } x

          // Implicit: N = array of input arrays
NmZ{   }  // Map each item Z in N to:
Zr*1      //  Reduce Z with multiplication.
||4/3*M.P //  If this is falsy, calculate 4/3 times Pi
*Zg p3    //  times the first item in Z to the 3rd power.
x         // Sum the result.
          // Implicit: output last expression


1

पिप , 23 बाइट्स

{$*a|4/3*PI*@a**3}MSg^s

इस कार्यक्रम को इनपुट देने के लिए कुछ तरीके हैं। यह प्रत्येक को तीन अंतरिक्ष-पृथक संख्याओं के कमांड-लाइन तर्क के रूप में ले सकता है (जिसे उद्धरणों में लपेटने की आवश्यकता होगी:) pip.py present.pip "1 4 3" "3 0 0"। वैकल्पिक रूप से, -rध्वज को निर्दिष्ट करें और प्रत्येक को तीन अंतरिक्ष-पृथक संख्याओं से मिलकर स्टड की एक पंक्ति के रूप में प्रस्तुत करें। इसे ऑनलाइन आज़माएं!

कैसे?

                         g is list of cmdline args (or lines of stdin, if using -r flag)
                         s is space, PI is what it says on the tin (implicit)
                    g^s  Split each argument on spaces, so we have a list of lists
{                }MS     Map this function to each sublist and sum the results:
 $*a                      Fold the list on * (i.e. take the product)
    |                     Logical OR: if the above value is zero, use this value instead:
     4/3*PI*              4/3 pi, times
            @a            First element of the list
              **3         Cubed
                         Autoprint the result

0

पर्ल 5, 142 बाइट्स

साथ चलाने के लिए -pकमांड लाइन में, और प्रकार संख्या, एक अल्पविराम से सीमांकित इसलिए की तरह:

5,0,0 या (5,0,0)

उत्पादन होगा

523.598820058997

piपर्ल में कोई कीवर्ड नहीं है । यह, ज्यादातर मामलों में, निर्दिष्ट किए गए महत्वपूर्ण आंकड़ों के लिए सटीक है, हालांकि अगर मुझे पता है कि पीआई के सभी आंकड़े टाइप किए गए हैं, तो भी यह कुछ गणनाओं के लिए बहुत सटीक नहीं होगा। इसलिए मैंने इसे छोड़ दिया 3.1415। मैं अनिश्चित हूं कि यह स्वीकार्य है या नहीं।

कोड:

@a=$_=~/(\d+,*)/g;$_=0;@n = map(split(/\D/),@a);for($i=0;$i<$#n;$i+=3){$x=$n[$i];$n[$i+1]==0?$_+=1420/339*$x**3:$_+=($x*$n[$i+1]*$n[$i+2]);}

डेनिस की सलाह पर अधिक सटीकता के लिए संपादित किया गया, जो कि बुनियादी गणित में मुझसे बेहतर है, और माइकलटी द्वारा बाइट को सटीक रूप से बचाए रखने के सुझाव से।


2
1. आप कैसे पार्स करेंगे 1511? 3. 2.1415 न तो ठीक से गोल है और न ही पर्याप्त रूप से सटीक है। यदि मेरी गणना सही है, तो त्रुटि 0.0000017 से अधिक नहीं होनी चाहिए । 3. (4/3)*3.1415एक फ्लोट के साथ प्रतिस्थापित किया जा सकता है।
डेनिस

1. ओपी कहते हैं कि हम मान सकते हैं कि शून्य का क्षेत्र के लिए है (जो वास्तव में उदाहरण इनपुट मैंने प्रदान किया है), 2. मुझे नहीं पता कि आप किस गणना का उपयोग कर रहे हैं, लेकिन मुझे यकीन है, मैं सटीकता बढ़ाऊंगा, और 3 अच्छा सुझाव है, मैं उस एक को याद किया। धन्यवाद!
कोडफुन 64

मेरे पास इस समय मेरे सामने संसाधन नहीं हैं, हालांकि मुझे आश्चर्य है कि क्या करने से 1420/339आपको कुछ समय के लिए एक उचित सन्निकटन मिल जाएगा। (यह 4/3 * 355/113 है)। -8.49130615e-8 के अंतर और मान के बीच का अंतर है

@MichaelT यह सबसे दिलचस्प बात है। क्या आपके पास एक स्क्रिप्ट है जो संख्याओं के सबसे छोटे अंशों का प्रतिनिधित्व करती है? ;)
कोडफुन 64

Codefun64 मैं सिर्फ पाई के लिए अन्य सामान्य सन्निकटन से दूर काम किया । 22/7 पर्याप्त सहिष्णुता के भीतर नहीं है, इसलिए मैंने en.wikipedia.org/wiki/Approximations_of_%CF%80 पर नज़र डाली, अगले एक का उपयोग यह देखने के लिए किया कि क्या यह सहिष्णुता से बेहतर है जो @ डेनिस पूछ रहा था।

0

लुआ, 115 104 बाइट्स

function f(a)b=0 for i=1,#a do c=a[i]b=b+(1<#c and c[1]*c[2]*c[3]or(4/3)*math.pi*c[1]^3)end return b end

सीधा हल, मुझे <condition> and <non-false> or <value if false>कोष्ठक में छद्म-टर्नरी ऑपरेशन को लपेटना होगा बी दोनों क्षेत्रों के साथ बी सम।

इनपुट फॉर्म में होना चाहिए array={{1,4,3},{2,2,2},{3},{4,4,4}}और परिणाम निष्पादित करके देखा जा सकता है print(f(array))


0

05AB1E , 18 16 बाइट्स

εDgi3m4žq*3/*]PO

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

स्पष्टीकरण:

ε                # Map each inner list of the (implicit) input to:
 D               #  Duplicate the current inner list
  gi             #  Is the length 1 (is it an `R`):
    3m           #   Take the duplicated current item and take its cube
                 #    i.e. [3] → [27]
      žq         #   PI
        4*       #   Multiplied by 4
          3/     #   Divided by 3
                 #    → 4.1887902047863905
            *    #   And multiply it with the current cubed `R`
                 #    [27] and 4.1887902047863905 → [113.09733552923254]
]                # Close both the if and map
 P               # Take the product of each inner list
                 #  i.e. [[1,4,3],[2,2,2],[113.09733552923254],[4,4,4]]
                 #   → [12,8,113.09733552923254,64]
  O              # Take the total sum (and output implicitly)
                 #  i.e. [12,8,113.09733552923254,64] → 197.09733552923254

0

आर, 38 36 बाइट्स

function(x,y=4*pi/3*x,z=x)sum(x*y*z)

मामलों के बीच स्विच करने के लिए डिफ़ॉल्ट तर्कों का उपयोग करता है: तीन तर्कों के साथ उत्पाद की गणना करता है, और एक तर्क के साथ क्षेत्र सूत्र की गणना करता है।


क्या आपको f<-और की जरूरत है {}?
ग्यूसेप

यह कोड परीक्षण मामले के लिए सही तरीके से आउटपुट नहीं करता है (5,0,0)। इसके अलावा, यह परीक्षण के मामले को समायोजित नहीं करता है जहां कई प्रस्तुतियां हैं और वॉल्यूम को एक साथ समन करने की आवश्यकता है।
राबर्ट एस।

(5,0,0) के लिए मुझे शून्य मिलता है - क्या यह सही नहीं है? का उपयोग करने के लिए संपादित किया है sum(और कुछ सामान है जो Giuseppe के सुझाव के अनुसार आवश्यक नहीं था)
JDL
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.