बाउल पानी से भर गया

Question

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो इनपुट और आउटपुट के रूप में एक कटोरे की मात्रा और उसमें पानी की मात्रा प्राप्त करता है या वांछित मात्राओं के साथ इसमें पानी के साथ एक कटोरी का ASCII प्रतिनिधित्व लौटाता है।

एक कटोरे में निम्नलिखित संरचना होती है:

 \     /
  \___/

कटोरे में कम से कम एक _पात्र होता है। \'S' और /'s ' की गिनती भी सकारात्मक है और वे समरूपता के कारण समान हैं।

कटोरा की मात्रा की कुल संख्या है _और spaceवर्णों के बीच \की और /के साथ साथ की प्रत्येक जोड़ी के लिए एक \और /। इसका मतलब है कि उपरोक्त कटोरे में इसकी मात्रा है 10:

 \     /  =>  xxxxx x (the last one is for the \/ pair)
  \___/        xxx x (the last one is for the \/ pair)

ध्यान दें कि दो अलग-अलग कटोरे में समान मात्रा हो सकती है। उदाहरण के लिए दोनों निम्नलिखित कटोरे की मात्रा 18 है:

\       /
 \     /      \         /
  \___/        \_______/

हम कटोरे में थोड़ा पानी डाल सकते हैं। पानी को ~कटोरे के अंदर रिक्त स्थान के बजाय पात्रों की एक पंक्ति के रूप में दर्शाया गया है । नीचे की पंक्ति में कोई स्थान नहीं है इसलिए इसमें ~'s' नहीं हो सकता । इसका अर्थ है कि हमारा उदाहरण केवल एक ही तरीके से पानी से भरा जा सकता है:

 \~~~~~/
  \___/

अन्य कटोरे कई तरीकों से भरे जा सकते हैं:

 \~~~~~/   \     /
  \   /     \~~~/
   \_/       \_/

एक कटोरे में पानी की मात्रा पात्रों के नीचे की पंक्तियों की मात्रा है ~। उपरोक्त उदाहरणों में 4, 6 and 2क्रमशः पानी की मात्रा है ।

इनपुट

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

उत्पादन

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

उदाहरण

प्रत्येक इनपुट पूर्णांक जोड़ी अपने एक या अधिक संभावित आउटपुट के बाद होती है।

6 2
\~~~/
 \_/

10 4
\~~~~~/
 \___/

24 8
\        /
 \~~~~~~/
  \    /
   \__/

42 12 //either of the two output is correct
\           /
 \         /
  \~~~~~~~/
   \     /
    \   /
     \_/

\               /
 \~~~~~~~~~~~~~/
  \___________/

90 68
\~~~~~~~~~~~~~~~~~~~~~/
 \                   /
  \                 /
   \               /
    \_____________/

102 42
\                     /
 \                   /
  \~~~~~~~~~~~~~~~~~/
   \               /
    \             /
     \___________/

यह कोड गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

Answer 1

CJam, 72 70 69 बाइट्स

q~:QW=3m*{:,2ff*),)ff+}%{::)1fbQ=}=~W%ee_,S*W'_t@,~'~t.{S\+.*"\/".+N}

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

रन टाइम और मेमोरी का उपयोग ओ (डरावना) है , इसलिए पिछले तीन परीक्षण मामलों को जावा दुभाषिया (और अतिरिक्त ढेर स्थान) का उपयोग करके सत्यापित किया जाना चाहिए।

उदाहरण चलाते हैं

$ time java -Xmx4G -jar cjam-0.6.5.jar bowl.cjam <<< '[42 102]'
\                     /
 \                   /
  \~~~~~~~~~~~~~~~~~/
   \               /
    \             /
     \___________/

real    0m40.669s
user    3m13.100s
sys     0m11.690s

यह काम किस प्रकार करता है

q~:Q     e# Read from STIDN, evaluate and save the result in Q.
W=       e# Select the last element of Q (bowl volume B).
3m*      e# Push all vectors of {0,...,B-1} × {0,...,B-1} x {0,...,B-1}.

{        e# For each vector [X Y Z]:
  :,     e#   Push [[0 1 ... X-1] [0 1 ... Y-1] [0 1 ... Z-1]].
  2ff*   e#   Multiply each coordinate by 2.
  ),)    e#   Pop the last vector, compute its length and increment.
  ff+    e#   Add the result to each component of each vector.
}%       e# Result: [[Z Z+2 ... Z+2(X-1)] [Z Z+2 ... Z+2(Y-1)]]

{        e# Find:
  ::)    e#   Increment each coordinate (to account for the volume in "\/").
  1fb    e#   Sum the coordinate of both vectors.
  Q=     e#   Compare the result to Q (desired volumes).
}=       e# If they match, push the array and break.

