একটি ASCII আর্ট টেবিলটিকে একটি ইউটিএফ -8 টেবিলে রূপান্তর করুন

13

আমি যখন ডকুমেন্টেশন, মন্তব্য ইত্যাদি লিখি তখন আমি ASCII টেবিল বানাতে পছন্দ করি। এগুলি সাধারণত বেশ ভাল দেখায়, তবে আমি সর্বদা অনুভব করি যে তারা আরও ভাল দেখতে পারে - বিশেষত যেহেতু ইউটিএফ -8 / ইউনিকোডে বক্স অঙ্কনের অক্ষর রয়েছে । যাইহোক, এই অক্ষরগুলি ব্যবহার করা খুব ভারী ens তোমার কাজ? এমন একটি প্রোগ্রাম বা একটি ফাংশন লিখুন যা ASCII টেবিলগুলি স্বয়ংক্রিয়ভাবে ইউটিএফ -8 / ইউনিকোড সমতুল্যে রূপান্তর করতে পারে।

এই চ্যালেঞ্জটি স্যান্ডবক্সযুক্ত ছিল ।

চ্যালেঞ্জ

একটি প্রোগ্রাম লিখুন, যা ইনপুট স্ট্রিং হিসাবে কোনও ASCII টেবিল দেয়, ইউনিকোড / ইউটিএফ -8 বক্স অঙ্কনের অক্ষরগুলির সাথে টেবিলটিকে আবার রঙ করে। বিশেষত, টেবিলের একটি অংশ এমন অক্ষরগুলি অনুবাদ করা উচিত:

(Unicode, 3 bytes each in UTF-8)
- to ─ (\u2500)
| to │ (\u2502)
= to ═ (\u2550)

and + to one of:
   ┌ (\u250C), ┐ (\u2510), └ (\u2514), ┘ (\u2518),
   ├ (\u251C), ┤ (\u2524), ┬ (\u252C), ┴ (\u2534),
   ┼ (\u253C)
or, if '=' on either side:
   ╒ (\u2552), ╕ (\u2555), ╘ (\u2558), ╛ (\u255D),
   ╞ (\u255E), ╡ (\u2561), ╤ (\u2564), ╧ (\u2567),
   ╪ (\u256A)

বিস্তারিত

ইনপুট / আউটপুট:

  • ডিফল্ট আই / ও অনুমোদিত
  • স্ট্রিং হিসাবে টেবিল বা টেবিলযুক্ত কোনও ফাইলের পথ সহ আপনি যেকোন যুক্তিসঙ্গত বিন্যাসে ইনপুট নিতে পারেন।
  • আপনি কোনও ফাইলে আউটপুট দিতে পারেন এবং অতিরিক্ত যুক্তি হিসাবে ফাইলটির নাম নিতে পারেন।
    • তবে আপনি ইনপুট ফাইলটি পরিবর্তন করতে পারবেন না । (এটি ভবিষ্যতের সম্পাদনা সহজ করার জন্য বজায় রাখা উচিত)

ইনপুট:

  • আপনি ধরে নিতে পারেন যে ইনপুটটির প্রতিটি সারি একই দৈর্ঘ্যের জন্য প্যাড করা হয়েছে ।
  • আপনি ধরে নিতে পারেন না যে একটি নতুন লাইনের পরে প্রথম অক্ষরটি টেবিলের সীমানার অংশ (যেমন এটি সাদা অংশ হতে পারে)।
  • ইনপুটটিকে বৈধ সারণী হিসাবে বিবেচনা করা হয় যদি সমস্ত অক্ষর (যা টেবিলের একটি অংশ) -=|ঠিক দুটি অক্ষরের +সাথে সংযুক্ত থাকে এবং কমপক্ষে একটি অক্ষরের সাথে অনুভূমিক এবং উল্লম্বভাবে সংযুক্ত থাকে।
  • আপনার প্রোগ্রামটি বৈধ ইনপুটগুলির সাথে কোনও ত্রুটি তৈরি করতে পারে না।
  • যদি ইনপুটটি বৈধ না হয় তবে আচরণটি সংজ্ঞায়িত এবং আপনি কোনও আউটপুট উত্পাদন করতে পারেন।
  • ইনপুটটিতে বাক্স অঙ্কনের অক্ষরগুলি সহ যে কোনও ইউটিএফ -8 অক্ষর থাকতে পারে।

