Pola ASCII wyglądają tak:

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

Oto kilka przykładów tych samych pól ASCII, implodowanych:

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

Oto link do wszystkich tych skrzynek testowych w łatwiejszym do kopiowania formacie. Kolejność obejmuje wszystkie dane wejściowe, a następnie wszystkie dane wyjściowe w tej samej kolejności.

Twoim celem jest wzięcie pola ASCII jako danych wejściowych i zwrócenie pola implodowanego. Zasady implozji są następujące:

1. „+” nigdy się nie zmienia; ani „-”, ani „|” bezpośrednio przylegające do „+”
2. Zaczynając od narożników, „-” i „|” przesuń się do środka o jedno pole więcej niż ta sama postać bliżej rogu. Jeśli „-” i „|” nigdy nie ruszyłby się w to samo miejsce, żaden ruch.
3. Jeśli „-” i „-” przesuną się w to samo miejsce, wstaw „=” w tym miejscu. Jeśli „|” i „|” przesuń się w to samo miejsce, umieść „w tym miejscu. Liczą się one jako dwie ich postacie w tym samym miejscu poruszające się w przeciwnych kierunkach.
4. Dwa „-” lub dwa „|” mogą przechodzić obok siebie, jak pokazano w lewym dolnym przykładzie.
5. Jeśli pudełko jest wystarczająco chude, zacznie się rozszerzać na zewnątrz w ten sam sposób, zawsze odsuwając się od strony, z której zaczął.
6. Wynik powinien być symetryczny wzdłuż linii środkowej w obu kierunkach xi y (ignorując znaki nowej linii); obejmuje to spacje, więc wynik może wymagać wypełnienia spacjami, aby to spełnić.

Szczegóły reguły:

1. To jest golf golfowy, więc wygrywa najkrótszy program w bajtach.
2. Obowiązują standardowe luki.
3. Możesz założyć, że każda linia kończy się znakiem nowej linii.
4. Jedynymi znakami w ciągu wejściowym będą „+”, „-”, „|”, „” i „\ n” (nowa linia), a ciąg wyjściowy powinien podlegać tym samym regułom, z dodaniem „=” i „jako możliwe znaki.
5. Opcjonalnie możesz mieć jeden końcowy znak nowej linii na końcu ostatniego wiersza.
6. Najmniejsze pole ASCII, które musisz obsłużyć, to lewy górny przykład. Każde pudełko ASCII będzie miało dokładnie 4 „+”, dokładnie w rogach.
7. Będziesz musiał obsługiwać pola wielkości m x ndla dowolnych liczb całkowitych, m,ntakich jak 2<=m,n<256(największy możliwy rozmiar ciągu 255*(255+1))
8. Możesz założyć, że zawsze dostaniesz jedno ważne pole ASCII jako dane wejściowe.

Python 2 , 591 555 545 527 525 496 436 351 334 333 303 bajtów

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)

Wypróbuj online!

EDYCJA : Moja stara metoda najpierw implodowała górę i dół, a następnie lewą i prawą. Zamiast tego możemy implodować górę, obrócić o 90 stopni i zrobić to 4 razy. Używałem również przyjaznego kodu, ten wymaga wprowadzenia danych w formie, [['+', '-', '-', '-', '-', '-', '+'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['+', '-', '-', '-', '-', '-', '+']]która jest brzydka, ale krótsza dla programu: P (Podziękowania dla Phoenix za złapanie tego)

Podziękowania dla Dziurawej Zakonnicy za kod nagłówka w łączu TIO używanym do konwersji danych czytelnych dla ludzi na dane czytelne dla komputera.

-85 bajtów dzięki Leaky Nun!
-17 bajtów poprzez zmianę z implozji od góry na implozję z lewej strony, co pozwala na przechowywanie całego wiersza w zmiennej i modyfikację. Dzięki Leaky Nun za sugestię!
-1 bajt, zmieniając rzeczy w celu usunięcia spacji.
-30 bajtów dzięki Leaky Nun!

C (clang) , 693 bajty

Dodano nowe wiersze dla czytelności. Pierwsze dwa są wymagane, ale pozostałe nie.

#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++);
}

Dzięki za wielkie wyzwanie! To było dość trudne, ale nadal dobrze się bawiłem.

Pobiera to dane wejściowe jako argumenty wiersza poleceń i dane wyjściowe do STDOUT ciągu wielu wierszy implodowanego pola. Jak zawsze, wskazówki dotyczące gry w golfa są bardzo mile widziane.

Wypróbuj online!