Le caselle ASCII si presentano così:

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

Ecco alcuni esempi delle stesse caselle ASCII, implose:

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

Ecco un link a tutte queste caselle di test in un formato più facile da copiare. L'ordine è composto da tutti gli input seguiti da tutti gli output nello stesso ordine.

Il tuo obiettivo è prendere una casella ASCII come input e restituire la casella implosa. Le regole dell'implosione sono:

1. "+" non cambia mai; né "-" o "|" direttamente adiacente a "+"
2. A partire dagli angoli, il "-" e "|" spostarsi verso l'interno di uno spazio in più rispetto allo stesso personaggio più vicino all'angolo. Se un "-" e "|" si sposterebbe mai nello stesso punto, né si muove.
3. Se un "-" e "-" si spostano nello stesso punto, metti un "=" in quel punto. Se un "|" e "|" spostati nello stesso punto, metti un "in quel punto. Questi contano come due dei loro rispettivi personaggi nello stesso punto muovendosi in direzioni opposte.
4. Due "-" o due "|" possono spostarsi l'uno accanto all'altro, come mostrato nell'esempio in basso a sinistra.
5. Se la scatola è abbastanza magra, inizierà a espandersi verso l'esterno allo stesso modo, allontanandosi sempre dal lato da cui è iniziata parte.
6. Il risultato dovrebbe essere simmetrico lungo la linea centrale in entrambe le direzioni xey (ignorando le nuove linee); questo include gli spazi, quindi potrebbe essere necessario riempire il risultato di spazi per soddisfarlo.

Dettagli regola:

1. Questo è code-golf, quindi vince il programma più breve in byte.
2. Si applicano scappatoie standard.
3. Puoi presumere che ogni riga termini con un carattere di nuova riga.
4. Gli unici caratteri nella stringa di input saranno "+", "-", "|", "" e "\ n" (newline) e la stringa di output dovrebbe seguire le stesse regole, con l'aggiunta di "=" e "come possibili personaggi.
5. Opzionalmente potresti avere una sola nuova riga finale alla fine dell'ultima riga.
6. La casella ASCII più piccola che devi gestire è l'esempio in alto a sinistra. Ogni casella ASCII avrà esattamente 4 "+" s, esattamente ai suoi angoli.
7. Dovrai gestire caselle di dimensioni m x nper qualsiasi numero intero m,ntale 2<=m,n<256(la dimensione della stringa più grande possibile di 255*(255+1))
8. Puoi presumere che otterrai sempre una singola casella ASCII valida come input.

Python 2 , 591 555 545 527 525 496 436 351 334 333 303 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)

Provalo online!

EDIT : Il mio vecchio metodo prima implode in alto e in basso, quindi a sinistra e a destra. Invece, possiamo implodere la parte superiore, ruotare di 90 gradi e farlo 4 volte. Inoltre, stavo usando il codice intuitivo, questo richiede che l'input sia nella forma [['+', '-', '-', '-', '-', '-', '+'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['|', ' ', ' ', ' ', ' ', ' ', '|'], ['+', '-', '-', '-', '-', '-', '+']]brutta ma più breve per il programma: P (Grazie a Phoenix per averlo scoperto)

Riconoscimenti a Leaky Nun per il codice dell'intestazione nel collegamento TIO utilizzato per convertire input leggibili dall'uomo in input leggibili dal computer.

-85 byte grazie a Leaky Nun!
-17 byte passando da implosione superiore a implosione sinistra che consente di archiviare e modificare l'intera riga in una variabile. Grazie a Leaky Nun per il suggerimento!
-1 byte cambiando le cose per rimuovere uno spazio.
-30 byte grazie a Leaky Nun!

C (clang) , 693 byte

Nuove righe aggiunte per la leggibilità. I primi due sono richiesti ma il resto no.

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

Grazie per la grande sfida! È stato piuttosto complicato, ma mi sono comunque divertito molto.

Ciò accetta l'input come argomenti della riga di comando e restituisce a STDOUT una stringa a più righe della casella implosa. Come sempre, i consigli sul golf sono molto apprezzati.

Provalo online!