ASCII वाटरवर्क्स

Question

पहचान

पात्रों की एक ग्रिड पर विचार करें f A\/जैसे कि

f  f  f  
      A  
   A / \ 
\ /     A
    A \/ 
   /     
 \/         

कहाँ पे:

• f एक नल का प्रतिनिधित्व करता है जो पानी की एक धारा को नीचे की ओर डालता है
• A ऊपर पानी की धारा bifurcates तो ठीक आधा बाएं जाती है और ठीक आधी दाईं ओर जाती है
• \ पानी की धारा को एक इकाई द्वारा दाईं ओर ऊपर स्थानांतरित करता है
• / एक इकाई द्वारा बाईं ओर ऊपर पानी की धारा को स्थानांतरित करता है
• संयोजन \/अनंत क्षमता के साथ एक गर्त बनाता है जो इसके ऊपर पानी की धाराओं को इकट्ठा करता है
• [space] खाली जगह है जहां से पानी जा सकता है

इससे हम पानी की पथ की कल्पना कर सकते हैं ( *क्योंकि यह नल से निकलता है और कुंड में या ग्रिड क्षेत्र से बाहर निकल जाता है):

f  f  f    <-- first second and third faucets
*  * *A* 
* *A*/ \*
\*/ *  *A  <-- a '*' is not drawn to the right of this A because it would be out of the 9×7 bounds
 * *A*\/   <-- upper trough
 **/ *   
 \/  *     <-- lower trough

3 faucets उत्पादन पानी की एक ही मात्रा में एक समय में हम देख सकते हैं कि मान लिया

• पहले नल का सारा पानी निचले कुंड में जाता है।
• दूसरे नल के पानी का आधा हिस्सा निचले कुंड में जाता है और दूसरा आधा निचले कुंड के बीच विभाजित होकर ग्रिड से गिरता है।
• तीसरे नल के पानी का एक चौथाई हिस्सा निचले गर्त में जाता है, एक चौथाई ग्रिड के तल से गिरता है, एक चौथाई ऊपरी गर्त में जाता है, और एक चौथाई ग्रिड से दाईं ओर गिरता है।

इससे हम यह बता सकते हैं कि (1 + 3/4 + 1/4 + 1/4) / 3 = 75%पानी कुंडों से पकड़ा गया है और (1/4 + 1/4 + 1/4) / 3 = 25%ग्रिड से गिर गया है।

चुनौतियां

आप इस ASCII जल प्रवाह सेटअप से संबंधित किसी भी या सभी चुनौतियों को पूरा कर सकते हैं। वे सभी कोड-गोल्फ हैं, प्रत्येक चुनौती के लिए सबसे छोटा जवाब विजेता है। स्वीकृत उत्तर वह व्यक्ति होगा जो टाई-ब्रेकर के रूप में कुल कोड लंबाई के साथ, सबसे अधिक चुनौतियों को पूरा करता है।

चुनौती 1
एक प्रोग्राम लिखें जो पानी के अंश का उत्पादन करता है जो किसी दिए गए ग्रिड के लिए गर्त में बहता है। ऊपर दिए गए उदाहरण का आउटपुट बस होगा 0.75।

चुनौती 2
एक प्रोग्राम लिखें, जो ग्रिड दिया गया हो, *जैसा कि मैंने ऊपर किया है, उन स्थानों पर पानी के बहाव को खींचता है। आपको अंतरिक्ष वर्णों के अलावा कुछ भी अधिलेखित नहीं करना चाहिए और ग्रिड का आकार नहीं बदलना चाहिए। तो जैसे कुछ के लिए

 f
/A

कुछ भी करने की जरूरत नहीं है, हालांकि पानी ए के दोनों तरफ बहता है, इसे बिना हटाए बाईं ओर /नहीं खींचा जा सकता है और इसे 2 × 2 ग्रिड को बड़ा किए बिना दाईं ओर नहीं खींचा जा सकता है।

