受启发于创建二元墙

给定一个正整数列表，我们可以像这样将它们彼此重叠地写出来，[2, 6, 9, 4]例如：

0010
0110
1001
0100

我们可以将其想象成一堵墙：

..#.
.##.
#..#
.#..

但是，这是一堵非常薄弱的​​墙，已经倒塌了！每个1（#）跌落直到撞到“地面”或另一个1（#）。的0S（.S）存在于由向左移动斑点1秒。

变为以下内容：

....
....
.##.
####

转换为：

0000
0000
0110
1111

作为数字列表，其为[0, 0, 6, 15]。

另一个测试案例

[10, 17, 19, 23]

变成：

01010
10001
10011
10111

变成：

00000
10011
10011
11111

翻译回：

[0, 19, 19, 31]

挑战

给定一个正整数列表，将此转换应用于列表。输入/输出为任何合理格式的正整数列表。有标准漏洞。

这是一个代码高尔夫球，因此最短答案以字节为单位！

MATL，4个字节

BSXB

在MATL Online上尝试

说明

    % Implicitly grab input as an array 
    %   STACK: [10, 17, 19, 23]
B   % Convert each element to binary where each decimal number results in a row
    %   STACK: [0 1 0 1 0;
    %           1 0 0 0 1;
    %           1 0 0 1 1;
    %           1 0 1 1 1]
S   % Sort each column, placing all of the 1's at the bottom of each column
    %   STACK: [0 0 0 0 0;
    %           1 0 0 1 1;
    %           1 0 0 1 1;
    %           1 1 1 1 1] 
XB  % Convert each row from its binary representation to its decimal number
    %   STACK: [0, 19, 19, 31]
    % Implicitly display the result

Python，68个字节

f=lambda a:a and[x|y&a[0]for x,y in zip([0]+f(a[1:]),f(a[1:])+[-1])]

在线尝试！

JavaScript（ES6），50个字节

f=a=>a.map(_=>a.map((e,i)=>a[a[i]|=a[--i],i]&=e))&&a

说明：假设两排墙是这样的：

0011
0101

结果需要是这样的：

0001
0111

换句话说，第一行成为两行的AND，第二行成为两行的OR。这仅需要重复足够的次数，以使所有位都下降到底部。

果冻，9个字节

BUz0Ṣ€ZUḄ

在线尝试！

Japt，16字节

m¤z3 ®¬n qÃz mn2

在线尝试！使用该-Q标志格式化数组结果。

说明

m¤z3 ®¬n qÃz mn2    Implicit: U = input array.
                        [10, 17, 19, 23]
m¤z3                Map U to binary strings and rotate the array left 90°
                         1010       0111
                        10001   ->  1011
                        10011       0001
                        10111       1000
                                     111
®¬n qà              Sort each binary string, putting 0s and spaces at the start
                        0111
                        0111
                        0001
                        0001
                         111
z mn2               Rotate right 90° and convert each back to a number
                         0000       0
                        10011   ->  19
                        10011       19
                        11111       31
                    Implicit output of resulting array

Mathematica，64个字节

#~FromDigits~2&/@(Sort/@(PadLeft[#~IntegerDigits~2&/@#]))&

是 \[Transpose]

这会将输入（数字列表）转换为数字列表，将其填充为方阵，对其进行转置，对行进行排序，以使“ 1”的“落”到底部，向后转置，然后转换回数字。

Python 3.5，60个字节

def f(a,*t):
 if t:b,*r=f(*t);t=f(a|b,*r);a&=b
 return(a,*t)

在线尝试！

接受类似的输入f(2, 6, 9, 4)。假设输入为非空。使用大量的元组拆包。

八度，29 25字节

@Stewie节省了4个字节

@(x)bi2de(sort(de2bi(x)))

J，13个字节

/:~"1&.|:&.#:

在线尝试！

说明

/:~"1&.|:&.#:  Input: array M
           #:  Convert each in M to binary with left-padding
       |:&     Transpose
/:~"1&         Sort each row
     &.|:      Inverse of transpose (which is just transpose)
         &.#:  Inverse of converting to binary

05AB1E，9个字节

bí0ζR€{øC

在线尝试！

Kinda与Magic的算法不同。

Dyalog APL， 24 21 19字节

2⊥↑{⍵[⍋⍵]}¨↓2⊥⍣¯1⊢⎕

在线尝试！（已修改，因此TryAPL将其视为有效）

怎么样？

• ⎕ 评估的输入（数组以空格分隔）
• 2⊥⍣¯1⊢ 将每个参数转换为二进制（转置问题中的内容）
• ↓ 将2D数组变成向量的向量
• {⍵[⍋⍵]}¨ 对向量的每个元素进行排序
• ↑ 将向量的向量再次转换为2D数组
• 2⊥ 从二进制转换（由于它进行了转置，因此我们得出了正确的结果）

Dyalog APL（23个字符）

{2⊥¨↓⍉↑{⍵[⍋⍵]}¨↓2⊥⍣¯1⊢⍵}

1. 将输入参数转换为二进制矩阵
2. 将矩阵拆分为列
3. 按升序对列进行排序
4. 将排序的行转换回十进制

例

  {2⊥¨↓⍉↑{⍵[⍋⍵]}¨↓2⊥⍣¯1⊢⍵}10 17 19 23
      0 19 19 31

感谢Zacharý在这一方面对我的纠正。

JavaScript，127125字节

a=>a[m='map'](_=>b[m]((n,i)=>n&&(b[i]--,d|=1<<i),d=0)&&d,b=[...Array(32)][m]((_,c)=>a[m](e=>d+=!!(2**c&e),d=0)&&d)).reverse()

在线尝试

母牛嘎嘎声 -2个字节

Python 2，142字节

...并且仍然打高尔夫球...希望-感谢您的帮助！

def c(l):b=[bin(n)[2:]for n in l];print[int(n,2)for n in map(''.join,zip(*map(sorted,zip(*['0'*(len(max(b,key=len))-len(x))+x for x in b]))))]

其中很大一部分是用零填充数字。

更具可读性：

def collapse(nums):
    bins = [bin(n)[2:] for n in nums]
    bins = [('0'*(len(max(bins, key = len)) - len(x))) + x for x in bins]
    print [int(n, 2) for n in map(''.join, zip(*map(sorted, zip(*bins))))]

这将创建一个二进制字符串表示形式的数组，将其填充，将其顺时针旋转90º，对每一行进行排序，将其旋转回90º，然后从每一行中创建整数。