¿Cuánto regalo recibiste por Navidad?

32

Sí, cómo mucho , no es cuántos ...

Como todos sabemos, un regalo grande es mucho mejor que uno pequeño. Por lo tanto, el valor de los regalos siempre debe medirse en volumen total, no en número de regalos, peso o incluso precio combinado.

Como está mal visto comparar la cantidad de regalos que uno recibe, no querrás un guión largo que otros puedan ver y leer fácilmente en la fiesta de Navidad. Por lo tanto, debe mantener el número de bytes en su script como mínimo.

Su tarea es simple: cree un programa que tome una lista de dimensiones como entrada, en cualquier formato adecuado, y genere el volumen combinado de sus regalos. La dimensión de cada presente será un conjunto de tres números o un solo número. Si la entrada es tres números ( L, W, H), el presente es un cuboide de dimensiones L x W x H. Si es un solo número ( R), el presente es una esfera de radio R.

Reglas:

  • Puede ser un programa completo o una función
  • La entrada puede estar en cualquier formato conveniente
    • Si es deseable, una esfera puede estar representada por un número seguido de dos ceros
    • Un cuboide siempre tendrá todas las dimensiones distintas de cero.
  • La salida debe ser un solo número decimal
    • Se acepta salida adicional siempre que sea obvio cuál es la respuesta
    • La salida debe tener al menos dos dígitos después del punto decimal
    • La salida puede estar en forma estándar / notación científica si el número es mayor que 1000.
    • En caso de que su idioma no tenga una constante Pi, la respuesta debe ser precisa hasta 9999.99.

Ejemplos:

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

Tabla de clasificación

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Mostrar fragmento de código

code-golf  math  arithmetic  geometry 
— Stewie Griffin
fuente
3
¿Ninguna mujer se pone el sombrero en una de esas divertidas cajas cilíndricas ?
— manatwork
2
@manatwork, no, todas las damas recibirán bombines, y puedes caber fácilmente en una esfera = P
— Stewie Griffin
1
Supongo que (5)es solo un ejemplo parcial y nuestro código solo tiene que manejar ((5)).
— manatwork
2
Si nuestro lenguaje de elección no tiene una constante Pi, ¿cuánta precisión se requiere?
— Dennis
1
@manatwork, + y * están bien siempre y cuando no signifiquen suma y multiplicación (u otras operaciones) en el idioma que está utilizando.
— Stewie Griffin

Respuestas:

10

Jalea , 19 18 bytes

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

Pruébalo en línea!

Desafortunadamente, Jelly aún no tiene una constante π , y el vectorizador no maneja los flotadores correctamente.

Para superar estos problemas, en lugar de multiplicar por 4π / 3 , multiplicamos por 1420 y dividimos por 339 . Desde 1420 ÷ 339 = 4.18879056 ... y 4π / 3 = 4.18879020 ... , esto es lo suficientemente preciso para cumplir con las reglas.

La versión más nueva de Jelly podría realizar esta tarea en 14 bytes , con mayor precisión.

Zµ*3×240°Ḣo@PS

Pruébalo en línea!

Cómo funciona

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 versión no competitiva usa en ×240°lugar de ×1420÷339, que se multiplica por 240 y convierte los productos a radianes.

— Dennis
fuente
9

Haskell, 40 bytes

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

Ejemplo de uso: sum.map q $ [[1,4,3],[2,2,2],[3],[4,4,4]]-> 197.09733552923254.

Cómo funciona: Para cada elemento de la lista de entrada: si tiene un solo elemento, xcalcule el volumen de la esfera, de lo contrario tome el product. Añádelo.

— nimi
fuente
1
¿Es esta forma de contar bytes generalmente válida? Hubiera dicho p=sum.map q(y luego le dije que lo usara pen una lista de listas de números)
— Leif Willerts
1
@LeifWillerts: Hay un tema reciente sobre meta que permite funciones sin nombre que se transmiten en definiciones globales. sum.map qes una función sin nombre que depende q, así que supongo que está bien.
— nimi
9

Pyth, 19 18 bytes

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

1 byte gracias a Dennis

Demostración

El formato de entrada es una lista de listas:

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

Simplemente multiplica las dimensiones para calcular el volumen del cubo. Si eso sale a cero, calcula el volumen de la esfera.

La constante de esfera, 4/3*pise calcula como 240 grados en radianes. .t ... 7convierte una entrada en grados a radianes y C\ðcalcula el punto de código de ð, que es 240.

