Belirli bir boyut kümesine göre nesnelerin hacmini belirleyebilirsiniz:

• Bir kürenin hacmi, tek bir sayı, yarıçap ( r) kullanılarak belirlenebilir.
• Bir silindirin hacmi, yarıçap ( r) ve yükseklik ( h) olmak üzere iki sayı kullanılarak belirlenebilir.
• Bir kutunun hacmi, uzunluk ( l), genişlik ( w) ve yükseklik ( h) olmak üzere üç sayı kullanılarak belirlenebilir.
• Düzensiz üçgen piramidin hacmi dört sayı, yan uzunluklar ( a, b, c) ve yükseklik ( h) kullanılarak belirlenebilir.

Zorluk, aşağıdaki girdilerden birine verilen bir nesnenin hacmini belirlemektir:

• Tek bir sayı (r)veya (r, 0, 0, 0)=>V = 4/3*pi*r^3
• İki sayı (r, h)veya (r, h, 0, 0)=>V = pi*r^2*h
• Üç sayı (l, w, h)veya (l, w, h, 0)=>V = l*w*h
• Dört sayı (a, b, c, h)=> V = (1/3)*A*h, burada Heron'un formülüA ile verilir :A = 1/4*sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))

Kurallar ve açıklamalar:

• Giriş hem tamsayı hem de ondalık sayı olabilir
• Tüm giriş boyutlarının pozitif olacağını varsayabilirsiniz.
• Pi kodlanmışsa, aşağıdakilere kadar doğru olmalıdır 3.14159.
• Daha az basamakla doğru olarak temsil edilebilen sayılar dışında, çıkışın en az 6 önemli basamağı olmalıdır. Sen çıkış can 3/4olarak 0.75, fakat 4/3olmalıdır 1.33333(daha rakam Tamam)
  • Yanlış değerlerin nasıl yuvarlanacağı isteğe bağlıdır
• Geçersiz giriş için davranış tanımlanmamış
• I / O için standart kurallar. Girdi liste veya bağımsız değişkenler olabilir

Bu kod golf, yani bayt en kısa çözüm kazanmak.

Test senaryoları:

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

İlgili, ancak farklı .

MATL , 57 53 51 44 bayt

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

Giriş, 1, 2, 3 veya 4 sayıdan oluşan bir dizidir.

Çevrimiçi deneyin!

açıklama

ifBaytlar açısından pahalı olan iç içe döngüler kullanmak yerine , bu herhangi bir girdi için dört olası sonucu hesaplar ve daha sonra girdi uzunluğuna bağlı olarak uygun sonucu alır.

Sonuçları hesaplarken, bunlardan sadece birinin geçerli olması gerekmesine rağmen, diğerleri hata veremez. Bu, örneğin, girişin dördüncü elemanının endekslenmesine izin verilmediği anlamına gelir, çünkü giriş dörtten daha az eleman içerebilir.

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

Bunu bana bir tabağa uzattığını sanıyordum, ama çözülecek bir hatayı buldum. Yine de bana zarar vermedi.

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

Temel olarak, girdinin farklı işlevler için belirli bir uzunluk olması nedeniyle, bu şeyleri yapmak için yöntem sözdizimi bana beslersiniz. Peki, yay, başarı!

Açıklama, her seferinde bir satır:

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.

Giriş, sonda sıfır olmadan soruda göründükleri gibi tam tersi komut satırı bağımsız değişkenleri olarak kabul edilir.

Çevrimiçi deneyin!

Bir kenara, şu anda geliştirilmekte olan bir şey.

Vitsy Paketi ile Java

Bu paketin devam etmekte olduğunu unutmayın; bu sadece bunun gelecekte nasıl çalışacağını göstermek içindir (bunun için dokümantasyon henüz yüklenmemiştir) ve golf değildir ve gerçek bir çeviridir:

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 bayt

#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)

