Dada una cadena que está potencialmente encuadrada, alterna la casilla. Esto se vuelve más claro en los casos de prueba y la explicación.

De entrada y salida

Formato de entrada

La entrada será una sola cadena separada por CR, LF o CRLF, o una lista de cadenas. El formato de entrada depende de usted para decidir.

Formato de salida

El formato de salida debe estar en el mismo formato que la entrada.

Explicación + Ejemplo

Tomemos una cadena en caja como ejemplo:

+-------------+
|Hello, World!|
+-------------+

Para alternar el cuadro, eliminamos la primera y última fila y la primera y última columna. Puede suponer que no habrá espacios en blanco finales después de la última línea (con una nueva línea final opcional al final de la última línea), y que no habrá espacios en blanco finales en ninguna línea, sin contar la nueva línea, por supuesto.

Esto se convertiría en:

Hello, World!

La otra manera

Si la cadena no está en un cuadro, agréguele un cuadro. Esto es bastante simple; anteponer+---...---+ su propia línea con kguiones donde kes la longitud de la línea más larga y luego, para cada línea, rellene con espacios en blanco finales para que coincida con la longitud de la línea más larga y luego anteponga y agregue un carácter de tubería ( "|"). Finalmente, agregue una línea que contenga la misma +---...---+configuración que la primera línea.

Por ejemplo:

Hello, World!

se convierte en:

+-------------+
|Hello, World!|
+-------------+

Puede suponer que ninguna de las líneas en la entrada tendrá espacios en blanco al final.

Otro ejemplo de una cadena que debería tener un cuadro alrededor:

Hello,
    World!

se convierte

+----------+
|Hello,    |
|    World!|
+----------+

Un ejemplo de algo que aún debe encuadrarse:

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

se convierte en:

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

Reglas + Especificaciones

• Se aplican lagunas estándar
• Ninguna línea de entrada tendrá espacios en blanco iniciales o finales tanto en general como en cada línea, independientemente de si se ha encuadrado o no en
• Las cajas solo tendrán +como esquinas y |para los bordes verticales y -para los lados horizontales.
• Una caja debe tener sus ventajas en su lugar para ser considerada una caja; si tiene alto o ancho 2 (es decir, sin contenido), aún debe estar sin caja, lo que daría lugar a un montón de nuevas líneas, dependiendo de la altura del cuadro.
• Si la entrada tiene un cuadro pero texto fuera del cuadro, todo debe estar encuadrado.
• Su programa debe verificar todo el perímetro de la cadena. Si un solo carácter en el exterior no es correcto (ya sea un carácter faltante o diferente de lo que debería ser), entonces debe estar encuadrado, no sin encuadrar.
• La cadena sin caja en sí puede contener + | -. Si la cadena sin caja tiene un cuadro alrededor, devuelva la cadena con la caja; solo debe desempacarse una vez.

Casos de borde

1: cajas pequeñas

Entrada:

++
++

La salida es una línea vacía o nueva

Entrada:

+----+
+----+

La salida está vacía o una nueva línea

Entrada:

++
||
||
++

La salida es de 2 líneas nuevas o 3 líneas nuevas

2: caja parcial

Entrada:

+-------+
| Hello |
+ ------+

Salida:

+---------+
|+-------+|
|| Hello ||
|+ ------+|
+---------+

3: Texto fuera del cuadro

Entrada:

 +-------+
a| Hello |
 +-------+

Salida:

+----------+
| +-------+|
|a| Hello ||
| +-------+|
+----------+

JavaScript (ES2017), 199 bytes

s=>/^\+-*\+\n(\|.*\|\n)*\+-*\+$/.test(s,s=s.split`
`,s.map(z=>z[y]?y=z.length:0,y=0))?s.slice(1,-1).join`
`.replace(/.(.*)./g,"$1"):(x=`+${'-'.repeat(y)}+`)+`
|${s.map(z=>z.padEnd(y)).join`|
|`}|
`+x

La ingenua solución. Puede o no ser el mejor, ya veremos ...

SOGL V0.12 , 72 bytes

2-┌* +1Ο;2-⁴┌@ŗΖ+|ŗ∙⁴++B
▓Aa1w⁄;lGB╬8a⁰I{_=}¹χ?ajk{jk}⁰←a1w⁄;l2+G2+B00╬5

Pruébalo aquí!

+7 bytes ( ⁰I{_=}¹χ) porque elementwise es igual no está implementado
+1 byte ( ▓) porque no se garantiza que la entrada sea cuadrada
+1 byte ( A) para mí ser flojo y no implementar entradas escritas (por lo que esto espera entrada en la pila. facilidad de uso, el enlace en línea incluye → para que se pueda usar el cuadro de entrada)

