バイナリ壁の作成に触発

正の整数のリストが与えられた場合、[2, 6, 9, 4]例として、次のようにそれらをすべて上に書き出すことができます。

0010
0110
1001
0100

これを壁として想像できます。

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

しかし、これは非常に弱い壁であり、崩壊しました！各1（#）は、「地面」または別の1（#）に当たるまで落ちます。0S（.S）が移動することにより左スポット中に存在する1S。

これは次のようになります。

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

次のように変換されます：

0000
0000
0110
1111

これは、数字のリストとしてです[0, 0, 6, 15]。

別のテストケース

[10, 17, 19, 23]

これは次のようになります。

01010
10001
10011
10111

になる：

00000
10011
10011
11111

に翻訳する：

[0, 19, 19, 31]

チャレンジ

正の整数のリストが与えられたら、この変換をリストに適用します。妥当な形式の正の整数のリストとしての入出力。標準の抜け穴が適用されます。

これはcode-golfなので、バイト単位の最短回答が勝ちです！

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

説明：壁の2つの列が次のようであると仮定します。

0011
0101

結果はこれである必要があります：

0001
0111

つまり、最初の行は2つの行のANDになり、2番目の行は2つの行の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

オンラインでお試しください！

マジックとはちょっと違うアルゴリズム。

Dyalog APL、24 21 19バイト

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

オンラインでお試しください！（TryAPLが有効として受け入れるように変更）

どうやって？

• ⎕ 評価された入力（配列はスペースで区切られます）
• 2⊥⍣¯1⊢ 各引数をバイナリに変換します（質問の内容を置き換えます）
• ↓ 2D配列をベクトルのベクトルに変換します
• {⍵[⍋⍵]}¨ ベクトルの各要素をソートします
• ↑ ベクトルのベクトルを再び2D配列に変換します
• 2⊥ バイナリから変換します（転置するため、正しい結果に到達します）

Dyalog APL（23文字）

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

1. 入力引数をバイナリ行列に変換します
2. 行列を列に分割する
3. 列を昇順に並べ替えます
4. ソートされた行を10進数に戻す

例

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

この問題を修正してくれたZacharýに感謝します。

JavaScript、127 125バイト

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バイト、Cows Quackのおかげ

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度戻されて、各行から整数が作成されます。