~        e# Dump both vectors on the stack.
W%       e# Reverse the rightmost one (corresponds to the bowl volume).
ee       e# Enumerate its coordinates.
         e# [Z+2(Y-1) ... Z+2 Z] -> [[0 Z+2(Y-1)] ... [Y-2 Z+2] [Y-1 Z]].
_,S*     e# Compute the length (Y) and push a string of Y spaces.
W'_t     e# Replace the last space with an underscore.
@        e# Rotate the leftmost vector (corresponds to the water volume) on top.
,        e# Compute its length (X).
~'~t     e# Replace the space at index X from the right with a tilde.

.{       e# For each enumerates coordinate and the corresponding character:
  S\+    e#   Append the character to the string " ".
  .*     e#   Vectorized repetition: [1 2] " ~" -> [" " "~~"]
  "\/".+ e#   Append the first (second) solidus to the first (second) string.
  N      e#   Push a linefeed.
}

Answer 2

सी, 231 229 बाइट्स

जल्दी प्रस्तुत करना :) यहाँ करने के लिए बहुत अधिक गोल्फिंग है।

v,V,w,h,H,i,j;main(c,a)char**a;{V=atoi(a[1]);v=atoi(a[2]);for(;++H;)for(h=0;h++<H;){for(w=1;h*h+w*h-h<v;++w);if(H*H+w*H-H==V){for(;H--;){printf("%*s",++i,"\\");for(j=0;j++<w-1+2*H;)putchar(H?H==h?'~':32:95);puts("/");}exit(0);}}}

Ungolfed:

int v,V,w,h,H,i,j;
int main(int c, char **a)
{
    V=atoi(a[1]); /* Volume of bowl */
    v=atoi(a[2]); /* Volume of water */

    for(;++H;) /* Make the bowl taller */
    {
        for(h=0;h++<H;) /* Make the water taller */
        {
            for(w=1;h*h+w*h-h<v;++w); /* Make the bowl wider until the water volume matches */
            if(H*H+w*H-H==V) /* if the bowl volume matches, then we're good */
            {
                for(;H--;) /* Print out the bowl, one line at a time */
                {
                    printf("%*s",++i,"\\"); /* Print the left edge */
                    /* Print the inside (either with air/water, the top of the water, or the bottom of the bowl */
                    for(j=0;j++<w-1+2*H;)
                        putchar(H?H==h?'~':32:95);
                    /* Print the right edge of the bowl */
                    puts("/");
                }
                exit(0); /* die, we're done */
            }
        }
    }
}

Comments

क्या कटोरे की मात्रा से मेल खाने वाले कटोरे का सामना करना संभव है लेकिन पानी की मात्रा को पूरा नहीं कर सकता है?

— वार्तन

At least one valid bowl-water configuration is guaranteed for the input values.- ओपी

— कोल कैमरन

Answer 3

जावास्क्रिप्ट ईएस 5, 364 बाइट्स

यह वही है जो मैं अपने दोपहर के भोजन के दौरान जल्दी से आ सकता हूं, मेरी पाली समाप्त होने पर मुझे इसे गोल्फ में मदद करें!

स्रोत

function V(x,v) { // calculate volume of bowl/water
    for(i=v,j=x;i--;j+=2) {
      v+=j; 
    }
    return v
}
function B(x,y,l) { // draw bowl/water
    for(s="",h=y,w = x+2*y;y--;s+="\n")
        for(i=w;i--;) {
            f= i>h-y-1 && w-i > h-y;
            s+=i==h-y-1?"/": 
                w-i == h-y? "\\":
                y==l-1 && f? "~" :
                !y && f?"_":" "
        }
    return s;
}
n=prompt().split(" ");
b=+n[0]; // bowl volume
w=+n[1]; // water volume
for(x=b;x;x--)  // loop through possible widths
  for(y=b;y;y--)  // loop through possible heights
    if(V(x,y)==b) // check if we found bowl volume
       for(y2=y;y2;y2--) { // check possible water heights
         v = V(x,y2-1);
         if(v==w){ // see if volume matches
          alert(B(x,y,y2));
          x=1;break;
         }
       }

golfed:

(संपीड़ित के माध्यम से संपीड़ित करने के लिए दौड़ा, लंच शिफ्ट समाप्त हो गया)

function V(f,r){for(i=r,j=f;i--;j+=2)r+=j;return r}function B(r,y,n){for(s="",h=y,w=r+2*y;y--;s+="\n")for(i=w;i--;)f=i>h-y-1&&w-i>h-y,s+=i==h-y-1?"/":w-i==h-y?"\\":y==n-1&&f?"~":!y&&f?"_":" ";return s}for(n=prompt().split(" "),b=+n[0],w=+n[1],x=b;x;x--)for(y=b;y;y--)if(V(x,y)==b)for(y2=y;y2;y2--)if(v=V(x,y2-1),v==w){alert(B(x,y,y2)),x=1;break}

