Các hộp ASCII trông như thế này:

++    +---+    +------+    +---+    +---+
++    |   |    |      |    |   |    |   |
      |   |    |      |    |   |    |   |
+-+   |   |    |      |    |   |    |   |
+-+   |   |    |      |    |   |    +---+
      +---+    |      |    |   |
+--+           |      |    |   |    ++
|  |           |      |    |   |    ||
|  |           +------+    |   |    ||
+--+                       |   |    ||
                           +---+    ||
                                    ||
                  +-----+           ||
+------------+    |     |           ++
|            |    |     |
|            |    |     |
+------------+    +-----+

Dưới đây là một số ví dụ về các hộp ASCII tương tự, được mã hóa:

++    +- -+    +-    -+    +- -+    +- -+
++    | - |    | -  - |    | - |    | - |
       | |      | -- |      | |      | |
+-+    | |       |  |        "      | - |
+-+   | - |       ||        | |     +- -+
      +- -+      |  |      |   |
+--+            | -- |      | |     ++
|  |           | -  - |      "      ||
|  |           +-    -+     | |     ||
+--+                       | - |   |  |
                           +- -+   |  |
      --                            ||
     -  -         +-   -+           ||
+-  -    -  -+    | - - |           ++
| --      -- |     | = |
| --      -- |    | - - |
+-  -    -  -+    +-   -+
     -  -
      --

Dưới đây là một liên kết đến tất cả các hộp trường hợp thử nghiệm này ở định dạng dễ sao chép hơn. Thứ tự là tất cả các đầu vào theo sau bởi tất cả các đầu ra theo cùng một thứ tự.

Mục tiêu của bạn là lấy một hộp ASCII làm đầu vào và trả lại hộp đã nổ. Các quy tắc của nổ là:

1. "+" không bao giờ thay đổi; không làm "-" hoặc "|" liền kề trực tiếp với "+"
2. Bắt đầu từ các góc, dấu "-" và "|" di chuyển vào bên trong bởi một không gian nhiều hơn cùng một nhân vật gần góc đã làm. Nếu một "-" và "|" sẽ không bao giờ di chuyển đến cùng một vị trí, không di chuyển.
3. Nếu "-" và "-" di chuyển đến cùng một vị trí, hãy đặt "=" vào vị trí đó. Nếu một "|" và "|" di chuyển đến cùng một vị trí, đặt một "vào vị trí đó. Chúng được tính là hai nhân vật tương ứng của chúng ở cùng một vị trí di chuyển theo hướng ngược lại.
4. Hai "-" hoặc hai "|" có thể di chuyển qua nhau, như được thấy trong ví dụ dưới cùng bên trái.
5. Nếu chiếc hộp đủ mỏng, nó sẽ bắt đầu mở rộng ra bên ngoài theo cùng một cách, luôn luôn di chuyển ra khỏi phía mà nó bắt đầu một phần.
6. Kết quả phải đối xứng qua đường trung tâm theo cả hai hướng x và y (bỏ qua các dòng mới); điều này bao gồm các khoảng trắng, vì vậy kết quả có thể cần được đệm bằng các khoảng trắng để đáp ứng điều đó.

Chi tiết quy tắc:

1. Đây là môn đánh gôn, vì vậy chương trình ngắn nhất tính bằng byte thắng.
2. Tiêu chuẩn áp dụng.
3. Bạn có thể giả sử mỗi dòng kết thúc bằng một ký tự dòng mới.
4. Các ký tự duy nhất trong chuỗi đầu vào sẽ là "+", "-", "|", "" và "\ n" (dòng mới) và chuỗi đầu ra của bạn phải tuân theo cùng quy tắc, với việc thêm "=" và "càng nhiều nhân vật càng tốt.
5. Bạn có thể tùy chọn có một dòng mới duy nhất ở cuối dòng cuối cùng.
6. Hộp ASCII nhỏ nhất bạn cần xử lý là ví dụ trên cùng bên trái. Mỗi hộp ASCII sẽ có chính xác 4 "+", chính xác tại các góc của nó.
7. Bạn sẽ cần xử lý các hộp có kích thước m x ncho bất kỳ số nguyên m,nnào 2<=m,n<256(kích thước chuỗi lớn nhất có thể 255*(255+1))
8. Bạn có thể giả sử rằng bạn sẽ luôn lấy một hộp ASCII hợp lệ làm đầu vào.

