ASCII हैमन्तशेन की गणना करें!

Question

आज पुरीम है, जिस पर एक रिवाज हैमंटासचेन (एकवचन: हैमंटासच ) भरने के साथ त्रिकोण के आकार की कुकीज़ को देना है । एक और रिवाज है जमकर पीना।

मैं सबसे परफेक्ट बेकर नहीं हूँ .... मेरे पास बाहर जाने के लिए बहुत सारे अनियमित आकार के हैमन्तशेन हैं और उन्हें देने के लिए बहुत सारे दोस्त हैं! अगर मैंने आपको अपनी कुकीज़ की एक तस्वीर भेजी है, तो क्या आप मुझे बता सकते हैं कि मेरे पास कितने आकार और भरने हैं? लेकिन क्योंकि यह पुरीम है और मैं बहुत ज्यादा कोड पढ़ने के लिए नशे में हूं, इसलिए इसे उतना ही छोटा कोड होना चाहिए जितना कि आप बना सकते हैं।

परिभाषाएं

आकार

एक हैमंटेश कोई भी आकार हो सकता है । सबसे छोटा हैमन्त्स आकार 1 है और इनकी तरह दिखता है:

/\  --
--  \/

कभी-कभी, कई हैमंटासचेन ओवरलैप कर सकते हैं । नीचे का आकार दो हैमन्तशेन (एक आकार 1, एक आकार 2) के रूप में गिना जाता है:

 /\
/\ \
----

कुछ हैमन्तशेन में भरना है । यह एक चरित्र के साथ अंदर सभी व्हाट्सएप को भरने के द्वारा इंगित किया जाएगा। ध्यान दें कि आकार 1 हैमंटासन में फिलिंग नहीं हो सकती है।

हम भरने और आकार के आधार पर हैमन्तशेन का नाम देंगे। चलो प्रारूप का उपयोग करें <filling> <size>और यदि अपूर्ण है, - <size>(आप इसके बजाय एक स्थान का उपयोग कर सकते हैं -, लेकिन मार्कडाउन ऐसा नहीं करता है)।

यहाँ एक . 2, एक . 4, और एक हैं - 3:

          /\
         /./\
 ----   /./  \
 \../  /./    \
  \/   --------

ये एक @ 3, . 2और एक हैं - 4:

          /\
         / /\
  /\    / /@@\
 /..\  / /@@@@\
 ----  --------

यहाँ कुछ और मुश्किल है। देखें कि & 2ओवरलैपिंग से तिरछा होने के कारण आपकी अपेक्षा से कम फिलिंग कैसे हुई है - 3? यह एक - 1, & 2एक - 3और एक है & 4:

--------
\   \/&/
 \  /\/
  \/&/
   \/

इनपुट

आपको एक पाठ फ़ाइल या हैमंटासचेन का एक स्ट्रिंग (वैकल्पिक अनुगामी न्यूलाइन और वैकल्पिक रूप से गद्देदार अनुरेखण व्हाट्सएप भी दिया जाएगा) दिया जाएगा।

सीमाएं

• आप स्ट्रिंग को वैध होने की उम्मीद कर सकते हैं - अर्थात, प्रत्येक गैर-व्हाट्सएप चरित्र एक स्वादिष्ट रूप से मीठे हैमन्तशेक (आटा बर्बाद क्यों?) में योगदान देता है।
• आप यह भी उम्मीद कर सकते हैं कि यह ठीक से भरा हुआ है या नहीं - अर्थात, प्रत्येक हैमंटशेक यह पूरी तरह से एक सुसंगत ASCII चरित्र - ASCII 32 के साथ भरा हुआ, या कुछ भी 32..127 भरा (छोड़कर /, \और -) के लिए होगा।
• इन हैमन्तशेन को 3-स्थान में नहीं रखा जाता है। सभी /और \दिखाई जाएगी। -वह सब जो अवरुद्ध नहीं है /और \दिखाई देगा। भरना बहुत आखिरी आता है।
• सभी हैमन्तशेन में कम से कम आधी क्षैतिज रेखा (गोलाई में) दिखाई देगी ।
• भरने का कोई भी सन्निहित ब्लॉक केवल सबसे छोटे हैमन्ताश को भरता है जो इसे घेरता है।

उत्पादन

उपरोक्त सभी मानदंडों को पूरा करते हुए पाया जा सकता है कि सभी हैमन्तशेन के "नामों" की सूची लौटाएँ। आउटपुट आपको जो भी रूप में हो सकता है (एक स्ट्रिंग, एक हैश, स्टडआउट, आदि) में हो सकता है।

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

टेस्ट केस # 1