Answer 4

पर्ल, 227 172 बाइट्स

एक एन विकल्प के साथ चलाएँ:

/ /;for$h(1..$`){for$w(1..$`){for$l(1..($h*($w+$h)==$`)*$h){if($l*($w+$l)==$'){for(0..$h-1){print$"x$_."\\".($_<$h-1?$_==$h-$l-1?"~":$":"_")x($w+($h-$_-1)*2)."/
"}exit}}}}

यह नीचे गोल्फ की मदद के लिए डेनिस के लिए धन्यवाद।

बाउल वॉल्यूम को ऊंचाई * (चौड़ाई + ऊंचाई) के रूप में परिकलित करता है, जहाँ चौड़ाई _वर्णों की संख्या और ऊँचाई वर्णों की संख्या है \।

ऊंचाई और चौड़ाई के प्रत्येक संयोजन का परीक्षण नेस्टेड छोरों की एक जोड़ी में किया जाता है जब तक कि सही कटोरी की मात्रा नहीं मिलती है, तब संभव ऊंचाई ऊंचाई पर एक और लूप यह पता लगाने के लिए किया जाता है कि उस चौड़ाई के साथ सही पानी की मात्रा संभव है या नहीं।

तीसरे लूप को केवल 1 के साथ द्विघात सूत्र का उपयोग करके जल स्तर की गणना करके संभव करना है, वांछित पानी की मात्रा के रूप में चौड़ाई और सी के रूप में ख, और यह पूर्णांक होने पर जाँच, लेकिन यह अधिक बाइट्स लेता है सिर्फ एक लूप करने से। यह वैसे भी है (183 बाइट्स):

/ /;for$h(1..$`){for$w(1..$`){if($h*($w+$h)==$`){$l=(sqrt($w*$w+4*$')-$w)/2;if(int$l==$l){for(0..$h-1){print$"x$_."\\".($_<$h-1?$_==$h-$l-1?"~":$":"_")x($w+($h-$_-1)*2)."/
"}exit}}}}

Answer 5

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

V,W=input()
r=1
while r*r<V:a=V/r-r;k=1;exec"if(a+k)*k==W*(V%r<1):i=1;exec\"print' '*~-i+'\%s/'%(' _~'[(i==r)-(i==r-k)]*(a+2*(r-i)));i+=1;\"*r;r=V\nk+=1\n"*r;r+=1

थोड़ा गड़बड़ है, लेकिन यहाँ मेरा पहला प्रयास है। यह पंक्तियों के सभी संभव संख्याओं की कोशिश करता है r, आधार संख्या की संख्या को निर्धारित करता है a = V/r-r। फिर यह सभी संभव जल स्तर ऊंचाइयों की कोशिश करता है kऔर जांचता है कि क्या कटोरा वैध है, यदि ऐसा है तो इसे प्रिंट करें।

Answer 6

पायथन 2.7, 284 270 260 बाइट्स

def f(b,w,i=1,e='while s<%s:j+=2;s+=j'):
 while 1:
    i+=1;j=s=i;exec e%w
    if s==w:p=j;exec e%b
    if s==b:break
 h=(j-i)/2+1;t=w=i+(h-1)*2+1
 for j in range(h):r,s,t=((' '*(t-2),'_'*(i-1))[j==h-1],'~'*(t-2))[j==h-(p-i)/2-2],(w-t)/2,t-2;print" "*s+"\\"+r+"/"+" "*s

यह मूल रूप से बाल्टी और पानी की ऊंचाई और चौड़ाई की गणना करता है और उन्हें प्रिंट करता है।

शुरुआत में लूप वाले हिस्से में बदसूरत हटाने के लिए कड़ी मेहनत की गई (जिसमें मैं बाल्टी की ऊंचाई की गणना करता हूं और जहां से पानी खींचा जाना चाहिए। वहीं, पिछले एक को छोड़कर कोड में सभी लाइनें चौड़ाई की गणना के लिए हैं। ऊंचाई)। अभी भी कोशिश कर रहा है: पी

विभिन्न मामलों के लिए यह परीक्षण -

>>> execfile("buckets.py")
(6, 2)
\~~~/
 \_/

(10, 4)
\~~~~~/
 \___/

(24, 8)
\        /
 \~~~~~~/
  \    /
   \__/

(42, 12)
\           /
 \         /
  \~~~~~~~/
   \     /
    \   /
     \_/

(90, 68)
\~~~~~~~~~~~~~~~~~~~~~/
 \                   /
  \                 /
   \               /
    \_____________/

(102, 42)
\                     /
 \                   /
  \~~~~~~~~~~~~~~~~~/
   \               /
    \             /
     \___________/