डोमिनोज़ डे के लिए गोल्फ


14

डोमिनोज के एक सेटअप को देखते हुए आपका काम यह पता लगाना है कि कौन से डोमिनोज गिरते हैं और कौन से नहीं।

इनपुट

एक डोमिनोज़ सेटअप का एक आयताकार ASCII प्रतिनिधित्व लें। निम्न वर्ण ASCII ग्रिड के लिए उपयोग किए जाते हैं:

  • (space): खाली सेल
  • |, -, /, \: डोमिनो

डोमिनोज़ 8 दिशाओं में गिर सकते हैं, जिन्हें निम्नलिखित अक्षरों (WASD झुकाव के समान) द्वारा दर्शाया गया है:

Q W E
A   D
Z X C

एक या अधिक डोमिनोज़ को इन अक्षरों में से एक से बदल दिया जाएगा ताकि यह इंगित किया जा सके कि प्रारंभ में डोमिनोज़ को धक्का दिया गया है। यहाँ एक उदाहरण है:

D||||/  
  -   / 
  -    -
  -    -
  /|||||

मैं नहीं चाहता कि यह चुनौती इनपुट पार्सिंग में एक अभ्यास में बदल जाए ताकि निम्नलिखित इनपुट रूपों में से किसी की अनुमति हो:

  • ग्रिड के साथ एक स्ट्रिंग (वैकल्पिक रूप से इसके आयामों से पहले यदि वह मदद करता है)
  • प्रत्येक पंक्ति के लिए एक स्ट्रिंग के साथ एक सरणी / सूची / ट्यूपल (वैकल्पिक रूप से चौड़ाई और ऊंचाई पूर्णांक के साथ)
  • ए (नेस्टेड) ​​सरणी / सूची / प्रत्येक ग्रिड सेल के लिए एक स्ट्रिंग / चरित्र के साथ ट्यूपल (वैकल्पिक रूप से चौड़ाई और ऊंचाई चर के साथ)

आप एसटीडीआईएन से पढ़ सकते हैं या फ़ंक्शन तर्क ले सकते हैं या यहां तक ​​कि इनपुट को एक चर में संग्रहीत करने की अपेक्षा कर सकते हैं।

उत्पादन

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

नियम

बेशक, डोमिनोज़ सेटअप के माध्यम से अपने पतन का प्रचार करते हैं। जैसा कि दौड़ की स्थिति हो सकती है, हम मानते हैं कि निश्चित समय कदम हैं और गिरने से प्रति चरण एक ग्रिड सेल का प्रसार होता है।

डोमिनोज़ आम तौर पर जिस तरह से आप उनसे सहजता से उम्मीद करते हैं वह गिर जाता है, लेकिन सामान्य ज्ञान का एक कठोर विनिर्देश काफी लंबा हो जाता है। इसके लिए क्षमा करें, मुझे आशा है कि उदाहरण मदद करेंगे। यहां सभी अद्वितीय दो-टाइल संयोजन (घुमाव और प्रतिबिंब तक) के साथ एक जिस्ट है । कठोर नियमों के लिए आगे पढ़ें।

प्रत्येक डोमिनो केवल दो दिशाओं में गिर सकता है:

           W       Q          E
A | D      -        /        \
           X         C      Z

जब भी कोई डोमिनोज गिरता है तो यह गिरावट की दिशा में सेल को प्रभावित करता है। यदि उस सेल में एक डोमिनोज़ होता है जो एक ही दिशा में या एक दिशा में गिर सकता है जो 45 डिग्री से भिन्न होता है, तो वह डोमिनोज़ अगली बार के कदम में ऐसा करता है।

उदाहरण:

D|    ->    DD      (falls in same direction)

D/    ->    DC      (falls at 45 degrees)

C     ->    C       (falls at 45 degrees)
 -           X

जब भी एक तिरछे उन्मुख डोमिनोज़ ( /या\ ) गिरता है, तो यह उन दो कोशिकाओं को भी प्रभावित करता है जो इसके पतन की दिशा में अपने सेल और सेल दोनों को छूते हैं। यदि इन कोशिकाओं में एक डोमिनोज़ होता है, जो मूल डोमिनोज़ के समान दिशा में गिर सकता है, या उससे दूर अक्ष-संरेखित दिशा में, तो यह है कि डोमिनोज़ अगली बार कदम में ऐसा करता है।

उदाहरण:

