Quanto regalo hai ricevuto per Natale?

32

Sì, come molto , non come tanti ...

Come tutti sappiamo, un grande regalo è molto meglio di uno piccolo. Pertanto, il valore dei regali deve essere sempre misurato in volume totale, non in numero di regali, peso o persino prezzo combinato.

Mentre è malvisto per confrontare la quantità di regali che si ottengono, non si desidera una sceneggiatura lunga che può essere facilmente vista e letta da altri alla festa di Natale. Pertanto è necessario mantenere almeno il numero di byte nello script.

Il tuo compito è semplice: crea un programma che accetta un elenco di dimensioni come input, in qualsiasi formato adatto, e genera il volume combinato dei tuoi regali. La dimensione di ciascun regalo sarà o un insieme di tre numeri o un singolo numero. Se l'input è di tre numeri ( L, W, H), il presente è un cubo di dimensioni L x W x H. Se è un singolo numero ( R), il presente è una sfera di raggio R.

Regole:

  • Può essere un programma completo o una funzione
  • L'input può essere in qualsiasi formato conveniente
    • Se desiderabile, una sfera può essere rappresentata da un numero seguito da due zeri
    • Un cuboide avrà sempre tutte dimensioni diverse da zero.
  • L'output dovrebbe essere un singolo numero decimale
    • L'output aggiuntivo è accettato purché sia ​​ovvio quale sia la risposta
    • L'output deve contenere almeno due cifre dopo il punto decimale
    • L'output può essere in forma standard / notazione scientifica se il numero è maggiore di 1000.
    • Nel caso in cui la tua lingua non abbia una costante Pi, la risposta dovrebbe essere accurata fino a 9999,99.

Esempi:

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

Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  math  arithmetic  geometry 
— Stewie Griffin
fonte
3
Nessuna signora prende il cappello in una di quelle divertenti scatole cilindriche ?
— arte
2
@manatwork, no, tutte le donne otterranno cappelli a bombetta, e puoi facilmente inserirli in una sfera = P
— Stewie Griffin,
1
Presumo (5)sia solo un esempio parziale e il nostro codice deve solo gestire ((5)).
— arte
2
Se la nostra lingua preferita non ha una costante Pi, quanta precisione è richiesta?
— Dennis,
1
@manatwork, + e * sono OK fintanto che non significano addizione e moltiplicazione (o altre operazioni) nella lingua che stai usando.
— Stewie Griffin,

Risposte:

10

Gelatina , 19 18 byte

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

Provalo online!

Sfortunatamente, Jelly non ha ancora una costante π e il vettorizzatore non gestisce correttamente i galleggianti.

Per superare questi problemi, invece di moltiplicare per 4π / 3 , moltiplichiamo per 1420 e dividiamo per 339 . Dal 1420 ÷ 339 = 4.18879056… e 4π / 3 = 4.18879020… , questo è sufficientemente preciso per conformarsi alle regole.

La versione più recente di Jelly potrebbe svolgere questo compito in 14 byte , con una maggiore precisione.

Zµ*3×240°Ḣo@PS

Provalo online!

Come funziona

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.

La versione non competitiva utilizza ×240°invece di ×1420÷339, che si moltiplica per 240 e converte i prodotti in radianti.

— Dennis
fonte
9

Haskell, 40 byte

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

Esempio di utilizzo: sum.map q $ [[1,4,3],[2,2,2],[3],[4,4,4]]-> 197.09733552923254.

Come funziona: per ogni elemento della lista di input: se ha un singolo elemento xcalcola il volume della sfera, altrimenti prendi il product. Riassumilo.

— Nome del modello
fonte
1
Questo modo di contare i byte è generalmente valido? Avrei detto p=sum.map q(e poi detto di usarlo pin un elenco di elenchi di numeri)
— Leif Willerts,
1
@LeifWillerts: c'è un argomento recente sulla meta che consente funzioni senza nome che si basano su definizioni globali. sum.map qè una funzione senza nome da cui dipende q, quindi immagino che vada bene.
— nimi,
9

Pyth, 19 18 byte

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

1 byte grazie a Dennis

Dimostrazione

Il formato di input è un elenco di elenchi:

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

Moltiplica semplicemente le dimensioni insieme per calcolare il volume del cubo. Se viene a zero, calcola il volume della sfera.

La costante della sfera, 4/3*piè calcolata come 240 gradi in radianti. .t ... 7converte un input in gradi in radianti e C\ðcalcola il punto di codice di ð, che è 240.

— isaacg
fonte
7

Python 2, 86 70 byte

