एक ASCII कला तालिका को UTF-8 तालिका में बदलें

Question

जब मैं प्रलेखन, टिप्पणियाँ, आदि लिखता हूँ तो मुझे ASCII टेबल बनाना बहुत पसंद है। वे आम तौर पर बहुत अच्छे दिखते हैं, लेकिन मुझे हमेशा लगता है कि वे और भी बेहतर दिख सकते हैं - खासकर यूटीएफ -8 / यूनिकोड में बॉक्स ड्रॉइंग कैरेक्टर शामिल हैं । हालांकि, इन पात्रों का उपयोग करने के लिए बहुत महत्वपूर्ण हैं, कई प्रमुख प्रेस डालने की आवश्यकता होती है। आपका कार्य? एक प्रोग्राम या एक फ़ंक्शन लिखें जो स्वचालित रूप से ASCII तालिकाओं को UTF-8 / यूनिकोड समकक्ष में बदल सकता है।

इस चुनौती को सैंडबॉक्स किया गया था ।

चुनौती

एक प्रोग्राम लिखें, जिसमें एक इनपुट स्ट्रिंग के रूप में ASCII तालिका दी गई है, यूनिकोड / UTF-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)

विवरण

मैं / हे:

• डिफ़ॉल्ट I / O की अनुमति है
• आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं, जिसमें एक स्ट्रिंग के रूप में तालिका, या तालिका युक्त फ़ाइल का पथ शामिल है।
• आप किसी फ़ाइल पर आउटपुट कर सकते हैं और अतिरिक्त तर्क के रूप में फ़ाइल का नाम ले सकते हैं।
  • हालाँकि, आप इनपुट फ़ाइल को संशोधित नहीं कर सकते हैं । (इसे भविष्य के संपादन में आसानी के लिए रखा जाना चाहिए)

इनपुट:

• आप मान सकते हैं कि इनपुट की प्रत्येक पंक्ति को उसी लंबाई के साथ गद्देदार किया गया है ।
• आप यह नहीं मान सकते हैं कि एक नई पंक्ति के बाद पहला चरित्र तालिका सीमाओं का एक हिस्सा है (जैसा कि यह व्हाट्सएप हो सकता है)।
• इनपुट को एक वैध तालिका माना जाता है यदि सभी वर्ण (जो तालिका का एक हिस्सा -=|हैं ) बिल्कुल दो वर्णों +से जुड़े होते हैं और क्षैतिज और लंबवत दोनों प्रकार के कम से कम एक वर्ण से जुड़े होते हैं।
• आपका प्रोग्राम मान्य इनपुट के साथ कोई त्रुटि उत्पन्न नहीं कर सकता है।
• यदि इनपुट मान्य नहीं है तो व्यवहार अपरिभाषित है और आप किसी भी उत्पादन का उत्पादन कर सकते हैं।
• इनपुट में कोई भी यूटीएफ -8 अक्षर शामिल हो सकते हैं, जिसमें बॉक्स ड्राइंग वर्ण भी शामिल हैं।

आउटपुट:

• कोई भी वर्ण -=|+जो तालिका का हिस्सा नहीं है, उसे छोड़ दिया जाना चाहिए।
• इसी तरह, किसी भी अन्य वर्ण को छोड़ दिया जाना चाहिए-जैसा है।
• एक अग्रणी और / या अनुगामी न्यूलाइन की अनुमति है।

अन्य:

• मानक खामियों को मना किया जाता है, हमेशा की तरह।
• यदि आपकी पसंदीदा भाषा में एक अंतर्निहित है जो इस समस्या को हल करता है, तो आप इसका उपयोग नहीं कर सकते हैं।
  • इसका मतलब है कि कार्यक्रम, कार्य, सबरूटीन्स या निर्देश जो बिना किसी अतिरिक्त के इस चुनौती के लिए मान्य प्रस्तुतियाँ होंगे।
• इस चुनौती में आवश्यक प्रत्येक वर्ण तीन बाइट्स लंबा होता है जब वे UTF-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>
       +--+

आखिरकार...

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतता है। हैप्पी गोल्फिंग!

Comments

पहले उदाहरण में, निरंतर +-+अंश को कनेक्टेड टेबल बनाने के लिए क्यों नहीं माना जाता है?

— पुनरावर्ती

