Empilez les cadeaux de Noël

21

Quelqu'un a empilé à la hâte les cadeaux de Noël, et c'est un vrai gâchis:

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

Comme, sérieusement, comment ce haut présente-t-il un équilibre égal? C'est probablement un marteau. Pour éviter que cette tour de cadeaux ne s'effrite, vous devez réorganiser les cadeaux pour qu'ils s'empilent bien:

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

Les règles

  • Chaque cadeau se compose d'un haut et d'un bas de =caractères et d'une ou plusieurs rangées centrales, composées de deux |séparées par des espaces. La largeur du présent est la même dans toutes ses rangées.
  • Il n'y a pas de lignes vides.
  • Les cadeaux consécutifs se chevaucheront dans au moins une colonne.
  • Les cadeaux doivent être empilés par ordre décroissant de largeur. En cas d'égalité, le plus grand présent devrait aller en dessous du plus plat présent.
  • Les cadeaux doivent être centrés sur le présent en dessous. Si le cadeau ne peut pas être placé exactement au centre (parce que la différence de largeur est étrange), vous pouvez choisir l'une ou l'autre position à un demi-caractère du centre.
  • Vous pouvez ou non supposer que l'entrée a une seule nouvelle ligne de fin, mais veuillez énoncer votre hypothèse.
  • Votre solution ne doit pas fonctionner pour une entrée vide, mais doit être capable de gérer un seul cadeau.
  • Vous pouvez écrire un programme ou une fonction, qui prend une entrée via STDIN ou un argument de fonction et renvoie le résultat ou l'imprime dans STDOUT.
  • Il s'agit du code golf, donc la réponse la plus courte (en octets) l'emporte.
code-golf  ascii-art  sorting 
— Martin Ender
source

Réponses:

15

CJam, 81 70 octets

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

Nous devons donc empiler les cadeaux de Noël? Ce code le fait comme une personne réelle le ferait * .

Tout d'abord , nous empilons tous les cadeaux contre un mur pour les déplacer facilement de haut en bas en utilisant ce code:

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

ensuite , nous identifions chaque cadeau comme un élément distinct en utilisant ce code:

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

puis , nous trions les cadeaux en fonction de leurs hauteurs et largeurs en utilisant ce code:

$

Jusqu'à présent , tous les cadeaux ont été empilés contre un mur afin d'avoir un alignement parfait les uns avec les autres. Mais comme c'est Noël, nous voulons placer les cadeaux alignés centrés comme un arbre de Noël! Ce code fait cela:

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

Voici une sortie étape par étape du code par exemple dans la question:

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

Essayez-le en ligne ici

* Peut différer d'une personne à l'autre cependant: P

— Optimiseur
source
C'est génial que l'ordre lexicographique standard arrive à répondre aux exigences de tri! Belle prise.
— wchargin
@WChargin ouais. M'a sauvé une tonne d'octets!
— Optimizer
3

Japt , 18 octets

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

Essayez-le en ligne!

J'utilise une stratégie suffisamment différente de l'autre réponse de Japt pour que je pense qu'elle valait sa propre réponse. Prend l'entrée et la sortie sous forme de tableau de lignes

Explication:

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

Je ne sais pas exactement pourquoi le "tri par défaut" fonctionne comme ça, mais j'ai testé que la boîte la plus haute des deux avec la même largeur se trouve en bas, quelle que soit la première entrée.

— Kamil Drakari
source
1
Imaginez que la chaîne la plus courte soit complétée à droite avec un caractère imaginaire avec le point de code -1 à la longueur de la plus longue.
— Erik the Outgolfer
1
Remplacez "=="par '=²pour enregistrer un octet.
— Shaggy
2

Rubis, 164

Beau défi! Je ne pouvais pas descendre beaucoup plus loin.

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

Explication

L'entrée Stringest découpée en un Arrayoù chaque cadeau est un élément. Ensuite, le tableau est trié par le nombre de caractères de canal et trié à nouveau par le nombre de signes égaux.

Il supprime ensuite tous les espaces blancs de tête et imprime chaque ligne individuellement, centrée sur la largeur du plus grand présent.

Il se comporte de la même façon avec ou sans retour à la ligne sur l'entrée.

Version lisible

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
source
1

05AB1E , 23 20 octets

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

-3 octets grâce à @ErikTheOutgolfer .

Essayez-le en ligne.

Explication:

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

Remarques:

  • Les cadeaux de largeur impaire sont centralisés à gauche. Cela peut être changé pour centré à droite en changeant les minuscules cde fin en majuscules C.
  • Le début |peut être supprimé si nous sommes autorisés à prendre l'entrée comme une liste de lignes de chaîne.
  • Suppose que l'entrée ne contient aucun espace de fin pour aucun des cadeaux (similaire à l'entrée dans la description du défi); les sauts de ligne sont très bien, puisque le |supprime quand même.
— Kevin Cruijssen
source
1
20 octets . ðδÛpeut être utilisé à la place d’ εðÛ}ici, ¶'=.øest identique à …=\n=( \nsignifie nouvelle ligne), 0'=.øest identique à …=0=.
— Erik the Outgolfer
@EriktheOutgolfer Ah, je suis un idiot pour utiliser à la .øplace des chaînes de 3 caractères littéraux .. Et merci pour ðδÛ. En fait, jamais utilisé δauparavant et je n'avais aucune idée que cela fonctionnait comme ça.
— Kevin Cruijssen
1

Attaché , 91 octets

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

Essayez-le en ligne!

Non golfé

?? 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
source
0

Python 2 , 221 196 octets

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)

Essayez-le en ligne!

Attend une chaîne entre guillemets sans retour à la ligne en fin de ligne.

Pas génial, mais c'est le mieux que je puisse faire.

— Triggernométrie
source
0

Japt , 23 20 19 octets

Approche similaire à la solution de Kevin . Le premier octet peut être supprimé si nous pouvons prendre l'entrée comme un tableau de lignes.

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

Essayez-le

·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
— Hirsute
source
0

Javascript 279 octets 275 octets

Je suis un peu novice en matière de code-golf, et pas du tout comme un expert en javascript mais le défi est intéressant et amusant. Je voudrais voir quelles astuces un vrai expert en js utiliserait.

Hypothèses

  • L'entrée et la sortie sont des tableaux de chaînes
  • Pas de lignes vides n'importe où
  • La hauteur d'une boîte est <= 99 lignes (cela me disqualifie-t-il)?
  • Les variables d'entrée et de sortie sont prédéfinies, la sortie étant initialement un tableau vide

Code

L'entrée est en g[]. Sortie en 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)})});

Le code fonctionne par

  1. la construction d'un tableau d'objets, chaque objet représentant une boîte, avec deux membres: K, une clé de tri étant les (largeur x 100 + hauteur) et O, un tableau des chaînes (coupées) constituant la boîte. Lors de la construction du tableau, le code se souvient de la largeur de la zone la plus large.

  2. Le tableau des objets boîte est trié dans l'ordre par la clé K. Lorsque les boîtes ont la même largeur, la clé s'assure qu'elles sont triées par hauteur.

  3. Après avoir trié les boîtes, les chaînes de chaque boîte sont poussées dans le tableau de sortie avec des espaces de tête ajoutés, ce qui positionne la boîte au centre du plus large.

Essayez-le en ligne!

— JohnRC
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.