चुनौती 3 (अपडेट किया गया)
एक प्रोग्राम लिखें जो दो गैर-नकारात्मक पूर्णांक, कुल T और K (T> = =) रखने के लिए राशि लेता है। जेनरेट करें और एक ग्रिड को बिल्कुल fऐसे बनाएं कि जब नल नल से पानी की टी यूनिट निकाले, तो वास्तव में K गर्त में बह जाएगा। यदि किसी विशेष (T, K) जोड़ी के लिए परिमित ग्रिड में ऐसा करना असंभव है तो आउटपुट 'असंभव'।

स्पष्टता (सभी चुनौतियों पर लागू)

• इनपुट स्टड, या फ़ाइल, या ग्रिड के स्ट्रिंग प्रतिनिधित्व पर एक फ़ंक्शन कॉल के माध्यम से भी हो सकता है। बस यह स्पष्ट करें कि विभिन्न इनपुट कैसे चलाएं।
• आउटपुट को stdout में जाना चाहिए।
• \Aऔर A/और AAभी troughs आपकी अपेक्षा कर रहे हैं।
• H ग्रिड द्वारा एक w हमेशा h की एक अच्छी तरह से स्वरूपित आयत होगी * h वर्ण जो नई वर्णनों की गिनती नहीं करते हैं। कोई अनुपस्थित अनुगामी स्थान और उसकी कोई घटना नहीं होगी *।
• ग्रिड आयाम 1 × 1 के रूप में छोटे और मनमाने ढंग से बड़े हो सकते हैं। (कारण के भीतर बड़े पैमाने पर, int.maxValue या एक स्वीकार्य सीमा है। वही T और K के लिए जाती है।)
• इसके fठीक ऊपर एक धारा ऊपर बहती है।
• नल कहीं भी हो सकते हैं, केवल शीर्ष पंक्ति पर नहीं।
• A हमेशा उस पर डाले गए पानी की मात्रा को आधे हिस्से में विभाजित करता है।

नोट: जैसी चीजें हैं /Aऔर //पूरी तरह से मान्य हैं। पानी है स्वतंत्र रूप से पात्रों के बीच प्रवाह (वहाँ पर्याप्त जगह यह आकर्षित करने के लिए नहीं है चुनौती 2 के लिए है)।

तो, सेटअप में

ff

/A

बायीं fधारा नीचे की ओर धंसती है, /और बायीं ओर से टकराती है। दायीं fधारा नीचे गिरती है, हिट करती है A, आधी दाईं जाती है और आधी और के बीच बाईं ओर जाती Aहै /।

जैसे

 ff
 **
*/A*
** *
** *

Comments

+1 अच्छी चुनौती। चुनौती 3 के लिए, शीर्ष पर ग्रिड एक वैध उत्तर नहीं होगा क्योंकि इसमें 3 fs

— edc65

@ edc65 आह, अच्छी पकड़!

— केल्विन के

बहुत ही समान: codegolf.stackexchange.com/questions/26059/…

— हावर्ड

दूसरी चुनौती के लिए, आपको यह निर्दिष्ट करने की आवश्यकता है कि /Aयदि पानी गिरता है तो इनपुट को कैसे संभालना है A। सभी चुनौतियों के लिए, यह स्पष्ट करना अच्छा होगा कि क्या \Aगर्त है। तीसरी चुनौती के लिए, क्या 3 इकाइयों Aको विभाजित करने के लिए माना जाना चाहिए 1.5 / 1.5(इसलिए इनपुट वास्तव में एक एकल तर्कसंगत संख्या है) या यह है 2 / 1, इस मामले में किस पक्ष को प्राप्त होता है 2?

— पीटर टेलर

@PeterTaylor साभार मैंने उन बिंदुओं को स्पष्ट किया है। मुझे लगता है कि टी और के फ्लोट हो सकते हैं लेकिन मैं उन्हें सरलता के लिए पूर्णांक बना रहा हूं। (लेकिन अगर टी = 3 हिट करता है Aतो दोनों पक्षों को 1.5 मिलता है। यह कोडर पर निर्भर है कि यह सुनिश्चित करने के लिए कि फ्लोट सटीक कोई मुद्दा नहीं है।)

