Dada uma sequência potencialmente encaixotada, alterne a caixa. Isso fica mais claro nos casos de teste e explicação.

Entrada / Saída

Formato de entrada

A entrada será uma única sequência separada por CR, LF ou CRLF ou uma lista de sequências. Você decide o formato de entrada.

Formato de saída

O formato de saída deve estar no mesmo formato que a entrada.

Explicação + Exemplo

Vamos pegar uma string em caixa como um exemplo:

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

Para alternar a caixa, removemos a primeira e a última linha e a primeira e a última coluna. Você pode assumir que não haverá espaço em branco à direita após a última linha (com uma nova linha à direita opcional no final da última linha) e nenhum espaço em branco à direita em nenhuma linha, sem contar a nova linha, é claro.

Isso se tornaria:

Hello, World!

O outro jeito

Se a sequência não estiver em uma caixa, adicione uma caixa a ela. Isso é bastante simples; faça um prefixo +---...---+em sua própria linha com ktraços onde kestá o comprimento da linha mais longa e, em seguida, para cada linha, preencha-o com espaço em branco à direita para corresponder ao comprimento da linha mais longa e, em seguida, adicione e acrescente um caractere de barra vertical ( "|"). Por fim, acrescente uma linha contendo a mesma +---...---+configuração da primeira linha.

Por exemplo:

Hello, World!

torna-se:

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

Você pode assumir que nenhuma das linhas na entrada terá espaços em branco à direita.

Outro exemplo de uma string que deve ter uma caixa colocada ao seu redor:

Hello,
    World!

torna-se

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

Um exemplo de algo que ainda deve estar em caixa:

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

torna-se:

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

Regras + Especificações

• As brechas padrão se aplicam
• Nenhuma linha de entrada terá espaços em branco à esquerda ou à direita, em geral e em cada linha, independentemente de ter sido encaixotada
• As caixas terão apenas +cantos, |bordas verticais e -horizontais.
• Uma caixa deve ter suas vantagens no lugar para ser considerada uma caixa; se tiver altura ou largura 2 (ou seja, sem conteúdo), ainda deverá estar fora da caixa, o que resultaria em várias linhas de nova linha, dependendo da altura da caixa.
• Se a entrada tiver uma caixa, mas o texto estiver fora da caixa, a coisa toda deve ser encaixotada.
• Seu programa deve verificar todo o perímetro da sequência. Se um único caractere do lado de fora não estiver correto (ausente ou com um caractere diferente do que deveria ser), ele deve estar na caixa, não na caixa.
• A própria sequência sem caixa pode conter + | -. Se a própria string sem caixa tiver uma caixa ao redor, retorne a string com a caixa; ele deve ser retirado da caixa de seleção apenas uma vez.

Casos Edge

1: caixas pequenas

Entrada:

++
++

A saída é uma linha vazia ou uma nova linha

Entrada:

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

A saída está vazia ou uma nova linha

Entrada:

++
||
||
++

A saída é de 2 novas linhas ou 3 novas linhas

2: Caixa Parcial

Entrada:

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

Resultado:

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

3: Texto fora da caixa

Entrada:

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

Resultado:

+----------+
| +-------+|
|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

A solução ingênua. Pode ou não ser o melhor, vamos ver ...

SOGL V0.12 , 72 bytes

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

Experimente aqui!

+7 bytes ( ⁰I{_=}¹χ) porque elemently igual não é implementado
+1 byte ( ▓) porque não é garantido que a entrada seja quadrada de
+1 byte ( A) por eu ser preguiçoso e por não implementar entradas digitadas (por isso, espera entrada na pilha. facilidade de uso, o link on-line inclui → para que a caixa de entrada possa ser usada)

Gelatina , 46 bytes

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

Experimente online!

Retina , 197 195 bytes

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

Experimente online! Explicação:

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

Esse estágio é bastante complicado por si só, então eu vou detalhar um pouco. +significa que o estágio se repete até que não sejam encontradas mais substituições. m`^significa que o estágio coincide com o início de qualquer linha. ((.)*)então coincide com a linha inteira. Agora $1é simplesmente a linha correspondente, mas $2é uma lista de correspondências, ou seja, caracteres. (¶depois coincide com o final da linha e, portanto, com o início da próxima linha. (?<-2>.)*usa um grupo de balanceamento .NET. As <-2>remove jogos de $2contanto que um personagem pode ser compensada na segunda linha. Neste ponto, uma das três coisas pode acontecer:

• Não havia caracteres suficientes na segunda linha. $2ainda tem alguns jogos restantes.
• As duas linhas tinham exatamente o mesmo comprimento. $2não tem correspondências restantes, e estamos no final da linha.
• A segunda linha é mais longa, então há pelo menos um caractere restante.

(?(2)$|(.)))ajuda a distingui-los usando uma condição. Se $2ainda houver algumas correspondências restantes, precisamos que isso seja porque a segunda linha é muito curta, portanto, correspondemos ao final da linha, mas se $2não houver correspondências restantes, queremos que a segunda linha seja mais longa, portanto, correspondemos um personagem (que entra $4para que saibamos que a partida aconteceu). Caso contrário, as duas linhas terão o mesmo comprimento e a correspondência falhará nesse ponto (ela poderá corresponder novamente mais tarde).

A cadeia de substituição é $1$#4$* $3$#2$*. Os $#4avaliada como 1se nós combinamos um carácter adicional na segunda linha, 0se não. Isso significa que $#4$*adiciona um espaço à primeira linha se a segunda linha for maior. Da mesma forma, $#2$*adiciona espaços à segunda linha se a primeira linha for mais longa. (De fato, acaba adicionando exatamente o número certo de espaços. Se estivéssemos equilibrando apenas duas linhas, um +poderia ter sido adicionado ao quarto grupo de captura para obter isso diretamente também no caso da segunda linha mais longa.)

O resultado disso é que esse estágio preenche a entrada em um retângulo. Agora podemos desenhar uma caixa em torno dela.

%`^|$
|

Coloque |s de cada lado.

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

Coloque +-...-+no topo.

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

E novamente no fundo.

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

Veja se criamos uma caixa dupla. Nesse caso, linhas em branco extras são adicionadas na parte superior e inferior para os estágios restantes corresponderem e excluir as duas caixas.

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

Se houver uma linha em branco à direita, remova dois caracteres do início e do fim de cada linha.

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

Se houver uma linha em branco à esquerda, exclua-a e as próximas duas linhas (que serão as -restantes na parte superior da caixa). Se houver uma linha em branco à direita, exclua-a e as duas linhas anteriores. Os (\G|¶)lida com o caso em que há apenas seis linhas (e, portanto, 5 ¶s) porque a caixa não tinha conteúdo.