คุณสามารถกำหนดปริมาณของวัตถุตามชุดมิติที่กำหนด:

• ปริมาตรของทรงกลมสามารถกำหนดได้โดยใช้หมายเลขเดียวรัศมี ( 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ซึ่งสูตรของ HeronAกำหนด: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(ตัวเลขเพิ่มเติมตกลง)
  • วิธีปัดเศษค่าที่ไม่ถูกต้องเป็นทางเลือก
• พฤติกรรมสำหรับการป้อนข้อมูลที่ไม่ถูกต้องจะไม่ได้กำหนด
• กฎมาตรฐานสำหรับ I / O อินพุตสามารถเป็นรายการหรืออาร์กิวเมนต์ที่แยกกัน

นี่คือรหัสกอล์ฟดังนั้นทางออกที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ:

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

ที่เกี่ยวข้อง แต่ที่แตกต่างกัน

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

Vitsy, 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)));
    }
}

C, 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: ลบทศนิยมที่ไม่จำเป็น.ขอบคุณ Immibis!

JavaScript ES6, _{129 126 125 116 114} 90 ไบต์

จำนวนไบต์ที่บันทึกไว้ (9) ด้วยสูตรที่ยอดเยี่ยมต้องขอบคุณ Stewie Griffin! เนื่องจากอินพุตต้องไม่ใช่ศูนย์จึง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>

Haskell, 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]

สำหรับทรงกลม ฯลฯ ฟังก์ชั่นคือ polymorphic สำหรับประเภทใด ๆ ที่ดำเนินการsqrt(ดังนั้นโดยทั่วไปFloatหรือDouble)

มันจะไม่ชนะการแข่งขันใด ๆ ด้วยความกะทัดรัด แต่ให้สังเกตว่ามันอ่านได้อย่างไร แม้ว่าคุณจะไม่รู้จัก Haskell จริงๆคุณสามารถบอกได้ว่ามันทำอะไรได้ง่ายมาก ไวยากรณ์การจับคู่รูปแบบของ Haskell ทำให้ง่ายต่อการกำหนดฟังก์ชั่นแปลก ๆ ที่ทำสิ่งต่าง ๆ โดยสิ้นเชิงขึ้นอยู่กับรูปร่างของอินพุต

PowerShell, 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]

ดังนั้น ... หลาย ๆ ... ดอลลาร์ ... (31 จาก 161 ตัวอักษร$สำหรับรหัส 19.25%) ... แต่บันทึก 4 ไบต์ขอบคุณ Stewie Griffin!

เรารับข้อมูลเข้าสี่รายการจากนั้นจัดทำดัชนีอย่างต่อเนื่องเป็นงบเทียมที่ประกอบไปด้วยลำดับที่กลับกัน เช่นการ(..., ...)[!$h]ทดสอบภายนอกว่ามีอินพุตที่สี่อยู่หรือไม่ ถ้าเป็นเช่นนั้น!$hจะเท่ากับ0และครึ่งแรกจะถูกดำเนินการ (ปริมาณของปิรามิดสามเหลี่ยมที่ผิดปกติ) มิฉะนั้น!$hมี$h = $null(ที่มัน uninitialized) จะเท่ากับ1ดังนั้นมันจะไปในช่วงครึ่งหลังที่ตัวเองเป็นหลอก ternary อยู่บนพื้นฐาน[!$c]และอื่น ๆ

นี่น่าจะใกล้เคียงกับสูตรที่เหมาะสมเนื่องจากสูตรที่สั้นกว่าที่คาดการณ์ไว้ (เช่น) Cᴏɴᴏʀ O'B Powerกำลังใช้งานจริงใน PowerShell อีก 2 ไบต์เนื่องจากการขาดตัว^ดำเนินการ ... การประหยัดที่แท้จริงมาจากการ(1/3)*(1/4)*A*$hเล่นกอล์ฟจนถึงA*$h/12และ การตั้งค่าใน$pภายหลังเพื่อบันทึกสองสามไบต์แทนการ[math]::PIโทรที่มีความยาว

CJam, 67 66 ไบต์

q~0-_,([{~3#4*P*3/}{~\_**P*}{:*}{)\a4*(a\[1W1]e!..*+::+:*mq*C/}]=~

ฉันจะทำงานให้สั้นลงในไม่ช้า ลองออนไลน์ !

คำอธิบายที่จะมา

อย่างจริงจัง65 59 55 ไบต์

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

ลองออนไลน์!

คำอธิบาย

อันนี้เป็น doozy ฉันจะแยกคำอธิบายออกเป็นหลายส่วน

ตัวหลัก:

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

Matlab, 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

Python 3 2, 127 119 116 ไบต์

ให้เครดิตกับใครบางคนและMegoสำหรับความช่วยเหลือด้านการเล่นกอล์ฟ ให้เครดิตกับCᴏɴᴏʀO'BʀɪᴇɴและJosh ด้วยขณะที่ฉันยืมคำตอบบางส่วนสำหรับสิ่งนี้

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]

Mathematica, 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.

ตัวคูณ 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.