জলে ভরা বাটি

Question

আপনার একটি প্রোগ্রাম বা ফাংশন লিখতে হবে যা একটি বাটির পরিমাণ এবং পানির পরিমাণকে পানির পরিমাণ হিসাবে ইনপুট এবং আউটপুট হিসাবে গ্রহণ করে বা কাঙ্ক্ষিত ভলিউমের সাথে একটি বাটিতে জল দিয়ে একটি ASCII প্রতিনিধিত্ব প্রদান করে।

একটি বাটিতে নিম্নলিখিত কাঠামো থাকে:

 \     /
  \___/

বাটিতে কমপক্ষে একটি _চরিত্র থাকে। গণনা \'s এবং /এর ইতিবাচক এবং তারা প্রতিসাম্য সমান কারণে।

বাটি ভলিউম মোট সংখ্যা হয় _এবং spaceঅক্ষরের মধ্যে \'s এবং /এর প্লাস প্রতিটি যুগল জন্য এক \এবং /। এর অর্থ হল উপরের বাটিটির পরিমাণ রয়েছে 10:

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

নোট করুন যে দুটি পৃথক বাটিতে একই ভলিউম থাকতে পারে। উদাহরণস্বরূপ নিম্নলিখিত দুটি বাটিটির আয়তন 18:

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

আমরা বাটিতে কিছু জল canালতে পারি। ~জলটি বাটির ভিতরে ফাঁকা স্থানগুলির পরিবর্তে অক্ষরের সারি হিসাবে উপস্থাপিত হয় । নীচের সারিতে কোনও স্পেস নেই তাই এতে এতে ~গুলি থাকা যায় না । এর অর্থ আমাদের উদাহরণটি কেবল একটি উপায়ে পানিতে পূর্ণ হতে পারে:

 \~~~~~/
  \___/

অন্যান্য বাটি একাধিক উপায়ে পূরণ করা যেতে পারে:

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

একটি বাটি মধ্যে জল ভলিউম বাটি সারির ভলিউম হয় নিচের~ অক্ষর। উপরের উদাহরণগুলিতে 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

সিজেম, 72 70 69 বাইট

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

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

রান সময় এবং মেমরির ব্যবহার হ'ল (ভীতিজনক) , তাই জাভা ইন্টারপ্রেটার (এবং অতিরিক্ত হিপ স্পেস) ব্যবহার করে শেষ তিনটি পরীক্ষার কেস যাচাই করা উচিত।

উদাহরণ রান

$ 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

জাভাস্ক্রিপ্ট ES5, 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 বাইট

-N বিকল্প দিয়ে চালান:

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

পাইথন ২.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)
\                     /
 \                   /
  \~~~~~~~~~~~~~~~~~/
   \               /
    \             /
     \___________/