Python 2 , 591 555 545 527 525 496 436 351 334 333 303 byte

s=input()
w=len(s[0])
h=len(s)
V=max(0,w/2-h)
H=max(0,h/2-w)
p=[[' ']*w]*V
q=[' ']*H
s=[q+k+q for k in p+s+p]
d,c=' -=',' |"'
exec"c,d,V,H,w,h=d,c,H,V,h,w;s=map(list,zip(*s))[::-1]\nfor j in range(h-4):q=s[V+j+2];q[H]=c[q[H]==c[2]];r=H+min(j+1,h-4-j);q[r]=c[1+(q[r]>' ')]\n"*4
for x in s:print''.join(x)

Hãy thử trực tuyến!

EDIT : Phương pháp cũ của tôi trước tiên làm nổ tung đỉnh và đáy, rồi sang trái và phải. Thay vào đó, chúng ta có thể nổ tung đỉnh, xoay 90 độ và làm điều đó 4 lần. Ngoài ra, tôi đang sử dụng mã thân thiện với người dùng, mã này yêu cầu đầu vào ở dạng [['+', '-', '-', '-', '-', '-', '+'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['+', '-', '-', '-', '-', '-', '+']]xấu nhưng ngắn hơn cho chương trình: P (Cảm ơn Phoenix vì đã nắm bắt được điều đó)

Tín dụng cho Leaky Nun cho mã tiêu đề trong liên kết TIO được sử dụng để chuyển đổi đầu vào có thể đọc được của con người thành đầu vào có thể đọc được trên máy tính.

-85 byte nhờ Leaky Nun!
-17 byte bằng cách chuyển từ nổ trên cùng sang nổ trái, cho phép toàn bộ hàng được lưu trữ thành một biến và được sửa đổi. Cảm ơn Leaky Nun cho lời đề nghị!
-1 byte bằng cách chuyển đổi mọi thứ xung quanh để loại bỏ một khoảng trắng.
-30 byte nhờ Leaky Nun!

C (tiếng kêu) , 693 byte

Dòng mới được thêm vào để dễ đọc. Hai cái đầu được yêu cầu nhưng phần còn lại thì không.

#define P B[i][l]
#define m malloc(8)
I(B,h,V,S,J,Z,i,j,l,n,H,W,c,C,a,z,_,L,G,u,N,M)char**B,**Z;char*L,*G,*u;{
V=strlen(B[0]);
S=J=0;
Z=m;
for(i=0,j=h-1;i<h/2+h%2;i++,j--){
for(l=0,n=V-1;l<V/2+V%2;l++,n--){
if(P!=43&&((B[i][l-1]!=43&&i<1)||(B[i-1][l]!=43&&l<1))){
H=P==45;
W=P=='|';
P=B[j][l]=B[i][n]=B[j][n]=32;
if(H){
c=(N=i+l-1)==(M=j-l+1)?61:45;
if(M<0)L=m,sprintf(L,"%*s",V,""),L[l]=L[n]=c,Z[J]=L,J++;
else B[N][l]=B[N][n]=B[M][l]=B[M][n]=c;
}
if(W){
c=(N=l+i-1)==(M=n-i+1)?34:'|';
if(M<0)G=m,sprintf(G,"|%*s%s%*s|",i-n-2,"",B[i],i-n-2,""),B[i]=B[j]=G,S++;
else B[i][N]=B[j][N]=B[i][M]=B[j][M]=c;
}
}
}
}
for(a=-J+1;a<=h+J;u=a<1?Z[-a]:a<=h?B[a-1]:Z[a-h-1],C=S+1-strlen(u)/2,printf("%*s%s\n",C>0?C:0,"",u),a++);
}

Cảm ơn những thách thức tuyệt vời! Nó khá khó khăn nhưng tôi vẫn có rất nhiều niềm vui.

Điều này nhận đầu vào là đối số dòng lệnh và đầu ra cho STDOUT một chuỗi nhiều dòng của hộp được mã hóa. Như mọi khi, mẹo chơi golf được đánh giá rất cao.

Hãy thử trực tuyến!