Inspiré par Créer un mur binaire

Étant donné une liste d'entiers positifs, nous pouvons les écrire les uns au-dessus des autres de cette manière, par [2, 6, 9, 4]exemple:

0010
0110
1001
0100

On peut imaginer cela comme un mur:

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

Cependant, c'est un mur très faible et il s'est effondré! Chaque 1( #) tombe jusqu'à ce qu'il touche le «sol» ou un autre 1( #). Les 0s ( .s) sont présents dans les taches laissées par les 1s déplacés .

Cela devient le suivant:

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

Ce qui se traduit par:

0000
0000
0110
1111

Ce qui, en tant que liste de nombres, est [0, 0, 6, 15].

Un autre cas de test

[10, 17, 19, 23]

Cela devient:

01010
10001
10011
10111

qui devient:

00000
10011
10011
11111

traduire en:

[0, 19, 19, 31]

Défi

Étant donné une liste d'entiers positifs, appliquez cette transformation à la liste. Entrée / sortie sous forme de listes d'entiers positifs dans n'importe quel format raisonnable. Des échappatoires standard s'appliquent.

Il s'agit d'un code-golf , donc la réponse la plus courte en octets gagne!

MATL , 4 octets

BSXB

Essayez-le sur MATL Online

Explication

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

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

Essayez-le en ligne!

JavaScript (ES6), 50 octets

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

Explication: Supposons que deux rangées de mur ressemblent à ceci:

0011
0101

Le résultat doit être le suivant:

0001
0111

En d'autres termes, la première ligne devient le ET des deux lignes et la deuxième ligne devient le OU des deux lignes. Cela doit juste être répété suffisamment de fois pour que tous les bits tombent au fond.

Gelée , 9 octets

BUz0Ṣ€ZUḄ

Essayez-le en ligne!

Japt , 16 octets

m¤z3 ®¬n qÃz mn2

Essayez-le en ligne! en utilisant l' -Qindicateur pour formater le résultat du tableau.

Explication

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 octets

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

 est \[Transpose]

Cela convertit l'entrée (une liste de nombres) en une liste de listes de chiffres, la remplit pour qu'elle soit une matrice carrée, la transpose, trie les lignes de sorte que le 1 "tombe" vers le bas, transpose en arrière, puis reconvertit en nombres .

Python 3.5 , 60 octets

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

Essayez-le en ligne!

Prend l'entrée comme f(2, 6, 9, 4). Suppose que l'entrée n'est pas vide. Utilise beaucoup de déballage de tuple .

Octave, 29 25 octets

4 octets enregistrés grâce à @Stewie

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

J , 13 octets

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

Essayez-le en ligne!

Explication

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

bí0ζR€{øC

Essayez-le en ligne!

Un algorithme un peu différent de Magic.

Dyalog APL, 24 21 19 octets

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

Essayez-le en ligne! (modifié pour que TryAPL l'accepte comme valide)

Comment?

• ⎕ entrée évaluée (les tableaux sont séparés par des espaces)
• 2⊥⍣¯1⊢ convertit chacun des arguments en binaire (transposé de ce qui est dans la question)
• ↓ transforme un tableau 2D en un vecteur de vecteurs
• {⍵[⍋⍵]}¨ trie chacun des éléments du vecteur
• ↑ transforme à nouveau le vecteur de vecteurs en tableau 2D
• 2⊥ convertir du binaire (car il le transpose en quelque sorte, nous arrivons au résultat correct)

Dyalog APL (23 caractères)

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

1. Convertissez les arguments d'entrée en une matrice binaire
2. Fractionner la matrice en colonnes
3. Trier les colonnes par ordre croissant
4. Convertissez les lignes triées en décimales

Exemple

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

Merci à Zacharý de m'avoir corrigé sur celui-ci.

JavaScript, 127 125 octets

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

Essayez-le en ligne

-2 octets grâce au charlatan des vaches

Python 2, 142 octets

... et toujours au golf ... j'espère –– Toute aide appréciée!

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

Une grande partie de cela est pour remplir les nombres avec des zéros.

Plus lisible:

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

Cela crée un tableau des représentations de chaînes binaires, le remplit, le fait pivoter de 90 ° dans le sens des aiguilles d'une montre, trie chaque ligne, le fait pivoter de 90 ° en arrière, puis crée des entiers à partir de chaque ligne.