Combien de cadeaux avez-vous reçu pour Noël?

32

Oui, combien plus , pas combien ...

Comme nous le savons tous, un grand cadeau est bien meilleur qu'un petit. Par conséquent, la valeur des cadeaux doit toujours être mesurée en volume total et non en nombre de cadeaux, en poids ou même en prix combiné.

Comme il est mal vu de comparer la quantité de cadeaux que l'on reçoit, vous ne voulez pas d'un long script facilement visible et lisible par les autres lors de la fête de Noël. Par conséquent, vous devez conserver le nombre d'octets dans votre script au minimum.

Votre tâche est simple: créez un programme qui prend une liste de dimensions en entrée, sur n'importe quel format approprié, et sort le volume combiné de vos cadeaux. La dimension de chaque cadeau sera soit un ensemble de trois nombres, soit un seul nombre. Si l'entrée est composée de trois nombres ( L, W, H), le présent est un cuboïde de dimensions L x W x H. S'il s'agit d'un seul nombre ( R), le présent est une sphère de rayon R.

Règles:

  • Il peut s'agir d'un programme complet ou d'une fonction
  • L'entrée peut être dans n'importe quel format pratique
    • Si cela est souhaitable, une sphère peut être représentée par un nombre suivi de deux zéros
    • Un cuboïde aura toujours toutes les dimensions non nulles.
  • La sortie doit être un seul nombre décimal
    • Une sortie supplémentaire est acceptée tant qu'il est évident quelle est la réponse
    • La sortie doit avoir au moins deux chiffres après le point décimal
    • La sortie peut être sous forme standard / notation scientifique si le nombre est supérieur à 1000.
    • Dans le cas où votre langue n'a pas de constante Pi, la réponse doit être précise jusqu'à 9999,99.

Exemples:

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

Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf math arithmetic geometry Stewie Griffin
la source
3
Aucune dame n'a de chapeau dans une de ces drôles de boîtes cylindriques ?
manatwork
2
@manatwork, non, toutes les dames recevront des chapeaux melons, et vous pouvez facilement les mettre dans une sphère = P
Stewie Griffin
1
Je suppose que ce (5)n'est qu'un exemple partiel et que notre code n'a qu'à le gérer ((5)).
manatwork
2
Si notre langue de choix n'a pas de constante Pi, quelle précision faut-il?
Dennis
1
@manatwork, + et * sont OK tant qu'ils ne signifient pas addition et multiplication (ou autres opérations) dans la langue que vous utilisez.
Stewie Griffin

Réponses:

10

Gelée , 19 18 octets

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

Essayez-le en ligne!

Malheureusement, Jelly n'a pas encore de constante π et le vectoriseur ne gère pas correctement les flottants.

Pour surmonter ces problèmes, au lieu de multiplier par 4π / 3 , nous multiplions par 1420 et divisons par 339 . Puisque 1420 ÷ 339 = 4.18879056… et 4π / 3 = 4.18879020… , cela est suffisamment précis pour respecter les règles.

La dernière version de Jelly pourrait accomplir cette tâche en 14 octets , avec une meilleure précision.

Zµ*3×240°Ḣo@PS

Essayez-le en ligne!

Comment ça marche

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 version non concurrente utilise ×240°au lieu de ×1420÷339, qui se multiplie par 240 et convertit les produits en radians.

Dennis
la source
9

Haskell, 40 octets

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

Exemple d'utilisation: sum.map q $ [[1,4,3],[2,2,2],[3],[4,4,4]]-> 197.09733552923254.

Comment ça marche: Pour chaque élément de la liste d'entrée: s'il a un seul élément xcalculer le volume de la sphère, sinon prenez le product. Résumer.

nimi
la source
1
Cette façon de compter les octets est-elle généralement valable? J'aurais dit p=sum.map q(et ensuite dit d'utiliser psur une liste de listes de numéros)
Leif Willerts
1
@LeifWillerts: Il y a un sujet récent sur les méta qui autorise les fonctions sans nom qui relaient sur les définitions globales. sum.map qest une fonction sans nom qui dépend q, donc je suppose que ça va.
nimi
9

Pyth, 19 18 octets

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

1 octet merci à Dennis

Manifestation

Le format d'entrée est une liste de listes:

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

Il multiplie simplement les dimensions ensemble pour calculer le volume du cube. Si cela revient à zéro, il calcule le volume de la sphère.

La constante de sphère 4/3*piest calculée à 240 degrés en radians. .t ... 7convertit une entrée en degrés en radians et C\ðcalcule le point de code de ð, qui est 240.

isaacg
la source
7

Python 2, 86 70 octets