আউটপুট:

  • -=|+সারণীর অংশ নয় এমন যে কোনও অক্ষর যেমন রয়েছে তেমনি রেখে দেওয়া উচিত ।
  • একইভাবে, অন্য কোনও অক্ষর যেমন রয়েছে তেমনি রেখে দেওয়া উচিত।
  • একটি একক শীর্ষস্থানীয় এবং / অথবা নতুন লাইন অনুমোদিত।

অন্য:

  • স্ট্যান্ডার্ড লুফোলগুলি যথারীতি নিষিদ্ধ।
  • যদি আপনার পছন্দের ভাষার কোনও বিল্ট-ইন থাকে যা এই সমস্যাটি সমাধান করে, আপনি এটি ব্যবহার করতে পারবেন না।
    • এর অর্থ এমন প্রোগ্রাম, ফাংশন, সাবরুটাইন বা নির্দেশাবলী যা এই চ্যালেঞ্জের জন্য কোনও সংযোজন ছাড়াই বৈধ সাবমিশন হবে।
  • এই চ্যালেঞ্জটিতে প্রয়োজনীয় প্রতিটি অক্ষর তিনটি বাইট দীর্ঘ হয় যখন তারা ইউটিএফ -8 এ এনকোড থাকে।

সংযুক্ত অক্ষর :

একটি চরিত্র অন্যটির সাথে সংযুক্ত থাকে, যদি:

  • এটি |সরাসরি এবং উপরে বা নীচে +বা |;
  • এটি -সরাসরি এবং আগে বা পরে +বা পরে -;
  • এটি =সরাসরি এবং আগে বা পরে +বা পরে =;
  • এটা +সরাসরি উপরে অথবা নিচে |বা +, বা আগে বা পরে সরাসরি -, =বা +।

একটি অক্ষরকে টেবিলের একটি অংশ হিসাবে বিবেচনা করা হয়, যদি এটি কোনও চরিত্রের সাথে সংযুক্ত থাকে যা টেবিলের একটি অংশ। সংজ্ঞা অনুসারে, +ইনপুটটিতে প্রথমটি সারণির একটি অংশ।

উদাহরণ

একটি অনুলিপি-গতযোগ্য সংস্করণ হিসাবে এখানে উদাহরণ উপলব্ধ ।

 Input:                    Output:
+------------------+      ┌──────────────────┐
|   Hello+World!   |      │   Hello+World!   │
+==================+      ╞══════════════════╡
| This is+my first |  ->  │ This is+my first │
|+-+ code|golf  +-+|      │+-+ code|golf  +-+│
|+-+chall|enge! +-+|      │+-+chall|enge! +-+│
+------------------+      └──────────────────┘

     +===+===+===+             ╒═══╤═══╤═══╕
     | 1 | 2 | 3 |             │ 1 │ 2 │ 3 │
 +---+===+===+===+         ┌───╪═══╪═══╪═══╡
 | 1 | 1 | 2 | 3 |         │ 1 │ 1 │ 2 │ 3 │
 +---+---+---+---+    ->   ├───┼───┼───┼───┤
 | 2 | 2 | 4 | 6 |         │ 2 │ 2 │ 4 │ 6 │
 +---+---+---+---+         ├───┼───┼───┼───┤
 |-3 |-3 |-6 |-9 |         │-3 │-3 │-6 │-9 │
 +===+---+---+---+         ╘═══╧───┴───┴───┘

      +-----+         ->      <Undefined>

      +-----+         ->      ┌─────┐
      +-----+                 └─────┘

