Noel için ne kadar hediye aldın?


32

Evet, ne kadar , ne kadar değil ...

Hepimizin bildiği gibi, büyük bir hediye küçük olandan çok daha iyidir. Bu nedenle, hediye değeri, hediye sayısı, ağırlık ve hatta birleşik fiyat değil, her zaman toplam hacim olarak ölçülmelidir.

Birinin aldığı hediyelerin miktarını karşılaştırmak için kaşlarını çattığından, Noel partisinde başkaları tarafından kolayca görülen ve okunan uzun bir senaryo istemezsiniz. Bu nedenle betiğinizdeki bayt sayısını minimumda tutmanız gerekir.

Göreviniz basit: Herhangi bir uygun formatta, girdi olarak boyutların listesini alan ve hediyelerinizin birleşik hacmini çıkaran bir program oluşturun. Her hediyenin boyutu ya üçlü bir sayı ya da tek bir sayı olacaktır. Giriş üç sayı ( L, W, H) ise, mevcut boyutlardan oluşan bir küboiddir L x W x H. Tek bir sayı ( R) ise, bugün yarıçap küresidir R.

Kurallar:

  • Tam bir program veya işlev olabilir
  • Giriş herhangi bir uygun biçimde olabilir
    • İstenirse, bir küre iki sayının ardından bir sayı ile temsil edilebilir
    • Bir küboid daima sıfır olmayan boyutlara sahip olacaktır.
  • Çıktı, tek bir ondalık sayı olmalıdır
    • Ek çıktı, cevabın ne olduğu açık olduğu sürece kabul edilir.
    • Çıktı, ondalık noktasından sonra en az iki basamak içermelidir
    • Sayı 1000'den büyükse, çıktı standart biçimde / bilimsel gösterimde olabilir.
    • Dilinizin Pi sabiti yoksa, cevap 9999.99'a kadar kesin olmalıdır.

Örnekler:

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

Liderler Sıralaması

Bu yazının altındaki Yığın Parçacığı, cevapları a) dil başına en kısa çözümün bir listesi olarak ve b) genel bir lider tablosu olarak oluşturur.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

## Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra pasajda görünecek bir bağlantı da yapabilirsiniz:

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


3
Komik silindirik kutulardan hiçbirinde şapka yok mu?
Manatwork

2
@manatwork, hayır, tüm bayanlar melon şapka alacaklar ve bunları bir küreye kolayca sığdırabilirsiniz = P
Stewie Griffin

1
Sanırım (5)sadece kısmi bir örnek ve kodumuzun sadece ele alması gerekiyor ((5)).
Manatwork

2
Tercih ettiğimiz dil Pi sabitine sahip değilse, ne kadar hassasiyet gerekir?
Dennis,

1
@manatwork, + ve * kullandığınız dilde toplama ve çarpma (veya diğer işlemler) anlamına gelmedikleri sürece normaldir.
Stewie Griffin

Yanıtlar:


10

Jöle , 19 18 bayt

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

Çevrimiçi deneyin!

Ne yazık ki, Jelly henüz π sabitine sahip değildir ve vectorizer düzgün yüzer şekilde işlemez.

Yerine çarpılmak Bu sorunları aşmak için 4π / 3 , biz çarpın tarafından 1420 tarafından ve bölün 339 . Yana 1420 ÷ 339 = 4,18879056 ... ve 4π / 3 = 4.18879020 ... , bu kurallara uygun olacak hassas.

Jelly'in en yeni sürümü bu görevi 14 byte ile daha iyi bir hassasiyetle gerçekleştirebildi.

Zµ*3×240°Ḣo@PS

Çevrimiçi deneyin!

Nasıl çalışır

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.

Rekabet etmeyen sürüm, ×240°bunun yerine 240 ile ×1420÷339çarparak ürünleri radyanlara dönüştüren yerine kullanıyor .


9

Haskell, 40 bayt

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

Kullanım örneği: sum.map q $ [[1,4,3],[2,2,2],[3],[4,4,4]]-> 197.09733552923254.

Nasıl çalışır: Girdi listesinin her elemanı için: Eğer tek bir eleman varsa xkürenin hacmini hesaplarsa, o zaman onu al product. Özetle.


1
Bu sayma baytları genellikle geçerli midir? Ben söylerdim p=sum.map q(ve sonra pbir sayılar listesi listesini kullanmak için söyledi )
Leif Willerts

1
@LeifWillerts: Meta üzerinde global tanımları aktaran isimsiz fonksiyonlara izin veren yeni bir konu var . sum.map qbağlı olan adsız bir işlevdir q, bu yüzden sanırım sorun değil.
nimi

9

Pyth, 19 18 bayt

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

Dennis'e 1 bayt teşekkürler

gösteri

Giriş formatı listelerin listesidir:

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

Küp hacmini hesaplamak için boyutları bir araya getirir. Bu sıfıra çıkarsa, küre hacmini hesaplar.

