주어진 치수 세트를 기반으로 객체의 부피를 결정할 수 있습니다.

• 구의 부피는 단일 숫자, 반경 ( 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))

규칙 및 설명 :

• 입력은 정수 및 / 또는 소수 일 수 있습니다.
• 모든 입력 치수가 양수라고 가정 할 수 있습니다
• Pi가 하드 코딩 된 경우 최대 정확해야합니다 3.14159.
• 더 적은 숫자로 정확하게 표현 될 수있는 숫자를 제외하고, 출력에는 유효 숫자가 6 자리 이상이어야합니다. 당신은 출력 할 수있는 3/4등 0.75,하지만 4/3해야합니다 1.33333(자세한 숫자는 OK입니다)
  • 부정확 한 값을 반올림하는 방법은 선택 사항입니다
• 유효하지 않은 입력에 대한 동작은 정의되어 있지 않습니다
• 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바이트 단위로 비싼 중첩 루프 를 사용하는 대신 입력에 대해 4 가지 가능한 결과를 계산 한 다음 입력 길이에 따라 적절한 결과를 선택합니다.

결과를 계산할 때 결과 중 하나만 유효하더라도 다른 것들은 오류를 줄 수 없습니다. 예를 들어 입력에 4 개 미만의 요소가있을 수 있으므로 입력의 4 번째 요소를 색인화 할 수 없습니다.

                    % 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.

입력은 질문에 표시되는대로 정확하게 0으로 끝나지 않고 명령 행 인수로 허용됩니다.

온라인으로 사용해보십시오!

제쳐두고, 여기에 현재 개발중인 것이 있습니다.

Vitsy 패키지를 포함한 Java

이 패키지는 진행 중입니다. 이것은 미래에 이것이 어떻게 작동하는지 보여주기위한 것입니다 (이 문서는 아직 업로드되지 않았습니다). 골프 되지 않았 으며 문자 그대로의 번역입니다.

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 : 불필요한 소수점을 제거하십시오 ..

자바 스크립트 ES6, _{129 126 125 116 114} 90 바이트

Stewie Griffin 덕분에 멋진 수식으로 많은 바이트 (9)를 절약했습니다! 입력은 0이 아니어야하므로 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>

하스켈, 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)에 대해 다형성입니다 .

간결한 경쟁에서 이길 수는 없습니다. 그러나 읽기 쉬운 지 확인 하십시오. 실제로 Haskell을 모르더라도 그 기능을 쉽게 알 수 있습니다. Haskell의 패턴 일치 구문을 사용하면 입력 형태에 따라 완전히 다른 기능을 수행하는 이상한 함수를 쉽게 정의 할 수 있습니다.

PowerShell, 165161 바이트

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 %입니다) ...하지만 Stewie Griffin 덕분에 4 바이트가 절약되었습니다!

우리는 4 개의 입력을받은 다음, 그것들을 기반으로 의사 삼진 문에 점진적으로 색인합니다. 예를 들어 외부 (..., ...)[!$h]는 네 번째 입력이 있는지 테스트합니다. 그렇다면 !$h의지가 같고 0전반이 실행됩니다 (불규칙한 삼각 피라미드의 양). 그렇지 않으면 !$hwith $h = $null(초기화되지 않음)는 같으 1므로 후반으로 넘어갑니다 [!$c].

예를 들어 Cᴏɴᴏʀ O'Bʀɪᴇɴ 가 사용 하는 더 짧은 공식 은 ^연산자 가 없기 때문에 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 bytes

`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치수 각각 영이 아닌 경우. 치수가 0 인 수식은 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

파이썬 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]

언 골프 드 :

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]

매스 매 티카, 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&

언 골프 드 :

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.