Tienes una piscina que está llena hasta el borde con agua. Necesita vaciarlo, pero no puede pensar en un método eficiente. Entonces decides usar tu copa roja en solitario. Llenará repetidamente la taza hasta el fondo y la arrojará fuera de la piscina.

Desafío

¿Cuánto tiempo llevará vaciar la piscina?

Entrada

[shape of pool] [dimensions] [shape of cup] [dimensions] [speed]

• shape of poolserá una de estas cadenas: circle, triangleo rectangle. Tenga en cuenta que en realidad se refieren a las formas tridimensionales: cilindro, prisma triangular y prisma rectangular.
• dimensions será diferente dependiendo de la forma.
  • círculo: [radius] [height]. Volumen = π r ² h
  • triángulo: [base] [height] [length]. Volumen = 1/2 (bh) * longitud
  • rectángulo: [width] [length] [height]Volumen = lwh
• shape of cupy dimensionstrabajar de la misma manera. La copa también puede ser un círculo, un triángulo o un rectángulo.
• speedes la cantidad de tiempo que lleva vaciar una taza llena de agua en segundos .

Salida

El número de segundos que lleva vaciar la piscina. Esto se puede redondear al segundo más cercano.

Notas

• No habrá unidades en la entrada. Se supone que todas las unidades de distancia son iguales (una forma no tendrá una altura en pulgadas y un ancho en pies).
• Use 3.14 para pi.
• La entrada estará compuesta por cadenas y números de punto flotante.
• Nunca lloverá. Nunca se agregará agua.
• Tienes una mano muy firme. Llenará la copa exactamente hasta el borde cada vez, y nunca derramará nada.
• Una vez que te acerques al final, será difícil recoger una taza llena de agua. No necesita preocuparse por esto. Eres muy fuerte, por lo que puedes inclinar la piscina hacia un lado (sin gastar más tiempo).
• Cada vez que haga un cálculo, está bien redondear a la centésima más cercana . Su respuesta final no necesitará ser exacta.

Casos de prueba

Entrada: triangle 10 12.25 3 circle 5 2.2 5
Salida: 10
Aunque queda menos de 172.7 en la última primicia, todavía toma los cinco segundos completos para vaciarla.

Entrada: triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2
Salida:804.2

• Debe redondear a la centésima más cercana después de cada cálculo.
• El cálculo final se redondea desde 804.05567 a 804.2. Esto se debe a que ese último pedacito de agua debe vaciarse.

Reglas

• Puede escribir un programa o función completa.
• La entrada debe tomarse de stdin o parámetros de función. La salida debe imprimirse a través de stdout o devolverse.
• El formato de entrada se puede reorganizar, siempre que lo especifique en el envío. También puede acortar las cadenas "círculo", "triángulo" y "rectángulo".
• Las bibliotecas y las funciones integradas que involucran volumen o área no están permitidas.

Puntuación

Este es el código de golf . La presentación con el menor número de bytes gana.

JavaScript ES6, 100 78 82 81 74 bytes

Gracias a @UndefinedFunction por ayudar al golf en 4 bytes

(a,z,d,f=([a,g,k,p])=>g*k*(a[6]?p/-~!a[8]:3.14*g))=>Math.ceil(f(a)/f(z))*d

Uso:

t(["triangle",10,12.25,3],["circle",5,2.2],5);

CJam, 46 bytes

{rc:Xr~r~@'c={\_**3.14*}{r~**X't=)/}?}2*/m]r~*

Explicación:

{                                    }2*       e# Repeat two times:
 rc:X                                          e#   Read a token, take first char, assign to X
     r~r~                                      e#   Read and eval two tokens
         @'c={         }            ?          e#   If the char was 'c':
              \_*                              e#     Square the first token (radius)
                 *                             e#     Multiply by the second one (height)
                  3.14*                        e#     Multiply by 3.14
                        {          }           e#   Else:
                         r~                    e#     Read and eval a token
                           **                  e#     Multiply the three together
                             X't=)/            e#     Divide by 2 if X == 't'
                                               e# Now the two volumes are on the stack
                                        /m]    e# ceil(pool_volume / cup_volume)
                                           r~* e# Read and evaluate token (time) and multiply

Pruébalo en línea .

Python 3, 340 304 bytes

def l(Y,Z):r=Z[1]*3.14*(Z[0]**2)if Y[0]in'c'else Z[0]*Z[1]*Z[2];return r/2 if Y[0]is't'else r
def q(i):import re,math;M,L,F,C=map,list,float,math.ceil;p,d,c,g,s=re.match("(\w)\s([\d .]+)\s(\w)\s([\d .]+)\s([\d.]+)",i).groups();k=lambda j:L(M(F,j.split(' ')));d,g=k(d),k(g);return C(C(l(p,d)/l(c,g))*F(s))

Uso:

q(i)

Dónde i está la cadena de información?

Ejemplos:

• q("t 10 12.25 3 c 5 2.2 5")
• q("t 5 87.3 20001 r 5.14 2 105.623 0.2")

Nota: Los nombres de las formas se han acortado a sus primeras letras, respectivamente.

Javascript (ES6), 91

Tomando la entrada como cadenas para las formas, matrices de números para las dimensiones y un solo número para la velocidad:

(a,b,c,d,e)=>(1+(v=(y,x)=>x[0]*x[1]*(y[6]?x[2]/(y[8]?1:2):x[0]*3.14))(a,b)/v(c,d)-1e-9|0)*e

Esto define una función anónima, así que para usar agregar g= antes. Entonces, se puede llamar comoalert(g("triangle", [10, 12.25, 3], "circle", [5, 2.2], 5))

Explicación:

(a,b,c,d,e)=>    //define function
                   //a = pool shape, b = pool dimensions
                   //c = cup shape, d = cup dimensions
                   //e = speed

( 1+     //part of the rounding up below

  (v=(y,x)=>       //define volume function

      x[0] * x[1] *     //multiply first 2 values of dimension by:

          (y[6] ?
               x[2] /     //if rectangle or triangle, the 3rd dimension
                   (y[8] ? 1 : 2)     //but if triangle divide by 2
                :
               x[0] * 3.14     //or if circle the radius * pi
          )    //(implicit return)

  )(a,b) / v(c,d)     //call the volume function for the pool/cup, and divide

         -1e-9 |0    //but round up the result

) * e     //and multiply by e
//(implicit return)

Mi solución original tomó una sola cadena y tenía 111 bytes de longitud:

s=>(1+(v=x=>s[i++]*s[i++]*(s[x][6]?s[i++]/(s[x][8]?1:2):s[i-2]*3.14))((i=1)-1,s=s.split` `)/v(i++)-1e-9|0)*s[i]

Esto también define una función anónima, por lo tanto, use agregar f=antes. Entonces, se puede llamar comoalert(f("triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2"))

K5 (oK), 123 bytes