Küre sabiti, 4/3*piradyan cinsinden 240 derece olarak hesaplanır. .t ... 7Bir girişi derece cinsinden radyanlara dönüştürür ve 240 olan C\ðkod noktasını hesaplar ð.


7

Python 2, 86 70 bayt

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

Ben senin olsun bayt sayısı Seninkini nasıl çıktın, 86 olarak?
wnnmaw

Ek olarak, byte'ları sadece pi için bir değer koyarak elle kaydedebilir, 3.14159265358979323hatta kırmak için bile kullanabilirsiniz
wnnmaw

@wnnmaw İthalatı saymayı unuttum -.-
TFeld

Pi için kodlanmış değerinizin biraz kapalı olduğuna inanıyorum :)
wnnmaw

4
@wnnmaw Bu Pi değil; 4Pi / 3.
Dennis,

5

Mathematica, 34 bayt

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

İç içe geçmiş bir uzunluk listesi alan ve birimi gerçek sayı olarak döndüren adsız bir işlev.

Tek tek değerleri karşılık gelen kürenin hacmiyle değiştiriyoruz /.{r_}:>{4r^3/3Pi}. Sonra her listenin içeriğini ile çarpıyoruz 1.##&@@@. Sonunda toplamı ile vektörün izini hesaplıyoruz Tr[...].


5

JavaScript (ES6), 56

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

Daha mantıklı .reduce versiyon 1 byte daha uzundur

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

Nitelik için yeterince doğru olması gerektiğinden, 4.11879yerine bir kaç byte tasarruf edebilirsiniz 4/3*Math.PI.
ETHProductions,

@ETHproductions evet, ama In case your language doesn't have a Pi-constant,ve benim dilimde PI sabiti var, o yüzden hak eder mi bilmiyorum
edc65

5

Python, 49 bayt

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

Kürelerin temsilini kullanır (a,0,0). Bir küboid olarak işlendiğinde, bunun hacmi 0'dır, bu durumda küre hacmi bunun yerine kullanılır. Sabitin ne kadar doğru olması gerektiği konusunda net değilim, umarım bu yeterlidir.


4

MATL , 20 bayt

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

Giriş formatı, her satırın bir küp veya küre tanımladığı bir matristir. Bir küre, o satırdaki yalnızca ilk sayı ile tanımlanır; diğer iki sayı sıfırdır. Bu yüzden mücadeleden ilk örnek şöyle olacaktır:

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

Bu, dilin şu anki sürümünü, bu zorluktan daha önceki olan 2.0.2 sürümünü kullanır .

Örnekler:

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

Açıklama:

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

Prolog, 115 100 bayt

Kod:

[]*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).

Açıklaması:

[]*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

Örnekler:

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

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

Burada çevrimiçi deneyin

Düzenleme: İkili bir yüklem belirleyerek 15 bayt kurtardı.


3

Perl, 52 47 bayt

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

İçin 46 + 1 -p(bu yaygındı; burada farklı olup olmadığını bana bildirin ve güncelleyeceğim)

Kullanım: bir dosyaya koymak ve echo 1,4,3 2,2,2 3 4,4,4 | perl -p x.pl

Yorumlarla:

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 $_

güncelleme 47 Bu numarayı kullanarak bazı baytları kaydettiğiniz için @Dennis 'a teşekkür ederiz .