+-----------------+
|  Hello, World!  |
| This is invalid |   ->      <Undefined>
|      input      |
 -----------------+

       ++++                      ┌┬┬┐
       ++++           ->         ├┼┼┤
       ++++                      └┴┴┘

       +--+
       ++++           ->      <Undefined>
       +--+

অবশেষে ...

এটি কোড-গল্ফ , তাই সর্বনিম্ন পরিমাণ বাইট জিততে পারে। শুভ গল্ফিং!

code-golf  ascii-art 
প্রথম উদাহরণে, পরের +-+অংশগুলি কেন সংযুক্ত টেবিল গঠনের জন্য বিবেচনা করা হয় না?
— পুনরাবৃত্তি
যদি কোনও 16-বিট ফাংশন represent উপস্থাপনের জন্য একটি একক বাইট ব্যবহার করে তবে বাইট গণনাটি কেমন?
— l4m2
@ রিসার্সিভ যদি আপনি প্রথম Hello Worldটেবিলটি বোঝাতে চান তবে অভ্যন্তরীণ সারণীগুলি একটি টেবিল গঠন হিসাবে বিবেচিত হবে না কারণ সারণীর অভ্যন্তরীণ পাঠ্যটি অবশ্যই অপরিবর্তিত থাকবে এবং সেগুলি সঠিকভাবে সংযুক্ত না হওয়ায় সেগুলি বাইরের সারণির সীমানার অংশ হিসাবে বিবেচিত হবে না।
আপনি যদি প্রথম +----+উদাহরণটি বোঝাতে চান তবে এটি হবে কারণ কোণগুলির দিকটি অস্পষ্ট হবে।
1
ওহ, "টেবিলের মধ্যে কোনও টেবিল না থাকলে যতক্ষণ না তারা বাহ্যতমতম সারণিকে প্রসারিত করতে সংযোগ করে" প্রয়োজনীয়তা এটিকে অনেক বেশি শক্ত করে তোলে।
— জোনাথন অ্যালান

উত্তর:

2

পাইথন 3, 392 281 বাইট

এটি বেশ খানিকটা গল্ফ করেছে এবং পুনরাবৃত্তির পরিবর্তে পুনরাবৃত্ত সমাধানে রূপান্তরিত হয়েছে:

def h(a):
 def g(i):
  k=-3;d=a[i]=='=';z[i]=''
  for p,j,r in zip((1,2,4,8),(i+1,i+w,i-1,i-w),('+-=','+|')*2):
   if 0<=j<len(a)and{a[i],a[j]}<={*r}:k+=p;d|=a[j]=='=';z[j]and g(j)
  z[i]="┌╒!!─═┐╕┬╤@@└╘││├╞┘╛┴╧┤╡┼╪"[2*k+d]
 w=a.find('\n')+1;z=[*a];g(a.find('+'))
 return''.join(z)

নিউলাইনগুলি দ্বারা বিভক্ত সমান দৈর্ঘ্যের সারিগুলির একটি স্ট্রিং নেয় এবং একই বিন্যাসে একটি স্ট্রিং প্রদান করে। অবৈধ ইনপুটটিতে একটি ব্যতিক্রম ফেলতে পারে।

পূর্ববর্তী সমাধান:

def h(a):
 i=a.find('+');q=[i];w=a.find('\n')+1;z=[*a]
 while q:
  i=q.pop();c=a[i];k=-5
  for p,j in enumerate((i+1,i-1,i+w,i-w)):
   r='++-|='[p>1::2]
   if 0<=j<len(a)and a[i]in r and a[j]in r:
    k+=1<<p;q+=[j][:z[j]<'─']
  z[i]='│'if c>'='else'─═'[a[i]>'-']if c>'+'else"┌╒┐╕┬╤@@└╘┘╛┴╧##├╞┤╡┼╪$$"['='in a[abs(i-1):i+2]::2][k]
 return''.join(z)