इनपुट # 1:

          /\
         / /\
  /\    / /@@\
 /..\  / /@@@@\
 ----  --------
    /\
   /**\
  /*/\*\
 /*/..\*\
 --------

आउटपुट # 1:

. 2
. 2
- 4
@ 3
* 4

टेस्ट केस # 2

इनपुट # 2:

  /\----
 /\/\*\/
/ /\d\/
------

आउटपुट # 2:

- 3
- 2
d 2
- 1    
* 2
- 1

टेस्ट # 3

इनपुट # 3:

----
\/\/
/\/\  /\
---- /::\
     ----

आउटपुट # 3:

- 1
- 1
- 2
- 1
- 1
- 2
: 2

टेस्ट # 4

इनपुट # 4:

 /\/\
/ /\$\
-/--/\\
 --/--\
  /xxx/\
 /xxx/##\
 ---/----\
   /      \
   -------- 

आउटपुट # 4:

$ 2
x 4
- 3
- 2
- 4
- 1
- 1
# 2

अवैध टेस्ट केस # 5

इनपुट:

/\
\/

आउटपुट:

आपको इसे संभालने की आवश्यकता नहीं है।

Comments

कैसे एक परीक्षण मामले के बारे में जिसमें hamentaschen अतिव्यापी है लेकिन एक ही क्षैतिज रेखा नहीं है? कोई दूसरी की क्षैतिज रेखा को भी अवरुद्ध कर सकता है।

— गर्वित हैकेलर

@proudhaskeller ठीक है, किया। हालाँकि, और मैंने इसे केवल पाठ में रखा है, यह 2-स्थान है। हम हमेशा सब देखेंगे /और \ , और -हमेशा ट्रम्प फिलिंग करेंगे।

— नहीं कि

@EasterlyIrk अन्य महत्वपूर्ण बिट्स भी हैं - एस्थर की किताब पढ़ना (और बुरे लोगों पर गर्व करना), गरीबों को दे - और पोशाक में ड्रेसिंग जैसी कम नींव वाली चीजें।

— चार्ल्स

फिर से प्रासंगिक बना दिया!

— डाउनरेप_नेशन

शून्य के एक प्रारंभिक स्तंभ के आधार पर, आपके सभी शीर्ष स्तंभ, को छोड़कर (1,0), बंद हैं +1। फिर भी, मुझे पता है कि आपका क्या मतलब है, और मैं असहमत हूं। ऐसा क्या संकेत है जो दो ऊपरी एस के शीर्ष दाएं और बाएं का (2, 2)शीर्ष केंद्र है, - 2न कि केवल शीर्ष पर - 1? कोई भी ऐसा नहीं जिसे मैं देख सकूं। और यही तर्क लागू होता है (3, 2)। जब तक आप अधिकतम संभव हैमन्तशेन को मानने के लिए एक नियम नहीं जोड़ना चाहते ...

— माइकल

Answer 1

सी #, 496 452 बाइट्स

संपादित करें: बाउंड चेकिंग के साथ एक बग मिला ... लेकिन बाइट्स का एक भार भी छीन लिया गया, जिससे मुझे अपने कोड को समझने के लिए मजबूर होना पड़ा। स्थानीय फ़ंक्शन को नियंत्रित करने में थोड़ी मदद मिली, और C # 7 विशिष्ट कोड को हटा दिया। यह सवाल बहुत मज़ेदार रहा।

using C=System.Console;class P{static void Main(){string D="",L;int W=0,H=0,z=0,d,q,c,j,b;for(;(L=C.ReadLine())!=null;H+=W=L.Length)D+=L;var B=new int[H];for(d=W;(d=-d)>0||++z<H*H;)for(c=1,q=z%H;c<=z/H&q%W+c<W&q>=d&q<H+d&&D[q]==(d>0?92:47)&D[j=q+c]==(d<0?92:47);q-=d+1,c+=2){for(b=0;j>q;)b+=D[--j-d]==45?2:0;for(char h='-',e;c==z/H&b>c;C.WriteLine(h+" "+c/2))for(b=c++;b>1;j=q+=d+1,b-=2)for(;j<q+b;)B[j]=h=B[j]<1&h==45&(e=D[j++])!=47&e!=92&e>32?e:h;}}}

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

पूरा कार्यक्रम, मानक में अंतरिक्ष-गद्देदार इनपुट की अपेक्षा करता है, आउटपुट को मानक से बाहर करता है। आउटपुट प्रति पंक्ति एक प्रविष्टि है, जिसमें लाइनिंग लाइन फीड है। कुकीज़ आकार के बढ़ते क्रम में आउटपुट की जाती हैं, ऊपरी-सबसे सबसे बाईं ओर। नियमों को समझने में मुझे अच्छा लगा, लेकिन मुझे लगता है कि यह सभी उदाहरण प्रदान करता है।

यह बार-बार वैध हैमंटासन के लिए पूरे ग्रिड की खोज करके, 'अनुमत' आकार को बढ़ाता है। प्रत्येक सेल के लिए, यह ऊपर और नीचे की जाँच करता है, निम्नलिखित \और /दोनों तरफ जहाँ तक यह कर सकता है। यदि यह नोटिस करता है कि अगली पंक्ति में बहुत सारे हैं -, और वर्तमान आकार 'अनुमत' आकार है, तो यह भरने को निर्धारित करता है और प्रविष्टि को प्रिंट करता है।

भरने को कुकी के पूरे स्थान की खोज करके, एक 'अप्रयुक्त' सेल की तलाश में पाया जाता है। जब एक अप्रयुक्त सेल पाया जाता है, तो इसका उपयोग के रूप में चिह्नित किया जाता है (चूंकि हम अनुमत आकार में वृद्धि करते हैं, हम जानते हैं कि हम सबसे छोटी कुकी हैं जिसमें यह शामिल है), और हम भरने को रिकॉर्ड करते हैं।

प्रारूपित और टिप्पणी की गई कोड:

using C=System.Console;

class P
{
    static void Main()
    {
        //   32
        // - 45
        // / 47
        // \ 92
        // range 32..127 (no mod for you)

        string D="", // the whole map
            L; // initally each line of the map, later each line of output

        int W=0, // width
            H=0, // length (width * height)
            z=0, // search tracker
            d, // check direction (this is backwards (1 byte saving!))
            q, // check tracker
            c, // counter (truely, this is the distance from the right to the left)
            //M, // c max (now inlined as z/H)
            j, // horiontal tracker
            b; // - count, and reverse counter

        // read map and width
        for(;(L=C.ReadLine())!=null; // read a line, while we can
                H+=W=L.Length) // record the width, and increment height
            D+=L; // add the line to the map

        var B=new int[H]; // whether this filling has been used already (0 -> false, >0 -> true)

        for(d=W; // init direction
            (d=-d)>0|| // swap direction, else increment z (this allows us to run the check for the same z twice with opposite direction)
            ++z<H*H; // for all M, for all q (z<H -> M=z/H=0 -> no valid cookies, so we can safetly skip them)
            )
            for(//M=z/H, // c allow (now inlined)
                c=1, // reset counter
                q=z%H; // note position
                c<=z/H& // counter check
                // no need for a left check: if we run off the left end, then the right check will necessarily fail
                q%W+c<W& // right check
                q>=d& // high check
                q<H+d&& // low check (short-circuit lookups)
                D[q]==(d>0?92:47)&D[j=q+c]==(d<0?92:47); // /\ or \/ check, and set j=q+c
                    q-=d+1, // move left tracker
                    c+=2) // increase counter (move right tracker)
            {
                // count the number of '-' into b
                for(b=0; // zero b
                    j>q; // for each element in the row below
                        ) // empty
                    b+=D[--j-d]==45?2:0; // add 2 to b if we tap a '-'

                // j = q

                // check valid before looking up cHaracter (so we don't mark unused stuff as taken)
                // if we are at the current max count, and we have enough -, then we are valid and should be commited
                for( // this runs either one or zero times, we only have a for here (rather than an if) so we can ditch a pair of braces
                    char h='-', // default filling
                         e; // filling we are considering
                    c==z/H&b>c;
                        C.WriteLine(h+" "+c/2)) // print filling and count
                    // continuously compute character
                    for(b=c++; // count b backwards, starting from c (add 1 to c so we can /2 in print)
                        b>1;j=q+=d+1,b-=2) // count q backwards toward z%H (where q came from), and b backwards toward 1 (for each row)
                        for(;j<q+b;) // for each cell in row
                            B[j]= // mark cell as taken (h,e > 0)
                            h= // record filling
                                B[j]<1& // check cell not already used
                                h==45& // '-'
                                (e=D[j++])!=47& // '/'
                                e!=92& // '\'
                                e>32 // ' '
                                ?e:h; // take first filling we can
                    // c runs out after this (exists both loops), so no need to action
            }
    }
}

4 परीक्षण मामलों के लिए आउटपुट:

testcase #1
. 2
. 2
@ 3
- 4
* 4

testcase #2
- 1
- 1
- 2
d 2
* 2
- 3

testcase #3
- 1
- 1
- 1
- 1
- 2
- 2
: 2

testcase #4
- 1
- 1
- 2
$ 2
# 2
- 3
x 4
- 4

Comments

मैं चकित हूं कि यह C # में कितना कॉम्पैक्ट है! बहुत बढ़िया!

— नहीं कि चार्ल्स

एकमात्र वैध उत्तर! मेरे पास कुछ ऐसा है जो लगभग कार्यात्मक है, लेकिन कुछ त्रुटियां हैं (लेकिन मैं खुद को वैसे भी विजेता के रूप में सेट नहीं करूंगा)

— ऐसा नहीं है कि