Ich habe irgendwo gehört, dass eine Sache, die die Technologie noch nicht kann, das Falten von Handtüchern _{1 ist} . Es ist nun Ihre Aufgabe, diese Aussage als falsch zu beweisen!

Wenn Sie eine Zeichenfolge als Eingabe verwenden, die aus Rechtecken (Handtüchern) besteht, falten Sie jedes Handtuch zweimal in zwei Hälften. Beispielsweise:

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

Beachten Sie, dass ein gefaltetes Handtuch zuerst gefaltet wird und dann von links nach rechts. Ihr Programm muss dieses Verhalten ebenfalls nachahmen. Beachten Sie auch, dass in den Testfällen die Handtücher an derselben Stelle bleiben, aber gefaltet sind.

Regeln:

• Standardmethoden für die Eingabe / Ausgabe.
• Es gelten Standardlücken.
• Eingabe und Ausgabe sollten als Zeichenfolge erfolgen.
• Schleppende Whatever sind in der Ausgabe in Ordnung, solange die Handtücher im richtigen Verhältnis zueinander stehen.
• Sie können davon ausgehen, dass die Länge jeder Seite des Handtuchs immer durch 2 teilbar ist.
• Die als Eingabe übergebenen Handtücher sind immer rechteckig.

• Die Handtücher werden immer getrennt - sie können jedoch durch unterschiedliche Beträge getrennt werden.

• Code-Golf , also gewinnt der kürzeste Code!

Testfälle:

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




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

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


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

Output:

   +-+
   | |
   +-+

        +

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

_{1: Dies wurde von Geobits und Laikoni widerlegt. Ich habe es jedoch irgendwo gehört.}

Retina , 245 Bytes

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

Probieren Sie es online!

Hinweis: Einige Zeilen enden in Leerzeichen. Erläuterung:

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

Löschen Sie jede zweite Zeile von jedem Handtuch (dies funktioniert, weil alle Handtücher gleich hoch sind),

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

verschiebe alle abgetrennten Handtuchstücke nach oben,

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

und befestigen Sie den Boden der Handtücher und falten Sie sie effektiv zusammen.

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

Falten Sie die Handtücher der Breite 2 nach rechts.

(?!\+ )     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

Falten Sie die restlichen Handtücher nach rechts.

Oktave mit Bildpaket , 277 272 Bytes

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

Eingabe und Ausgabe sind 2D-Zeichen-Arrays.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle: 1 , 2 , 3 , 4 . (Beachten Sie, dass endfunctionin den Testfällen nur die Funktion vom nachfolgenden Code getrennt werden muss. Dies ist nicht erforderlich, wenn die Funktion in einer eigenen Datei gespeichert ist.)

Lesbare Version und Erklärung

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