অবরুদ্ধ সংস্করণ:

def h(a):
    i = a.find('+')         # find index of first '+'. It is first node
    q = [i]                 # in the queue of indexes to convert to unicode
    w = a.find('\n')+1      # width of the table
    z = [*a]                # strings are immutable, so copy it to a list

    while q:                # while the queue isn't empty
        i=q.pop()           # get the next index to process
        c=a[i]              # and the associated character

        k=-5                # 'k' is the index into the unicode string, U.  The way they
                            # are encoded, the first unicode value is at index 5. 

                 # directions  E   W   S   N
        for p,j in enumerate((i+1,i-1,i+w,i-w)):  # j is the index of an adjacent cell

            # r='++-|='[p>1::2] is equivalent to:
            if p > 1:
                r = '+|'    # compatible symbols for vertical connections
            else:
                r = '+-='   # compatible symbols for horizontal connections

            # if adjacent cell index is valid and the characters are compatible
            if 0 <= j < len(a) and a[i] in r and a[j] in r:
                k += 1<<p                 # update the unicode symbol index

                # q += [j][:z[j]<'─'] is equivalent to:
                if z[j] < '-':            # if the adjacent cell hasn't been converted already
                    q.append(j)           #  append it's index to the queue

            if c > '=':
                z[i] = '│'                # replace a '|' with a '│'

            elif c > '+':
                z[i] = '─═'[a[i]>'-']     # replace a '-' or '=' with '─' or '═' respectively 

            else:                                      # it's a '+'
                U = "┌╒┐╕┬╤@@└╘┘╛┴╧##├╞┤╡┼╪$$"         # even indexes are single horizontal line, 
                                                       # double horizontal lines are at odd indexes

                z[i] = U['='in a[abs(i-1):i+2]::2][k]  # '='in a[abs(i-1):i+2] is true if there is an '=' to the left or right
                                                       # so this selects the odd chars from U
                                                       #  then [k] selects the correct char

 return''.join(z)
— RootTwo
সূত্র
3

পাইথন 3 , 914 898 827 823 594 587 569 540 469 বাইট

সম্পাদনা: কৌশলগতভাবে উল্লেখযোগ্যভাবে পরিবর্তন হয়েছে, এখন প্রতিবেশীদের একটি বিটফিল্ড তৈরি হয়েছে (মৃত-সম্ভাবনার উত্তরের মতো)। আমি নীচের আগের সংস্করণটি রেখে এসেছি।

H='─│═-|=└╘++++┌╒├╞++┘╛++┴╧┐╕┤╡┬╤┼╪'
def n(l):
 def j(r,c,t=0):O=(0,r-1,c),(1,r,c+1),(2,r+1,c),(3,r,c-1);v=f(r,c);b=t|any(f(Y,X)=='='for i,Y,X in O);l[r][c]={'+':H[b+2*sum((f(Y,X)in H)<<x for x,Y,X in O)],**dict(zip(H[3:6],H))}.get(v,v);[f(Y,X)!=';'and v in'+++-|='[i%2::2]and j(Y,X,v=='=')for i,Y,X in O]
 for i,I in enumerate(l):
  if'+'in I:f=lambda r,c:l[r][c]if len(l)>r>=0and 0<=c<len(l[r])else';';j(i,I.index('+'));break

এটি অনলাইন চেষ্টা করুন!

ইনপুট অক্ষরের তালিকাগুলির তালিকার আকারে রয়েছে, যা জায়গায় পরিবর্তিত হয়েছে। এটি প্রথম যেটি খুঁজে পায় তা থেকে পুনরাবৃত্তি ঘটে।