अगर एक 16-बिट फ़ंक्शन ╡ का प्रतिनिधित्व करने के लिए एक एकल बाइट का उपयोग करता है, तो बाइट कैसे गिना जाता है?

— l4m2

@recursive यदि आपका मतलब पहली Hello Worldतालिका से है, तो इनर टेबल को टेबल नहीं माना जाता है क्योंकि टेबल के अंदर का टेक्स्ट अपरिवर्तित रहना चाहिए, और उन्हें बाहरी टेबल सीमाओं का हिस्सा नहीं माना जाता है क्योंकि वे उनसे ठीक से जुड़े नहीं हैं।

यदि आप पहले +----+उदाहरण का मतलब है , यह होगा क्योंकि कोनों की दिशा अस्पष्ट होगी।

ओह, "तालिकाओं के भीतर कोई तालिकाओं जब तक वे सबसे बाहरी संभव तालिका का विस्तार करने के लिए कनेक्ट नहीं करते हैं" आवश्यकता इसे बहुत कठिन बना देती है।

— जोनाथन एलन

Answer 1

पायथन 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)

Ungolfed संस्करण:

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)

Answer 2

पायथन 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

Comments

9 बाइट्स बचाने के लिए मामूली सुधार (814 से नीचे) bit.ly/2NOu7HF

— mypetlion

कुछ और 9 बाइट्स के लिए अधिक (805 बाइट्स अब) bit.ly/2pYom0x

— mypetlion

नीचे 763: bit.ly/2OxErsJ

— mypetlion

Answer 3

जावास्क्रिप्ट, 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``)

f=
X=>(W=X.indexOf('\n')+1,O=[...X],P=(I,j=0,_=0)=>!P[I]&&(P[I]=1,['-─1','|│','=═1'].map(([a,b,n=W])=>[-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``)


console.log(
f(
`+------------------+
|   Hello+World!   |
+==================+
| This is+my first |
|+-+ code|golf  +-+|
|+-+chall|enge! +-+|
+------------------+`
))

console.log(
f(
`     +===+===+===+
     | 1 | 2 | 3 |
 +---+===+===+===+
 | 1 | 1 | 2 | 3 |
 +---+---+---+---+
 | 2 | 2 | 4 | 6 |
 +---+---+---+---+
 |-3 |-3 |-6 |-9 |
 +===+---+---+---+`
))

console.log(
f(
`+-----+
+-----+`))

console.log(
f(
`++++
++++
++++`))

व्याख्या

पहले पाया +जंक्शन पर शुरू , कार्यक्रम हर दिशा में अन्य जंक्शनों के लिए रास्ता खोजने का प्रयास करता है, प्रतिस्थापन को प्रदर्शन करता है जैसा कि यह जाता है। यह पाया गया दिशाओं और "डबल-बॉर्डर" स्थिति को एक बिटमैप में संग्रहीत करता है, जो तब उचित जंक्शन चरित्र को निर्धारित करता है।

// 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``
}

Comments

फिक्स्ड - मैंने कैरेक्टर काउंट देखा होगा न कि बाइट काउंट।

— darrylyeo

Answer 4

पायथन 3 , 599 बाइट्स

मैं पायथन 3 में गोल्फिंग में वास्तव में अच्छा नहीं हूं, लेकिन (मेरी शर्म की बात है) मैं Python 2 में UTF-8 वर्णों का सामान्य उत्पादन प्राप्त नहीं कर सका। इसलिए यहां हम हैं।

मुझे लगता है कि यहां केवल दिलचस्प चाल है जो कि +विरूपण का निर्णय ले रही है ।
मैंने 4-बिट एड्रेन्स के साथ सभी संभावित वेरिएंट्स को एनकोड किया है। प्रत्येक बिट एड्रेस नेथबोर सेल से जुड़ता है। तो 0 - कोई कनेक्शन नहीं और 1 - कनेक्शन।
1111is ┼
0011is ┐
etc
कनेक्शन के कुछ विन्यास अमान्य हैं और उन्हें डमी मानों से बदल दिया गया है:'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)]])

r8 स्ट्रिंग स्ट्रिंग शामिल हैं, जहां हर दो वर्ण 1/0 और वास्तविक neightbour चार हैं।
उदाहरण के लिए 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))

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