ডোমিনো দিবসের জন্য গল্ফিং

Question

ডোমিনোস সেটআপ দেওয়া আপনার কাজ হ'ল কোন ডোমিনোস পড়ে এবং কোনটি না তা নির্ধারণ করা।

ইনপুট

ডোমিনো সেটআপটির একটি আয়তক্ষেত্রাকার ASCII উপস্থাপনা নিন। নিম্নলিখিত অক্ষরগুলি ASCII গ্রিডের জন্য ব্যবহৃত হয়:

• (স্পেস): খালি ঘর
• |, -, /, \: Dominoes

ডোমিনোস 8 টি দিকের মধ্যে পড়ে যেতে পারে যা নিম্নলিখিত বর্ণগুলি দ্বারা প্রতিনিধিত্ব করা হয় (ডাব্লুএএসডি ওরিয়েন্টেশনের অনুরূপ):

Q W E
A   D
Z X C

ডোমিনো শুরুতে ধাক্কা দিয়ে গেছে তা বোঝাতে এক বা একাধিক ডোমিনোস এই অক্ষরের একটি দ্বারা প্রতিস্থাপন করা হবে। এখানে একটি উদাহরণ:

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

আমি চাই না যে এই চ্যালেঞ্জটি ইনপুট পার্সিংয়ের অনুশীলনে রূপান্তরিত করুক যাতে নিম্নলিখিত যেকোন ইনপুট ফর্মের অনুমতি দেওয়া হয়:

• গ্রিড সহ একটি স্ট্রিং (optionচ্ছিকভাবে এটির সাহায্যে এর মাত্রাগুলি দ্বারা পূর্বে)
• প্রতিটি লাইনের জন্য একটি স্ট্রিং সহ একটি অ্যারে / তালিকা / টিপল (বিকল্পভাবে প্রস্থ এবং উচ্চতার পূর্ণসংখ্যার পাশাপাশি)
• প্রতিটি গ্রিড কোষের জন্য একটি স্ট্রিং / অক্ষর সহ একটি (নেস্টেড) অ্যারে / তালিকা / টিপল (বিকল্পভাবে প্রস্থ এবং উচ্চতার ভেরিয়েবলগুলির সাথে)

আপনি STDIN থেকে পড়তে পারেন বা কোনও ফাংশন আর্গুমেন্ট নিতে পারেন বা ইনপুটটি কোনও ভেরিয়েবলের মধ্যে সঞ্চয় করার আশাও করতে পারেন।

আউটপুট

STDOUT এ লিখুন বা কোনও বৈধ ইনপুট ফর্ম্যাটে ফলস্বরূপ গ্রিডটি প্রত্যাবর্তন করুন (বা কোনও পরিবর্তনশীল সংরক্ষণ করুন) যা ডমিনোস পড়েছে এবং কোনটি পড়ে না তা নির্দেশ করে। অর্থাত, প্রতিটি পতিত ডোমিনো এর সাথে প্রতিস্থাপন করুন# এবং প্রতিটি স্ট্যান্ডিং ডোমিনো যেমন ইনপুটটিতে থাকে তেমন ছেড়ে দিন।

বিধি

অবশ্যই, ডোমিনোস সেটআপের মাধ্যমে তাদের পতনের প্রচার করে। জাতিগুলির শর্ত যেমন হতে পারে, আমরা ধরে নিই যে নির্দিষ্ট সময়ের পদক্ষেপ রয়েছে এবং পড়ন্ত সময় প্রতি ধাপে একটি গ্রিড সেল প্রচার করে।

ডোমিনোস সাধারণত আপনি যেভাবে স্বজ্ঞাতভাবে তাদের কাছে প্রত্যাশা করতেন সেভাবে পড়ে যায় তবে সাধারণ জ্ঞানের একটি কঠোর স্পেসিফিকেশন বেশ দীর্ঘ হয় to এর জন্য দুঃখিত, আমি আশা করি উদাহরণগুলি সাহায্য করবে। এখানে একটি সংক্ষেপ সমস্ত অনন্য দ্বি-টাইল সংমিশ্রণ (ঘূর্ণন এবং প্রতিবিম্ব পর্যন্ত) সহ একটি সংক্ষিপ্তসার রয়েছে। কঠোর নিয়মের জন্য পড়ুন।