düzenlemek 1: gereksiz ondalık kaldırmak ., teşekkürler Immibis!

JavaScript ES6, _{129 126 125 116 114} 90 bayt

Stewie Griffin sayesinde harika bir formülle çok sayıda bayt (9) kurtardı! Girdi sıfırdan farklı olması gerektiğinden, variable?bir tanımlama kontrolü için yeterli olacaktır.

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}

Test edin!

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 bayt

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)

Bir sayı listesi alır ve bir birim döndürür. Şöyle söyle

v[7]

Bu fonksiyon, uygulayan herhangi bir tip için polimorfiktir sqrt(temelde Floatya da Double).

Kısalık için herhangi bir yarışma kazanmayacak. Ancak ne kadar okunabilir olduğuna dikkat edin . Haskell'i gerçekten bilmeseniz bile, ne yaptığını kolayca anlayabilirsiniz. Haskell'in desen eşleştirme sözdizimi, girişin şekline bağlı olarak tamamen farklı bir şey yapan garip işlevleri tanımlamayı gerçekten kolaylaştırır.

PowerShell, 165 161 bayt

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]

Yani ... Birçok ... Dolar ... (161 karakterin 31'i $, kodun% 19.25'i için) ... ancak Stewie Griffin sayesinde 4 bayt tasarruf etti!

Dört girdi alıyoruz ve daha sonra bunları ters sırayla temel alan sahte üçlü ifadelere aşamalı olarak indeksliyoruz. Örneğin, (..., ...)[!$h]dördüncü girişin mevcut olup olmadığını test eder. Eğer öyleyse, !$hirade eşittir 0ve ilk yarı yürütülür (düzensiz bir üçgen piramidin hacmi). Aksi takdirde, !$hile $h = $null(bu başlatılmamış bulunuyor gibi) eşit olur 1bu kendisini temel alan bir sözde üçlü ikinci yarısında, gider, böylece[!$c] vb.

Bu muhtemelen en uygun olana yakındır , çünkü (örneğin) Cᴏɴᴏʀ O'Bʀɪᴇɴ'nin kullandığı sözde daha kısa formül , bir ^operatör eksikliği sayesinde aslında PowerShell'de 2 bayt daha uzundur ... Tek gerçek tasarruf (1/3)*(1/4)*A*$hgolf oynamaktanA*$h/12 ve ayarı $pbirkaç yerine şu uzun süren bayt tasarrufu için daha sonra [math]::PIçağrı.

CJam, 67 66 bayt

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

Yakında kısaltmaya çalışacağım. Çevrimiçi deneyin !

Gelmek için açıklama.

Ciddi, 65 59 55 bayt

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

Çevrimiçi deneyin!

açıklama

Bu bir doozy. Açıklamayı birden fazla parçaya ayıracağım.

Ana gövde:

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

İşlev 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)

İşlev 1:

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

İşlev 2:

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

İşlev 3 (21 bayt; program uzunluğunun neredeyse yarısı!)

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 bayt

@(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;

Kesinlikle bundan daha kısa olamaz. ~b, ~cVe ~d, olan 0boyutların her birinin sıfır olmayan ise. Sıfır boyutlu bir formül sadece sıfır verir. Bu şekilde, formüllerin her biri toplanabilir. Hayır ifve elsegerekli.

Bu şekilde arayın (veya çevrimiçi olarak buradan deneyin ):

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 bayt

Kredi biri ve Mego golf ile tüm yardım için. Kredi ayrıca Cᴏɴᴏʀ O'Bʀɪᴇɴ ve Josh için bu bir yanıtlarına parçalarını ödünç olarak.

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)

Saf fonksiyon: 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 &

Kullanımı:

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

Adlandırılmış işlevlere izin veriliyorsa: 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

Kullanımı:

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

Faktör, 783 bayt

Bu sonsuza dek sürdü.

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 ;

Arayın { array of numbers } volume.