Hai una piscina che è piena fino all'orlo di acqua. Devi svuotarlo, ma non riesci a pensare a un metodo efficiente. Quindi decidi di usare la tua tazza da solista rossa. Riempirai ripetutamente la tazza fino in fondo e la scaricherai fuori dalla piscina.

Sfida

Quanto tempo ci vorrà per svuotare la piscina?

Ingresso

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

• shape of poolsarà una di queste stringhe: circle, triangleo rectangle. Si noti che questi in realtà si riferiscono alle forme tridimensionali: cilindro, prisma triangolare e prisma rettangolare.
• dimensions sarà diverso a seconda della forma.
  • cerchio: [radius] [height]. Volume = π r ² h
  • triangolo: [base] [height] [length]. Volume = 1/2 (bh) * lunghezza
  • rettangolo: [width] [length] [height]Volume = lwh
• shape of cupe dimensionslavorare allo stesso modo. La tazza può anche essere un cerchio, un triangolo o un rettangolo.
• speedè il tempo necessario per svuotare una tazza piena d'acqua in pochi secondi .

Produzione

Il numero di secondi necessari per svuotare la piscina. Questo può essere arrotondato al secondo più vicino.

Appunti

• Non ci saranno unità nell'input. Si presume che tutte le unità di distanza siano uguali (una forma non avrà un'altezza in pollici e una larghezza in piedi).
• Utilizzare 3.14 per pi.
• L'input sarà composto da stringhe e numeri in virgola mobile.
• Non pioverà mai. Non verrà mai aggiunta acqua.
• Hai una mano molto ferma. Riempirai la tazza esattamente fino all'orlo ogni volta e non ne verserai mai.
• Una volta che ti avvicini alla fine, sarà difficile raccogliere una tazza piena d'acqua. Non devi preoccuparti di questo. Sei molto forte, quindi puoi inclinare la piscina su un lato (senza perdere altro tempo).
• Ogni volta che fai un calcolo, va bene arrotondare al centesimo più vicino . La tua risposta finale non dovrà essere esatta.

Casi test

Input: triangle 10 12.25 3 circle 5 2.2 5
Output: 10
Anche se nell'ultimo scoop sono rimasti meno di 172.7, ci vogliono comunque tutti i cinque secondi per svuotarlo.

Ingresso: triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2
Uscita:804.2

• Dovresti arrotondare al centesimo più vicino dopo ogni calcolo.
• Il calcolo finale è arrotondato per eccesso da 804.05567 a 804.2. Questo perché l'ultimo po 'd'acqua deve essere svuotato.

Regole

• È possibile scrivere un programma o una funzione completi.
• L'input deve essere preso dallo stdin o dai parametri della funzione. L'output deve essere stampato tramite stdout o restituito.
• Il formato di input può essere riorganizzato, purché sia ​​specificato nell'invio. Puoi anche accorciare le stringhe "cerchio", "triangolo" e "rettangolo".
• Non sono consentite librerie e funzioni integrate che coinvolgono volume o area.

punteggio

Questo è code-golf . Vince l'invio con il minor numero di byte.

JavaScript ES6, 100 78 82 81 74 byte

Grazie a @UndefinedFunction per aver aiutato a giocare a golf con 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

Uso:

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

CJam, 46 byte

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

Spiegazione:

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

Provalo online .

Python 3, 340 304 byte

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)

Dov'è ila stringa di informazioni.

Esempi:

• 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: i nomi delle forme sono stati abbreviati rispettivamente nelle prime lettere.

Javascript (ES6), 91

Prendendo input come stringhe per le forme, matrici di numeri per le dimensioni e un singolo numero per la velocità:

(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

Questo definisce una funzione anonima, quindi per usare aggiungi g=prima di essa. Quindi, può essere chiamato comealert(g("triangle", [10, 12.25, 3], "circle", [5, 2.2], 5))

Spiegazione:

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

La mia soluzione originale ha preso una singola stringa ed era lunga 111 byte:

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]

Questo definisce anche una funzione anonima, quindi usare add f=prima di essa. Quindi, può essere chiamato comealert(f("triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2"))

K5 (oK), 123 byte

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 byte

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)

Ciò presuppone che verrà data solo la prima lettera dei nomi delle forme. Altrimenti la soluzione è più lunga di 6 byte.

Ungolfed + spiegazione:

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

Risparmiato 21 byte grazie a edc65 e 10 grazie a UndefinedFunction!

F #, 217 186 184 160 byte

Dannati requisiti di rientro!

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

Aggiornare

Grazie ad Alex per il commento sul rientro nello spazio singolo, che F # sembra supportare

Riuscito a ridurre ulteriormente il carico cambiando da arraya listtipi matchnell'istruzione

Python 2.7 306 byte

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

Riceve input dallo stdin.
Test it-

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

Implementazione abbastanza semplice. Grazie a Sp3000 per il -(-n//1)trucco per il soffitto, che dovrebbe funzionare in tutti i casi (cioè non ho ancora trovato un problema con esso).

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'input deve essere formattato in questo modo:

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

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

Soluzione originale, 222 byte

Questo è stato fatto quando le regole avevano ancora bisogno che tu inserissi l'intera parola anziché una lettera. Ho usato il fatto che hash(s)%5li ha mappati circle -> 2, triangle -> 3, rectangle -> 1, tuttavia se prendo solo una lettera come input, penso che posso ottenere questo più breve.

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 byte

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

Esempi di utilizzo:

$ 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

Le versioni solo Python 2 e solo Python 3 differiscono solo nel modo in cui ricevono input; raw_input()per Python 2 e input()per Python 3, al contrario re.sys.stdin.readline()della versione Python2 / 3.

Python 2, 240 237 byte

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 byte

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

I cambiamenti:

Modificato for o in[0,3if i[0]<'d'else 4]:in for o in[0,[4,3][i[0]<'d']]:. Grazie a Vioz per l'ispirazione :).

Pyth - 40 39 36 35 34 byte

Utilizza un metodo semplice, mappando su entrambi i contenitori e quindi riducendo per divisione.

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

Prende virgola ingresso separato da stdin, con la prima lettera di ogni forma come: "t", 10, 12.25, 3, "c", 5, 2.2, 5.

Test Suite .