v:{((({y*3.14*x*x};{z*(x*y)%2};{x*y*z})@"ctr"?s)..:'t#1_x;(1+t:2+~"c"=s:**x)_x)};f:{{(.**|r)*_(~w=_w)+w:x%*r:v y}.v[" "\x]}

Julia, 122 116 95 89 79 bytes

f(p,P,c,C,s)=(V(a,x)=prod(x)*(a<'d'?3.14x[1]:a>'s'?.5:1);ceil(V(p,P)/V(c,C))*s)

Esto supone que solo se dará la primera letra de los nombres de las formas. De lo contrario, la solución es 6 bytes más larga.

Ungolfed + explicación:

function f(p::Char, P::Array, c::Char, C::Array, s)
    # p - Pool shape (first character only)
    # P - Pool dimensions
    # c - Cup shape (first character only)
    # C - Cup dimensions
    # s - Speed

    # Define a function to compute volume
    function V(a::Char, x::Array)
        prod(x) * (a < 'd' ? 3.14x[1] : a > 's' ? 0.5 : 1)
    end

    # Return the ceiling of the number of cups in the pool
    # times the number of seconds per cup
    ceil(V(p, P) / V(c, C)) * s
end

¡Ahorró 21 bytes gracias a edc65 y 10 gracias a UndefinedFunction!

F #, 217 186 184 160 bytes

¡Malditos requisitos de sangría!

let e(p,P,c,C,s)=
 let V(s:string)d=
  match(s.[0],d)with
  |('c',[x;y])->3.14*x*x*y
  |('t',[x;y;z])->((x*y)/2.)*z
  |('r',[x;y;z])->x*y*z
 ceil(V p P/V c C)*s

Uso:

e("triangle",[5.;87.3;20001.],"rectangle",[5.14;2.;105.623],0.2);;

Actualizar

Gracias a Alex por comentar sobre la sangría de espacio único, que F # parece admitir

Se las arregló para eliminar una carga más al cambiar de arraya listtipos en la matchdeclaración

Python 2.7 306 Bytes

import math as z,re
t,m,r,w=float,map,reduce,[e.split() for e in re.split(' (?=[a-z])| (?=\d+(?:\.\d+)?$)',raw_input())]
def f(S,D):i=r(lambda x,y:x*y,D);return((i,i*.5)[S[0]=='t'],3.14*i*D[0])[S[0]=="c"]
print z.ceil(r(lambda x,y:x/y,m(lambda q:f(q[0],q[1:]),m(lambda x:[x[0]]+m(t,x[1:]),w[:-1]))))*t(*w[-1])

Toma entrada de stdin.
Probándolo

$ python pool.py
triangle 10 12.25 3 circle 5 2.2 5
10.0
$ python pool.py
triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2
804.2

Python 2, 222 146 139 119 103 93 bytes

Implementación bastante sencilla. Gracias a Sp3000 por el -(-n//1)truco para el techo, que debería funcionar en todos los casos (es decir, todavía no he encontrado un problema).

u=lambda q,k,l,m=1:k*l*[3.14*k,m][q>'c']*-~(q<'t')/2.
f=lambda a,b,c,d,s:-u(a,*c)//u(b,*d)*-s

La entrada debe formatearse así:

f(shape1, shape2, dimensions1, dimensions2, speed)
"Where shape1 and shape2 are one of 'c','r','t', dimensions1 is a list of the dimensions
 of the first shape, dimensions 2 is a list of the dimensions for the second shape, and
 speed is the speed of emptying in seconds."

Uso:

>>> f('t', 'r', [5, 87.3, 20001], [5.14, 2, 105.623], 0.2)
804.2
>>> f('t', 'c', [10, 12.25, 3], [5, 2.2], 5)
10.0

Sin golf:

import math

def volume(shape, dimensions):
    out = dimensions[0] * dimensions[1]
    if shape == 'c':
        out *= 3.14 * dimensions[0]
    else:
        out *= dimensions[2]
    if shape == 't':
        out /= 2.0
    return out

def do(shape1, shape2, dimensions1, dimensions2, speed):
    volume1 = volume(shape1, dimensions1)
    volume2 = volume(shape2, dimensions2)
    return math.ceil(volume1 / volume2) * speed

Solución original, 222 bytes.

Esto se hizo cuando las reglas aún necesitaban que ingresara la palabra completa en lugar de una letra. Utilicé el hecho de que los hash(s)%5asigné circle -> 2, triangle -> 3, rectangle -> 1, sin embargo, si solo tomo una letra como entrada, creo que puedo acortar esto.

from math import*
u=lambda p,q:[[p[0]*p[1]*p[-1],3.14*p[0]**2*p[1]][1<q<3],0.5*p[0]*p[1]*p[-1]][q>2]
def f(*l):k=hash(l[0])%5;d=4-(1<k<3);v=l[1:d];r=hash(l[d])%5;g=4-(1<r<3);h=l[1+d:d+g];s=l[-1];print ceil(u(v,k)/u(h,r))*s

Uso:

>>> f('triangle',10,12.25,3,'circle',5,2.2,5)
10.0
>>> f('triangle',5,87.3,20001,'rectangle',5.14,2,105.623,0.2)
804.2

Python 2/3, 252 249 bytes

import re,math;i=[float(x)if re.match('[\d.]+',x)else x for x in re.sys.stdin.readline().split()]
for o in[0,[4,3][i[0]<'d']]:
 w=i[o+1]*i[o+2]*i[o+3]
 if i[o]<'d':w*=3.14*i[o+1]/i[o+3]
 if i[o]>'s':w*=.5
 a=a/w if o else w
print(math.ceil(a)*i[-1])

Ejemplos de uso:

$ echo 'triangle 10 12.25 3 circle 5 2.2 5' | python stack_codegolf_54454.py
10.0
$ echo 'triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2' | python stack_codegolf_54454.py
804.2

Las versiones solo Python 2 y Python 3 solo son diferentes en cómo reciben la entrada; raw_input()para Python 2 yinput() para Python 3, en oposición are.sys.stdin.readline() de la versión Python2 / 3.

Python 2, 240 237 bytes

import re,math;i=[float(x)if re.match('[\d.]+',x)else x for x in raw_input().split()]
for o in[0,[4,3][i[0]<'d']]:
 w=i[o+1]*i[o+2]*i[o+3]
 if i[o]<'d':w*=3.14*i[o+1]/i[o+3]
 if i[o]>'s':w*=.5
 a=a/w if o else w
print(math.ceil(a)*i[-1])

Python 3, 236 233 bytes

import re,math;i=[float(x)if re.match('[\d.]+',x)else x for x in input().split()]
for o in[0,[4,3][i[0]<'d']]:
 w=i[o+1]*i[o+2]*i[o+3]
 if i[o]<'d':w*=3.14*i[o+1]/i[o+3]
 if i[o]>'s':w*=.5
 a=a/w if o else w
print(math.ceil(a)*i[-1])

Cambios:

Cambiado for o in[0,3if i[0]<'d'else 4]:a for o in[0,[4,3][i[0]<'d']]:. Gracias a Vioz por la inspiración :).

Pyth - 40 39 36 35 34 bytes

Utiliza un método simple, mapeo sobre ambos contenedores y luego reduce por división.

*h/Fmc*Ftd@,/JChd58c.318@d1Jc2PQeQ

Toma una coma de entrada separada de stdin, con la primera letra de cada forma como: "t", 10, 12.25, 3, "c", 5, 2.2, 5 .

Test Suite .