Jemand hat die Weihnachtsgeschenke hastig gestapelt, und es ist ein ziemliches Durcheinander:

           ========================
           |                      |
           ========================
     =============
     |           |
     |           |
     |           |
     |           |
     |           |
     |           |
     =============
        =======
        |     |
        |     |
        |     |
        =======
  ===================
  |                 |
  |                 |
  |                 |
  ===================
=================
|               |
|               |
|               |
|               |
=================
   =======
   |     |
   |     |
   =======

Im Ernst, wie präsentiert dieses Top das Gleichgewicht? Es ist wahrscheinlich ein Hammer. Um zu verhindern, dass dieser Turm aus Geschenken zusammenbricht, müssen Sie die Geschenke neu anordnen, damit sie gut gestapelt werden:

        =======
        |     |
        |     |
        =======
        =======
        |     |
        |     |
        |     |
        =======
     =============
     |           |
     |           |
     |           |
     |           |
     |           |
     |           |
     =============
   =================
   |               |
   |               |
   |               |
   |               |
   =================
  ===================
  |                 |
  |                 |
  |                 |
  ===================
========================
|                      |
========================

Die Regeln

• Jedes Geschenk besteht aus einem oberen und unteren =Zeichenbereich und einer oder mehreren mittleren Reihen, die aus zwei |durch Leerzeichen getrennten Zeichen bestehen . Die Breite der Gegenwart ist in allen Reihen gleich.
• Es sind keine Leerzeilen vorhanden.
• Aufeinanderfolgende Geschenke überlappen sich in mindestens einer Spalte.
• Geschenke sind in abnehmender Reihenfolge zu stapeln. Bei einem Unentschieden sollte das größere Geschenk unter das flachere Geschenk fallen.
• Geschenke sollten auf die darunter liegende Gegenwart zentriert sein. Wenn das Geschenk nicht genau in der Mitte platziert werden kann (weil der Breitenunterschied ungerade ist), können Sie eine der beiden Positionen wählen, die ein halbes Zeichen von der Mitte entfernt sind.
• Sie können davon ausgehen, dass die Eingabe eine einzelne nachgestellte Zeile enthält, geben Sie jedoch Ihre Annahme an.
• Ihre Lösung muss nicht für eine leere Eingabe funktionieren, sondern muss in der Lage sein, ein einzelnes Geschenk zu verarbeiten.
• Sie können ein Programm oder eine Funktion schreiben, die Eingaben über STDIN oder ein Funktionsargument entgegennimmt und das Ergebnis zurückgibt oder an STDOUT ausgibt.
• Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

CJam, 81 70 Bytes

