Ktoś pospiesznie układa prezenty świąteczne i jest to dość bałagan:

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

Poważnie, w jaki sposób ta góra zapewnia równowagę. To prawdopodobnie młotek. Aby zapobiec zawaleniu się wieży z prezentami, musisz zmienić kolejność prezentów, aby ładnie się układały:

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

Zasady

• Każdy prezent składa się z góry i dołu =znaków oraz jednego lub więcej środkowych rzędów, składających się z dwóch |oddzielonych spacjami. Szerokość teraźniejszości jest taka sama we wszystkich rzędach.
• Nie ma pustych linii.
• Kolejne prezenty będą się nakładać w co najmniej jednej kolumnie.
• Prezenty należy układać w stosy w kolejności malejącej szerokości. W przypadku remisu wyższy prezent powinien zejść poniżej prezentu bardziej płaskiego.
• Prezenty powinny być wyśrodkowane na teraźniejszości poniżej. Jeśli teraźniejszości nie można umieścić dokładnie na środku (ponieważ różnica szerokości jest nieparzysta), możesz wybrać dowolną pozycję, która jest o pół znaku poza środkiem.
• Możesz założyć lub nie, że dane wejściowe mają jedną końcową linię nowego wiersza, ale proszę podać swoje założenie.
• Twoje rozwiązanie nie musi działać dla pustych danych wejściowych, ale musi być w stanie obsłużyć pojedynczy prezent.
• Możesz napisać program lub funkcję, która pobiera dane wejściowe za pomocą argumentu STDIN lub funkcji i zwraca wynik lub drukuje go do STDOUT.
• To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

CJam, 81 70 bajtów

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

Więc musimy układać prezenty świąteczne? Ten kod robi to tak, jak zrobiłaby to prawdziwa osoba ^* .

Najpierw układamy wszystkie prezenty pod ścianą, aby łatwo je przesuwać w górę i w dół za pomocą tego kodu:

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

następnie identyfikujemy każdy prezent jako osobny element za pomocą tego kodu:

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

następnie sortujemy prezenty według ich wysokości i szerokości za pomocą tego kodu:

$

Do tej pory wszystkie prezenty były układane na ścianie w celu idealnego dopasowania do siebie. Ale ponieważ są święta, chcemy, aby prezenty były ułożone tak, aby były wyśrodkowane jak choinka! Ten kod to:

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

Oto wyjście kodu krok po kroku, na przykład w pytaniu:

"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";
        =======
        |     |
        |     |
        =======
        =======
        |     |
        |     |
        |     |
        =======
     =============
     |           |
     |           |
     |           |
     |           |
     |           |
     |           |
     =============
   =================
   |               |
   |               |
   |               |
   |               |
   =================
  ===================
  |                 |
  |                 |
  |                 |
  ===================
========================
|                      |
========================

Wypróbuj online tutaj

_{* Może się jednak różnić w zależności od osoby: P}

Japt , 18 bajtów

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

Wypróbuj online!

Używam wystarczająco innej strategii niż inne odpowiedzi Japt, że uważam, że jest wart własnej odpowiedzi. Pobiera dane wejściowe i wyjściowe jako tablicę wierszy

Wyjaśnienie:

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

Nie wiem dokładnie, dlaczego tak działa „sortowanie domyślne”, ale przetestowałem, że wyższe pole dwóch o tej samej szerokości znajduje się na dole, niezależnie od tego, co jest pierwsze na wejściu.

Ruby, 164

Zgrabne wyzwanie! Nie mogłem zejść znacznie dalej.

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)}}}

Wyjaśnienie

Dane wejściowe Stringsą podzielone na miejsce, w Arrayktórym każdy prezent jest elementem. Następnie tablica jest sortowana według liczby znaków potoku i sortowana ponownie według liczby znaków równości.

Następnie usuwa wszystkie wiodące białe znaki i drukuje każdą linię osobno, wyśrodkowaną na szerokości największego prezentu.

Zachowuje się tak samo z końcowym znakiem nowej linii na wejściu lub bez niego.

Wersja do odczytu

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 bajtów

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

-3 bajty dzięki @ErikTheOutgolfer .

Wypróbuj online.

Wyjaśnienie:

|         # 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)

Uwagi:

• Prezenty o nieparzystej szerokości są scentralizowane po lewej stronie. Można to zmienić na skupione na prawej stronie, zmieniając kończącą się małą literę cna wielką C.
• Wiodące |można usunąć, jeśli możemy przyjąć dane wejściowe jako listę linii ciągów.
• Zakłada, że ​​dane wejściowe nie zawierają spacji końcowych dla żadnego z prezentów (podobnie jak dane wejściowe w opisie wyzwania); końcowe znaki nowej linii są w porządku, ponieważ i |tak je usuwają.

Attache , 91 bajtów

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

Wypróbuj online!

Nie golfił

?? 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 bajtów

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

Wypróbuj online!

Python 2 , 221 196 bajtów

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)

Wypróbuj online!

Oczekiwany jest ciąg cytowany bez wprowadzania nowych wierszy jako danych wejściowych.

Nie wspaniale, ale to najlepsze, co mogę zrobić.

Japt , 23 20 19 bajtów

Podobne podejście do rozwiązania Kevina . Pierwszy bajt można usunąć, jeśli weźmiemy dane wejściowe jako tablicę wierszy.

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

Spróbuj

·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 bajtów 275 bajtów

Jestem nowicjuszem w dziedzinie golfa i nie jestem ekspertem od javascript, ale wyzwanie jest interesujące i przyjemne. Chciałbym zobaczyć, jakich sztuczek użyłby prawdziwy ekspert od js.

Założenia

• Dane wejściowe i wyjściowe są tablicami ciągów
• Nigdzie nie ma pustych linii
• Wysokość pudełka wynosi <= 99 linii (czy to mnie dyskwalifikuje)?
• Zmienne wejściowe i wyjściowe są predefiniowane, przy czym dane wyjściowe są początkowo pustą tablicą

Kod

Wejście jest w g[]. Wyjście w 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)})});

Kod działa przez

1. budowanie tablicy obiektów, z których każdy reprezentuje jedno pudełko, z dwoma elementami: K, kluczem sortowania jest (szerokość x 100 + wysokość) i O, tablica (przyciętych) ciągów tworzących pudełko. Podczas budowania tablicy kod zapamiętuje szerokość najszerszego pola.

2. Tablica obiektów skrzynek jest sortowana w kolejności według klucza K. W przypadku skrzynek o tej samej szerokości klucz zapewnia sortowanie według wysokości.

3. Po posortowaniu pól ciągi każdego pola są wypychane do tablicy wyjściowej z dodanymi spacjami wiodącymi, które ustawiają pole centralnie nad najszerszym.

Wypróbuj online!