— isaacg
fuente
7

Python 2, 86 70 bytes

lambda i:sum(x[0]*x[1]*x[2]if len(x)>1 else x[0]**3*4.18879for x in i)
— TFeld
fuente
Recibo tu byte como 86, ¿cómo obtuviste el tuyo?
— wnnmaw
Además, puede guardar bytes simplemente 3.14159265358979323
— ingresando
@wnnmaw Olvidé contar la importación -.-
— TFeld
Creo que su valor codificado para PI es un poco fuera :)
— wnnmaw
44
@wnnmaw Eso no es Pi; es 4Pi / 3.
— Dennis
5

Mathematica, 34 bytes

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

Una función sin nombre que toma una lista anidada de longitudes y devuelve el volumen como un número real.

Primero reemplazamos los valores individuales con el volumen de la esfera correspondiente con /.{r_}:>{4r^3/3Pi}. Luego multiplicamos el contenido de cada lista con 1.##&@@@. Finalmente calculamos la suma como la traza del vector con Tr[...].

— Martin Ender
fuente
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 versión más sensata .reduce es 1 byte más larga

l=>l.reduce((t,[x,y,z])=>t+(y?x*y*z:x*x*x*4/3*Math.PI),0)
— edc65
fuente
Puede guardar un par de bytes utilizando 4.11879en lugar de 4/3*Math.PI, ya que eso debería ser lo suficientemente preciso como para calificar.
— ETHproductions
@ETHproductions sí, pero In case your language doesn't have a Pi-constant,mi lenguaje tiene una constante PI, así que no sé si califica
— edc65
5

Python, 49 bytes

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

Utiliza la representación de esferas como (a,0,0). Si se trata como un cuboide, tiene el volumen 0, en cuyo caso se usa el volumen de la esfera. No tengo claro qué tan precisa debe ser la constante, así que espero que sea suficiente.

— xnor
fuente
4

MATL , 20 bytes

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

El formato de entrada es una matriz en la que cada fila describe un cubo o una esfera. Una esfera se define solo por el primer número de esa fila; Los otros dos números son cero. Entonces, el primer ejemplo del desafío sería:

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

Utiliza la versión actual del lenguaje 2.0.2 , que es anterior a este desafío.

Ejemplos:

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

Explicación:

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

Prolog, 115100 bytes

Código:

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

Explicado:

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

Ejemplos:

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

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

Pruébalo en línea aquí

Editar: ahorró 15 bytes definiendo un predicado diádico.

— Emigna
fuente
3

Perl, 52 47 bytes

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

46 + 1 para -p(eso ha sido común; avíseme si es diferente aquí y lo actualizaré)

Uso: poner en un archivo y echo 1,4,3 2,2,2 3 4,4,4 | perl -p x.pl

Con comentarios:

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

actualización 47 Gracias a @Dennis por guardar algunos bytes usando este truco .

