Ispirato da Crea un muro binario

Dato un elenco di numeri interi positivi, possiamo scriverli tutti uno sopra l'altro in questo modo, per [2, 6, 9, 4]esempio:

0010
0110
1001
0100

Possiamo immaginarlo come un muro:

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

Tuttavia, questo è un muro molto debole, ed è crollato! Ciascuno 1( #) cade finché non colpisce il "terreno" o un altro 1( #). Le 0s .sono presenti nei punti lasciati dalle mosse 1.

Questo diventa il seguente:

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

Il che si traduce in:

0000
0000
0110
1111

Che, come un elenco di numeri, è [0, 0, 6, 15].

Un altro caso di test

[10, 17, 19, 23]

Questo diventa:

01010
10001
10011
10111

che diventa:

00000
10011
10011
11111

traduzione di nuovo a:

[0, 19, 19, 31]

Sfida

Dato un elenco di numeri interi positivi, applica questa trasformazione all'elenco. Input / Output come elenchi di numeri interi positivi in ​​qualsiasi formato ragionevole. Si applicano scappatoie standard.

Questo è un codice-golf , quindi vince la risposta più breve in byte!

MATL , 4 byte

BSXB

Provalo su MATL Online

Spiegazione

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

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

Provalo online!

JavaScript (ES6), 50 byte

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

Spiegazione: Supponiamo che due file del muro fossero così:

0011
0101

Il risultato deve essere questo:

0001
0111

In altre parole, la prima riga diventa AND delle due righe e la seconda riga diventa OR delle due righe. Questo deve solo essere ripetuto abbastanza volte perché tutti i bit cadano verso il basso.

Gelatina , 9 byte

BUz0Ṣ€ZUḄ

Provalo online!

Japt , 16 byte

m¤z3 ®¬n qÃz mn2

Provalo online! usando il -Qflag per formattare il risultato dell'array.

Spiegazione

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 byte

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

 è \[Transpose]

Questo converte l'input (un elenco di numeri) in un elenco di elenchi di cifre, lo inserisce in una matrice quadrata, lo traspone, ordina le righe in modo che la "caduta" dell'1 in basso, trasponi indietro, quindi converta nuovamente in numeri .

Python 3.5 , 60 byte

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

Provalo online!

Accetta input come f(2, 6, 9, 4). Presuppone che l'input non sia vuoto. Usa un sacco di tuple disimballando .

Ottava, 29 25 byte

4 byte salvati grazie a @Stewie

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

J , 13 byte

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

Provalo online!

Spiegazione

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

bí0ζR€{øC

Provalo online!

Un algoritmo diverso da quello di Magic.

Dyalog APL, 24 21 19 byte

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

Provalo online! (modificato in modo che TryAPL lo accetti come valido)

Come?

• ⎕ input valutato (le matrici sono separate da spazio)
• 2⊥⍣¯1⊢ converte ciascuno degli argomenti in binario (trasposto di ciò che è nella domanda)
• ↓ trasforma un array 2D in un vettore di vettori
• {⍵[⍋⍵]}¨ ordina ciascuno degli elementi del vettore
• ↑ trasforma di nuovo il vettore dei vettori in un array 2D
• 2⊥ converti da binario (dal momento che lo traspone, arriviamo al risultato corretto)

Dyalog APL (23 caratteri)

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

1. Converti gli argomenti di input in una matrice binaria
2. Dividi la matrice in colonne
3. Ordina le colonne in ordine crescente
4. Converti le righe ordinate in decimali

Esempio

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

Grazie a Zacharý per avermi corretto su questo.

JavaScript, 127 125 byte

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

Provalo online

-2 byte grazie al ciarlatano Cows

Python 2, 142 byte

... e ancora giocando a golf ... speriamo –– Ogni aiuto è apprezzato!

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

Un grosso pezzo di questo è per riempire i numeri con zero.

Più leggibile:

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

Questo crea un array di rappresentazioni di stringhe binarie, lo riempie, lo ruota di 90º in senso orario, ordina ogni riga, lo ruota indietro di 90º e quindi crea numeri interi da ogni riga.