প্রতিটি ডোমিনো কেবল দুটি দিকেই পড়ে যেতে পারে:

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

আপনি যদি ভাবেন যে আমি কোনও ভুল করেছি (বিশেষত শেষটির সাথে) me

Answer 1

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

যেহেতু আমার অনেক বেশি সময় আছে আমি ডমিনোসগুলির একটি অ্যানিমেটেড জিআইএফ আউটপুট করার জন্য অলগল্ড সংস্করণটি সংশোধন করেছি ( এই এসও প্রশ্ন এবং এই নথিগুলির সাহায্যে 1 2 )। এটিতে কেবল কোড যুক্ত হয়েছে, এবং এটি হয় একটিতে#if gifness ব্লকে বা পরিষ্কারভাবে চিহ্নিত করা হয়েছে marked

জিআইএফ তৈরি করতে আপনি ফ্রেম টাইমস, আউটপুট ফাইল, ইত্যাদি বর্ণনা করে একটি জোড়া কমান্ড লাইন যুক্তি সরবরাহ করেন,

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

তৃতীয় যুক্তি হ'ল প্রতিটি ফ্রেমের ফ্রেম সময় (1 / 100s সেকেন্ড)। চতুর্থ যুক্তি হ'ল শেষ ফ্রেমের (1 / 100s সেকেন্ড) ফ্রেমের সময়। দ্বিতীয় আর্গুমেন্টটি জিআইএফ-এর আউটপুট ফাইলের নাম। আপনি কেবল কনসোল আউটপুট চাইলে আপনি ফাইলের নাম, বিলম্ব এবং চূড়ান্ত বিলম্ব বাদ দিতে পারেন। প্রথম যুক্তি হ'ল মিলি সেকেন্ডে টার্মিনালে রেকর্ড করা ফ্রেমের মধ্যে বিলম্ব। আপনি যদি কোনও অ্যানিমেশন কিছু না চান এবং ফলাফলটি দেখতে চান তবে আপনি সমস্ত যুক্তি বাদ দিতে পারেন। এটি গল্ফযুক্ত সংস্করণের মতো স্টডিনের থেকে ডোমিনো ডেটা পড়ে। এই কোডটি নিজস্ব পদ্ধতিতে ভয়ঙ্কর (জিআইফের কসাই দেয় যাতে এটি লুপ হয়)।

অগল্ফড জিআইএফ-উত্পন্নকারী কোড:

#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
    }
}

তৃতীয় উদাহরণ ইনপুটটির জন্য একটি জিআইফ উদাহরণ (এবং এটি উপরে প্রদর্শিত)

উদাহরণ এলোমেলোভাবে 100x25 ডোমিনো লেআউট উত্পন্ন

ডোমিনোজে "ডোমিনো"

Answer 2

পাইথন 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।

Comments

আপনি ঠিক বলেছেন, এগুলি দুটি টাইপ ছিল, যদিও শেষটি একটি হওয়ার কথা ছিল E(এটি নয় যে এটি কোনও পার্থক্য করে ...)। দেখে মনে হচ্ছে আপনি খালি ন্যূনতম ইনডেন্টেশন গভীরতা হ্রাস করে অক্ষরের একটি গুচ্ছ সংরক্ষণ করতে পারেন।

— মার্টিন ইন্ডার

আমি নিশ্চিত নই যে আমি তৃতীয় উদাহরণটি কপি-পেস্ট করার জন্য কিছু ভুল করেছি কিনা, তবে ব্যাকস্ল্যাশগুলি হ্রাস পাবে না (যদিও তারা চতুর্থ উদাহরণে কাজ করবে বলে মনে হয়)

— মার্টিন ইন্ডার

@ মার্টিনব্যাটনার, যদিও আমার কপি-পেস্ট করতে কিছু সমস্যা হয়েছে (নিশ্চিত করুন যে লাইনের শেষে কোনও পেছনের শ্বেতক্ষেত্র নেই, এবং কোনও ট্যাব নেই, কেবল ফাঁকা জায়গা নেই) মনে হয় এটি সঠিক হয়ে যাওয়ার পরে এটি কার্যকর হয়। একই লাইনে প্রত্যাশিত ফলাফল ছাড়াই অনুলিপিটির অনুলিপিটিকে অনুলিপি-পেস্ট করা সহজ হতে পারে।

— কেএসব