x=range
C='┌┐└┘','╒╕╘╛'
D='┬┤┴├','╤╡╧╞'
A='┼╪'
H,V,T='─│═'
J={'-':H,'|':V,'=':T}
K=C[1]+D[1]+A[1]+'='+T
E=('+|','+-=')*2
F=['+|'+V,'+-='+H+T]*2
O=(0,-1,0),(1,0,1),(2,1,0),(3,0,-1)
for i in x(4):
 for j in{0,1,2,3}-{i}:F[i+2&3]+=D[0][j]+D[1][j]
 h=C[0][i]+C[1][i];F[i&2]+=h;F[3-2*(i&1)]+=h
def n(l):
 for i,I in enumerate(l):
  if'+'in I:r=i;c=I.index('+');break
 else:return l
 def f(r,c):
  try:assert c>=0 and r>=0;return l[r][c]
  except:return'\0'
 def j(r,c):
  v=f(r,c)
  l[r][c]=J.get(v,v)
  if v=='+':
   X=[f(r+Y,c+X)for i,Y,X in O];B=any(x in K for x in X);X=[X[x]in F[x]for x in x(4)];L=sum(X)
   if L in(2,3,4):l[r][c]=D[B][X.index(False)]if L==3 else C[B][X[0]*2+X[3]]if L==2 else A[B]
  for i,Y,X in O:
   if v in E[i]and f(r+Y,c+X)in E[i]:j(r+Y,c+X)
 j(r,c);return l

এটি অনলাইন চেষ্টা করুন!

আমি একটি অলংগ সংস্করণ নিকটতম জিনিস এখানে:

def tr(s):
    t='┌┐└┘','╒╕╘╛'
    t2='┬┤┴├','╤╡╧╞'
    A = '┼','╪'
    H,V,T = '─│═'
    Th = ''.join(x[1]for x in (t,t2,A))+'='+T
    ps = ['+|'+V, '+-='+H+T, '+|'+V, '+-='+H+T]
    ps2 = ('+|', '+-=')*2
    for i in range(4):
        for j in {0,1,2,3}-{i}:
            ps[(i+2)%4] += t2[0][j]+t2[1][j]
        h=t[0][i] + t[1][i]
        ps[i & 2] += h
        ps[3 - 2 * (i & 1)] += h

    l = [list(x) for x in s.split('\n')]
    r = 0
    for i,I in enumerate(l):
        if'+'in I:
            r=i;c=I.index('+')
            break
    def g(r,c): return l[r][c]
    def G(r,c):
        if r >= 0 and r < len(l) and c >= 0 and c < len(l[r]):
            return g(r,c)
        return '\0'
    def process(r,c):
        v = g(r,c)
        if v == '-': l[r][c] = H
        elif v == '|': l[r][c] = V
        elif v == '=': l[r][c] = T
        elif v == '+':
            all=[G(r-1,c),G(r,c+1),G(r+1,c),G(r,c-1)]
            bold=any(x in Th for x in all)
            for i in range(4):all[i] = all[i] in ps[i]
            N,E,S,W=all
            tt=sum(all)
            if tt == 3:
                l[r][c]=t2[bold][all.index(False)]
            elif tt == 2:
                l[r][c]=t[bold][N*2+W]
            elif tt == 4:
                l[r][c]=A[bold]
            else: return
        for i,(dy,dx) in enumerate(((-1,0),(0,1),(1,0),(0,-1))):
            if v in ps2[i] and G(r+dy,c+dx) in ps2[i]:
                process(r+dy,c+dx)
    process(r,c)
    return l
— pbfy0
সূত্র
ক্ষুদ্র উন্নতি 9 বাইট সংরক্ষণ করতে (814 ডাউন) bit.ly/2NOu7HF
— mypetlion
অন্য 9 বাইট জন্য আরো কয়েকটি (805 এখন বাইটস) bit.ly/2pYom0x
— mypetlion
763-এ নামা
— mypetlion
1

জাভাস্ক্রিপ্ট, 311 307 বাইট