'"qN/{__Sm0=#>}%N*"=
="/"=\"\"="*'"++~]$_W='=/,f{1$'=/,m4/\N/\f{S*\N}}

Also müssen wir die Weihnachtsgeschenke stapeln? Dieser Code macht es so, wie es eine tatsächliche Person tun würde ^* .

Zuerst stapeln wir alle Geschenke gegen eine Wand, um sie mit diesem Code leicht auf und ab zu bewegen:

'"qN/{__Sm0=#>}%N*

Dann identifizieren wir jedes Geschenk als einen separaten Gegenstand unter Verwendung dieses Codes:

"=
="/"=\"\"="*'"++~]

Dann sortieren wir die Geschenke anhand ihrer Höhe und Breite mit diesem Code:

$

Bis jetzt wurden alle Geschenke gegen eine Wand gestapelt, um eine perfekte Ausrichtung zueinander zu erreichen. Aber da dies Weihnachten ist, möchten wir die Geschenke zentriert wie einen Weihnachtsbaum platzieren! Dieser Code macht das:

_W=Af{1$Am4/\N/\f{S*\N}}

Hier ist eine schrittweise Ausgabe des Codes zum Beispiel in der Frage:

"Step 1 - Stack the presents against a wall";
========================
|                      |
========================
=============
|           |
|           |
|           |
|           |
|           |
|           |
=============
=======
|     |
|     |
|     |
=======
===================
|                 |
|                 |
|                 |
===================
=================
|               |
|               |
|               |
|               |
=================
=======
|     |
|     |
=======

"Step 2 - Identify the presents as a collection of presents";
["========================
|                      |
========================" "=============
|           |
|           |
|           |
|           |
|           |
|           |
=============" "=======
|     |
|     |
|     |
=======" "===================
|                 |
|                 |
|                 |
===================" "=================
|               |
|               |
|               |
|               |
=================" "=======
|     |
|     |
======="]

"Step 3 - Sort on height & width, with presents stacked against a wall to help sort them";
=======
|     |
|     |
=======
=======
|     |
|     |
|     |
=======
=============
|           |
|           |
|           |
|           |
|           |
|           |
=============
=================
|               |
|               |
|               |
|               |
=================
===================
|                 |
|                 |
|                 |
===================
========================
|                      |
========================

"Final step - stack them like a Christmas Tree";
        =======
        |     |
        |     |
        =======
        =======
        |     |
        |     |
        |     |
        =======
     =============
     |           |
     |           |
     |           |
     |           |
     |           |
     |           |
     =============
   =================
   |               |
   |               |
   |               |
   |               |
   =================
  ===================
  |                 |
  |                 |
  |                 |
  ===================
========================
|                      |
========================

Probieren Sie es hier online aus

_{* Kann sich jedoch von Person zu Person unterscheiden: P}

Japt , 18 Bytes

mx óÈíY b'=²Ãn c û

Probieren Sie es online!

Ich benutze eine ausreichend andere Strategie als die andere Japt-Antwort, die ich für eine eigene Antwort wert hielt. Nimmt Ein- und Ausgabe als Array von Zeilen

Erläuterung:

mx                    #Trim leading whitespace from each line
   ó        Ã         #Split the array between lines where:
    ÈíY               # The lines interleaved (e.g. "abc","def" => "adbecf")
        b'=²          # starts with "=="
             n        #Default sorting for "array of arrays of strings"
               c      #Flatten to a single array of lines
                 û    #Pad each line so they are centered

Ich weiß nicht genau, warum "Standardsortierung" so funktioniert, aber ich habe getestet, dass sich das größere Kästchen der beiden mit der gleichen Breite unten befindet, unabhängig davon, welches in der Eingabe zuerst kommt.

Rubin, 164

Ordentliche Herausforderung! Konnte es nicht viel weiter runterholen.

f=->x{y=x.scan(/\s+=+[\s|]+\s+=+/).sort_by{|p|-p.count(?|)}.sort_by{|p|p.count ?=}
y.map{|p|p.gsub(/^\s+/,'').each_line{|l|puts l.strip.center(y[-1].count(?=)/2)}}}

Erläuterung

Die Eingabe Stringwird in Arrayein Element zerlegt, in dem jedes Vorhandene ein Element ist. Dann wird das Array nach der Anzahl der Pipe-Zeichen und erneut nach der Anzahl der Gleichheitszeichen sortiert .

Anschließend werden alle führenden Leerzeichen entfernt und jede Zeile einzeln gedruckt, zentriert um die Breite des größten Geschenks.

Es verhält sich mit oder ohne abschließende Zeilenumbrüche in der Eingabe gleich.

Lesbare Version

f = lambda do |x|
  y = x.scan(/\s+=+[\s|]+\s+=+/)
       .sort_by { |p| -p.count("|") }
       .sort_by { |p|  p.count("=") }

  y.map do |p|
    p.gsub(/^\s+/,'').each_line do |l|
      puts l.strip.center(y.last.count("=") / 2 )
    end
  end
end

05AB1E , 23 20 Bytes

|ðδÛ»…=
=…=0=:0¡{».c

-3 Bytes dank @ErikTheOutgolfer .

Probieren Sie es online aus.

Erläuterung:

|         # Take the input split by newlines
 ðδÛ      # Remove leading spaces from each line
    »     # And join everything back together again with a newline delimiter
…=
=         # Push string "=\n="
 …=0=     # Push string "=0="
     :    # Replace all "=\n=" with "=0="
0¡        # Now split on "0"
          # (We now have our list of presents without any leading spaces)
  {       # Sort this list (with default string-wise sorting)
   »      # Join the list of presents by newlines
    .c    # Left-focused centralize the string (and output implicitly)

Anmerkungen:

• Geschenke mit ungerader Breite werden zentral nach links fokussiert. Dies kann durch Ändern des nachgestellten Kleinbuchstabens cin einen Großbuchstaben auf rechts eingestellt werden C.
• Das Leading |kann weggelassen werden, wenn wir die Eingabe als Liste von String-Zeilen annehmen dürfen.
• Angenommen, die Eingabe enthält keine nachgestellten Leerzeichen für Geschenke (ähnlich wie die Eingabe in der Herausforderungsbeschreibung). nachgestellte Zeilenumbrüche sind in Ordnung, da die |sowieso entfernt werden.

Attache , 91 Bytes

Join&lf@{Center&#(_@-1@0)@>_}@{SortBy[&{#_'#__},Strip@>Lines=>Split[_,/"(?<==)\\s+(?==)"]]}

Probieren Sie es online!

Ungolfed

?? returns [length of first entry, number of entries]
revDim := &{#_'#__}

?? regex
SPLIT_ON_BARRIERS := /"(?<==)\\s+(?==)"

splitPresents[str] := (
    chopped .= Split[str, SPLIT_ON_BARRIERS];;
    normalized .= Strip @> Lines => chopped
)

orderPresents[presents] :=
    SortBy[revDim, presents]

fixPresents[ordered] := (
    ?? number of columns of bottom-most present
    pad_size .= Size[Last[ordered][0]];;
    ?? center each line of each present
    Center&pad_size @> _
)

joinNewlines := Join&lf

stackPresents := joinNewlines@fixPresents@orderPresents@splitPresents

Perl 5 -n0 , 123 Bytes

sub k{pop=~y/=//}say s+^\s*+$"x((k($p[-1])- k$_)/4)+rmge for@p=sort{k($a)- k$b||$a=~y/|//-$b=~y/|//}/\s*(=+[| 
]+\s*\=+)/gs

Probieren Sie es online!

Python 2 , 221 196 Bytes

s,a,b,i=[c.strip()for c in input().split("\n")]+["="],[],[],0
exec"a+=[s[i].center(max(map(len,s)))]\nif s[i][0]==s[i+1][0]=='=':b+=[a];a=[]\ni+=1;"*(len(s)-1)
for c in sorted(b):print"\n".join(c)

Probieren Sie es online!

Erwartet eine Zeichenfolge in Anführungszeichen, ohne Zeilenumbrüche als Eingabe zu verfolgen.

Nicht großartig, aber es ist das Beste, was ich tun kann.

Japt , 23 20 19 Bytes

Ähnliches Vorgehen wie bei Kevins Lösung . Das erste Byte kann entfernt werden, wenn die Eingabe als Array von Zeilen erfolgen kann.

·mx ·r¥¬·È·Ãq, n ·û

Versuch es

·mx ·r¥¬·È·Ãq, n ·û     :Implicit input of string
·                       :Split on newlines
 m                      :Map
  x                     :  Trim
    ·                   :Join with newlines
     r                  :Global replace
      ¥                 :  Shortcut for the == operator. Passing an operator as the first argument of a method in Japt implicitly converts it to a string
       ¬                :  Split
        ·               :  Join with newlines, giving the string "=\n=" to be replaced
         È              :  Pass each match through a function
          ·             :    Split on newlines. As we're working within a string, the resulting array gets cast to a string (i.e., "=\n=" -> ["=","="] -> "=,="
           Ã            :End replace
            q,          :Split on ","
               n        :Sort
                 ·      :Join with newlines
                  û     :Centre pad each line with spaces to the length of the longest

Javascript 279 Bytes 275 Bytes

Ich bin ein Anfänger im Code-Golf und kein Experte für Javascript, aber die Herausforderung ist interessant und macht Spaß. Ich würde gerne sehen, welche Tricks ein echter Experte in Js anwenden würde.

Annahmen

• Input und Output sind Arrays von Strings
• Keine leeren Zeilen
• Die Höhe einer Box beträgt <= 99 Zeilen (disqualifiziert mich dies)?
• Eingabe- und Ausgabevariablen sind vordefiniert, wobei die Ausgabe anfänglich ein leeres Array ist

Code

Eingang ist in g[]. Ausgabe in m[].

a=[];s='';b=0;c=0;o=[];g.forEach((t,x)=>{t=t.trim(),c=Math.max(c,t.length);o.push(t);if(s==''){s=t;b=x}else{if(t==s){a.push({"K":s.length*100+x-b,"O":o});s='';o=[]}}});a.sort((p,q)=>{return p.K-q.K});a.forEach((t)=>{t.O.forEach((q)=>{m.push(" ".repeat((c-q.length)/2)+q)})});

Der Code funktioniert von

1. Erstellen eines Arrays von Objekten, wobei jedes Objekt eine Box darstellt, mit zwei Elementen: K, wobei ein Sortierschlüssel die (Breite x 100 + Höhe) und O ist, ein Array der (abgeschnittenen) Zeichenfolgen, aus denen die Box besteht. Während der Erstellung des Arrays merkt sich der Code die Breite der breitesten Box.

2. Die Anordnung der Box-Objekte wird nach dem Schlüssel K sortiert. Wenn die Boxen die gleiche Breite haben, wird durch den Schlüssel sichergestellt, dass sie nach der Höhe sortiert sind.

3. Nach dem Sortieren der Felder werden die Zeichenfolgen für jedes Feld in das Ausgabearray verschoben, wobei führende Leerzeichen hinzugefügt werden, wodurch das Feld zentral über dem breitesten positioniert wird.

Probieren Sie es online!