Inspirado por Criar uma parede binária

Dada uma lista de números inteiros positivos, podemos escrevê-los todos acima um do outro, assim, por [2, 6, 9, 4]exemplo:

0010
0110
1001
0100

Podemos imaginar isso como uma parede:

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

No entanto, este é um muro muito fraco e entrou em colapso! Cada 1( #) cai até atingir o "solo" ou outro 1( #). Os 0s .estão presentes nos pontos deixados pelos 1s movidos .

Isso se torna o seguinte:

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

O que se traduz novamente em:

0000
0000
0110
1111

Qual, como uma lista de números, é [0, 0, 6, 15].

Outro caso de teste

[10, 17, 19, 23]

Isso se torna:

01010
10001
10011
10111

que se torna:

00000
10011
10011
11111

traduzindo de volta para:

[0, 19, 19, 31]

Desafio

Dada uma lista de números inteiros positivos, aplique essa transformação à lista. Entrada / Saída como listas de números inteiros positivos em qualquer formato razoável. Aplicam-se brechas padrão.

Este é um código-golfe , então a resposta mais curta em bytes vence!

MATL , 4 bytes

BSXB

Experimente no MATL Online

Explicação

    % 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 bytes

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

Experimente online!

JavaScript (ES6), 50 bytes

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

Explicação: Suponha que duas linhas da parede sejam assim:

0011
0101

O resultado precisa ser este:

0001
0111

Em outras palavras, a primeira linha se torna o AND das duas linhas e a segunda linha se torna o OU das duas linhas. Isso só precisa ser repetido vezes suficientes para que todos os bits caiam no fundo.

Geléia , 9 bytes

BUz0Ṣ€ZUḄ

Experimente online!

Japonês , 16 bytes

m¤z3 ®¬n qÃz mn2

Experimente online! usando o -Qsinalizador para formatar o resultado da matriz.

Explicação

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 bytes

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

 é \[Transpose]

Isso converte a entrada (uma lista de números) em uma lista de listas de dígitos, forma uma matriz quadrada, transpõe, classifica as linhas para que o 1 "caia" no fundo, transponha de volta e depois converta novamente em números .

Python 3.5 , 60 bytes

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

Experimente online!

Toma entrada como f(2, 6, 9, 4). Assume que a entrada não está vazia. Usa muita descompactação de tupla .

Oitava, 29 25 bytes

4 bytes salvos graças a @Stewie

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

J , 13 bytes

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

Experimente online!

Explicação

/:~"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 bytes

bí0ζR€{øC

Experimente online!

Algoritmo meio diferente do Magic.

Dyalog APL, 24 21 19 bytes

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

Experimente online! (modificado para que o TryAPL aceite como válido)

Quão?

• ⎕ entrada avaliada (matrizes são separadas por espaço)
• 2⊥⍣¯1⊢ converte cada um dos argumentos em binário (transposto do que está em questão)
• ↓ transforma uma matriz 2D em um vetor de vetores
• {⍵[⍋⍵]}¨ classifica cada um dos elementos do vetor
• ↑ transforma o vetor de vetores em uma matriz 2D novamente
• 2⊥ converter de binário (uma vez que o transpõe, chegamos ao resultado correto)

Dyalog APL (23 caracteres)

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

1. Converta os argumentos de entrada em uma matriz binária
2. Dividir a matriz em colunas
3. Classifique as colunas em ordem crescente
4. Converta as linhas classificadas novamente em decimal

Exemplo

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

Obrigado a Zacharý por me corrigir neste.

JavaScript, 127 125 bytes

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

Experimente online

-2 bytes graças ao vacas charlatão

Python 2, 142 bytes

... e ainda jogando golfe ... espero - Qualquer ajuda apreciada!

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

Uma grande parte disso é para preencher os números com zeros.

Mais legível:

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

Isso cria uma matriz de representações de cadeias binárias, a preenche, gira 90º no sentido horário, classifica cada linha, gira 90º para trás e cria números inteiros a partir de cada linha.