Inspirado en Crear un muro binario

Dada una lista de enteros positivos, podemos escribirlos uno encima del otro, por [2, 6, 9, 4]ejemplo:

0010
0110
1001
0100

Podemos imaginar esto como un muro:

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

Sin embargo, esta es una pared muy débil, ¡y se ha derrumbado! Cada 1( #) cae hasta que toca el "suelo" u otro 1( #). Las 0s ( .s) están presentes en los puntos que dejó la 1s movida .

Esto se convierte en lo siguiente:

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

Lo que se traduce de nuevo a:

0000
0000
0110
1111

Que, como una lista de números, es [0, 0, 6, 15].

Otro caso de prueba

[10, 17, 19, 23]

Esto se convierte en:

01010
10001
10011
10111

que se convierte en:

00000
10011
10011
11111

traduciendo de nuevo a:

[0, 19, 19, 31]

Reto

Dada una lista de enteros positivos, aplique esta transformación a la lista. Entrada / Salida como listas de enteros positivos en cualquier formato razonable. Se aplican lagunas estándar.

Este es un código de golf , por lo que gana la respuesta más corta en bytes.

MATL , 4 bytes

BSXB

Pruébalo en MATL Online

Explicación

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

Pruébalo en línea!

JavaScript (ES6), 50 bytes

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

Explicación: Supongamos que dos filas de la pared fueran así:

0011
0101

El resultado debe ser este:

0001
0111

En otras palabras, la primera fila se convierte en el AND de las dos filas y la segunda fila se convierte en el OR de las dos filas. Esto solo necesita repetirse suficientes veces para que todos los bits caigan al fondo.

Jalea , 9 bytes

BUz0Ṣ€ZUḄ

Pruébalo en línea!

Japt , 16 bytes

m¤z3 ®¬n qÃz mn2

Pruébalo en línea! usando la -Qbandera para formatear el resultado de la matriz.

Explicación

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&/@#]))&

 es \[Transpose]

Esto convierte la entrada (una lista de números) en una lista de listas de dígitos, la convierte en una matriz cuadrada, la transpone, ordena las filas para que el 1 "caiga" al fondo, se transpone de nuevo, luego se convierte de nuevo en 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)

Pruébalo en línea!

Toma entrada como f(2, 6, 9, 4). Asume que la entrada no está vacía. Utiliza muchas tuplas para desempacar .

Octava, 29 25 bytes

4 bytes guardados gracias a @Stewie

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

J , 13 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Algoritmo algo diferente del de Magic.

Dyalog APL, 24 21 19 bytes

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

Pruébalo en línea! (modificado para que TryAPL lo acepte como válido)

¿Cómo?

• ⎕ entrada evaluada (las matrices están separadas por espacios)
• 2⊥⍣¯1⊢ convierte cada uno de los argumentos a binario (transpuesto de lo que está en la pregunta)
• ↓ convierte una matriz 2D en un vector de vectores
• {⍵[⍋⍵]}¨ ordena cada uno de los elementos del vector
• ↑ convierte el vector de vectores en una matriz 2D nuevamente
• 2⊥ convertir de binario (dado que lo transpone, llegamos al resultado correcto)

Dyalog APL (23 caracteres)

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

1. Convierta los argumentos de entrada en una matriz binaria
2. Dividir la matriz en columnas.
3. Ordenar las columnas en orden ascendente
4. Convierta las filas ordenadas nuevamente a decimales

Ejemplo

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

Gracias a Zacharý por corregirme en este caso.

JavaScript, 127125 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()

Pruébalo en línea

-2 bytes gracias a Cows quack

Python 2, 142 bytes

... y aún jugando al golf ... con suerte –– ¡Se agradece cualquier ayuda!

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

Una gran parte de esto es para rellenar los números con ceros.

Más legible:

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

Esto crea una matriz de representaciones de cadenas binarias, las rellena, gira 90º en el sentido de las agujas del reloj, ordena cada fila, la gira 90º hacia atrás y luego crea números enteros fuera de cada fila.