Vous avez une piscine remplie à ras bord d'eau. Vous devez le vider, mais vous ne pouvez pas penser à une méthode efficace. Vous décidez donc d'utiliser votre tasse solo rouge. Vous remplissez la tasse à plusieurs reprises et la jetez à l'extérieur de la piscine.

Défi

Combien de temps faut-il pour vider la piscine?

Contribution

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

• shape of poolsera l'une de ces chaînes: circle, triangleou rectangle. Notez que ceux-ci se réfèrent en fait aux formes tridimensionnelles: cylindre, prisme triangulaire et prisme rectangulaire.
• dimensions sera différent selon la forme.
  • cercle: [radius] [height]. Volume = π r ² h
  • triangle: [base] [height] [length]. Volume = 1/2 (bh) * longueur
  • rectangle: [width] [length] [height]Volume = lwh
• shape of cupet dimensionstravailler de la même manière. La coupe peut également être un cercle, un triangle ou un rectangle.
• speedest le temps qu'il faut pour vider une tasse pleine d'eau en quelques secondes .

Production

Le nombre de secondes qu'il faut pour vider la piscine. Cela peut être arrondi à la seconde près.

Remarques

• Il n'y aura pas d'unités dans l'entrée. Toutes les unités de distance sont supposées être les mêmes (une forme n'aura pas une hauteur en pouces et une largeur en pieds).
• Utilisez 3.14 pour pi.
• L'entrée sera composée de chaînes et de nombres à virgule flottante.
• Il ne pleuvra jamais. Aucune eau ne sera jamais ajoutée.
• Vous avez une main très stable. Vous remplirez la tasse exactement à ras bord à chaque fois et vous n'en renverserez jamais.
• Une fois que vous approchez de la fin, il sera difficile de ramasser une tasse pleine d'eau. Vous n'avez pas à vous en préoccuper. Vous êtes très fort, vous pouvez donc incliner la piscine sur le côté (sans utiliser plus de temps).
• Chaque fois que vous effectuez un calcul, vous pouvez arrondir au centième près . Votre réponse finale n'aura pas besoin d'être exacte.

Cas de test

Entrée: triangle 10 12.25 3 circle 5 2.2 5
Sortie: 10
Même s'il reste moins de 172,7 sur le dernier scoop, il faut tout de même cinq secondes pour le vider.

Entrée: triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2
Sortie:804.2

• Vous devez arrondir au centième près après chaque calcul.
• Le calcul final est arrondi de 804.05567 à 804.2. En effet, ce dernier peu d'eau doit être vidé.

Règles

• Vous pouvez écrire un programme ou une fonction complète.
• L'entrée doit être prise à partir de paramètres stdin ou de fonction. La sortie doit être imprimée via stdout ou renvoyée.
• Le format d'entrée peut être réorganisé, tant que vous le spécifiez dans la soumission. Vous pouvez également raccourcir les chaînes "cercle", "triangle" et "rectangle".
• Les bibliothèques et les fonctions intégrées qui impliquent un volume ou une zone ne sont pas autorisées.

Notation

C'est du code-golf . La soumission avec le moins d'octets gagne.

JavaScript ES6, 100 78 82 81 74 octets

Merci à @UndefinedFunction pour avoir aidé le golf sur 4 octets

(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

Usage:

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

CJam, 46 octets

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

Explication:

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

Essayez-le en ligne .

Python 3, 340 304 octets

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

Usage:

q(i)

Où iest la chaîne d'informations.

Exemples:

• 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")

Remarque: Les noms des formes ont été raccourcis respectivement dans leurs premières lettres.

Javascript (ES6), 91

Prendre l'entrée sous forme de chaînes pour les formes, de tableaux de nombres pour les dimensions et d'un nombre unique pour la vitesse:

(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

Cela définit une fonction anonyme, donc utilisez add g=avant. Ensuite, il peut être appelé commealert(g("triangle", [10, 12.25, 3], "circle", [5, 2.2], 5))

Explication:

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

Ma solution d'origine prenait une seule chaîne et mesurait 111 octets:

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]

Cela définit également une fonction anonyme, donc utilisez add f=avant. Ensuite, il peut être appelé commealert(f("triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2"))

K5 (oK), 123 octets

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 octets

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)

Cela suppose que seule la première lettre des noms de forme sera donnée. Sinon, la solution est plus longue de 6 octets.

Non golfé + explication:

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

Enregistré 21 octets grâce à edc65 et 10 grâce à UndefinedFunction!

F #, 217 186 184 160 160 octets

Foutues exigences d'indentation!

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

Usage:

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

Mise à jour

Merci à Alex d'avoir remarqué l'indentation d'un seul espace, que F # semble prendre en charge

Géré pour réduire la charge en changeant de arrayen listtypes dans l' matchinstruction

Python 2,7 306 octets

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

Prend l'entrée de stdin.
Le tester-

$ 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 139 119 103 93 octets

Mise en œuvre assez simple. Merci à Sp3000 pour l' -(-n//1)astuce pour le plafond, qui devrait fonctionner dans tous les cas (c'est-à-dire qui n'a pas encore trouvé de problème).

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

L'entrée doit être formatée comme suit:

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

Usage:

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

Non 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

Solution d'origine, 222 octets

Cela a été fait lorsque les règles exigeaient toujours que vous entriez le mot entier plutôt qu'une lettre. J'ai utilisé le fait de les hash(s)%5mapper circle -> 2, triangle -> 3, rectangle -> 1, mais si je ne prends qu'une lettre comme entrée, je pense que je peux raccourcir cela.

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

Usage:

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

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

Exemples d'utilisation:

$ 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

Les versions Python 2 uniquement et Python 3 uniquement ne sont différentes que dans la façon dont elles reçoivent les entrées; raw_input()pour Python 2 et input()pour Python 3, par opposition à re.sys.stdin.readline()pour la version Python2 / 3.

Python 2, 240 237 octets

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 octets

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

Changements:

Changé for o in[0,3if i[0]<'d'else 4]:en for o in[0,[4,3][i[0]<'d']]:. Merci à Vioz pour l'inspiration :).

Pyth - 40 39 36 35 34 octets

Utilise une méthode simple, mappant sur les deux conteneurs, puis réduisant par division.

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

Prend virgule entrée séparée de l' entrée standard, avec la première lettre de chaque forme comme: "t", 10, 12.25, 3, "c", 5, 2.2, 5.

Suite de tests .