X=>(O=[...X],P=(I,j=0,_=0)=>!P[I]&&(P[I]=1,['-─1','|│','=═1'].map(([a,b,n=X.indexOf('\n')+1])=>[-n,+n].map(n=>{for(i=I;X[i+=n]==a;)O[i]=b
if(X[i]=='+')j|=[1,2,4,8,I-i>1&&17,i-I>1&&18][_],P(i)
_++})),O[I]='┘└┴ ┐┌┬ ┤├┼     ╛╘╧ ╕╒╤ ╡╞╪'[j-5]),P(X.indexOf`+`),O.join``)

কোড স্নিপেট দেখান

ব্যাখ্যা

প্রথম পাওয়া +জংশন থেকে শুরু করে , প্রোগ্রামটি প্রতিটি দিক থেকে অন্যান্য জংশনের পাথ অনুসন্ধান করার চেষ্টা করে, প্রতিস্থাপনগুলি যেমন চলছে তেমনই। এটি বিটম্যাপে প্রাপ্ত দিকনির্দেশ এবং "ডাবল-সীমান্তযুক্ত" স্টোর সংরক্ষণ করে, যা পরে উপযুক্ত জংশন চরিত্রটি নির্ধারণ করে।

// Take an input string X
f = X => {
    // Copy the input string into an array so characters can be overwritten and eventually output
    O = [...X]

    // Define a function that processes a junction ("+" symbol) at index I in the input string X:
    P = I => {
        // Make a bitmap to keep track of the direction coming out of the junction and double borders
        // Bits from right to left: west, east, north, south, double border
        // E.g. a double-bordered south/east junction corresponds to the binary number 11010 ("╒")
        let j = 0

        // A counter
        let _ = 0

        // Ensure this junction hasn't already been processed
        if(!P[I]){
            P[I] = 1,

            // We'll walk away from the junction in each of the four directions, then west and east again to check for double borders
            // i.e. walk along `a`, replace with `b`, move index `i` by `n`
            // 1st pass: walk along "-", replace with "─", move index by 1
            // 2nd pass: walk along "|", replace with "│", move index by the width of the input (plus 1 for the newline) to traverse vertically
            // 3rd pass: walk along "=", replace with "═", move index by 1
            ['-─1','|│','=═1'].map(([a, b, n = X.indexOf('\n') + 1])=>
                // We'll walk in the negative and positive directions for each pass
                [-n,+n].map(n=>{
                    // Start the walk
                    i=I
                    // Keep walking (incrementing by n) as long as we're on a "path" character, "a"
                    while(i += n, X[i] == a)
                        // Replace the corresponding character in the output with "b"
                        O[i] = b

                    // Upon reaching another junction at index i:
                    if(X[i] == '+'){
                        // OR the bitmap according to the direction we walked
                        j |= [
                            // Pass 1: Horizontal
                            1, // west
                            2, // east

                            // Pass 2: Vertical
                            4, // north
                            8, // south

                            // Pass 3: Double Horizontal (only if we've walked more than 1 step)
                            I-i > 1 && 17, // west, double border
                            i-I > 1 && 18 // east, double border
                        ][_]

                        // Process the junction we walked to
                        P(i)
                    }
                    _++
                })
            )

            // Finally, replace the "+" with a proper junction character based on the bitmap value
            O[I] = '     ┘└┴ ┐┌┬ ┤├┼     ╛╘╧ ╕╒╤ ╡╞╪'[j]
        }
    }

    // Process the first junction to kick off the recursion
    P(X.indexOf`+`)

    // Return our modified character array as a joined string
    return O.join``
}
— darrylyeo
সূত্র
স্থির - আমি অবশ্যই বাইট গণনা নয় চরিত্রের গণনা দেখেছি।
— darrylyeo
1

পাইথন 3 , 599 বাইট

আমি পাইথন 3 তে গল্ফ করাতে আসলেই ভাল নই, তবে (আমার লজ্জার বিষয়) আমি পাইথন 2-তে ইউটিএফ -8 অক্ষরের স্বাভাবিক আউটপুট পেতে পারি না So সুতরাং আমরা এখানে।

