एक स्विमिंग पूल खाली करें। । । केवल एक लाल सोलो कप के साथ

Question

आपके पास एक स्विमिंग पूल है जो पानी से भरा हुआ है। आपको इसे खाली करने की आवश्यकता है, लेकिन आप एक कुशल विधि के बारे में नहीं सोच सकते। तो आप अपने लाल एकल कप का उपयोग करने का निर्णय लेते हैं। आप बार-बार कप को पूरे रास्ते भरेंगे और पूल के बाहर डंप करेंगे।

चुनौती

पूल को खाली करने में कितना समय लगेगा?

इनपुट

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

• shape of pool: इन तार में से एक होगी circle, triangleया rectangle। ध्यान दें कि ये वास्तव में 3-आयामी आकृतियों को संदर्भित करते हैं: सिलेंडर, त्रिकोणीय प्रिज़्म और आयताकार प्रिज़्म।
• dimensions आकार के आधार पर अलग होगा।
  • चक्र: [radius] [height]। मात्रा = π r ² h
  • त्रिकोण: [base] [height] [length]। मात्रा = 1/2 (bh) * लंबाई
  • आयत: [width] [length] [height]आयतन = lwh
• shape of cupऔर dimensionsउसी तरह काम करते हैं। कप या तो एक चक्र, त्रिकोण, या आयत हो सकता है।
• speedएक कप पानी को सेकंड में खाली करने में कितना समय लगता है ।

उत्पादन

स्विमिंग पूल को खाली करने में सेकंड की संख्या । यह निकटतम दूसरे के लिए गोल किया जा सकता है।

टिप्पणियाँ

• इनपुट में कोई इकाई नहीं होगी। सभी दूरी इकाइयों को एक समान माना जाता है (एक आकार इंच में ऊंचाई और पैरों में चौड़ाई नहीं होगी)।
• 3.14 का प्रयोग करें pi।
• इनपुट स्ट्रिंग्स और फ्लोटिंग-पॉइंट नंबरों से बना होगा।
• कभी बारिश नहीं होगी। कभी पानी नहीं डाला जाएगा।
• आपका बहुत स्थिर हाथ है। आप कप को हर बार पूरी तरह से भर देंगे, और आप कभी भी छलकेंगे नहीं।
• एक बार जब आप अंत के पास पहुंच जाते हैं, तो पानी का एक पूरा कप निकालना मुश्किल हो जाएगा। इसके लिए आपको चिंता करने की जरूरत नहीं है। आप बहुत मजबूत हैं, इसलिए आप पूल को अपनी तरफ झुका सकते हैं (बिना किसी अधिक समय के उपयोग के)।
• किसी भी समय आप एक गणना करते हैं, यह निकटतम सौवें दौर के लिए ठीक है । आपके अंतिम उत्तर को सटीक होने की आवश्यकता नहीं होगी।

परीक्षण के मामलों

इनपुट: triangle 10 12.25 3 circle 5 2.2 5
आउटपुट: 10
भले ही अंतिम स्कूप पर 172.7 से कम बचा है, फिर भी इसे खाली करने में पूरे पांच सेकंड लगते हैं।

इनपुट: triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2
आउटपुट:804.2

• आपको प्रत्येक गणना के बाद निकटतम सौवें पर गोल करना चाहिए।
• अंतिम गणना को गिरफ्तार किया गया है 804,2 करने के लिए 804,05567 से। इसका कारण यह है कि पानी का अंतिम थोड़ा खाली होना चाहिए।

नियम

• आप एक पूर्ण कार्यक्रम या फ़ंक्शन लिख सकते हैं।
• इनपुट को स्टडिन या फ़ंक्शन मापदंडों से लिया जाना चाहिए। आउटपुट को स्टडआउट या प्रिंट के माध्यम से प्रिंट किया जाना चाहिए।
• इनपुट प्रारूप को फिर से व्यवस्थित किया जा सकता है, जब तक कि आप इसे प्रस्तुत करने में निर्दिष्ट करते हैं। आप स्ट्रिंग्स को "सर्कल", "त्रिकोण" और "आयत" भी छोटा कर सकते हैं।
• लाइब्रेरी और बिल्ट-इन फ़ंक्शंस जिसमें वॉल्यूम या क्षेत्र शामिल हैं, की अनुमति नहीं है।