s/,/*/g||s@$@**3*4.18879@,$\+=eval for/\S+/g;}{birkaç bayt kaydeder.
Dennis,

@Dennis Teşekkürler! Daha önce $ \ ile denedim, ancak $_maliyeti de sıfırladım . Yine ne olduğunu net neden $_mi .. gerçi yeni bloğunda reset olduğu $_blok-yerel while(<>){}?
Kenney,

Evet, $_mevcut kapsamın varsayılan değişkenidir. END bloğunda tanımsız.
Dennis

2

CJam, 24 21 bayt

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

Burada test et.

açıklama

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

PowerShell, 67 Bayt

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

Burada bir kara büyü oluyor. Sorunsuz bir şekilde yürümeye çalışacağım.

Öncelikle, örneğin virgülle ayrılmış diziler gibi beklenen girdilerimizi alıyoruz (1,4,3) (2,2,2) (3) (4,4,4)ve bunu bir döngüye dönüştürüyoruz |%{}.

Döngü içinde, ilk önce, düşündüğümüz $_dizinin yalnızca bir öğeye sahip olup olmadığını kontrol ederiz ve onu bir diziye endekslemek için kullanırız (aslında eğer daha kısasa / başka bir yapı ise) Birden fazla öğe varsa, (1,4,3)girdi olarak varsayalım , ilk yarıyı çalıştırırız ki bu sadece diziyi tükürmek $_gibi (1,4,3). Aksi taktirde, elementten üç kez oluşan (,$_*3)ve yaklaşık 4 / 3rd * Pi değerindeki birleşimden oluşan yeni bir dinamik dizi yaratırız . Giriş için (3)bu (3,3,3,4.18879)çıkışla sonuçlanacaktır .

Evet, PowerShell, .NET çağrısı yoluyla erişilen bir Pi sabitine sahiptir [math]::PI, ancak bu daha uzun ve kullanmak istemiyorum. : p

Ne olursa olsun, bu çıkış dizisini yıldız işaretleriyle -join'*', böylece birleştiririz "1*4*3". Tamamen döngüden geçtikten sonra, şimdi bir dizi dizgimiz var. Bunları -join'+'hep birlikte iexeklememiz için ve sonuçları hesaplamak için ifade ediyoruz.

Uf.


1

Yakut, 58 karakter

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

Örnek çalışma:

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

Yakut, 50 karakter

İyileştirme fikri utanmadan çalınan edc65 'ın JavaScript cevap .

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

Örnek çalışma:

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

Japt, 27 22 bayt

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

Girdiyi boşlukla ayrılmış diziler olarak alır. Çevrimiçi deneyin!

Nasıl çalışır

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

Pip , 23 bayt

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

Bu programa giriş yapmanın birkaç yolu var. Her hediyeyi boşlukla ayrılmış üç sayının komut satırı argümanı olarak alabilir (tırnak işaretleri ile sarılması gerekir pip.py present.pip "1 4 3" "3 0 0") :) . Alternatif olarak, -rbayrağı belirtin ve her birine, boşlukla ayrılmış üç sayıdan oluşan bir stdin çizgisi verin. Çevrimiçi deneyin!

Nasıl?

                         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

Perl 5, 142 bayt

-pKomut satırında çalıştırın ve virgülle ayrılmış sayıları yazın, şöyle:

5,0,0 veya (5,0,0)

üretmek

523.598820058997

piPerl de anahtar kelime yok . Bu, çoğu durumda, belirtilen belirgin rakamlara doğrudur, ancak tüm pi rakamlarını yazsam bile, bazı hesaplamalar için çok doğru olmaz. Ben de bıraktım 3.1415. Bunun kabul edilebilir olup olmadığından emin değilim.

Kod:

@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]);}

Temel matematikte benden daha iyi olan Dennis'in tavsiyesi üzerine daha kesin bir şekilde ve MichaelT'nin kesin olarak kalırken baytları tasarruf etmesinin bir önerisi için düzenlendi.


2
1. Nasıl ayrıştırırsınız 1511? 2. 3.1415 ne düzgün bir şekilde yuvarlanır ne de yeterince kesindir . Hesaplarım doğruysa, hata 0,0000017'den büyük olmamalıdır . 3. (4/3)*3.1415tek bir şamandıra ile değiştirilebilir.
Dennis,

1. OP, küreler için sıfırın (varsa, aslında verdiğim örnek girişidir) sıfır olduğunu varsayabileceğimizi söylüyor, 2. Hangi hesaplamaları kullandığınızı bilmiyorum, ama kesin olarak hassasiyeti artıracağım ve 3 iyi öneri, bunu özledim. Teşekkürler!
Codefun64

Şu anda önümdeki kaynaklarım yok, ancak yapmamın 1420/339size makul bir yaklaşımla birkaç bayt geri verip vermeyeceğini merak ediyorum . (bu 4/3 * 355/113'tür). Fraksiyon ile sahip olduğunuz değer arasındaki fark -8.49130615e-8

@MichaelT Bu en ilginç şey. Sayıların en küçük kesirli gösterimini bulan bir senaryo var mı? ;)
Codefun64

Codefun64 Pi için diğer genel yaklaşımlar üzerinde çalıştım . 22/7 yeterince tolerans içinde değil, bu yüzden @Dennis'in istediğinden daha iyi bir toleransı olup olmadığını görmek için bir sonrakini en.wikipedia.org/wiki/Approximations_of_%CF%80 ' e baktım.

0

Lua, 115 104 bayt

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

Basit bir çözüm olarak, sahte üçlü işlemi <condition> and <non-false> or <value if false>parantez içinde silmeliyim, aksi takdirde b her iki alanla da toplanır.

Giriş formunda olmalı array={{1,4,3},{2,2,2},{3},{4,4,4}}ve sonuç çalıştırılarak görülebilir print(f(array)).


0

05AB1E , 18 16 bayt

εDgi3m4žq*3/*]PO

Çevrimiçi deneyin.

Açıklama:

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

R, 38 bayt

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

Vakalar arasında geçiş yapmak için varsayılan argümanları kullanır: üç argümanla ürünü hesaplar ve bir argümanla küre formülünü hesaplar.


f<-ve ihtiyacınız var {}mı?
Giuseppe

Bu kod, test durumu için doğru şekilde çıkmıyor (5,0,0). Ayrıca, çok sayıda hediye bulunan ve hacimlerin birlikte toplanması gereken test senaryosuna uymuyor.
Robert S.

(5,0,0) için sıfır alıyorum - bu doğru değil mi? Kullanmayı düzenledi sum(ve Giuseppe'nin önerisi için gerekli olmayan bazı şeyleri
kaldırın
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.