— केल्विन के

Answer 1

सभी चुनौतियां C # 690bytes (416bytes + 274bytes)

चुनौतियाँ 1 और 2 C # 579 446 416bytes

यह एक पूर्ण कार्यक्रम है, जिसे सिर्फ 1 के बारे में चुनौतियां 1 और 2 करना चाहिए। यह स्टड से इनपुट की लाइनों को पढ़ता है जब तक कि यह एक खाली लाइन प्राप्त नहीं करता है। यह चुनौती 2 के लिए परिणाम को प्रिंट करता है, और फिर चुनौती के लिए परिणाम 1। किसी भी गोल त्रुटियों से बचने के लिए .NET दशमलव वर्ग का उपयोग करता है।

using C=System.Console;class P{static void Main(){decimal u,t=0,f=0;string c,z="";for(decimal[]n=null,o;(c=C.ReadLine())!="";z+='\n'){int s=c.Length,i=s,e;o=n;n=new decimal[s];for(o=o??n;i-->0;n[i]+=(e&2)*u/2){e=c[i]%13;u=o[i]/(e<1?2:1);if(e%8<1)if(i>0)if(c[i-1]%7<3)t+=u;else n[i-1]+=u;if(e<2)if(i<s-1)if(c[i+1]%2>0)t+=u;else n[i+1]+=u;if(e>9){u++;f++;}}for(;++i<s;)z+=c[i]<33&n[i]>0?'*':c[i];}C.WriteLine(z+t/f);}}

कम गोल्फ वाला:

using C=System.Console;
class P
{
    static void Main()
    {
        decimal u,t=0,f=0;
        string c,z="";

        for(decimal[]n=null,o;(c=C.ReadLine())!="";z+='\n')
        {
            int s=c.Length,i=s,e;
            o=n;
            n=new decimal[s];
            for(o=o??n;i-->0;n[i]+=(e&2)*u/2)
            {
                e=c[i]%13;
                u=o[i]/(e<1?2:1);

                if(e%8<1)
                    if(i>0)
                        if(c[i-1]%7<3)t+=u;
                        else n[i-1]+=u;
                if(e<2)
                    if(i<s-1)
                        if(c[i+1]%2>0)t+=u;
                        else n[i+1]+=u;
                if(e>9)
                {
                    u++;
                    f++;
                }
            }
            for(;++i<s;)
                z+=c[i]<33&n[i]>0?'*':c[i];
        }

        C.WriteLine(z+t/f);
    }
}

टेस्ट रन (अनुगामी रिक्त स्थान की कमी के साथ जो मैं वादा करता हूं):

f  f  f
      A
   A / \
\ /     A
    A \/
   /
 \/

f  f  f
*  * *A*
* *A*/ \*
\*/ *  *A
 * *A*\/
 **/ *
 \/  *
0.75

चुनौती 3 C # 274bytes

यह एक पूर्ण कार्यक्रम है जिसे चैलेंज को पूरा करना चाहिए। 3. मैं Splitएक ReadLineऔर उपयोग करने के बजाय इनपुट पढ़ने के लिए अपने स्वयं के पूर्णांक पार्सर लिखकर 6bytes को बचाने में कामयाब रहा long.Parse;

using C=System.Console;class P{static void Main(){long t=-1,f=t,k;for(;f<0;)for(f=t,t=0;(k=C.Read())>47;)t=t*10+k-48;var r="Impossible\n";for(k=t;k<t*f;)k*=2;if(f<1||(k/f)*f==k)for(r=" f \n";t>0&t<f;t-=(t/f)*f)r+=((t*=2)<f?" ":"A")+"A \n/ /\n";C.Write(r+(t<f?"":"AAA\n"));}}

कम गोल्फ वाला:

using C=System.Console;
class P
{
    static void Main()
    {
        long t=-1,f=t,k;
        for(;f<0;)
            for(f=t,t=0;(k=C.Read())>47;)
                t=t*10+k-48;

        var r="Impossible\n";
        for(k=t;k<t*f;)
            k*=2;
        if(f<1||(k/f)*f==k)
            for(r=" f \n";t>0&t<f;t-=(t/f)*f)
                r+=((t*=2)<f?" ":"A")+"A \n/ /\n";
        C.Write(r+(t<f?"":"AAA\n"));
    }
}

टेस्ट रन (फिर से पीछे चल रहे रिक्त स्थान की कमी के साथ जो मैं वादा करता हूं):

32 17
 f
AA
/ /
 A
/ /
 A
/ /
 A
/ /
AA
/ /

Answer 2

सबसे पहले, मेरे पास चुनौती के संबंध में एक प्रश्न है। चूँकि मेरे पास इस सवाल पर टिप्पणी करने के लिए पर्याप्त प्रतिष्ठा नहीं है, इसलिए मैं इसे यहाँ लिख रहा हूँ:

• /A( //इस सिद्धांत पर बहने वाला पानी ), (दाएं तरफ बहता पानी) और इस सिद्धांत के बदलावों का व्यवहार क्या है ? क्या पानी पहले "मुक्त स्थान" की तरफ बहता है या उसके पड़ोसी के नीचे "प्रवाह" होता है?

---

बस एक सरल कोशिश है, इसे वायाए सरलीकृत किया जा सकता है (जो मैं इस पोस्ट को संपादित करके बाद में करूंगा)।

संपादित करें: दूसरा संस्करण, थोड़ा छोटा। मैं एक अलग दृष्टिकोण के लिए गया: शीर्ष और पक्षों से क्या आ रहा है यह जांचने के लिए प्रत्येक सेल की तलाश करने के बजाय, मैं पुनरावृत्ति के साथ नल और "प्रवाह" से नीचे की ओर शुरू करता हूं।

जावास्क्रिप्ट, 226 बाइट्स (चुनौती 1)

function f(c){function h(b,a,d,e){b<c.length&&0<=a&&a<c[0].length&&("\\"==c[b][a]?"/"==e||"A"==e?g+=d:h(b,a+1,d,"\\"):"/"==c[b][a]?"\\"==e||"A"==e?g+=d:h(b,a-1,d,"/"):"A"==c[b][a]?"A"==e||"\\"==e||"/"==e?g+=d:(h(b,a-1,d/2,"A"),h(b,a+1,d/2,"A")):h(b+1,a,d,c[b][a]))}for(var g=0,m=0,k=0;k<c.length;k++)for(var l=0;l<c[k].length;l++)"f"==c[k][l]&&(h(k+1,l,1),m++);alert(g/m)};

जावास्क्रिप्ट, 204 बाइट्स (चैलेंज 2)

function f(c){function e(b,a,d){b<c.length&&0<=a&&a<c[0].length&&("\\"==c[b][a]?"/"!=d&&"A"!=d&&e(b,a+1,"\\"):"/"==c[b][a]?"\\"!=d&&"A"!=d&&e(b,a-1,"/"):"A"==c[b][a]?"A"!=d&&"\\"!=d&&"/"!=d&&(e(b,a-1,"A"),e(b,a+1,"A")):(" "==c[b][a]&&(c[b][a]="*"),e(b+1,a,c[b][a])))}for(var g=0;g<c.length;g++)for(var h=0;h<c[g].length;h++)"f"==c[g][h]&&e(g+1,h)};

जावास्क्रिप्ट, 238 बाइट्स (चुनौती 1 + 2)

function f(c){function h(b,a,d,e){b<c.length&&0<=a&&a<c[0].length&&("\\"==c[b][a]?"/"==e||"A"==e?g+=d:h(b,a+1,d,"\\"):"/"==c[b][a]?"\\"==e||"A"==e?g+=d:h(b,a-1,d,"/"):"A"==c[b][a]?"A"==e||"\\"==e||"/"==e?g+=d:(h(b,a-1,d/2,"A"),h(b,a+1,d/2,"A")):(" "==c[b][a]&&(c[b][a]="*"),h(b+1,a,d,c[b][a])))}for(var g=0,m=0,k=0;k<c.length;k++)for(var l=0;l<c[k].length;l++)"f"==c[k][l]&&(h(k+1,l,1),m++);alert(g/m)};

---

कैसे इस्तेमाल करे

मानचित्र का एक दो आयामी प्रतिनिधित्व प्रदान करें। यहां प्रश्न में दिए गए उदाहरण दिए गए हैं:

var input = [["f"," "," ","f"," "," ","f"," "," "],[" "," "," "," "," "," ","A"," "," "],[" "," "," ","A"," ","/"," ","\\"," "],["\\"," ","/"," "," "," "," "," ","A"],[" "," "," "," ","A"," ","\\","/"," "],[" "," "," ","/"," "," "," "," "," "],[" ","\\","/"," "," "," "," "," "," "]];
f(input);

उत्पादन

चुनौती 1: यह केवल परिणाम के साथ एक डायलॉग बॉक्स (अलर्ट) बनाएगा (उपरोक्त उदाहरण के लिए 0.75)।

चुनौती 2: यह सीधे मानचित्र को संशोधित करेगा। क्या मुझे इसे छापना चाहिए? यदि ऐसा है, तो कंसोल है। एक वैध उत्पादन के रूप में?

चुनौती 1 + 2: उपरोक्त दोनों संयुक्त, स्पष्ट रूप से ...

Comments

पानी पात्रों के बीच ऐसे बहता रहता है जैसे कि वह या ढलान की रेखाओं को गले लगा रहा हो A। मैंने स्पष्ट किया है कि प्रश्न में।

— केल्विन के

प्रश्न में कहा गया हैOutput must go to stdout.

— 18:80 पर user80551

आपने इनपुट प्रारूप के रूप में निर्दिष्ट किया है कि आपके पास प्रत्येक पंक्ति में एक-वर्ण स्ट्रिंग्स की एक सरणी है, लेकिन ध्यान रखें कि आप str[0]स्ट्रिंग्स में अनुक्रमित कर सकते हैं। यह वर्णों के सरणियों की एक सरणी के बजाय तार की एक सरणी होगी।

— tomsmeding

user80551 धन्यवाद, मुझे नहीं पता कि यह मेरे दिमाग से क्यों फिसल गया। मैं जल्द से जल्द अपना कोड अपडेट करूंगा। @tomsmeding हां, यह चुनौती के मेरे जवाब के लिए काम करता है। 1. लेकिन चुनौती 2 के लिए मैं सीधे इनपुट को संशोधित कर रहा हूं और आप स्ट्रिंग [i] का उपयोग करके किसी वर्ण को संशोधित नहीं कर सकते हैं, इसलिए सारणियों के एक सरणी का उपयोग करते हैं।

— रिफ्रेशफ्रंट

Answer 3

पायथन 3, 186 बाइट्स (चैलेंज 3)

मैंने VisualMelon के उत्तर से ग्रिड के लिए विचार लिया । समारोह में मनमाने ढंग से बड़े टी और के लिए स्टडआउट के लिए एक वैध ग्रिड प्रिंट करना चाहिए, बशर्ते कि यह (परिमित आकार का ग्रिड) निश्चित रूप से संभव हो।

from fractions import*
def c(T,K):
 p=print;g=gcd(T,K);K//=g;T//=g
 if T&(T-1):p('Impossible')
 else:
  p(' f ')
  while T-1:
   T//=2;p('A/'[K<T]+'A \n///')
   if K>=T:K-=T
  p('AAA'*K)

---

कैसे इस्तेमाल करे

cतर्कों के रूप में रखने के लिए कुल राशि और राशि के साथ फ़ंक्शन को कॉल करें ।

>>> c(24, 9)
 f 
/A 
///
AA 
///
AA 
///

>>> c(6, 2)
Impossible