lambda i:sum(x[0]*x[1]*x[2]if len(x)>1 else x[0]**3*4.18879for x in i)
TFeld
la source
Je reçois votre nombre d'octets 86, comment avez-vous obtenu le vôtre?
wnnmaw
De plus, vous pouvez économiser des octets en mettant simplement manuellement une valeur pour pi, vous pouvez utiliser jusqu'à pour 3.14159265358979323atteindre le seuil de rentabilité
wnnmaw
@wnnmaw J'ai oublié de compter l'importation -.-
TFeld
Je crois que votre valeur codée en dur pour pi est un peu
décalée
4
@wnnmaw Ce n'est pas Pi; c'est 4Pi / 3.
Dennis
5

Mathematica, 34 octets

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

Une fonction sans nom qui prend une liste imbriquée de longueurs et renvoie le volume comme un nombre réel.

Nous remplaçons d'abord les valeurs simples par le volume de la sphère correspondante avec /.{r_}:>{4r^3/3Pi}. Ensuite, nous multiplions le contenu de chaque liste avec 1.##&@@@. Enfin, nous calculons la somme comme la trace du vecteur avec Tr[...].

Martin Ender
la source
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 version la plus sensible.reduce est 1 octet de plus

l=>l.reduce((t,[x,y,z])=>t+(y?x*y*z:x*x*x*4/3*Math.PI),0)
edc65
la source
Vous pouvez économiser quelques octets en utilisant 4.11879à la place de 4/3*Math.PI, car cela devrait être suffisamment précis pour être qualifié.
ETHproductions
@ETHproductions oui, mais In case your language doesn't have a Pi-constant,et ma langue a une constante PI, donc je ne sais pas si elle est admissible
edc65
5

Python, 49 octets

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

Utilise la représentation des sphères comme (a,0,0). Traitée comme un cuboïde, elle a le volume 0, auquel cas le volume de la sphère est utilisé à la place. Je ne suis pas sûr de la précision de la constante, donc j'espère que cela suffit.

Xnor
la source
4

MATL , 20 octets

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

Le format d'entrée est une matrice dans laquelle chaque ligne décrit un cube ou une sphère. Une sphère est définie uniquement par le premier nombre de cette ligne; les deux autres nombres sont nuls. Le premier exemple du défi serait donc:

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

Cela utilise la version actuelle du langage, 2.0.2 , qui est antérieure à ce défi.

Exemples:

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

Explication:

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
la source
3

Prolog, 115100 octets

Code:

[]*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 expliqué:

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

Exemples:

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

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

Essayez-le en ligne ici

Edit: économisé 15 octets en définissant un prédicat dyadique.

Emigna
la source
3

Perl, 52 47 octets

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

46 + 1 pour -p(c'est courant; faites-moi savoir si c'est différent ici et je mettrai à jour)

Utilisation: mettre dans un fichier et echo 1,4,3 2,2,2 3 4,4,4 | perl -p x.pl

Avec commentaires:

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

mise à jour 47 Merci à @Dennis d' avoir enregistré quelques octets en utilisant cette astuce .

