J'ai entendu quelque part qu'une chose que la technologie ne peut pas encore faire est de plier les serviettes ₁ . C'est maintenant à vous de prouver que cette affirmation est fausse!

Étant donné une chaîne en entrée, composée de rectangles (serviettes), comme ci-dessous, pliez chaque serviette en deux deux fois. Par exemple:

+------+    +------+        +--+
|      |    |      |        |  |
|      |    |      |        |  |
|      | -> +------+ ->     +--+
|      |    
|      |    
|      |    
+------+    

Notez que lorsqu'une serviette est pliée, elle est d'abord pliée, puis de gauche à droite. Votre programme doit également imiter ce comportement. Notez également que dans les cas de test, les serviettes restent au même endroit, mais pliées.

Règles:

• Méthodes standard d'entrée / sortie.
• Des échappatoires standard s'appliquent.
• L'entrée et la sortie doivent être sous forme de chaîne.
• Les feuilles de queue sont correctes en sortie, tant que les serviettes sont au bon endroit les unes par rapport aux autres.
• Vous pouvez supposer que la longueur de chaque côté de la serviette sera toujours divisible par 2.
• Les serviettes passées en entrée seront toujours rectangulaires.

• Les serviettes seront toujours séparées - cependant, elles peuvent être séparées par des quantités variables.

• code-golf , donc le code le plus court gagne!

Cas de test:

Input:
+------+
|      |
|      |
|      |
|      |
|      |
|      |
+------+
Output:
    +--+
    |  |
    |  |
    +--+




Input:
+--+ +--+ +--+
|  | |  | |  |
|  | |  | |  |
+--+ +--+ +--+

Output:
  ++   ++   ++
  ++   ++   ++


Input:
+----+
|    |
|    |
|    |
|    | ++
+----+ ++

Output:

   +-+
   | |
   +-+

        +

Input:
+--+
+--+     ++
         ||
         ||
         ++
Output:
  ++
          +
          +

_{1: Cela a été réfuté par Geobits et Laikoni. Cependant, je l'ai entendu quelque part.}

Rétine , 245 octets

m1+`^((.)*(?!\+ )[+|]([- ])*[+|].*¶(?<-2>.)*)([+|][- ]*[+|])
$1$.4$* 
m+`^((.)*) ( *) (.*¶(?<-2>.)*)(?(2)(?!))\|\3\|
$1|$3|$4 $3 
m+`^((.)*)\|( *)\|(?=.*¶(?<-2>.)*(?(2)(?!)) )
$1+$.3$*-+
([+|])\1
 $1
(?!\+ )([+|])([- ])\2(\2*)\3\1
$.3$*   $1$3$1

Essayez-le en ligne!

Remarque: certaines lignes se terminent par des espaces. Explication:

m1+`                    Repeatedly search from the beginning of input
    ^((.)*              Optional indentation
      (?!\+ )           Towel does not start with a plus and a space
      [+|]([- ])*[+|]   A row of towel
      .*¶               Rest of the line
      (?<-2>.)*         Some indentation on the next line
     )
     ([+|][- ]*[+|])    Another row of towel
$1$.4$*                 Replace the second row with blanks

Supprimez toutes les autres lignes de chaque serviette (cela fonctionne car toutes les serviettes ont une même hauteur),

m+`             Repeatedly search
   ^((.)*)      Optional indentation
    ( *)        Find some space
    (.*¶        Rest of the line
     (?<-2>.)*) Matching indentation on the next line
    (?(2)(?!))  Ensure that the indentation exactly matches
    \|\3\|      Piece of towel
$1|$3|$4 $3     Swap the piece into the space above

déplacer toutes les pièces de serviettes détachées,

m+`                 Repeatedly search
   ^((.)*)          Optional indentation
    \|( *)\|        Piece of towel
    (?=             Followed by
       .*¶          Rest of the line
       (?<-2>.)*    Matching indentation on the next line
       (?(2)(?!))   Ensure that the indentation exactly matches
        )           Nothing on the next line
$1+$.3$*-+          Change the piece into a towel bottom

et fixez le bas des serviettes, en les pliant efficacement.

([+|])\1    Match a row of towel of width 2, which is just ++ or ||
 $1         Change the first column to a space, which folds it

Pliez les serviettes de largeur 2 vers la droite.

(?!\+ )     Towel does not start with a plus and a space
([+|])      Start with a + or a |
([- ])\2    Then at least two -s or spaces
(\2*)\3     Then an even number of -s or spaces
\1          Then another + or |
$.3$*       Replace the left half with spaces
$1$3$1      Replace the first character of the right half

Pliez les serviettes restantes vers la droite.

Octave avec paquet d'images , 277 272 octets

function x=f(x)
[i,j,v]=find(bwlabel(x-32));a=@(w)accumarray(v,w,[],@max);r=-a(-i);R=a(i);s=-a(-j);S=a(j);x(:)=32;for k =1:nnz(r)
u=(r(k)+R(k)-1)/2;v=(s(k)+S(k)+1)/2;p=v:S(k);x(r(k),p)=45;x(u,p)=45;q=r(k):u;x(q,v)=124;x(q,S(k))=124;x(u,[v S(k)])=43;x(r(k),[v S(k)])=43;end

L'entrée et la sortie sont des tableaux de caractères 2D.

Essayez-le en ligne! Ou vérifiez tous les cas de test: 1 , 2 , 3 , 4 . (Notez que endfunctiondans les cas de test, il suffit de séparer la fonction du code suivant. Ce n'est pas nécessaire si la fonction est enregistrée dans son propre fichier.)

Version et explication lisibles

function x = f(x)
[i,j,v] = find(bwlabel(x-32)); % make background equal to 0 by subtracting 32.
% Then label each connected component (i.e. towel) with a unique integer
% Then get row indices (i) and column indices (j) of nonzero values (v)
a = @(w)accumarray(v,w,[],@max); % helper function. Gives the maximum of w for
% each group given by an integer label in v
r = -a(-i); % upper coordinate of each towel (minimum row index)
R = a(i); % lower coordinate of each towel (maximum row index)
s = -a(-j); % left coordinate of each towel (minimum column index)
S = a(j); % right coordinate of each towel (maximum column index)
x(:) = 32; % remove all towels: fill x with spaces
for k = 1:nnz(r) % for each original towel: create the new, folded towel 
    u = (r(k)+R(k)-1)/2; % new lower coordinate
    v = s(k)+S(k)+1)/2; % new left coordinate
    p = v:S(k); % column indices of horizontal edges
    x(r(k),p) = 45; % fill upper horizontal edge with '-'
    x(u,p) = 45; % fill lower horizontal edge with '-'
    q = r(k):u; % row indices of vertical edges
    x(q,v) = 124; % fill left vertical edge with '|'
    x(q,S(k)) = 124; % fill right vertical edge with '|'
    x(u,[v S(k)]) = 43; % fill lower corners with '+'
    x(r(k),[v S(k)]) = 43; % fill upper corners with '+'
end