Impila i regali di Natale

21

Qualcuno ha impilato frettolosamente i regali di Natale, ed è un bel casino:

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

Come seriamente, in che modo il presente presenta un equilibrio uniforme. Probabilmente è un martello. Per evitare che questa torre di regali si sgretoli, devi riordinare i regali in modo che si accumulino bene:

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

Le regole

  • Ogni presente è costituito da una parte superiore e inferiore di =caratteri e da una o più file centrali, costituite da due |separate da spazi. La larghezza del presente è la stessa in tutte le sue file.
  • Non ci sono righe vuote.
  • I regali consecutivi si sovrapporranno in almeno una colonna.
  • I regali devono essere impilati in ordine decrescente di larghezza. In caso di pareggio, il presente più alto dovrebbe scendere al di sotto del presente più piatto.
  • I regali dovrebbero essere centrati sul presente sottostante. Se il presente non può essere posizionato esattamente al centro (perché la differenza in larghezze è dispari), puoi scegliere una posizione che è mezzo carattere al centro.
  • Si può o meno supporre che l'input abbia una sola nuova riga finale, ma si prega di indicare la propria ipotesi.
  • La tua soluzione non deve funzionare per un input vuoto, ma deve essere in grado di gestire un singolo regalo.
  • È possibile scrivere un programma o una funzione, che accetta input tramite STDIN o argomento della funzione e restituisce il risultato o lo stampa su STDOUT.
  • Questo è il golf del codice, quindi vince la risposta più breve (in byte).
code-golf  ascii-art  sorting 
— Martin Ender
fonte

Risposte:

15

CJam, 81 70 byte

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

Quindi dobbiamo impilare i regali di Natale? Questo codice fa come farebbe una persona reale * .

Innanzitutto , impiliamo tutti i regali contro un muro per spostarli facilmente su e giù usando questo codice:

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

quindi , identifichiamo ogni regalo come un articolo separato usando questo codice:

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

quindi , ordiniamo i regali in base alle loro altezze e larghezze usando questo codice:

$

Fino ad ora , tutti i doni sono stati impilati contro un muro per avere un perfetto allineamento tra loro. Ma dato che questo è Natale, vogliamo posizionare i regali allineati centrati come un albero di Natale! Questo codice fa questo:

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

Ecco un output passo passo del codice, ad esempio nella domanda:

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

Provalo online qui

* Potrebbe differire da persona a persona però: P

— Optimizer
fonte
È fantastico che l'ordine lessicografico standard soddisfi i requisiti di selezione! Bella presa.
— wchargin,
@WChargin sì. Mi ha salvato un sacco di byte!
— Ottimizzatore il
3

Japt , 18 byte

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

Provalo online!

Uso una strategia sufficientemente diversa dall'altra risposta di Japt che pensavo valesse la sua risposta. Accetta input e output come una matrice di linee

Spiegazione:

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

Non so esattamente perché "ordinamento predefinito" funzioni in questo modo, ma ho testato che il riquadro più alto dei due con la stessa larghezza è sul fondo, indipendentemente da quale viene prima nell'input.

— Kamil Drakari
fonte
1
Immagina che la stringa più corta sia imbottita a destra con un carattere immaginario con codice punto -1 alla lunghezza di quella più lunga.
— Erik the Outgolfer,
1
Sostituisci "=="con '=²per salvare un byte.
— Shaggy,
2

Ruby, 164

Sfida ordinata! Non è riuscito a farlo scendere molto oltre.

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

Spiegazione

L'input Stringè suddiviso in un punto in Arraycui ogni regalo è un elemento. Quindi l'array viene ordinato in base al numero di caratteri pipe e ordinato nuovamente base al numero di segni uguali.

Quindi rimuove tutti gli spazi bianchi principali e stampa ogni riga singolarmente, centrata dalla larghezza del più grande presente.

Si comporta allo stesso modo con o senza una nuova riga finale sull'input.

Versione leggibile

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
— britishtea
fonte
1

05AB1E , 23 20 byte

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

-3 byte grazie a @ErikTheOutgolfer .

Provalo online.

Spiegazione:

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

Gli appunti:

  • I regali di larghezza dispari sono centralizzati a sinistra. Questo può essere modificato in focalizzato a destra cambiando la minuscola finale cin maiuscola C.
  • Il comando iniziale |può essere eliminato se ci è permesso di prendere l'input come un elenco di linee di stringa.
  • Presuppone che l'input non contenga spazi finali per nessuno dei regali (simile all'input nella descrizione della sfida); le nuove righe finali vanno bene, poiché le |rimuove comunque.
— Kevin Cruijssen
fonte
1
20 byte . ðδÛpuò essere usato al posto di εðÛ}qui, ¶'=.øè lo stesso di …=\n=( \nsignifica newline), 0'=.øè lo stesso di …=0=.
— Erik the Outgolfer,
@EriktheOutgolfer Ah, sono un idiota per usare al .øposto delle stringhe letterali a 3 caratteri .. E grazie per ðδÛ. In realtà non l' δho mai usato prima e non avevo idea che funzionasse così.
— Kevin Cruijssen il
1

Attache , 91 byte

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

Provalo 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
— Conor O'Brien
fonte
0

Perl 5 -n0 , 123 byte

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

Provalo online!

— Xcali
fonte
0

Python 2 , 221 196 byte

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)

Provalo online!

Si aspetta una stringa tra virgolette senza trascinare le nuove righe come input.

Non eccezionale, ma è il massimo che posso fare.

— Triggernometry
fonte
0

Japt , 23 20 19 byte

Approccio simile alla soluzione di Kevin . Il primo byte può essere rimosso se possiamo prendere l'input come una matrice di linee.

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

Provalo

·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
— ispido
fonte
0

Javascript 279 byte 275 byte

Sono un principiante del code-golf, e non qualcosa di simile a un esperto di JavaScript ma la sfida è interessante e divertente. Mi piacerebbe vedere quali trucchi userebbe un vero esperto di js.

ipotesi

  • Input e output sono matrici di stringhe
  • Nessuna linea vuota da nessuna parte
  • L'altezza di una casella è <= 99 righe (mi squalifica)?
  • Le variabili di input e output sono predefinite, essendo inizialmente un array vuoto

Codice

L'ingresso è in g[]. Uscita 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)})});

Il codice funziona da

  1. costruendo una matrice di oggetti, ogni oggetto che rappresenta una scatola, con due membri: K, una chiave di ordinamento è la (larghezza x 100 + altezza) e O, una matrice delle stringhe (tagliate) che compongono la scatola. Durante la creazione dell'array, il codice ricorda la larghezza della casella più ampia.

  2. L'array di oggetti box viene ordinato in base alla chiave K. Se le scatole hanno la stessa larghezza, la chiave assicura che siano ordinate in base all'altezza.

  3. Dopo aver ordinato le caselle, le stringhe per ciascuna casella vengono inserite nell'array di output con spazi iniziali aggiunti, che posizionano la casella centralmente su quella più ampia.

Provalo online!

— JohnRC
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.