Sie haben ein Schwimmbad, das randvoll mit Wasser gefüllt ist. Sie müssen es leeren, können sich aber keine effiziente Methode vorstellen. Sie entscheiden sich also für Ihren roten Solo-Pokal. Sie werden die Tasse wiederholt bis zum Anschlag füllen und sie außerhalb des Pools ablassen.

Herausforderung

Wie lange dauert es, bis der Pool geleert ist?

Eingang

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

• shape of poolwird eine dieser Zeichenketten sein: circle, triangleoderrectangle . Beachten Sie, dass sich diese tatsächlich auf die dreidimensionalen Formen beziehen: Zylinder, dreieckiges Prisma und rechteckiges Prisma.
• dimensions wird je nach Form unterschiedlich sein.
  • Kreis: [radius] [height]. Volumen = π r ² h
  • Dreieck: [base] [height] [length] . Volumen = 1/2 (bh) * Länge
  • Rechteck: [width] [length] [height]Volumen = lwh
• shape of cup und dimensions arbeiten auf die gleiche Weise. Die Tasse kann auch ein Kreis, ein Dreieck oder ein Rechteck sein.
• speedist die Zeit, die benötigt wird, um eine Tasse Wasser in Sekunden zu entleeren .

Ausgabe

Die Anzahl der Sekunden , die zum Entleeren des Schwimmbeckens benötigt werden. Dies kann auf die nächste Sekunde gerundet werden.

Anmerkungen

• Die Eingabe enthält keine Einheiten. Es wird angenommen, dass alle Abstandseinheiten gleich sind (eine Form hat keine Höhe in Zoll und keine Breite in Fuß).
• Verwenden Sie 3.14 für pi.
• Die Eingabe besteht aus Zeichenfolgen und Gleitkommazahlen.
• Es wird niemals regnen. Es wird niemals Wasser hinzugefügt.
• Sie haben eine sehr ruhige Hand. Sie werden die Tasse jedes Mal bis zum Rand füllen und nie etwas verschütten.
• Wenn Sie sich dem Ende nähern, wird es schwierig, eine volle Tasse Wasser zu schöpfen. Sie brauchen sich darüber keine Sorgen zu machen. Sie sind sehr stark, sodass Sie den Pool auf die Seite legen können (ohne mehr Zeit zu verbrauchen).
• Bei jeder Berechnung kann auf das nächste Hundertstel gerundet werden . Ihre endgültige Antwort muss nicht exakt sein.

Testfälle

Eingabe: triangle 10 12.25 3 circle 5 2.2 5
Ausgabe:10
Auch wenn der letzte Messlöffel weniger als 172,7 Sekunden enthält, dauert es immer noch die ganzen fünf Sekunden, bis er geleert ist.

Eingabe: triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2
Ausgabe:804.2

• Sie sollten nach jeder Berechnung auf das nächste Hundertstel runden.
• Die endgültige Berechnung wird von 804.05567 auf 804.2 aufgerundet. Dies liegt daran, dass das letzte bisschen Wasser geleert werden muss.

Regeln

• Sie können ein vollständiges Programm oder eine Funktion schreiben.
• Die Eingabe sollte aus Standard- oder Funktionsparametern erfolgen. Die Ausgabe sollte über stdout gedruckt oder zurückgesandt werden.
• Das Eingabeformat kann neu angeordnet werden, solange Sie dies in der Übermittlung angeben. Sie können auch die Zeichenfolgen "Kreis", "Dreieck" und "Rechteck" kürzen.
• Bibliotheken und integrierte Funktionen, die Volumen oder Bereich betreffen, sind nicht zulässig.

Wertung

Das ist Code-Golf . Einreichung mit der geringsten Anzahl von Bytes gewinnt.

JavaScript ES6, 100 78 82 81 74 Bytes

Vielen Dank an @UndefinedFunction für die Unterstützung beim Golfspielen bei 4 Byte

(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

Verwendung:

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

Erläuterung:

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

Probieren Sie es online aus .

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

Verwendung:

q(i)

Wo iist die Zeichenfolge der Informationen.

Beispiele:

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

Hinweis: Die Namen der Formen wurden auf die ersten Buchstaben gekürzt.

Javascript (ES6), 91

Eingaben als Zeichenfolgen für die Formen, Anordnungen von Zahlen für die Dimensionen und eine einzelne Zahl für die Geschwindigkeit:

(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

Dies definiert eine anonyme Funktion, um add g=davor zu verwenden . Dann kann man es so nennenalert(g("triangle", [10, 12.25, 3], "circle", [5, 2.2], 5))

Erläuterung:

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

Meine ursprüngliche Lösung bestand aus einer einzelnen Zeichenfolge und war 111 Byte lang:

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]

Dies definiert auch eine anonyme Funktion, um add f=davor zu verwenden . Dann kann man es so nennenalert(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)

Dies setzt voraus, dass nur der erste Buchstabe der Formnamen angegeben wird. Ansonsten ist die Lösung 6 Byte länger.

Ungolfed + Erklärung:

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

21 Bytes dank edc65 und 10 dank UndefinedFunction eingespart!

F #, 217 186 184 160 Bytes

Verdammte Eindrücke!

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

Verwendung:

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

Aktualisieren

Vielen Dank an Alex für die Bemerkung zu einzelnen Leerzeichen, die F # zu unterstützen scheint

Es ist gelungen, eine Last mehr abzuwerfen, indem in der Anweisung von arrayzu listTypen gewechselt wurdematch

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

Übernimmt die Eingabe von stdin.
Testen Sie es-

$ 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

Ziemlich unkomplizierte Implementierung. Danke an Sp3000 für das-(-n//1) Trick für die Decke, der in allen Fällen funktionieren sollte (dh noch kein Problem damit gefunden).

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

Die Eingabe sollte folgendermaßen formatiert sein:

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

Verwendung:

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

Ungolfed:

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

Ursprüngliche Lösung, 222 Bytes

Dies wurde gemacht, als Sie nach den Regeln immer noch das ganze Wort anstatt eines Buchstabens eingeben mussten. Ich habe die Tatsache hash(s)%5ausgenutzt , dass sie auf abgebildet circle -> 2, triangle -> 3, rectangle -> 1wurden. Wenn ich jedoch nur einen Buchstaben als Eingabe nehme, kann ich diese wahrscheinlich kürzer machen.

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

Verwendung:

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

Anwendungsbeispiele:

$ 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

Die Versionen nur für Python 2 und nur für Python 3 unterscheiden sich nur darin, wie sie Eingaben empfangen. raw_input()für Python 2 und input()für Python 3 im Gegensatz zur re.sys.stdin.readline()Python2 / 3-Version.

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

Änderungen:

Geändert for o in[0,3if i[0]<'d'else 4]:zu for o in[0,[4,3][i[0]<'d']]:. Vielen Dank an Vioz für die Inspiration :).

Pyth - 40 39 36 35 34 Bytes

Verwendet eine einfache Methode, die über beide Container hinweg abbildet und dann durch Unterteilung reduziert.

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

Nimmt von stdin getrenntes Eingabekomma, wobei der erste Buchstabe jeder Form wie folgt lautet: "t", 10, 12.25, 3, "c", 5, 2.2, 5 .

Test Suite .