เมื่อมีการตั้งค่าของโดมิโนงานของคุณคือการพิจารณาว่าโดมิโนตัวใดที่ล้มและไม่ทำ

อินพุต

ทำหน้าที่เป็นตัวแทนรูปแบบ ASCII รูปสี่เหลี่ยมผืนผ้าของการตั้งค่าโดมิโน อักขระต่อไปนี้ใช้สำหรับกริด ASCII:

• (ช่องว่าง): เซลล์ว่าง
• |, -, /, \: แต้ม

แต้มสามารถอยู่ใน 8 ทิศทางซึ่งแสดงด้วยตัวอักษรต่อไปนี้ (คล้ายกับทิศทางของ WASD):

Q W E
A   D
Z X C

โดมิโนอย่างน้อยหนึ่งตัวจะถูกแทนที่ด้วยตัวอักษรตัวใดตัวหนึ่งเหล่านี้เพื่อระบุว่าโดมิโนถูกผลักไปในตอนเริ่มต้น นี่คือตัวอย่าง:

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

ฉันไม่ต้องการให้ความท้าทายนี้เปลี่ยนเป็นการฝึกหัดในการแยกวิเคราะห์อินพุตดังนั้นจึงอนุญาตให้ใช้แบบฟอร์มอินพุตต่อไปนี้:

• สตริงที่มีกริด (นำหน้าด้วยมิติของตัวเลือกถ้าช่วยได้)
• Array / list / tuple ที่มีหนึ่งสตริงสำหรับแต่ละบรรทัด (เป็นทางเลือกพร้อมกับจำนวนเต็มความกว้างและความสูง)
• A (ซ้อนกัน) array / list / tuple ที่มีหนึ่งสตริง / ตัวอักษรสำหรับแต่ละเซลล์กริด (ตัวเลือกพร้อมกับตัวแปรความกว้างและความสูง)

คุณสามารถอ่านได้จาก STDIN หรือรับฟังก์ชั่นอาร์กิวเมนต์หรือคาดว่าอินพุตจะถูกเก็บไว้ในตัวแปร

เอาท์พุต

เขียนไปที่ STDOUT หรือส่งคืน (หรือบันทึกในตัวแปร) กริดผลลัพธ์ในรูปแบบอินพุตที่ถูกต้องใด ๆ ซึ่งบ่งชี้ว่าโดมิโนใดที่ล้มและไม่มี นั่นคือแทนที่โดมิโนแต่ละอันที่ตกลงมาด้วย#และปล่อยโดมิโนแต่ละอันที่ยืนอยู่ในอินพุต

กฎระเบียบ

แน่นอนแต้มแต้มถ่ายทอดการตกสู่การตั้งค่า เนื่องจากอาจมีเงื่อนไขการแข่งขันเราคิดว่ามีขั้นตอนเวลาที่แน่นอนและการลดลงของการแพร่กระจายเซลล์หนึ่งตารางต่อขั้นตอนเวลา

โดยทั่วไปแล้ว Dominoes จะล้มลงในแบบที่คุณคาดหวังไว้ แต่สัญชาตญาณที่เข้มงวดของสามัญสำนึกนั้นค่อนข้างยาว ขออภัยด้วยฉันหวังว่าตัวอย่างจะช่วยได้ นี่คือส่วนสำคัญกับชุดค่าผสมสองแบบที่ไม่ซ้ำกันทั้งหมด (สูงถึงการหมุนและการสะท้อน) อ่านต่อไปสำหรับกฎที่เข้มงวด

โดมิโนแต่ละอันสามารถตกได้ในสองทิศทางเท่านั้น:

           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||\-|\---/         ####-|\---/

แจ้งให้เราทราบหากคุณคิดว่าฉันทำผิดพลาด (โดยเฉพาะกับที่ผ่านมา)

C # 1048 907 850bytes

ตอนนี้เล่นกอล์ฟหนักมากเพียงแค่สับสนเล็กน้อยเกี่ยวกับการดำเนินการบิตในจำนวนเต็มสองมิติจำนวน enums อาจจะค่อนข้างสั้นลงโดยใช้อาร์เรย์ 1 มิติ แต่ฉันไม่ได้เตรียมที่จะลองใช้งานอีกครั้ง ณ จุดนี้ อ่านขนาดและสตริงจาก stdin ตัวอย่างเช่น:

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

แข็งแรงเล่นกอล์ฟ:

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++];}}

เนื่องจากฉันมีเวลามากเกินไปฉันจึงปรับเปลี่ยนเวอร์ชั่นที่ไม่ได้แต่งแต้มเพื่อส่งออก gif ที่เคลื่อนไหวได้ของโดมิโนที่ตกลงมา (ด้วยความช่วยเหลือจากคำถาม SOและเอกสารเหล่านี้1 2 ) นี่เป็นเพียงการเพิ่มรหัสและมันอาจอยู่ใน#if gifnessบล็อกหรือทำเครื่องหมายไว้อย่างชัดเจน

ในการสร้าง gif ให้คุณใส่อาร์กิวเมนต์บรรทัดคำสั่งคู่หนึ่งซึ่งอธิบายเวลาเฟรมไฟล์เอาต์พุต ฯลฯ

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

อาร์กิวเมนต์ที่สามคือเวลาของเฟรมสำหรับแต่ละเฟรม (1/100 วินาทีของวินาที) อาร์กิวเมนต์ที่สี่คือเวลาของเฟรมสำหรับเฟรมสุดท้าย (1/100 วินาที) อาร์กิวเมนต์ที่สองคือชื่อไฟล์เอาต์พุตสำหรับ gif คุณสามารถละเว้นชื่อไฟล์, การหน่วงเวลา, และการหน่วงเวลาสุดท้ายหากคุณต้องการเอาท์พุทของคอนโซล อาร์กิวเมนต์แรกคือความล่าช้าระหว่างเฟรมที่เรนเดอร์ไปยังเทอร์มินัลเป็นมิลลิวินาที คุณสามารถละเว้นการขัดแย้งทั้งหมดหากคุณไม่ต้องการให้มีภาพเคลื่อนไหวเลยและต้องการเห็นผลลัพธ์ มันอ่านข้อมูลโดมิโนจาก stdin เช่นเดียวกับรุ่น golfed รหัสนี้น่ากลัวในแบบของตัวเอง (ดู gif เพื่อให้ลูป)

โค้ดที่สร้าง 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
    }
}

ตัวอย่าง gif สำหรับอินพุตตัวอย่างที่ 3 (และที่แสดงด้านบน)

ตัวอย่างการสร้างรูปแบบโดมิโนแบบสุ่ม 100x25

"Domino" ในโดมิโน

Python 1188

โดยทั่วไปจะวนซ้ำอย่างต่อเนื่องจับคู่ regex แข็งแรงบางอย่างจนกว่าจะหยุดการเปลี่ยนแปลง จริง ๆ แล้วมันตรงกับแรงผลักดันทั้งหมดของแต่ละทิศทางแยกกัน (ผ่าน regex) จากนั้นจะรวบรวมผลลัพธ์ที่แตกต่างกันเพื่อให้แน่ใจว่าไม่มีความขัดแย้งและเช่นนั้น

regex สามารถทำได้มากกว่าที่มีขนาดกะทัดรัด แต่สำหรับตอนนี้ที่นี่คือสิ่งที่ฉันมี (สมมติว่ากริดเก็บอยู่ในสตริง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)

ungolfed เพิ่มเติม:

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