lambda i:sum(x[0]*x[1]*x[2]if len(x)>1 else x[0]**3*4.18879for x in i)
— TFeld
fonte
Ottengo il tuo numero di byte come 86, come hai ottenuto il tuo?
— wnnmaw,
Inoltre, puoi salvare byte semplicemente inserendo manualmente un valore per pi, puoi usarlo fino a 3.14159265358979323raggiungere il pareggio
— wnnmaw,
@wnnmaw Ho dimenticato di contare l'importazione -.-
— TFeld il
Credo che il tuo valore hardcoded per pi sia un po 'fuori :)
— wnnmaw,
4
@wnnmaw Quello non è Pi; è 4Pi / 3.
— Dennis,
5

Mathematica, 34 byte

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

Una funzione senza nome che accetta un elenco nidificato di lunghezze e restituisce il volume come un numero reale.

Sostituiamo innanzitutto i singoli valori con il volume della sfera corrispondente con /.{r_}:>{4r^3/3Pi}. Quindi moltiplichiamo il contenuto di ogni elenco con 1.##&@@@. Infine calcoliamo la somma come traccia del vettore con Tr[...].

— Martin Ender
fonte
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

La versione più sensata .reduce è più lunga di 1 byte

l=>l.reduce((t,[x,y,z])=>t+(y?x*y*z:x*x*x*4/3*Math.PI),0)
— edc65
fonte
È possibile salvare un paio di byte usando 4.11879al posto di 4/3*Math.PI, poiché dovrebbe essere abbastanza preciso per qualificarsi.
— ETHproductions
@ETHproductions sì, ma In case your language doesn't have a Pi-constant,e la mia lingua ha una costante PI, quindi non so se si qualifica
— edc65
5

Python, 49 byte

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

Utilizza la rappresentazione di sfere come (a,0,0). Considerato come un cuboide, questo ha volume 0, nel qual caso viene invece utilizzato il volume della sfera. Non sono chiaro su quanto deve essere precisa la costante, quindi spero che sia abbastanza.

— XNOR
fonte
4

MATL , 20 byte

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

Il formato di input è una matrice in cui ogni riga descrive un cubo o una sfera. Una sfera è definita solo dal primo numero in quella riga; gli altri due numeri sono zero. Quindi il primo esempio della sfida sarebbe:

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

Questo utilizza l'attuale versione della lingua, 2.0.2 , che è precedente a questa sfida.

Esempi:

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

Spiegazione:

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
— Luis Mendo
fonte
3

Prolog, 115 100 byte

Codice:

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

Ha spiegato:

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

Esempi:

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

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

Provalo online qui

Modifica: salvato 15 byte definendo un predicato diadico.

— Emigna
fonte
3

Perl, 52 47 byte

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

46 + 1 per -p(è stato comune; fammi sapere se qui è diverso e aggiornerò)

Utilizzo: inserire un file e echo 1,4,3 2,2,2 3 4,4,4 | perl -p x.pl

Con commenti:

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

aggiornamento 47 Grazie a @Dennis per aver salvato alcuni byte usando questo trucco .