Jalea , 46 bytes

ẋ2jЀ
z©⁶”|çZṖ”-çµḢ⁾-+yWWçWẎZ
ḊṖZḊṖÇ
Ỵ®2ĿÇ⁼$?Y

Pruébalo en línea!

Retina , 197 195 bytes

+m`^((.)*)(¶(?<-2>.)*(?(2)$|(.)))
$1$#4$* $3$#2$* 
%`^|$
|
^.(.*).
+$.1$*-+¶$&
.(.*).$
$&¶+$.1$*-+
^(\+-*\+)¶(\|\+-*\+\|)¶(\|\|.*\|\|¶)*\2¶\1$
¶$&¶
..(.*)..(?=(.|¶)*¶$)
$1
^¶-*¶-*¶|(\G|¶)-*¶-*¶$

Pruébalo en línea! Explicación:

+m`^((.)*)(¶(?<-2>.)*(?(2)$|(.)))
$1$#4$* $3$#2$* 

Esta etapa es bastante complicada en sí misma, así que la desglosaré un poco. +significa que la etapa se repite hasta que no se puedan encontrar más reemplazos. m`^significa que la etapa coincide al comienzo de cualquier línea. ((.)*)luego coincide con toda la línea. Ahora $1es simplemente la línea coincidente, pero $2es una lista de coincidencias, es decir, caracteres. (¶luego coincide con el final de la línea y, por lo tanto, el comienzo de la siguiente línea. (?<-2>.)*usa un grupo de equilibrio .NET. Los <-2>partidos elimina de $2tanto tiempo como un personaje puede ser igualada en la segunda línea. En este punto, puede suceder una de tres cosas:

• No había suficientes personajes en la segunda línea. $2Todavía le quedan algunos partidos.
• Las dos líneas tenían exactamente la misma longitud. $2no le quedan partidos, y estamos al final de la línea.
• La segunda línea es más larga, por lo que queda al menos un carácter.

(?(2)$|(.)))Ayuda a distinguir estos utilizando una condición. Si $2aún quedan algunas coincidencias, necesitamos que esto se deba a que la segunda línea es demasiado corta, por lo que coincidimos con el final de la línea, pero si $2no quedan coincidencias, entonces queremos que la segunda línea sea más larga, por lo que coincidimos un personaje (que entra $4para que sepamos que ocurrió el partido). De lo contrario, las dos líneas tienen la misma longitud y la coincidencia falla en este punto (podría coincidir nuevamente en una línea posterior, por supuesto).

La cadena de reemplazo es $1$#4$* $3$#2$*. El $#4evalúa 1si coincidimos con un carácter adicional en la segunda línea, 0si no. Esto significa que $#4$*agrega un espacio a la primera línea si la segunda línea era más larga. Del mismo modo $#2$*agrega espacios a la segunda línea si la primera línea era más larga. (De hecho, termina agregando exactamente el número correcto de espacios. Si solo estuviéramos equilibrando dos líneas, se +podría haber agregado al cuarto grupo de captura para lograr esto directamente para el caso de la segunda línea más larga también).

El resultado de todo esto es que esta etapa rellena la entrada en un rectángulo. Ahora podemos dibujar un cuadro a su alrededor.

%`^|$
|

Coloque |s a cada lado.

^.(.*).
+$.1$*-+¶$&

Colocar +-...-+en la parte superior.

.(.*).$
$&¶+$.1$*-+

Y de nuevo en la parte inferior.

^(\+-*\+)¶(\|\+-*\+\|)¶(\|\|.*\|\|¶)*\2¶\1$
¶$&¶

Vea si hemos creado una caja doble. Si es así, se agregan líneas en blanco adicionales en la parte superior e inferior para que las etapas restantes coincidan para eliminar ambos cuadros.

..(.*)..(?=(.|¶)*¶$)
$1

Si hay una línea en blanco al final, elimine dos caracteres del inicio y el final de cada línea.

^¶-*¶-*¶|(\G|¶)-*¶-*¶$

Si hay una línea en blanco inicial, elimínela y las siguientes dos líneas (que serán las -s restantes en la parte superior del cuadro). Si hay una línea en blanco al final, elimínela y las dos líneas anteriores. Se (\G|¶)trata del caso en el que solo hay seis líneas (y, por lo tanto, 5 ¶s) porque la caja no tenía contenido.