เมื่อฉันเขียนเอกสารความคิดเห็น ฯลฯ ฉันชอบทำตาราง ASCII พวกเขามักจะจบลงดูสวยดี แต่ฉันมักจะรู้สึกว่าพวกเขาจะดูดียิ่งขึ้น - โดยเฉพาะอย่างยิ่งตั้งแต่ UTF-8 / Unicode รวมถึงตัวละครกล่องวาดภาพ อย่างไรก็ตามตัวละครเหล่านี้มีภาระที่ต้องใช้งานเป็นอย่างมากทำให้ต้องใช้การกดปุ่มหลายครั้งในการแทรก งานของคุณ? เขียนโปรแกรมหรือฟังก์ชั่นที่สามารถแปลงตาราง ASCII โดยอัตโนมัติให้เทียบเท่ากับ UTF-8 / Unicode

ความท้าทายนี้ได้รับการทดลองใช้ผลิตภัณฑ์

ท้าทาย

เขียนโปรแกรมที่ให้ตาราง ASCII เป็นสตริงอินพุตเอาต์พุตตารางที่วาดใหม่ด้วยอักขระการวาดกล่อง Unicode / 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:

• อนุญาตให้ใช้I / O เริ่มต้น
• คุณสามารถป้อนข้อมูลในรูปแบบที่เหมาะสมรวมถึงตารางเป็นสตริงหรือเส้นทางไปยังไฟล์ที่มีตาราง
• คุณสามารถส่งออกไปยังไฟล์และใช้ชื่อไฟล์เป็นอาร์กิวเมนต์เพิ่มเติม
  • อย่างไรก็ตามคุณไม่สามารถแก้ไขไฟล์อินพุตได้ (ควรเก็บไว้เพื่อความสะดวกในการแก้ไขในอนาคต)

การป้อนข้อมูล:

• คุณอาจจะสมมติว่าอินพุตทุกแถวมีความยาวเท่ากัน
• คุณไม่สามารถสันนิษฐานได้ว่าตัวอักษรตัวแรกหลังจากขึ้นบรรทัดใหม่เป็นส่วนหนึ่งของเส้นขอบตาราง (เนื่องจากอาจเป็นช่องว่าง)
• อินพุตถือว่าเป็นตารางที่ถูกต้องหากอักขระทั้งหมด (ที่เป็นส่วนหนึ่งของตาราง) -=|เชื่อมต่อกับอักขระสองตัวและ+เชื่อมต่อกับอักขระอย่างน้อยหนึ่งตัวทั้งแนวนอนและแนวตั้ง
• โปรแกรมของคุณอาจไม่สร้างข้อผิดพลาดใด ๆ กับอินพุตที่ถูกต้อง
• หากอินพุตไม่ถูกต้องพฤติกรรมจะไม่ได้กำหนดและคุณอาจสร้างเอาต์พุตใด ๆ
• อินพุตอาจมีอักขระ UTF-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>
       +--+

สุดท้าย ...

นี่คือโค้ดกอล์ฟดังนั้นจำนวนไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ มีความสุขในการเล่นกอล์ฟ!

Python 3, 392 281 ไบต์

Golfed มันค่อนข้างมากและแปลงเป็นโซลูชันแบบเรียกซ้ำแทนที่จะเป็นแบบวนซ้ำ:

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)

Python 3 , 914 898 827 823 594 587 569 540 469 ไบต์

แก้ไข: กลยุทธ์ที่มีการเปลี่ยนแปลงอย่างมีนัยสำคัญตอนนี้สร้าง bitfield ของเพื่อนบ้าน (คล้ายกับคำตอบของผู้ตาย) ฉันออกจากรุ่นก่อนหน้านี้ด้านล่าง

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

JavaScript, 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(
`++++
++++
++++`))

คำอธิบาย

เริ่มต้นที่+จุดเชื่อมต่อที่พบครั้งแรกโปรแกรมจะพยายามค้นหาเส้นทางไปยังทางแยกอื่น ๆ ในทุกทิศทางโดยดำเนินการแทนที่ตามที่ไป จะเก็บทิศทางที่พบและสถานะ "double-bordered" ในบิตแมปซึ่งจะกำหนดอักขระการเชื่อมต่อที่เหมาะสม

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

Python 3 , 599 ไบต์

ฉันไม่ค่อยเก่งเรื่องการเล่นกอล์ฟใน Python 3 แต่ (เพราะความอับอายของฉัน) ฉันไม่สามารถรับ UTF-8 chars แบบธรรมดาได้ใน Python 2 ดังนั้นเราอยู่ที่นี่

ฉันเดาว่าเคล็ดลับที่น่าสนใจเพียงอย่างเดียวที่นี่คือการตัดสินใจ+เปลี่ยนรูปแบบ
ฉันเข้ารหัสตัวแปรที่เป็นไปได้ทั้งหมดด้วย adresses 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)]])

rมีความยาวของสตริง 8 ซึ่งทุก ๆ สองตัวอักษรเป็น 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))

ลองออนไลน์!