— Kenney
fonte
s/,/*/g||s@$@**3*4.18879@,$\+=eval for/\S+/g;}{salva qualche byte.
— Dennis,
@Dennis Grazie! Ho provato con $ \ prima ma reimpostando il $_costo tanto. Non è ancora chiaro il motivo per cui $_viene reimpostato in un nuovo blocco, però ... Il $_blocco è locale while(<>){}?
— Kenney,
Sì, $_è la variabile predefinita dell'ambito corrente. Nel blocco END, non è definito.
— Dennis,
2

CJam, 24 21 byte

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

Provalo qui.

Spiegazione

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.
— Martin Ender
fonte
2

PowerShell, 67 byte

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

Qualche magia nera sta accadendo qui. Proverò a percorrerlo senza intoppi.

Innanzitutto prendiamo il nostro input, previsto come singole matrici delimitate da virgole (1,4,3) (2,2,2) (3) (4,4,4), ad esempio , e lo inseriamo in un loop|%{} .

All'interno del ciclo, controlliamo prima se $_, il particolare array che stiamo prendendo in considerazione, ha un solo elemento e lo usiamo per indicizzarlo in un array (essenzialmente una costruzione if / else più corta). Se è più di un elemento, supponiamo (1,4,3)come input, eseguiamo la prima metà, che è semplicemente quella di sputare l'array via $_, ad esempio (1,4,3). Altrimenti, creiamo un nuovo array dinamico costituito dall'elemento tre volte con (,$_*3)e virata su un'approssimazione di 4 / 3rd * Pi. Per l'input (3), ciò comporterà(3,3,3,4.18879) output.

Sì, PowerShell ha una costante Pi, accessibile tramite chiamata .NET [math]::PI , ma è più lunga e non voglio usarla. : p

Indipendentemente da ciò, concateniamo tale array di output con asterischi tramite -join'*', quindi "1*4*3". Una volta che abbiamo completato il ciclo, ora abbiamo una raccolta di stringhe. Noi -join'+'tutti coloro insieme per il nostro Inoltre, eiex l'espressione per calcolare il risultato.

Uff.

— AdmBorkBork
fonte
1

Rubino, 58 caratteri

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

Esecuzione di esempio:

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

Rubino, 50 caratteri

Miglioramento idea spudoratamente rubato da edc65 's risposta JavaScript .

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

Esecuzione di esempio:

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
— uomo al lavoro
fonte
1

Japt, 27 22 byte

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

Accetta input come array separati da spazio. Provalo online!

Come funziona

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
— ETHproductions
fonte
1

Pip , 23 byte

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

Ci sono un paio di modi per dare input a questo programma. Può prendere ogni regalo come argomento della riga di comando di tre numeri separati da spazi (che dovranno essere racchiusi tra virgolette:) pip.py present.pip "1 4 3" "3 0 0". In alternativa, specifica il -rflag e assegna a ciascun regalo una linea di stdin composta da tre numeri separati da spazi.Provalo online!

Come?

                         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
— DLosc
fonte
0

Perl 5, 142 byte

Esegui con -pnella riga di comando e digita i numeri delimitati da una virgola, in questo modo:

5,0,0 o (5,0,0)

produrrebbe

523.598820058997

Non esiste una piparola chiave in Perl. Questo è, nella maggior parte dei casi, accurato per le cifre significative specificate, tuttavia anche se ho digitato tutte le cifre di pi che conosco, non sarebbe molto preciso per alcuni calcoli. Quindi l'ho lasciato con3.1415 . Non sono sicuro che questo sia accettabile o meno.

Codice:

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

A cura di una maggiore precisione su consiglio di Dennis, che è meglio in matematica di base di me, e da un suggerimento di MichaelT di salvare byte rimanendo preciso.

— Codefun64
fonte
2
1. Come analizzeresti 1511? 2. 3.1415 non è arrotondato correttamente né sufficientemente preciso. Se i miei calcoli sono corretti, l'errore non deve essere maggiore di 0,0000017 . 3. (4/3)*3.1415può essere sostituito con un solo galleggiante.
— Dennis,
1. L'OP afferma che potremmo assumere zero finali per le sfere (che in realtà è l'input di esempio che ho fornito), 2. Non so quali calcoli stai usando, ma sicuramente aumenterò la precisione e 3 buon suggerimento, mi è mancato quello. Grazie!
— Codefun64,
Al momento non ho le risorse di fronte a me, anche se mi chiedo se farlo 1420/339ti restituirebbe qualche byte con una ragionevole approssimazione. (questo è 4/3 * 355/113). La differenza tra la frazione e il valore che hai è -8.49130615e-8
@MichaelT Questa è la cosa più interessante. Hai una sceneggiatura che trova la più piccola rappresentazione frazionaria dei numeri? ;)
— Codefun64
Codefun64 Ho appena lavorato sull'altra approssimazione comune per pi. Il 22/7 non è abbastanza tollerante, quindi ho dato un'occhiata a en.wikipedia.org/wiki/Approximations_of_%CF%80 e ho usato quello successivo per vedere se aveva una tolleranza migliore di quella che chiedeva @Dennis.
0

Lua, 115 104 byte

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

Soluzione semplice, devo concludere l'operazione pseudo-ternaria <condition> and <non-false> or <value if false>tra parentesi, altrimenti b riassumerebbe con entrambe le aree.

L'input deve essere nella forma array={{1,4,3},{2,2,2},{3},{4,4,4}}e il risultato può essere visto eseguendo print(f(array)).

— Katenkyo
fonte
0

05AB1E , 18 16 byte

εDgi3m4žq*3/*]PO

Provalo online.

Spiegazione:

ε                # 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
— Kevin Cruijssen
fonte
0

R, 38 36 byte

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

Utilizza gli argomenti predefiniti per passare da un caso all'altro: con tre argomenti calcola il prodotto e con un argomento calcola la formula della sfera.

— JDL
fonte
hai bisogno del f<-e il {}?
— Giuseppe,
Questo codice non viene emesso correttamente per il test case (5,0,0). Inoltre, non soddisfa il caso di test in cui sono presenti più regali e i volumi devono essere sommati.
— Robert S.
Per (5,0,0) ottengo zero - non è corretto? Hanno modificato per usare sum(e rimosso alcune cose che non erano necessarie per il suggerimento di Giuseppe)
— JDL
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.