— Kenney
fuente
s/,/*/g||s@$@**3*4.18879@,$\+=eval for/\S+/g;}{Guarda algunos bytes.
— Dennis
@ Dennis Gracias! Intenté con $ \ antes pero restablecer el $_costo tanto. Sin embargo, todavía no está claro por qué $_se restablece en un nuevo bloque. ¿Está $_bloqueado local while(<>){}?
— Kenney
Sí, $_es la variable predeterminada del alcance actual. En el bloque END, no está definido.
— Dennis
2

CJam, 24 21 bytes

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

Pruébalo aquí.

Explicación

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

PowerShell, 67 bytes

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

Un poco de magia negra sucediendo aquí. Trataré de atravesarlo sin problemas.

Primero tomamos nuestra entrada, esperada como matrices individuales delimitadas por comas, por ejemplo (1,4,3) (2,2,2) (3) (4,4,4), y la canalizamos en un bucle |%{}.

Dentro del ciclo, primero verificamos si $_, la matriz particular que estamos considerando, tiene solo un elemento y lo usamos para indexar en una matriz (esencialmente una construcción if / else más corta). Si es más de un elemento, supongamos que (1,4,3)como entrada, ejecutamos la primera mitad, que es simplemente escupir la matriz a través de $_, como (1,4,3). De lo contrario, creamos una nueva matriz dinámica que consiste en el elemento tres veces con (,$_*3)una aproximación de 4/3 * Pi. Para la entrada (3), esto dará como resultado la (3,3,3,4.18879)salida.

Sí, PowerShell tiene una constante Pi, a la que se accede mediante una llamada .NET [math]::PI, pero es más larga y no quiero usarla. :pags

De todos modos, concatenamos esa matriz de salida con asteriscos vía -join'*', entonces "1*4*3". Una vez que hemos pasado por completo el ciclo, ahora tenemos una colección de cadenas. Todos -join'+'juntos para nuestra suma, y iexla expresión para calcular el resultado.

Uf.

— AdmBorkBork
fuente
1

Ruby, 58 caracteres.

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

Ejecución de muestra:

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

Idea de mejora robada descaradamente de la respuesta JavaScript de edc65 .

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

Ejecución de muestra:

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
— hombre trabajando
fuente
1

Japt, 27 22 bytes

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

Toma datos como matrices separadas por espacios. Pruébalo en línea!

Cómo funciona

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
— ETHproducciones
fuente
1

Pip , 23 bytes

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

Hay un par de formas de dar su opinión a este programa. Puede tomar cada presente como un argumento de línea de comandos de tres números separados por espacios (que deberán estar entre comillas pip.py present.pip "1 4 3" "3 0 0"). Alternativamente, especifique la -rbandera y dé a cada presente como una línea de stdin que consta de tres números separados por espacios. Pruébalo en línea!

¿Cómo?

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

Perl 5, 142 bytes

Ejecute con -pen la línea de comando y escriba números delimitados con una coma, así:

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

produciría

523.598820058997

No hay pipalabra clave en Perl. Esto, en la mayoría de los casos, es exacto para las cifras significativas especificadas, sin embargo, incluso si escribí todas las cifras de pi que conozco, no sería muy preciso para algunos cálculos. Entonces lo dejé con 3.1415. No estoy seguro de si esto es aceptable o no.

Código:

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

Editado para una mayor precisión siguiendo el consejo de Dennis, que es mejor en matemáticas básicas que yo, y de una sugerencia de MichaelT para guardar bytes sin dejar de ser preciso.

— Codefun64
fuente
2
1. ¿Cómo analizarías 1511? 2. 3.1415 no se redondea adecuadamente ni es lo suficientemente precisa. Si mis cálculos son correctos, el error no debe ser mayor que 0.0000017 . 3. (4/3)*3.1415se puede reemplazar con un solo flotador.
— Dennis
1. El OP dice que podemos suponer ceros al final de las esferas (que de hecho es la entrada de ejemplo que proporcioné), 2. No sé qué cálculos está utilizando, pero claro, aumentaré la precisión, y 3 buena sugerencia, me perdí esa. ¡Gracias!
— Codefun64
No tengo los recursos frente a mí en este momento, aunque me pregunto si hacerlo 1420/339le devolvería unos pocos bytes con una aproximación razonable. (Esto es 4/3 * 355/113). La diferencia entre la fracción y el valor que tiene es -8.49130615e-8
@MichaelT Eso es lo más interesante. ¿Tiene un script que encuentra la representación fraccionaria más pequeña de números? ;)
— Codefun64
Codefun64 Acabo de trabajar con la otra aproximación común para pi. 22/7 no está dentro de la tolerancia suficiente, así que eché un vistazo a en.wikipedia.org/wiki/Approximations_of_%CF%80 y usé el siguiente para ver si tenía una tolerancia mejor de lo que @Dennis estaba pidiendo.
0

Lua, 115104 bytes

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

Solución directa, tengo que envolver la operación pseudoternaria <condition> and <non-false> or <value if false>entre paréntesis, de lo contrario b sumaría con ambas áreas.

La entrada debe estar en el formulario array={{1,4,3},{2,2,2},{3},{4,4,4}}y el resultado se puede ver ejecutando print(f(array)).

— Katenkyo
fuente
0

05AB1E , 18 16 bytes

εDgi3m4žq*3/*]PO

Pruébalo en línea.

Explicación:

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

R, 38 36 bytes

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

Utiliza argumentos predeterminados para cambiar entre los casos: con tres argumentos calcula el producto y con un argumento calcula la fórmula de la esfera.

— JDL
fuente
necesitas el f<-y el {}?
— Giuseppe
Este código no sale correctamente para el caso de prueba (5,0,0). Además, no se adapta al caso de prueba donde hay múltiples regalos y los volúmenes deben sumarse.
— Robert S.
Para (5,0,0) obtengo cero, ¿no es correcto? Edité para usar sum(y eliminé algunas cosas que no eran necesarias según la sugerencia de Giuseppe)
— JDL
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.