Kenney
la source
s/,/*/g||s@$@**3*4.18879@,$\+=eval for/\S+/g;}{enregistre quelques octets.
Dennis
@Dennis Merci! J'ai essayé avec $ \ avant mais en réinitialisant le $_coût autant. Toujours pas clair de savoir pourquoi $_est remis à zéro dans un nouveau bloc, mais .. est - $_bloc local while(<>){}?
Kenney
Oui, $_est la variable par défaut de la portée actuelle. Dans le bloc END, il n'est pas défini.
Dennis
2

CJam, 24 21 octets

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

Testez-le ici.

Explication

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
la source
2

PowerShell, 67 octets

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

De la magie noire se produit ici. Je vais essayer de le parcourir en douceur.

Nous prenons d'abord notre entrée, attendue en tant que tableaux séparés par des virgules (1,4,3) (2,2,2) (3) (4,4,4), par exemple , et les canalisons dans une boucle |%{}.

À l'intérieur de la boucle, nous vérifions d'abord si $_, le tableau particulier que nous considérons, n'a qu'un seul élément et nous l'utilisons pour indexer dans un tableau (essentiellement une construction if / else plus courte). S'il s'agit de plusieurs éléments, supposons (1,4,3)en entrée, nous exécutons la première moitié, qui consiste simplement à cracher le tableau via $_, comme (1,4,3). Sinon, nous créons un nouveau tableau dynamique composé de l'élément trois fois avec (,$_*3)et clouant sur une approximation de 4 / 3rd * Pi. Pour l'entrée (3), cela se traduira par une (3,3,3,4.18879)sortie.

Oui, PowerShell a une constante Pi, accessible via un appel .NET [math]::PI, mais c'est plus long et je ne veux pas l'utiliser. : p

Quoi qu'il en soit, nous concaténons ce tableau de sortie avec des astérisques via -join'*', donc "1*4*3". Une fois que nous avons complètement parcouru la boucle, nous avons maintenant une collection de chaînes. Nous -join'+'tous tous ensemble pour notre ajout, et iexl'expression pour calculer le résultat.

Phew.

AdmBorkBork
la source
1

Ruby, 58 caractères

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

Échantillon échantillon:

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

Ruby, 50 caractères

Idée d'amélioration sans vergogne dérobée à la réponse JavaScript d' edc65 .

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

Échantillon échantillon:

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
homme au travail
la source
1

Japt, 27 22 octets

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

Prend les entrées sous forme de tableaux séparés par des espaces. Essayez-le en ligne!

Comment ça marche

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
la source
1

Pip , 23 octets

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

Il existe deux façons de contribuer à ce programme. Il peut prendre chaque présent comme argument de ligne de commande de trois nombres séparés par des espaces (qui devront être entourés de guillemets:) pip.py present.pip "1 4 3" "3 0 0". Alternativement, spécifiez le -rdrapeau et donnez à chaque cadeau une ligne de stdin composée de trois nombres séparés par des espaces. Essayez-le en ligne!

Comment?

                         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
la source
0

Perl 5, 142 octets

Exécutez avec -pdans la ligne de commande et tapez des nombres délimités par une virgule, comme ceci:

5,0,0 ou (5,0,0)

produirait

523.598820058997

Il n'y a pas de pimot clé en Perl. C'est, dans la plupart des cas, exacts par rapport aux chiffres significatifs spécifiés, mais même si j'ai tapé tous les chiffres de pi que je connais, ce ne serait pas très précis pour certains calculs. Alors je l'ai laissé avec3.1415 . Je ne sais pas si cela est acceptable ou non.

Code:

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

Édité pour plus de précision sur les conseils de Dennis, qui est meilleur en mathématiques de base que moi, et sur une suggestion de MichaelT pour économiser des octets tout en restant précis.

Codefun64
la source
2
1. Comment analyseriez-vous 1511? 2. 3.1415 n'est ni arrondi correctement ni suffisamment précis. Si mes calculs sont corrects, l'erreur ne doit pas être supérieure à 0,0000017 . 3. (4/3)*3.1415peut être remplacé par un seul flotteur.
Dennis
1. L'OP dit que nous pouvons supposer des zéros de fin pour les sphères (ce qui est en fait l'exemple d'entrée que j'ai fourni), 2. Je ne sais pas quels calculs vous utilisez, mais bien sûr, j'augmenterai la précision, et 3 bonne suggestion, j'ai raté celle-là. Merci!
Codefun64
Je n'ai pas les ressources devant moi pour le moment, bien que je me demande si cela vous 1420/339rendrait quelques octets avec une approximation raisonnable. (c'est le 4/3 * 355/113). La différence entre la fraction et la valeur que vous avez est de -8.49130615e-8
@MichaelT C'est la chose la plus intéressante. Avez-vous un script qui trouve la plus petite représentation fractionnaire des nombres? ;)
Codefun64
Codefun64 Je viens de travailler sur l' autre approximation commune pour pi. 22/7 n'est pas dans une tolérance suffisante, j'ai donc jeté un coup d'œil à en.wikipedia.org/wiki/Approximations_of_%CF%80 et j'ai utilisé le suivant pour voir s'il avait une tolérance meilleure que celle demandée par @Dennis.
0

Lua, 115104 octets

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

Solution simple, je dois encapsuler l'opération pseudo-ternaire <condition> and <non-false> or <value if false>entre parenthèses, sinon b résumerait les deux zones.

L'entrée doit être sous la forme array={{1,4,3},{2,2,2},{3},{4,4,4}}et le résultat peut être vu en exécutant print(f(array)).

Katenkyo
la source
0

05AB1E , 18 16 octets

εDgi3m4žq*3/*]PO

Essayez-le en ligne.

Explication:

ε                # 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
la source
0

R, 38 36 octets

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

Utilise des arguments par défaut pour basculer entre les cas: avec trois arguments calcule le produit et avec un argument calcule la formule de la sphère.

JDL
la source
avez-vous besoin du f<-et du {}?
Giuseppe
Ce code ne s'affiche pas correctement pour le scénario de test (5,0,0). En outre, il ne convient pas au cas de test où il y a plusieurs cadeaux et les volumes doivent être additionnés ensemble.
Robert S.
Pour (5,0,0) j'obtiens zéro - n'est-ce pas correct? Ont modifié pour utiliser sum(et supprimé des éléments qui n'étaient pas nécessaires selon la suggestion de Giuseppe)
JDL