Étant donné une chaîne potentiellement encadrée, basculez la boîte. Cela devient plus clair dans les cas de test et l'explication.

Entrée sortie

Format d'entrée

L'entrée sera soit une seule chaîne séparée par CR, LF ou CRLF, soit une liste de chaînes. Le format d'entrée est à vous de décider.

Format de sortie

Le format de sortie doit être au même format que l'entrée.

Explication + exemple

Prenons une chaîne encadrée comme exemple:

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

Pour basculer la case, nous supprimons la première et la dernière ligne et la première et la dernière colonne. Vous pouvez supposer qu'il n'y aura aucun espace de fin après la dernière ligne (avec un retour à la ligne facultatif à la fin de la dernière ligne), et aucun espace de fin sur aucune ligne, sans compter le retour à la ligne bien sûr.

Cela deviendrait:

Hello, World!

L'autre côté

Si la chaîne n'est pas dans une boîte, ajoutez-y une boîte. C'est assez simple; ajouter +---...---+sur sa propre ligne avec des ktirets où kest la longueur de la ligne la plus longue, puis pour chaque ligne, le remplir avec des espaces de fin pour correspondre à la longueur de la ligne la plus longue, puis ajouter et ajouter un caractère de tuyau ( "|"). Enfin, ajoutez une ligne contenant la même +---...---+configuration que la première ligne.

Par exemple:

Hello, World!

devient:

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

Vous pouvez supposer qu'aucune des lignes de l'entrée n'aura d'espace blanc de fin.

Un autre exemple de chaîne qui devrait contenir une boîte:

Hello,
    World!

devient

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

Un exemple de quelque chose qui devrait encore être encadré:

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

devient:

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

Règles + spécifications

• Les échappatoires standard s'appliquent
• Aucune ligne d'entrée ne comportera d'espaces de début ou de fin à la fois globalement et sur chaque ligne, qu'elle ait ou non été encadrée
• Les boîtes n'auront que +leurs coins et |pour les bords verticaux et -pour les côtés horizontaux.
• Une boîte doit avoir ses avantages en place pour être considérée comme une boîte; s'il a une hauteur ou une largeur 2 (c'est-à-dire aucun contenu), il doit toujours être déballé, ce qui entraînerait un tas de nouvelles lignes, selon la hauteur de la boîte.
• Si l'entrée a une boîte mais du texte en dehors de la boîte, le tout doit être encadré.
• Votre programme doit vérifier tout le périmètre de la chaîne. Si un seul caractère à l'extérieur n'est pas correct (soit un caractère manquant ou différent de ce qu'il devrait être), alors il doit être encadré et non déballé.
• La chaîne non mise en boîte elle-même peut contenir + | -. Si la chaîne non encadrée elle-même a une boîte autour d'elle, renvoyez la chaîne avec la boîte; il ne doit être déballé qu'une seule fois.

Étuis Edge

1: Petites boîtes

Contribution:

++
++

La sortie est un vide ou une nouvelle ligne

Contribution:

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

La sortie est vide ou une nouvelle ligne

Contribution:

++
||
||
++

La sortie est 2 nouvelles lignes ou 3 nouvelles lignes

2: Boîte partielle

Contribution:

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

Production:

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

3: Texte à l'extérieur de la boîte

Contribution:

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

Production:

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

JavaScript (ES2017), 199 octets

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 solution naïve. Que ce soit ou non le meilleur, on verra ...

SOGL V0.12 , 72 octets

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

Essayez-le ici!

+7 octets ( ⁰I{_=}¹χ) car élément par égal à n'est pas implémenté
+1 octet ( ▓) car l'entrée n'est pas garantie carrée
+1 octet ( A) pour moi étant paresseux et n'implémentant pas d'entrées typées (donc cela attend l'entrée sur la pile. Pour facilité d'utilisation, le lien en ligne inclut → pour que la boîte de saisie puisse être utilisée)

Gelée , 46 octets

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

Essayez-le en ligne!

Rétine , 197 195 octets

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

Essayez-le en ligne! Explication:

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

Cette étape est assez compliquée en soi, je vais donc la décomposer un peu. +signifie que l'étape se répète jusqu'à ce qu'aucun autre remplaçant ne soit trouvé. m`^signifie que l'étape correspond au début d'une ligne. ((.)*)correspond alors à toute la ligne. Il $1s'agit maintenant simplement de la ligne correspondante, mais d' $2une liste de correspondances, c'est-à-dire de caractères. (¶correspond alors à la fin de la ligne et donc au début de la ligne suivante. (?<-2>.)*utilise un groupe d'équilibrage .NET. Le <-2>supprime les correspondances à partir du $2moment où un caractère peut être mis en correspondance sur la deuxième ligne. À ce stade, l'une des trois choses suivantes peut se produire:

• Il n'y avait pas assez de caractères sur la deuxième ligne. $2il reste encore quelques matchs.
• Les deux lignes avaient exactement la même longueur. $2n'a plus de matchs et nous sommes en fin de ligne.
• La deuxième ligne est plus longue, il reste donc au moins un caractère.

(?(2)$|(.)))permet de les distinguer à l'aide d'une condition. S'il $2reste encore des correspondances, alors nous avons besoin que ce soit parce que la deuxième ligne est trop courte, donc nous correspondons à la fin de la ligne, mais s'il $2n'y a plus de correspondance, alors nous voulons que la deuxième ligne soit plus longue, donc nous correspondons un personnage (qui entre $4pour que nous sachions que le match a eu lieu). Sinon, les deux lignes sont de la même longueur et la correspondance échoue à ce stade (elle peut correspondre à nouveau ultérieurement, bien sûr).

La chaîne de remplacement est $1$#4$* $3$#2$*. L' $#4évalue 1si nous avons trouvé un caractère supplémentaire sur la deuxième ligne, 0sinon. Cela signifie que cela $#4$*ajoute un espace à la première ligne si la deuxième ligne était plus longue. De même, $#2$*ajoute des espaces à la deuxième ligne si la première ligne était plus longue. (En fait, cela finit par ajouter exactement le bon nombre d'espaces. Si nous n'avions équilibré que deux lignes, un +aurait pu être ajouté au quatrième groupe de capture pour y parvenir directement pour le cas de la deuxième ligne plus longue également.)

Le résultat de tout cela est que cette étape remplit l'entrée dans un rectangle. Nous pouvons maintenant dessiner une boîte autour d'elle.

%`^|$
|

Placez |s de chaque côté.

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

Placer +-...-+sur le dessus.

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

Et encore une fois en bas.

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

Voyez si nous avons créé une double boîte. Si c'est le cas, des lignes vierges supplémentaires sont ajoutées en haut et en bas pour que les étapes restantes correspondent pour supprimer les deux cases.

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

S'il y a une ligne vide de fin, supprimez deux caractères au début et à la fin de chaque ligne.

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

S'il y a une première ligne vierge, supprimez-la ainsi que les deux lignes suivantes (qui seront les -s restants en haut de la boîte). S'il y a une ligne vide de fin, supprimez-la ainsi que les deux lignes précédentes. Il (\G|¶)s'agit du cas où il n'y a que six lignes (et donc 5 ¶s) car la boîte n'avait pas de contenu.