C/     ->   CC      (the cell in the direction of the fall is the one below
                     the /, so it falls in the same direction)

C|     ->   CD      (falls in the axis-aligned direction away from the C)

C-     ->   C-       (the direction away from the Q is W, 
  or                  but neither - nor \ can fall to W)
C\     ->   C\     

अपवाद : यदि एक डोमिनो को एक ही समय में दोनों वैध दिशाओं में धकेल दिया जाता है (यानी यदि उपरोक्त नियमों में से कोई भी संघर्ष में है), तो यह गिरता नहीं है।

उदाहरण:

D|A   ->    D|A     (central domino in pushed in both directions)

  Z           Z     (although it's pushed in one direction by two dominoes
D\A   ->    D\A      and in the other by only one, it doesn't fall)


 X           X      (the domino is being pushed from two opposing sides
D-A   ->    DXA      D and A, but neither is valid for that domino. Hence,
                     there is no conflict and the X can push the domino over)

 Z           Z      (pushed in the same direction by two dominoes, so falls)
\A    ->    ZA

   Z           Z           Z    (once the conflict arises, the affected
  \   ->      Z   ->      Z      domino is locked in its position and can't
D|A         D|A         D|A      be pushed over by future dominoes)

उदाहरण

8 5
D||||/            ######  
  -   /             -   # 
  -    -    -->     -    #
  -    -            -    #
  /|||||            /|||||

===============================================

17 9
E|/|||/                    #######          
  -   -                      #   #          
  -   -                      #   #          
  -   -                      #   #          
  /|||/|||||||||/    -->     ###############
       /        -                 #        #
        /       -                  #       -
         /      -                   #      #
          /|||||\                    #######

===============================================

19 8
       \|/                        ###           
       - -                        # #           
D||||/|\ /|||/             ######## #####       
      /      -                   #      #       
       -    \-       -->          -    \#       
      \-   \ -                   #-   \ #       
D||||\ /  \  /             ###### /  \  #       
        |\    |||||                |\    #####  

==============================================

11 11
-\\\/|\|\-|         -\##/|###-|
-|\\||\-|\-         -|#####-|\-
|\//\//|-/-         |#//\//|#/-
\|//|-|\-\|         #####-|##\|
---||/-\//|         #-######//|
///|||\----   -->   #/#####----
-|/---|-|-\         #|##--|-|-\
--|--\/|///         ####-\/|///
/|//--|//-|         ####--|//-|
|/\-|||-/-\         |/\####-/-\
E||\-|\---/         ####-|\---/

मुझे पता है कि अगर आपको लगता है कि मैंने गलती की है (विशेषकर पिछले एक के साथ)।

जवाबों:


15

C # 1048 907 850bytes

अब भारी रूप से गोल्फ, बहुत ज्यादा सिर्फ बिट ऑपरेशनों की एक गड़गड़ाहट पूर्णांक के दो आयामी सरणी पर। शायद 1-आयामी सरणी का उपयोग करके कुछ हद तक कम किया जा सकता है, लेकिन मैं इस बिंदु पर इसे आज़माने और फिर से काम करने के लिए तैयार नहीं हूं। उदाहरण के लिए, स्टड से आयाम और स्ट्रिंग को पढ़ता है:

11 11 -\\\/|\|\-|-|\\||\-|\-|\//\//|-/-\|//|-|\-\|---||/-\//|///|||\-----|/---|-|-\--|--\/|////|//--|//-||/\-|||-/-\E||\-|\---/

golfed:

using L=System.Console;class R{static void Main(){int p=255,e,c,E=7,D,C,X,Z,A,m=-1,t=m,f=t,u,i=t;for(;t<0;)for(t=f,f=0;(C=L.Read())>47;)f=f*10+C-48;var T=new int[f,t];for(;++i<f;)for(c=0;c<t;T[i,c++]=(C>99?68:C>91?34:C>89?112:C>87?56:C>86?131:C>80?193:C>68?7:C>67?14:C>66?28:C>64?224:C>46?136:C>44?17:0)*(C>64&C<91?1:257))C=L.Read();for(;i+E>0;E=-E)for(i=c=m;++c<f;)for(C=m;++C<t;){if(E>0&(A=D=T[c,C])>0&D<p){T[c,C]=m; X=C+(i=(D&4)>0?1:(D&64)/-64);Z=c+(u=(D&16)>0?1:D%2*m);System.Action v=()=>{if(Z>m&Z<f&X>m&X<t&&(e=T[Z,X])>p&(e>>8&A)>0)T[Z,X]&=65280|A;};v();if((i&u)!=0){X=i==u?C:X;Z=i==u?Z:c;A=((D&128)/128+D*2)&D;v();X=C+i-X+C;Z=c+u-Z+c;A=(D%2*128+D/2)&D;v();}i=8;}if(E<0&D>p&((D=D&p)&(D-1))<1&D>0)T[c,C]=D<2?131:D>64?193:D/2*7;}for(D=m;++D<f;L.WriteLine())for(c=0;c<t;L.Write(C<0?'#':(C=C>>8)>99?'/':C>67?'|':C>33?'\\':C>9?'-':' '))C=T[D,c++];}}

क्योंकि मेरे पास बहुत अधिक समय है, मैंने गिरते हुए डोमिनोज़ के एक एनिमेटेड जिफ़ को आउटपुट करने के लिए ungolfed संस्करण को संशोधित किया है ( इस SO प्रश्न और इन दस्तावेजों 1 2 की मदद से )। इसमें केवल कोड जोड़ा गया है, और यह या तो एक में है#if gifness ब्लॉक में है या स्पष्ट रूप से चिह्नित है।

Gifs बनाने के लिए आप फ़्रेम टाइम, आउटपुट फ़ाइल, आदि का वर्णन करते हुए कमांड लाइन की एक जोड़ी प्रदान करते हैं।

dominoGolf.exe console_delay (out_file_name (gif_frame_time (final_frame_time)))
dominoGolf.exe 0 outfile.gif 1 100

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

Ungolfed जिफ़-जनरेटिंग कोड:

#define gifness

using L=System.Console;

class R
{
    static void Main(string[] args) // don't need args
    {
        int p=255,P=0xFF00,m=15,M=240, // might be able to inline a couple of these
        w=1,e=2,d=4,c=8,x=16,z=32,a=64,q=128, // most of these are reusable
        W=131,E=7,D=14,C=28,X=56,Z=X*2,A=Z*2,Q=193, // most (all?) of these are reusable
        Y=w+x,U=a+d,N=c+q,B=z+e, // one of these atleast is pre-evalable

        // recognise this?
        t=-1,f=t,k,u,i=t,j,J,K,o,O,b;
        for(;t<0;)
            for(t=f,f=0;(k=L.Read())>47;)
                f=f*10+k-48;

        var T=new int[f,t]; // main arr
        // domino: dir, copy(for render)
        // motion: pickup

        // input
        for(;++i<f;) // values of i and j don't matter, just counters
        {
            for(j=0;j<t;) // increment done 3down
            {
                k=L.Read();
                T[i,j++]=(
                // fallen
                k=='W'?W:k=='E'?E:k=='D'?D:k=='C'?C:k=='X'?X:k=='Z'?Z:k=='A'?A:k=='Q'?Q:
                // dominos
                k==' '?0:k=='-'?Y:k=='/'?N:k=='|'?U:B // ASCII, order for >
                )*(k>64&k<91?1:257);
            }
        }

        #if gifness
        System.Drawing.Font font1 = null;
        System.Windows.Media.Imaging.GifBitmapEncoder genc = null;
        System.Drawing.Bitmap bmp = null;
        System.Drawing.Graphics g = null;
        if (args.Length > 1)
        {
            font1 = new System.Drawing.Font(System.Drawing.FontFamily.GenericMonospace, 12, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel);
            genc = new System.Windows.Media.Imaging.GifBitmapEncoder();
            bmp = new System.Drawing.Bitmap(t * 8, f * 14); // I have no clue what these should be in relation to em size
            g = System.Drawing.Graphics.FromImage(bmp);
        }
        #endif

        if (args.Length > 0) // not important
        {
            L.Clear();
        }

        // main
        for(;i>0;) // can do i=1-i and swap setting 1 for 0 to remove {}
        {

            if (args.Length > 0) // non-critical, renders the current state to the console/gif
            {
                var os="";
                for (o=0;o<f;o++) // values of i and j don't matter, just counters
                {
                    for (j=0;j<t;j++)
                    {
                        k=T[o,j];
                        os += k==0?' ':k<p?'#':(k=k>>8)==Y?'-':k==N?'/':k==U?'|':'\\'; // order for >
                    }
                    os+="\n";
                }
                L.SetCursorPosition(0, 0);
                L.Write(os);

                #if gifness
                if (args.Length > 1)
                {
                    g.Clear(System.Drawing.Color.White);
                    g.DrawString(os, font1, System.Drawing.Brushes.Black, 0, 0);
                    System.IO.MemoryStream bms = new System.IO.MemoryStream();
                    bmp.Save(bms, System.Drawing.Imaging.ImageFormat.Gif);
                    var bmpf = System.Windows.Media.Imaging.BitmapFrame.Create(bms);
                    genc.Frames.Add(bmpf);

                    // do I chose the frame duraton1??!?!?! (take from args[2] is present else args[0])
                }
                #endif

                System.Threading.Thread.Sleep(int.Parse(args[0]));
            }

            // back to important stuff
            i=0; // set me to 1 if we do anything (8 in golfed version due to E being 7)

            // move motions
            for (j=0;j<f;j++) // careful!!
            {
                for (k=0;k<t;k++) // careful!!
                {
                    O=o=T[j,k];
                    if (o>0&o<p) // we are motion
                    {
                        T[j,k]=-1; // do this so we can't skip it

                        K=k+(i=((o&d)>1?1:(o&a)>0?-1:0));
                        J=j+(u=((o&x)>1?1:(o&w)>0?-1:0));

                        System.Action v=()=>{
                            if(J>=0&J<f&K>=0&K<t&&(b=T[J,K])>p&&((b>>8)&O)>0)
                            {
                                T[J,K]&=(P|O);
                            }
                        };

                        v();
                        if (i!=0&u!=0)
                        {
                            K=i==u?k:K; // k+i == K
                            J=i==u?J:j; // j+u == J
                            O=(((o&q)>0?w:0)+o*2)&o;
                            v();

                            K=K==k?k+i:k;
                            J=J==j?j+u:j;
                            O=(((o&w)>0?q:0)+o/2)&o;
                            v();
                        }

                        i=1;
                    }
                }
            }

            // move dominos
            for (j=0;j<f;j++) // careful!!
            {
                for (k=0;k<t;k++) // careful!!
                {
                    o=T[j,k];
                    if (o>p) // we are domino
                    {
                        o=o&p;
                        if ((o&m)<1!=(o&M)<1)
                        { // we have motion
                            T[j,k]=o==w?W:o==q?Q:o+o/2+o*2;
                        }
                    }
                }
            }
        }

        if (args.Length > 0)
        {
            L.SetCursorPosition(0, 0);
        }

        // output
        for (o=0;o<f;o++)
        {
            for (j=0;j<t;j++)
            {
                k=T[o,j];
                L.Write(k<0?'#':(k=k>>8)==0?' ':k==Y?'-':k==N?'/':k==U?'|':'\\'); // order for >
            }
            L.WriteLine();
        }


        #if gifness
        if (args.Length > 1)
        {
            g.Dispose();
            bmp.Dispose();

            System.IO.MemoryStream ms = new System.IO.MemoryStream();

            genc.Save(ms);
            byte[] data = ms.GetBuffer();
            byte[] netscape = { 0x21, 0xFF, 0x0B, 0x4E, 0x45, 0x54, 0x53, 0x43, 0x41, 0x50, 0x45, 0x32, 0x2E, 0x30, 0x03, 0x01, 0x00, 0x00, 0x00 };

            if (args.Length > 2)
            {
                int last = -1;
                int duration = int.Parse(args[2]);

                // promise yourself now you will never use this in production code
                // I've not read enough of the GIF spec to know if this is a bad idea or not
                for (i = 0; i < ms.Length - 5; i++)
                {
                    if (data[i] == 0x21 && data[i+1] == 0xF9 && data[i+2] == 0x04 && data[i+3] == 01)
                    {
                        data[i+4] = (byte)(duration & p); // something endian (least significant first)
                        data[i+5] = (byte)((duration & P) >> 8);
                        last = i+4;
                    }
                }

                if (last != -1 && args.Length > 3)
                {
                    duration = int.Parse(args[3]);
                    data[last] = (byte)(duration & p);
                    data[last+1] = (byte)((duration & P) >> 8);
                }
            }

            using (System.IO.FileStream fs = new System.IO.FileStream(args[1], System.IO.FileMode.Create))
            {
                fs.Write(data, 0, 13);

                // behold
                fs.Write(netscape, 0, netscape.Length);

                fs.Write(data, 13, (int)ms.Length - 13); // lets hope these arn't in excess of 2GBs
            }
        }
        #endif
    }
}

3 उदाहरण इनपुट के लिए एक उदाहरण gif (और जो ऊपर दिखाया गया है)

तीसरा उदाहरण

उदाहरण बेतरतीब ढंग से उत्पन्न 100x25 डोमिनोज़ लेआउट

100x25 डोमिनोज़ लेआउट

डोमिनोज़ में "डोमिनोज़"

डोमिनोज़ में "डोमिनोज़"


3

अजगर 1188

मूल रूप से बस कुछ भारी रेगेक्स से लगातार मेल खाता रहता है जब तक कि वह बदलना बंद नहीं करता। यह वास्तव में प्रत्येक दिशा के सभी पुशों को अलग-अलग (रेगेक्स के माध्यम से) से मेल खाता है, और फिर अलग-अलग परिणामों की रचना करता है सुनिश्चित करता है कि कोई संघर्ष नहीं है और ऐसे।

रेगेक्स शायद बहुत अधिक कॉम्पैक्ट रूप से किया जा सकता है, लेकिन अब मेरे लिए यहां वही है (यह मानता है कि ग्रिड एक स्ट्रिंग में संग्रहीत है g, और आयाम में हैं xऔर y):

import re;L='QWEADZXC';a='';m=(x*y+y);o=[0]*m;X='(.{%s})';t=X%x;u=X%(x+1);v=X%(x-1);R=range
def S(s,l):
 f=s
 for p,r in l:
    n=re.sub(p,r,s,flags=re.DOTALL)
    for i in R(len(n)):
     if n[i]!=s[i]:f=f[:i]+n[i]+f[i+1:]
 return f
while g != a:
 a=g;n='';d=[S(g,[(r'D\|','DD'),(r'D\\','DE'),('D/','DC')]),S(g,[(r'\|A','AA'),(r'\\A','ZA'),('/A','QA')]),S(g,[('-%sW'%t,r'W\1W'),(r'\\%sW'%t,r'E\1W'),('/%sW'%t,r'Q\1W')]),S(g,[('X%s-'%t,r'X\1X'),(r'X%s\\'%t,r'X\1Z'),(r'X%s/'%t,r'X\1C')]),S(g,[('C%s/'%u,r'C\1C'),('C%s-'%u,r'C\1X'),(r'C%s\|'%u,r'C\1D'),('C%s/'%t,r'C\1C'),('C%s-'%t,r'C\1X'),('C/','CC'),(r'C\|','CD')]),S(g,[(r'Z%s\\'%v,r'Z\1Z'),('Z%s-'%v,r'Z\1X'),(r'Z%s\|'%v,r'Z\1A'),(r'Z%s\\'%t,r'Z\1Z'),('Z%s-'%t,r'Z\1X'),(r'\\Z','ZZ'),(r'\|Z','AZ')]),S(g,[('/%sQ'%u,r'Q\1Q'),('-%sQ'%u,r'W\1Q'),(r'\|%sQ'%u,r'A\1Q'),('/%sQ'%t,r'Q\1Q'),('-%sQ'%t,r'W\1Q'),('/Q','QQ'),(r'\|Q','AQ')]),S(g,[(r'\\%sE'%v,r'E\1E'),('-%sE'%v,r'W\1E'),(r'\|%sE'%v,r'D\1E'),(r'\\%sE'%t,r'E\1E'),('-%sE'%t,r'W\1E'),(r'E\\','EE'),(r'E\|','ED')])]
 for i in range(m):
    c=0
    for r in d:
     if r[i]in L:
        if c==0:c=r[i]
        elif r[i]!=c:o[i]=1;break
    n+=g[i]if c==0 or o[i]else c
 g=n
print re.sub(r'\w','#',g)

अधिक अपंग:

import re

L = 'QWEADZXC'

def sub_all(string,lst):
    final = string
    for p,r in lst:
        new = re.sub(p,r,string,flags=re.DOTALL)
        for i in range(len(new)):
            if new[i]!=string[i]:
                final=final[:i]+new[i]+final[i+1:]
    return final

def dominoes(grid,x,y):
    print len(grid),x*y+y
    print grid

    last = ''
    locked = [0]*(x*y+y)
    while grid != last:
        last = grid

        Dgrid = sub_all(grid,[(r'D\|','DD'),(r'D\\','DE'),('D/','DC')])
        Agrid = sub_all(grid,[(r'\|A','AA'),(r'\\A','ZA'),('/A','QA')])
        Wgrid = sub_all(grid,[('-(.{%s})W'%x,r'W\1W'),(r'\\(.{%s})W'%x,r'E\1W'),('/(.{%s})W'%x,r'Q\1W')])
        Xgrid = sub_all(grid,[('X(.{%s})-'%x,r'X\1X'),(r'X(.{%s})\\'%x,r'X\1Z'),(r'X(.{%s})/'%x,r'X\1C')])

        Cgrid = sub_all(grid,[('C(.{%s})/'%(x+1),r'C\1C'),('C(.{%s})-'%(x+1),r'C\1X'),(r'C(.{%s})\|'%(x+1),r'C\1D'),
                        ('C(.{%s})/'%x,r'C\1C'),('C(.{%s})-'%x,r'C\1X'),
                        ('C/','CC'),(r'C\|','CD')])

        Zgrid = sub_all(grid,[(r'Z(.{%s})\\'%(x-1),r'Z\1Z'),('Z(.{%s})-'%(x-1),r'Z\1X'),(r'Z(.{%s})\|'%(x-1),r'Z\1A'),
                        (r'Z(.{%s})\\'%x,r'Z\1Z'),('Z(.{%s})-'%x,r'Z\1X'),
                        (r'\\Z','ZZ'),(r'\|Z','AZ')])

        Qgrid = sub_all(grid,[('/(.{%s})Q'%(x+1),r'Q\1Q'),('-(.{%s})Q'%(x+1),r'W\1Q'),(r'\|(.{%s})Q'%(x+1),r'A\1Q'),
                        ('/(.{%s})Q'%x,r'Q\1Q'),('-(.{%s})Q'%x,r'W\1Q'),
                        ('/Q','QQ'),(r'\|Q','AQ')])

        Egrid = sub_all(grid,[(r'\\(.{%s})E'%(x-1),r'E\1E'),('-(.{%s})E'%(x-1),r'W\1E'),(r'\|(.{%s})E'%(x-1),r'D\1E'),
                        (r'\\(.{%s})E'%x,r'E\1E'),('-(.{%s})E'%x,r'W\1E'),
                        (r'E\\','EE'),(r'E\|','ED')])

        grids = [Dgrid,Agrid,Wgrid,Xgrid,Cgrid,Zgrid,Qgrid,Egrid]
        ngrid = ''

        for i in range(x*y+y):
            c = None
            for g in grids:
                if g[i] in L:
                    if c==None: c = g[i]
                    elif g[i] != c:
                        ngrid += grid[i]
                        locked[i]=1
                        break
            else:
                ngrid += grid[i] if c==None or locked[i] else c
        grid = ngrid
        print grid
    return re.sub(r'\w','#',grid)

सूचीबद्ध इनपुट तीसरे को छोड़कर सभी अपने आउटपुट का उत्पादन करते हैं, जिसमें मुझे पूरा यकीन है कि एक गलती है ( यदि \-/बहुत ऊपर होना चाहिए \|/अगर दिए गए आउटपुट वांछित हैं)। मैं यह भी मान रहा हूं कि .पिछले एक के निचले बाएं कोने में एक होने का इरादा था D


आप सही कह रहे हैं, वे दो टाइपो थे, हालांकि अंतिम एक होना चाहिए था E(ऐसा नहीं है कि इससे कोई फर्क पड़ता है ...)। ऐसा लगता है कि आप नंगे न्यूनतम करने के लिए इंडेंटेशन की गहराई को कम करके पात्रों का एक गुच्छा बचा सकते हैं।
मार्टिन एंडर

मुझे यकीन नहीं है कि क्या मैंने तीसरा उदाहरण कॉपी-पेस्ट करने में कुछ गलती की है, लेकिन बैकस्लैश उनके पतन नहीं होगा (वे चौथे उदाहरण में काम करना चाहते थे)
मार्टिन एंडर

1
@ मार्टिनबटनर, हालांकि मुझे कुछ परेशानी कॉपी-पेस्ट करने में हुई (यह सुनिश्चित करें कि लाइनों के अंत में कोई अनुगामी व्हॉट्सएप नहीं है, और कोई टैब नहीं है, केवल रिक्त स्थान हैं) यह काम करने के लिए लगता है एक बार मैंने इसे सही कर लिया। यह एक ही तर्ज पर अपेक्षित परिणामों के बिना, कॉपी-पेस्ट करने के लिए आसान प्रारूप में उदाहरण इनपुट की मदद कर सकता है।
20
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.