स्कोरिंग

यह कोड-गोल्फ है । कम से कम बाइट्स जीत के साथ सबमिशन।

Comments

पूल के निचले भाग में पानी का स्तर कप की ऊंचाई से कम होने के बाद, आपको अंत में समस्याएं होंगी। उस समय यह पूर्ण कप पाने के लिए कठिन और कठिन होगा। क्या इस मुद्दे को नजरअंदाज किया जाना चाहिए?

— डारेल हॉफमैन

हाँ @DarrelHoffman, आइए दिखाते हैं कि आप वास्तव में मज़बूत हैं और पूल को इस तरफ झुका सकते हैं (बिना किसी अधिक समय के उपयोग के)।

— निक बी।

Answer 1

जावास्क्रिप्ट ईएस 6, 100 78 82 81 74 बाइट्स

4 बाइट से गोल्फ की मदद के लिए @UndefinedFunction का धन्यवाद

(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

उपयोग:

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

Comments

इसके बजाय .5*v, क्या आप नहीं कर सकते v/2?

— एलेक्स ए।

@AlexA। ओह, हाँ ... पूरी तरह से उस के बारे में भूल गया

— डाउनगैट

@vihan क्या होता है यदि पूल वॉल्यूम कप वॉल्यूम का एक सटीक मल्टीपल है, जैसे t(["triangle", [10, 12.25, 3]], ["triangle", [10, 12.25, 3]], 5)? मुझे मिलता है 10लेकिन जवाब नहीं होना चाहिए 5? संपादित करें: बस edc65 द्वारा पीटा, एक ही समस्या।

— 16

मेरे समाधान पर एक नज़र है, मैं इसे पोस्ट नहीं कर सकता क्योंकि यह आपके समान है ...f=(p,c,s,v=([s,a,b,c])=>s<'r'?a*a*b*3.14:a*b*c/(s<'t'?1:2))=>Math.ceil(v(p)/v(c))*s

— edc65

@ edc65 मुझे लगता है कि अब यह काम करना चाहिए। -~दशमलव संख्याओं के साथ समस्या थी और इसके परिणामस्वरूप एक अतिरिक्त कदम होगा। मुझे जोड़ना है a<'t'?1:2क्योंकि (1+(a>'t'))किसी कारण से काम नहीं करता है।

— डाउनग्रेड

Answer 2

सीजेएम, 46 बाइट्स

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

स्पष्टीकरण:

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

इसे ऑनलाइन आज़माएं ।

Answer 3

पायथन 3, 340 304 बाइट्स

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

उपयोग:

q(i)

iजानकारी का तार कहां है।

उदाहरण:

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

नोट: आकृतियों के नाम क्रमशः उनके पहले अक्षरों को छोटा कर दिया गया है।

Comments

आप ".5" के साथ ".5" की जगह एक बाइट बचा सकते हैं।

— पोटाटोमेटो

"(Z [0] ** 2)" में कोष्ठक अनावश्यक हैं। "Z [0] ** 2" के साथ "(Z [0] ** 2)" को प्रतिस्थापित करते हुए फ़ंक्शन के परिणामों को प्रभावित किए बिना 2 वर्णों को सहेजना चाहिए। इसके अतिरिक्त, "/ 2 इफ़" ("रिटर्न आर / 2 से यदि Y [0] ...) में स्थान एक चरित्र को बचाते हुए निकाला जा सकता है।

— पोटाटोमेटो

मैंने यह कोशिश की है और इसने परिणामों को प्रभावित किया है। @Potatomato

— Zach गेट्स

मैंने जो बदलाव प्रस्तावित किए हैं, वे ठीक काम करते हैं ( repl.it/BBNh/1 से पता चलता है कि समान मूल्य वापस आ गए हैं)।

— पोटाटोमेटो

Answer 4

जावास्क्रिप्ट (ईएस 6), 91

आकृतियों के लिए स्ट्रिंग्स के रूप में इनपुट लेना, आयामों के लिए संख्याओं के सरणियों और गति के लिए एक एकल संख्या:

(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

यह एक अनाम फ़ंक्शन को परिभाषित करता है, इसलिए g=इससे पहले ऐड का उपयोग करने के लिए । फिर, इसे कहा जा सकता हैalert(g("triangle", [10, 12.25, 3], "circle", [5, 2.2], 5))

स्पष्टीकरण:

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

मेरे मूल समाधान ने एक ही तार लिया, और 111 बाइट लंबा था:

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]

यह एक अनाम फ़ंक्शन को भी परिभाषित करता है, इसलिए f=इससे पहले ऐड का उपयोग करने के लिए । फिर, इसे कहा जा सकता हैalert(f("triangle 5 87.3 20001 rectangle 5.14 2 105.623 0.2"))

Answer 5

K5 (oK), 123 बाइट्स

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

Answer 6

जूलिया, 122 116 95 89 79 बाइट्स

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)

यह मानता है कि केवल आकृति नामों का पहला अक्षर दिया जाएगा। अन्यथा समाधान 6 बाइट्स लंबा है।

असंगठित + स्पष्टीकरण:

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 बाइट्स edc65 के लिए और 10 अनफाइंडफंक्शन के लिए धन्यवाद!

Comments

क्या आपके पास ceilजूलिया में नहीं है, इसके बजाय उपयोग करने के लिए floor, पूर्णांक परिणाम के बारे में सभी जांच काट कर?

— edc65

@ edc65 मैंने यह कैसे नहीं देखा ?! धन्यवाद, कि 21 बाइट बचा लिया!

— एलेक्स ए।

इसे बदलना संभव होगा a>'s'?prod(x)/2:prod(x)साथ prod(x)/(a>'s'?2:1)? (संभवतः कोष्ठक के बिना भी, मेरे पास हाथ पर एक रसिया विचारधारा नहीं है, और यह परीक्षण करने में सक्षम नहीं है)

— jrich

या संभावित रूप से भी बदल रहा a<'d'?3.14x[1]^2*x[2]:a>'s'?prod(x)/2:prod(x)है prod(x)*(a<'d'?3.14x[1]:a>'s'?.5:1)? (फिर से, untested)

— jrich

@UndefinedFunction हाँ, यह काम करता है! धन्यवाद, कि 10 बाइट्स मुंडा!

— एलेक्स ए।

Answer 7

एफ #, 217 186 184 160 बाइट्स

धिक्कार है इंडेंटेशन की जरूरतें!

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

उपयोग:

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

अपडेट करें

एलेक्स को सिंगल स्पेस इंडेंटेशन पर टिप्पणी करने के लिए धन्यवाद, जो एफ # का समर्थन करता है

से बदलकर अधिक दूर एक लोड दस्तक करने में कामयाब arrayकरने के लिए listमें प्रकार matchबयान

Comments

यदि आप इंडेंटेशन के लिए सिंगल स्पेस या टैब का उपयोग कर सकते हैं, तो आप इसे 186 बाइट्स तक प्राप्त कर सकते हैं। लेकिन अब आपके पास वास्तव में 211 है, 217 नहीं।

— एलेक्स ए।

@ एलेक्सा.ए सिंगल स्पेस काम करता है, मैं अपडेट करूंगा - धन्यवाद! क्यों / 211 था, 217 नहीं, जब मैंने इसे नोटपैड में रखा, तो यह 217 वर्णों के रूप में दिखाई दे रहा है, और इसे एक फ़ाइल में सहेजना 217 को दिखाता है (क्षमा करें, पहले गोल्फ, इसलिए आकार की गणना करने पर गलत हो सकता है)

— Psytronic

मैं इस आसान उपकरण का उपयोग करके बाइट्स गिन रहा था । विंडोज दो-बाइट लाइन ब्रेक का उपयोग करता है ताकि विसंगति की व्याख्या हो सके।

— एलेक्स ए।

@AlexA। आह, धन्यवाद, यह समझ में आता है! यह संस्करण 180 होना चाहिए फिर मुझे लगता है।

— Psytronic

बल्कि x**2.आप कर सकते हैं x*x? वह बोया बचाओ 2 बाइट्स।

— एलेक्स ए।

Answer 8

पायथन 2.7 306 बाइट्स

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

स्टड से इनपुट लेता है।
इसका परीक्षण-

$ 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

Answer 9

पायथन 2, 222 146 139 119 103 93 बाइट्स

बहुत ही सीधा कार्यान्वयन। -(-n//1)छत के लिए चाल के लिए Sp3000 के लिए धन्यवाद , जो सभी मामलों में काम करना चाहिए (यानी अभी तक इसके साथ कोई समस्या नहीं मिली है)।

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

इनपुट को इस तरह स्वरूपित किया जाना चाहिए:

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

उपयोग:

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

---

मूल समाधान, 222 बाइट्स

यह तब बनाया गया था जब नियमों को अभी भी आपको पत्र के बजाय पूरे शब्द को इनपुट करने की आवश्यकता थी। मैंने इस तथ्य का उपयोग किया कि hash(s)%5उन्हें मैप किया जाए circle -> 2, triangle -> 3, rectangle -> 1, हालांकि अगर मैं सिर्फ एक पत्र को इनपुट के रूप में लेता हूं, मुझे लगता है कि मैं इसे छोटा कर सकता हूं।

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

उपयोग:

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

Comments

ठीक है, अगर आप धोखा देना चाहते हैं ..;)

— साइफेज

@Cyphase यह कैसे धोखा है? मैंने सभी पुनर्व्यवस्थित इनपुट किए, जो कि बहुत सारे लोगों ने यहां किया है ..

— Kade

(अरे अरे, यह नहीं देखा कि यह तुम थे।) मैं सिर्फ मजाक कर रहा था :)। मैं इसे अनुकूलित इनपुट के साथ भी कोशिश करने जा रहा हूं।

