堆放圣诞礼物

21

有人急忙堆放圣诞节礼物，真是一团糟：

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

认真地讲，顶端如何平衡。可能是锤子。为防止礼物塔坍塌，您需要对礼物重新排序，以便它们堆叠良好：

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

规则

  • 每个礼物由一个=字符的顶部和底部以及一个或多个中间行组成，中间行由两个|以空格隔开的行组成。礼物的宽度在所有行中都相同。
  • 没有空行。
  • 连续礼物将至少重叠一列。
  • 礼物应按宽度减小的顺序堆叠。如果出现平局，较高的礼物应低于较平的礼物。
  • 礼物应以下方的礼物为中心。如果礼物不能精确地放置在中心位置（因为宽度的差异是奇数），则可以选择距离中心位置半个字符的任一位置。
  • 您可能会或可能不会认为输入中只有一个结尾的换行符，但请说明您的假设。
  • 您的解决方案不必用于空输入，但必须能够处理一个单据。
  • 您可以编写程序或函数，该程序或函数通过STDIN或函数参数获取输入，然后将结果返回或将其打印到STDOUT。
  • 这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。
code-golf  ascii-art  sorting 
— 马丁·恩德
source

Answers:

15

CJam，81 70字节

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

所以我们必须堆放圣诞礼物吗？这段代码就像实际的人所做的那样*。

首先，我们将所有礼物堆叠在墙上，以使用以下代码轻松地上下移动它们：

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

然后，我们使用此代码将每个礼物标识为单独的物品：

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

然后，我们使用以下代码根据礼物的高度和宽度对礼物进行排序：

$

到现在为止，所有礼物都被堆放在墙上，以使彼此完美对齐。但是由于这是圣诞节，我们希望将礼物排列成像圣诞树一样居中！此代码执行以下操作：

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

这是示例中的代码的逐步输出：

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

在这里在线尝试

*可能因人而异：P

— 优化器
source
标准字典顺序恰好可以满足排序要求，这真棒！不错的收获。
— wchargin 2014年
@WChargin是的。为我节省了很多字节！
— Optimizer
3

Japt，18个字节

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

在线尝试！

我使用与Japt另一个答案完全不同的策略，我认为这是值得的。将输入和输出作为线阵列

说明：

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

我不知道为什么“默认排序”会这样工作，但是我已经测试了两个宽度相同的较高框位于底部，而不管输入中哪个先出现。

— 卡米尔（Kamil Drakari）
source
1
想象一下，较短的字符串用一个假想的字符填充，其代码点为-1，长度为较长。
— 暴民埃里克（Erik the Outgolfer）
1
替换"=="与'=²保存字节。
— 毛茸茸的
2

红宝石164

整齐的挑战！无法继续下去。

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

说明

输入String被切成Array每个存在的元素。然后，根据管道字符的数量对数组进行排序，并根据等号的数量再次对数组进行排序。

然后，它将删除所有前导空白，并以最大的当前宽度为中心单独打印每行。

无论输入是否带有尾随换行符，它的行为都相同。

可读版本

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
— 英国茶
source
1

05AB1E，23 20 字节

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

-3个字节，感谢@ErikTheOutgolfer。

在线尝试。

说明：

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

笔记：

  • 奇数宽度的礼物向左集中。通过将尾随的小写字母c更改为大写字母，可以将其更改为右焦点C。
  • |如果允许我们将输入作为字符串列表，则可以删除前导。
  • 假设输入中没有任何礼物的尾随空格（类似于挑战说明中的输入）；尾随换行符很好，因为|无论如何都将其删除。
— 凯文·克鲁伊森
source
1
20个字节。ðδÛ可以代替εðÛ}此处使用，¶'=.ø与…=\n=（\n表示换行符）0'=.ø相同，与相同…=0=。
— Erik the Outgolfer
@EriktheOutgolfer啊，我是个白痴，.ø而不是使用文字3个字符的字符串ðδÛ。实际上以前从未使用δ过，也不知道它会那样工作。
— 凯文·克鲁伊森
1

附件，91字节

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

在线尝试！

不打高尔夫球

?? 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
— 科纳·奥布莱恩
source
0

Perl -n0 5、123字节

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

在线尝试！

— Xcali
source
0

Python 2中，221个 196字节

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)

在线尝试！

期望用引号引起来的字符串，而不会在输入后加上换行符。

不好，但这是我能做的最好的。

— 触发法
source
0

Japt，23 20 19 字节

与Kevin的解决方案类似的方法。如果我们可以将输入作为行数组，则可以删除第一个字节。

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

试试吧

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

Javascript 279字节 275字节

我是代码高尔夫球的新手，虽然不是javascript专家，但是挑战很有趣。我想看看真正的js专家会使用什么技巧。

假设条件

  • 输入和输出是字符串数组
  • 任何地方都没有空行
  • 盒子的高度小于等于99行（这会使我失去资格）吗？
  • 输入和输出变量是预定义的，输出最初是一个空数组

码

输入为g[]。在中输出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)})});

该代码由

  1. 构建一个对象数组，每个对象代表一个框，其中包含两个成员：K（排序键为（宽度x 100 +高度））和O（构成框的（修剪）字符串的数组）。在构建数组时，代码会记住最宽框的宽度。

  2. 框对象的数组由键K排序。在框具有相同宽度的情况下，键确保它们按高度排序。

  3. 在对框进行排序之后，将每个框的字符串添加到输出数组中，并添加前导空格，该空格将框居中放置在最宽的框上。

在线尝试！

— 约翰·RC
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.