আমি অনুমান করি যে এখানে একমাত্র আকর্ষণীয় কৌশলটি +ট্রান্সফর্মেশনটির সিদ্ধান্ত নেওয়া।
আমি 4-বিট অ্যাড্রেস সহ সমস্ত সম্ভাব্য রূপগুলি এনকোড করেছি। প্রতিটি বিট অ্যাড্রেস নেটবার কক্ষে সংযোগের অনুরূপ। সুতরাং 0 - কোনও সংযোগ এবং 1 - সংযোগ নেই।
1111হয় ┼
0011হয় ┐
ইত্যাদি
সংযোগের কিছু কনফিগারেশনের অবৈধ এবং ডামি মান দিয়ে প্রতিস্থাপিত আছেন:'012┐45┌┬8┘0┤└┴├┼'

যদি কোনও নেটবার কক্ষ থাকে তবে =দ্বিতীয় তালিকা দ্বিগুণ রেখার সাথে ব্যবহৃত হবে।

['012┐45┌┬8┘0┤└┴├┼','012╕45╒╤8╛0╡╘╧╞╪']['='in r]

অ্যাড্রেস এখানে মিলিত হয়। 

r=''.join([str(int(V(y,x)))+W(y,x)for y,x in[(Y-1,X),(Y,X+1),(Y+1,X),(Y,X-1)]])

rস্ট্রিং দৈর্ঘ্য 8 রয়েছে, যেখানে প্রতি দুটি অক্ষর 1/0 এবং প্রকৃতপক্ষে নেত্রবার চর হয়।
উদাহরণস্বরূপ: 1+0y1-1|।
এটি আগের মতো বিকল্পগুলির তালিকা বাছাই করতে ব্যবহৃত হয়। এবং তারপরে অ্যাড্রেসে চুক্তিবদ্ধ:int(r[0::2],2)

এই কোষের স্থানাঙ্ক বৈধ এবং যাচাই করার জন্য ব্যবহৃত এই ল্যাম্বদাটি '+ - | =' এর মধ্যে একটি

V=lambda y,x:~0<x<len(I[0])and~0<y<len(I)and I[y][x]in'+-|='

এই ল্যাম্বদা সেল থেকে চর গ্রহণ করত। রিটার্নস ' 'যদি স্থানাঙ্ক অবৈধ। (অবশ্যই গল্ফ করা যেতে পারে)

W=lambda y,x:V(y,x)and I[y][x]or' '

পুনরাবৃত্তি জন্য শর্ত। গল্ফযোগ্য হতে পারে।

if Z in'+-=':F(Y,X+1);F(Y,X-1)
if Z in'+|':F(Y-1,X);F(Y+1,X)

I=eval(input())
J=[i[:]for i in I]
V=lambda y,x:~0<x<len(I[0])and~0<y<len(I)and I[y][x]in'+-|='
W=lambda y,x:V(y,x)and I[y][x]or' '
def F(Y,X):
 if V(Y,X)and I[Y][X]==J[Y][X]:
  Z=I[Y][X]
  if','>Z:
   r=''.join([str(int(V(y,x)))+W(y,x)for y,x in[(Y-1,X),(Y,X+1),(Y+1,X),(Y,X-1)]])
   J[Y][X]=['012┐45┌┬8┘0┤└┴├┼','012╕45╒╤8╛0╡╘╧╞╪']['='in r][int(r[0::2],2)]
  else:J[Y][X]=dict(zip('|-=','│─═'))[Z]
  if Z in'+-=':F(Y,X+1);F(Y,X-1)
  if Z in'+|':F(Y-1,X);F(Y+1,X)
e=enumerate
F(*[(y,x)for y,r in e(I)for x,c in e(r)if'+'==c][0])
for r in J:print(''.join(r))

এটি অনলাইন চেষ্টা করুন!

— ডেড পসুম
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.