— साइफेज

Answer 10

पायथन 2/3, 252 249 बाइट्स

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

उपयोग के उदाहरण:

$ 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

पायथन 2 केवल और पायथन 3 केवल संस्करण केवल भिन्न हैं कि वे इनपुट कैसे प्राप्त करते हैं; raw_input()पायथन 2 के लिए और input()पायथन 3 के लिए, पायथन re.sys.stdin.readline()2/3 संस्करण के लिए विरोध के रूप में ।

पायथन 2, 240 237 बाइट्स

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

पायथन 3, 236 233 बाइट्स

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

परिवर्तन:

को बदल for o in[0,3if i[0]<'d'else 4]:दिया for o in[0,[4,3][i[0]<'d']]:। प्रेरणा के लिए Vioz को धन्यवाद :)।

Comments

नहीं, रुको, कोई बात नहीं। यह काम नहीं करेगा, क्योंकि लूप खत्म हो गया है [0, 3 if i[0] < 'd' else 4]। देर हो चुकी है (जल्दी?): पी।

— साइलेज

ओह, मैंने इसे याद किया: पी नेवरमाइंड।

— Kade

लेकिन मैं forबयान में उस तकनीक का उपयोग कर सकता हूं :)।

— साइफेज

Answer 11

पायथ - 40 39 36 35 34 बाइट्स

सरल विधि का उपयोग करता है, दोनों कंटेनरों पर मैपिंग और फिर विभाजन द्वारा कम करना।

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

इनपुट कॉमा को स्टड से अलग किया जाता है, जैसे प्रत्येक आकृति का पहला अक्षर "t", 10, 12.25, 3, "c", 5, 2.2, 5:।

टेस्ट सूट ।

Comments

यह बहुत छोटा है! शानदार कार्य! :)

— निक बी।