Inspiriert von Erstellen Sie eine binäre Wand

Ausgehend von einer Liste positiver Ganzzahlen können wir sie wie folgt übereinander schreiben [2, 6, 9, 4]:

0010
0110
1001
0100

Wir können uns das als Wand vorstellen:

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

Dies ist jedoch eine sehr schwache Mauer, die eingestürzt ist! Jedes 1( #) fällt herunter, bis es auf den "Boden" oder ein anderes 1( #) trifft . Die 0s ( .s) sind an Stellen vorhanden, die von bewegten 1s übrig bleiben .

Dies wird wie folgt:

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

Was übersetzt zurück zu:

0000
0000
0110
1111

Was als Liste von Zahlen ist [0, 0, 6, 15].

Ein weiterer Testfall

[10, 17, 19, 23]

Dies wird:

01010
10001
10011
10111

was wird:

00000
10011
10011
11111

zurück zu übersetzen:

[0, 19, 19, 31]

Herausforderung

Wenden Sie diese Transformation bei einer Liste positiver Ganzzahlen auf die Liste an. Eingabe / Ausgabe als Liste positiver Ganzzahlen in einem beliebigen Format. Es gelten Standardlücken.

Dies ist ein Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

MATL , 4 Bytes

BSXB

Probieren Sie es bei MATL Online aus

Erläuterung

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

Probieren Sie es online!

JavaScript (ES6), 50 Byte

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

Erläuterung: Angenommen, zwei Zeilen der Wand lauten wie folgt:

0011
0101

Das Ergebnis muss sein:

0001
0111

Mit anderen Worten wird die erste Zeile zum UND der beiden Zeilen und die zweite Zeile zum ODER der beiden Zeilen. Dies muss nur so oft wiederholt werden, dass alle Bits auf den Grund fallen.

Gelee , 9 Bytes

BUz0Ṣ€ZUḄ

Probieren Sie es online!

Japt , 16 Bytes

m¤z3 ®¬n qÃz mn2

Probieren Sie es online! Verwenden Sie das -QFlag, um das Array-Ergebnis zu formatieren.

Erläuterung

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

 ist \[Transpose]

Dies wandelt die Eingabe (eine Liste von Zahlen) in eine Liste von Ziffernlisten um, füllt sie als quadratische Matrix auf, transponiert sie, sortiert die Zeilen so, dass die Einsen nach unten fallen, transponiert zurück und wandelt sie dann wieder in Zahlen um .

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)

Probieren Sie es online!

Nimmt Eingaben wie f(2, 6, 9, 4). Angenommen, die Eingabe ist nicht leer. Verwendet viel Tupel-Auspacken .

Oktave, 29 25 Bytes

4 Bytes gespart dank @Stewie

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

J , 13 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Ein bisschen anderer Algorithmus als bei Magic.

Dyalog APL, 24 21 19 Bytes

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

Probieren Sie es online! (so geändert, dass TryAPL es als gültig akzeptiert)

Wie?

• ⎕ ausgewertete Eingabe (Arrays sind durch Leerzeichen getrennt)
• 2⊥⍣¯1⊢ konvertiert jedes Argument in ein Binärargument (umgesetzt von dem, was in Frage kommt)
• ↓ verwandelt ein 2D-Array in einen Vektor von Vektoren
• {⍵[⍋⍵]}¨ sortiert jedes der Elemente des Vektors
• ↑ verwandelt den Vektor von Vektoren wieder in ein 2D-Array
• 2⊥ konvertiere von binär (da es es irgendwie transponiert, kommen wir zum richtigen Ergebnis)

Dyalog APL (23 Zeichen)

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

1. Konvertieren Sie die Eingabeargumente in eine binäre Matrix
2. Teilen Sie die Matrix in Spalten auf
3. Sortieren Sie die Spalten in aufsteigender Reihenfolge
4. Konvertieren Sie die sortierten Zeilen wieder in Dezimalzahlen

Beispiel

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

Vielen Dank an Zacharý für die Korrektur.

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

Probieren Sie es online aus

-2 Bytes dank Kühe quaken

Python 2, 142 Bytes

... und immer noch Golf spielen ... hoffentlich –– Jede Hilfe wird geschätzt!

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

Ein großer Teil davon dient zum Auffüllen der Zahlen mit Nullen.

Besser lesbar:

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

Dadurch wird ein Array der binären Zeichenfolgendarstellungen erstellt, aufgefüllt, um 90 ° im Uhrzeigersinn gedreht, jede Zeile sortiert, um 90 ° zurückgedreht und dann aus jeder Zeile Ganzzahlen erstellt.